Java基础类库-2

AI摘要：

对应《疯狂Java讲义（第5版）》7.3-7.4 章节

Object类

Object是所有类、数组、枚举类的父类，没有使用extends显式指定父类的类默认继承Object类

  • boolean equals(Object obj) 是否为同一对象

  • protected void finalize() 垃圾回收器清理该对象资源

  • Class<?> getClass() 返回运行时类

  • int hashCode() 默认根据地址计算，与System.identityHashCode(Object x)相同，但很多类改写了该方法

  • String toString() 对象的字符串表示，默认返回运行时类名@16进制hashCode

  • wait()、notify()、notifyAll() 控制线程的运行和暂停

  • protected Clone() 实现对象的“自我克隆”，得到一个完全隔离的副本

    • “浅克隆”，只克隆该对象的所有成员变量值，不会对引用类型的成员变量引用的对象进行克隆
    • “深克隆”需要开发者自己进行“递归克隆”
    1. 实现 Cloneable 接口（只是一个标记，接口里没有任何方法）
    2. 实现自定义的 clone() 方法
    3. 通过 super.clone() 调用父类的克隆方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Address
{
	String detail;
	public Address(String detail)
	{
		this.detail = detail;
	}
}
// 实现Cloneable接口
class User implements Cloneable
{
	int age;
	Address address;
	public User(int age)
	{
		this.age = age;
		address = new Address("广州天河");
	}
	// 通过调用super.clone()来实现clone()方法
	public User clone()
		throws CloneNotSupportedException
	{
		return (User)super.clone();
	}
}
public class CloneTest
{
	public static void main(String[] args)
		throws CloneNotSupportedException
	{
		User u1 = new User(29);
		// clone得到u1对象的副本。
		User u2 = u1.clone();
		// 判断u1、u2是否相同
		System.out.println(u1 == u2);      //①
		// 判断u1、u2的address是否相同
		System.out.println(u1.address == u2.address);     //②
	}
}

操作对象的Objects工具类（Java 7）

提供的工具方法大都“空指针”安全，不会引发空指针异常，如toSting()将输出null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ObjectsTest
{
	// 定义一个obj变量，它的默认值是null
	static ObjectsTest obj;
	public static void main(String[] args)
	{
		// 输出一个null对象的hashCode值，输出0
		System.out.println(Objects.hashCode(obj));
		// 输出一个null对象的toString，输出null
		System.out.println(Objects.toString(obj));
		// 要求obj不能为null，如果obj为null则引发异常
		System.out.println(Objects.requireNonNull(obj
			, "obj参数不能是null！"));
	}
}

  • requireNonNull()

    传入不是null时，返回参数本身，否则将引发NullPointerException异常

1
2
3
4
public Foo(Bar bar){
    //校验bar参数，为null将引发NullPointerException异常
    this.bar = Objects.requireNonNull(bar);
}

String、StringBuffer、StringBuilder类（Java 9 改进）

String是不可变类，包含的字符序列不可修改

StringBuffer对象代表一个字符序列可变的字符串

StringBuilder和StringBuffer基本相同，但StringBuffer线程安全，StringBuilder没有实现线程安全，所以性能略高

都实现了CharSequence接口，字符串协议接口

Java 9 以前采用char[]数组保存字符， 每个字符占用2字节；Java 9 开始采用byte[]数组再加一个encoding-flag字段来保存字符，每个字符只占1字节

String

下面是 String 类支持的方法，更多详细，参看 Java String API 文档:

1char charAt(int index) 返回指定索引处的 char 值。
2int compareTo(Object o) 把这个字符串和另一个对象比较。
3int compareTo(String anotherString) 按字典顺序比较两个字符串。
4int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。
5String concat(String str) 将指定字符串连接到此字符串的结尾。
6boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
7static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。
8static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
9boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
10boolean equals(Object anObject) 将此字符串与指定的对象比较。
11boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
12byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
13byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
14void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。
15int hashCode() 返回此字符串的哈希码。
16int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
17int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
18int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
19int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
20String intern() 返回字符串对象的规范化表示形式。
21int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
22int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
23int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
24int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
25int length() 返回此字符串的长度。
26boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
27boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
28boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。
29String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。
33String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。
34boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
35boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列。
37String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。
38String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
39char[] toCharArray() 将此字符串转换为一个新的字符数组。
40String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42String toString() 返回此对象本身（它已经是一个字符串！）。
43String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45String trim() 返回字符串的副本，忽略前导空白和尾部空白。
46static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。
47contains(CharSequence chars) 判断是否包含指定的字符系列。
48isEmpty() 判断字符串是否为空。

StringBuilder和StringBuffer

StringBuilder提供了一系列插入、追加、改变该字符串包含的字符序列的方法

length和capacity，length代表字符序列长度，可以setLength(int len)，capacity表示StringBuilder的容量，通常大于length

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class StringBuilderTest
{
	public static void main(String[] args)
	{
		StringBuilder sb = new StringBuilder();
		// 追加字符串
		sb.append("java");//sb = "java"
		// 插入
		sb.insert(0 , "hello "); // sb="hello java"
		// 替换
		sb.replace(5, 6, ","); // sb="hello,java"
		// 删除
		sb.delete(5, 6); // sb="hellojava"
		System.out.println(sb);
		// 反转
		sb.reverse(); // sb="avajolleh"
		System.out.println(sb);
		System.out.println(sb.length()); // 输出9
		System.out.println(sb.capacity()); // 输出16
		// 改变StringBuilder的长度，将只保留前面部分
		sb.setLength(5); // sb="avajo"
		System.out.println(sb);
	}
}

Math类

提供更复杂的数学运算，构造器为 private ，方法均为类方法，以及两个类变量 PI 和 E

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
public class MathTest
{
	public static void main(String[] args)
	{
		/*---------下面是三角运算---------*/
		// 将弧度转换角度
		System.out.println("Math.toDegrees(1.57)："
			+ Math.toDegrees(1.57));
		// 将角度转换为弧度
		System.out.println("Math.toRadians(90)："
			+ Math.toRadians(90));
		// 计算反余弦，返回的角度范围在 0.0 到 pi 之间。
		System.out.println("Math.acos(1.2)：" + Math.acos(1.2));
		// 计算反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。
		System.out.println("Math.asin(0.8)：" + Math.asin(0.8));
		// 计算反正切；返回的角度范围在 -pi/2 到 pi/2 之间。
		System.out.println("Math.atan(2.3)：" + Math.atan(2.3));
		// 计算三角余弦。
		System.out.println("Math.cos(1.57)：" + Math.cos(1.57));
		// 计算值的双曲余弦。
		System.out.println("Math.cosh(1.2 )：" + Math.cosh(1.2 ));
		// 计算正弦
		System.out.println("Math.sin(1.57 )：" + Math.sin(1.57 ));
		// 计算双曲正弦
		System.out.println("Math.sinh(1.2 )：" + Math.sinh(1.2 ));
		// 计算三角正切
		System.out.println("Math.tan(0.8 )：" + Math.tan(0.8 ));
		// 计算双曲正切
		System.out.println("Math.tanh(2.1 )：" + Math.tanh(2.1 ));
		// 将矩形坐标 (x, y) 转换成极坐标 (r, thet));
		System.out.println("Math.atan2(0.1, 0.2)：" + Math.atan2(0.1, 0.2));
		/*---------下面是取整运算---------*/
		// 取整，返回小于目标数的最大整数。
		System.out.println("Math.floor(-1.2 )：" + Math.floor(-1.2 ));
		// 取整，返回大于目标数的最小整数。
		System.out.println("Math.ceil(1.2)：" + Math.ceil(1.2));
		// 四舍五入取整
		System.out.println("Math.round(2.3 )：" + Math.round(2.3 ));
		/*---------下面是乘方、开方、指数运算---------*/
		// 计算平方根。
		System.out.println("Math.sqrt(2.3 )：" + Math.sqrt(2.3 ));
		// 计算立方根。
		System.out.println("Math.cbrt(9)：" + Math.cbrt(9));
		// 返回欧拉数 e 的n次幂。
		System.out.println("Math.exp(2)：" + Math.exp(2));
		// 返回 sqrt(x2 +y2)
		System.out.println("Math.hypot(4 , 4)：" + Math.hypot(4 , 4));
		// 按照 IEEE 754 标准的规定，对两个参数进行余数运算。
		System.out.println("Math.IEEEremainder(5 , 2)："
			+ Math.IEEEremainder(5 , 2));
		// 计算乘方
		System.out.println("Math.pow(3, 2)：" + Math.pow(3, 2));
		// 计算自然对数
		System.out.println("Math.log(12)：" + Math.log(12));
		// 计算底数为 10 的对数。
		System.out.println("Math.log10(9)：" + Math.log10(9));
		// 返回参数与 1 之和的自然对数。
		System.out.println("Math.log1p(9)：" + Math.log1p(9));
		/*---------下面是符号相关的运算---------*/
		// 计算绝对值。
		System.out.println("Math.abs(-4.5)：" + Math.abs(-4.5));
		// 符号赋值，返回带有第二个浮点数符号的第一个浮点参数。
		System.out.println("Math.copySign(1.2, -1.0)："
			+ Math.copySign(1.2, -1.0));
		// 符号函数；如果参数为 0，则返回 0；如果参数大于 0，
		// 则返回 1.0；如果参数小于 0，则返回 -1.0。
		System.out.println("Math.signum(2.3)：" + Math.signum(2.3));
		/*---------下面是大小相关的运算---------*/
		// 找出最大值
		System.out.println("Math.max(2.3 , 4.5)：" + Math.max(2.3 , 4.5));
		// 计算最小值
		System.out.println("Math.min(1.2 , 3.4)：" + Math.min(1.2 , 3.4));
		// 返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。
		System.out.println("Math.nextAfter(1.2, 1.0)："
			+ Math.nextAfter(1.2, 1.0));
		// 返回比目标数略大的浮点数
		System.out.println("Math.nextUp(1.2 )：" + Math.nextUp(1.2 ));
		// 返回一个伪随机数，该值大于等于 0.0 且小于 1.0。
		System.out.println("Math.random()：" + Math.random());
	}
}

ThreadLocalRandom （Java 7）与 Random

Random 类专门生成伪随机数，两个构造器，一个以当前时间为种子，另一个需显示传入 long 型证书作为种子

ThreadLocalRandom 在并发访问环境可以减少线程资源竞争，提高线程安全性，通过静态 current() 方法返回 ThreadLocalRandom 对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class RandomTest
{
	public static void main(String[] args)
	{
		Random rand = new Random();
		System.out.println("rand.nextBoolean()："
			+ rand.nextBoolean());
		byte[] buffer = new byte[16];
		rand.nextBytes(buffer);
		System.out.println(Arrays.toString(buffer));
		// 生成0.0~1.0之间的伪随机double数
		System.out.println("rand.nextDouble()："
			+ rand.nextDouble());
		// 生成0.0~1.0之间的伪随机float数
		System.out.println("rand.nextFloat()："
			+ rand.nextFloat());
		// 生成平均值是 0.0，标准差是 1.0的伪高斯数
		System.out.println("rand.nextGaussian()："
			+ rand.nextGaussian());
		// 生成一个处于int整数取值范围的伪随机整数
		System.out.println("rand.nextInt()：" + rand.nextInt());
		// 生成0~26之间的伪随机整数
		System.out.println("rand.nextInt(26)：" + rand.nextInt(26));
		// 生成一个处于long整数取值范围的伪随机整数
		System.out.println("rand.nextLong()：" +  rand.nextLong());
	}
}

如果两个Random对象的种子相同，且方法的调用顺序相同，则会产生相同的数字序列（伪随机），推荐使用当前时间作为Random对象的种子 System.currentTimeMillis()

ThreadLoaclRandom用法：

1
2
3
ThreadLocalRandom rand = ThreadLoaclRandom.current();
int val1 = rand.nextInt(4, 20);
int val2 = rand.nextDouble(2.0, 10.0);

BigDecimal类

BigDecimal 类可以实现精确的浮点运算，float、double两种基本浮点类型会引起精度丢失

不推荐 new BigDecimal( 0.1 ) , 推荐 new BigDecimal( “0.1” )，因为浮点数的值不会正好等于0.1
如果使用浮点数作为参数，则使用 BigDecimal.valueOf(0.01);

提供了 add()、substract()、multiply()、divide()、pow(）等精确浮点数运算方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class BigDecimalTest
{
	public static void main(String[] args)
	{
		BigDecimal f1 = new BigDecimal("0.05");
		BigDecimal f2 = BigDecimal.valueOf(0.01);
		BigDecimal f3 = new BigDecimal(0.05);
		System.out.println("使用String作为BigDecimal构造器参数：");
		System.out.println("0.05 + 0.01 = " + f1.add(f2));
		System.out.println("0.05 - 0.01 = " + f1.subtract(f2));
		System.out.println("0.05 * 0.01 = " + f1.multiply(f2));
		System.out.println("0.05 / 0.01 = " + f1.divide(f2));
		System.out.println("使用double作为BigDecimal构造器参数：");
		System.out.println("0.05 + 0.01 = " + f3.add(f2));
		System.out.println("0.05 - 0.01 = " + f3.subtract(f2));
		System.out.println("0.05 * 0.01 = " + f3.multiply(f2));
		System.out.println("0.05 / 0.01 = " + f3.divide(f2));
	}
}

定义一个 Arith 工具类，提供double类型的精确计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public class Arith
{
	// 默认除法运算精度
	private static final int DEF_DIV_SCALE = 10;
	// 构造器私有，让这个类不能实例化
	private Arith()	{}
	// 提供精确的加法运算。
	public static double add(double v1,double v2)
	{
		BigDecimal b1 = BigDecimal.valueOf(v1);
		BigDecimal b2 = BigDecimal.valueOf(v2);
		return b1.add(b2).doubleValue();
	}
	// 提供精确的减法运算。
	public static double sub(double v1,double v2)
	{
		BigDecimal b1 = BigDecimal.valueOf(v1);
		BigDecimal b2 = BigDecimal.valueOf(v2);
		return b1.subtract(b2).doubleValue();
	}
	// 提供精确的乘法运算。
	public static double mul(double v1,double v2)
	{
		BigDecimal b1 = BigDecimal.valueOf(v1);
		BigDecimal b2 = BigDecimal.valueOf(v2);
		return b1.multiply(b2).doubleValue();
	}
	// 提供（相对）精确的除法运算，当发生除不尽的情况时.
	// 精确到小数点以后10位的数字四舍五入。
	public static double div(double v1,double v2)
	{
		BigDecimal b1 = BigDecimal.valueOf(v1);
		BigDecimal b2 = BigDecimal.valueOf(v2);
		return b1.divide(b2 , DEF_DIV_SCALE
			, RoundingMode.HALF_UP).doubleValue();
	}
	public static void main(String[] args)
	{
		System.out.println("0.05 + 0.01 = "
			+ Arith.add(0.05 , 0.01));
		System.out.println("1.0 - 0.42 = "
			+ Arith.sub(1.0 , 0.42));
		System.out.println("4.015 * 100 = "
			+ Arith.mul(4.015 , 100));
		System.out.println("123.3 / 100 = "
			+ Arith.div(123.3 , 100));
	}
}

Date类（java.util.Date）

用于处理日期与时间，大部分方法、构造器已经过时

构造器

  • Date() 底层调用System.currentTimeMillis() ,生成当前日期参数的Date对象
  • Date( long date )

方法

  • boolean after( date when )
  • boolean before( date when )
  • long getTime()
  • void setTime()
1
2
3
4
5
6
7
8
9
10
11
12
public class DateTest
{
	public static void main(String[] args)
	{
		Date d1 = new Date();
		// 获取当前时间之后100ms的时间
		Date d2 = new Date(System.currentTimeMillis() + 100);
		System.out.println(d2);
		System.out.println(d1.compareTo(d2));
		System.out.println(d1.before(d2));
	}
}

Calender 类

Calander 是一个抽象类，是所有日历类的模板，本身不能实例化，Java提供了一个 GregorianCalendar 类，一个代表格里高利日历的子类。也可以创建自己的 Calendar 子类，作为 Calendar 对象使用（多态）

通过getInstance()方法获取Calendar对象，依据TimeZone和Local类

tips：Month范围 0~11，代表1~12月

  • void add(int field, int amount)

    加减指定的时间量，上一级字段会进位，下一级字段会修正到变化最小的值 ，如 2003-8-31 =》 2004-2-29

  • int get(int field)

  • int getActualMaximum(int field)

  • int getActualMinimum(int field)

  • void roll(int field, int amount)

    与add类似，但不会向上一字段进位

  • void set(int field, int value)

  • void set(int year, int month, int date)

  • void set(int year, int month, int date, int hourOfDay, int minute, int second)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.util.*;
import static java.util.Calendar.*;
public class CalendarTest
{
	public static void main(String[] args)
	{
		Calendar c = Calendar.getInstance();
		// 取出年
		System.out.println(c.get(YEAR));
		// 取出月份
		System.out.println(c.get(MONTH));
		// 取出日
		System.out.println(c.get(DATE));
		// 分别设置年、月、日、小时、分钟、秒
		c.set(2003 , 10 , 23 , 12, 32, 23); //2003-11-23 12:32:23
		System.out.println(c.getTime());
		// 将Calendar的年前推1年
		c.add(YEAR , -1); //2002-11-23 12:32:23
		System.out.println(c.getTime());
		// 将Calendar的月前推8个月
		c.roll(MONTH , -8); //2002-03-23 12:32:23
		System.out.println(c.getTime());


		Calendar cal1 = Calendar.getInstance();
		cal1.set(2003, 7, 23, 0, 0 , 0); // 2003-8-23
		cal1.add(MONTH, 6); //2003-8-23 => 2004-2-23
		System.out.println(cal1.getTime());


		Calendar cal2 = Calendar.getInstance();
		cal2.set(2003, 7, 31, 0, 0 , 0); // 2003-8-31
		// 因为进位到后月份改为2月，2月没有31日，自动变成29日
		cal2.add(MONTH, 6); // 2003-8-31 => 2004-2-29
		System.out.println(cal2.getTime());


		Calendar cal3 = Calendar.getInstance();
		cal3.set(2003, 7, 23, 0, 0 , 0); //2003-8-23
		// MONTH字段“进位”，但YEAR字段并不增加
		cal3.roll(MONTH, 6); //2003-8-23 => 2003-2-23
		System.out.println(cal3.getTime());


		Calendar cal4 = Calendar.getInstance();
		cal4.set(2003, 7, 31, 0, 0 , 0); //2003-8-31
		// MONTH字段“进位”后变成2，2月没有31日，
		// YEAR字段不会改变，2003年2月只有28天
		cal4.roll(MONTH, 6); //2003-8-31 => 2003-2-28
		System.out.println(cal4.getTime());
	}
}

Calendar 的容错性

setLenient(false) 可以关闭容错性（non-lenient），进行严格的参数检查，超出允许范围将抛出异常

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class LenientTest
{
	public static void main(String[] args
	{
		Calendar cal = Calendar.getInstance();
		// 结果是YEAR字段加1，MONTH字段为1（二月）
		cal.set(MONTH , 13);   //①
		System.out.println(cal.getTime());
		// 关闭容错性
		cal.setLenient(false);
		// 导致运行时异常
		cal.set(MONTH , 13);   //②
		System.out.println(cal.getTime());
	}
}

set() 方法的延迟修改

日历字段 f 立即更改，但 Calendar 代表的时间不会立即修改，需等到下次 get()、add()等时才会重新计算日历的时间，防止多次set()时不必要的计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class LazyTest
{
	public static void main(String[] args)
	{
		Calendar cal = Calendar.getInstance();
		cal.set(2003 , 7 , 31);  //2003-8-31
		// 将月份设为9，但9月31日不存在。
		// 如果立即修改，系统将会把cal自动调整到10月1日。
		cal.set(MONTH , 8);
		// 下面代码输出10月1日
//		System.out.println(cal.getTime());    //①
		// 设置DATE字段为5
		cal.set(DATE , 5);    //②
        // 输出 2003-9-5 而不是 2003-10-5
		System.out.println(cal.getTime());    //③
	}
}

新的日期、时间包（java.time）

Java 8 新增 java.time 包，包含了以下类：

  • Clock（指定时区的当前日期、时间）
  • Duration（持续时间，一段时间）
  • Instant （具体时刻）
  • LocalDate（不带时区的日期）2007-12-03
  • LocalTime（不带时区的时间）10:15:30
  • LocalDateTime 2007-12-03T10:15:30
  • MonthDay（月日） –04-12
  • Year 2014
  • YearMonth（年月） 2014-04
  • ZonedDateTime（时区化的日期、时间）
  • ZoneId（代表一个时区）
  • DayOfWeek （枚举类，周日到周六的枚举值）
  • Month（枚举类，一月到十二月的枚举值）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
import java.time.*;
public class NewDatePackageTest
{
	public static void main(String[] args)
	{
		// -----下面是关于Clock的用法-----
		// 获取当前Clock
		Clock clock = Clock.systemUTC();
		// 通过Clock获取当前时刻
		System.out.println("当前时刻为：" + clock.instant());
		// 获取clock对应的毫秒数，与System.currentTimeMillis()输出相同
		System.out.println(clock.millis());
		System.out.println(System.currentTimeMillis());
		// -----下面是关于Duration的用法-----
		Duration d = Duration.ofSeconds(6000);
		System.out.println("6000秒相当于" + d.toMinutes() + "分");
		System.out.println("6000秒相当于" + d.toHours() + "小时");
		System.out.println("6000秒相当于" + d.toDays() + "天");
		// 在clock基础上增加6000秒，返回新的Clock
		Clock clock2 = Clock.offset(clock, d);
		// 可看到clock2与clock1相差1小时40分
		System.out.println("当前时刻加6000秒为：" +clock2.instant());
		// -----下面是关于Instant的用法-----
		// 获取当前时间
		Instant instant = Instant.now();
		System.out.println(instant);
		// instant添加6000秒（即100分钟），返回新的Instant
		Instant instant2 = instant.plusSeconds(6000);
		System.out.println(instant2);
		// 根据字符串中解析Instant对象
		Instant instant3 = Instant.parse("2014-02-23T10:12:35.342Z");
		System.out.println(instant3);
		// 在instant3的基础上添加5小时4分钟
		Instant instant4 = instant3.plus(Duration
			.ofHours(5).plusMinutes(4));
		System.out.println(instant4);
		// 获取instant4的5天以前的时刻
		Instant instant5 = instant4.minus(Duration.ofDays(5));
		System.out.println(instant5);
		// -----下面是关于LocalDate的用法-----
		LocalDate localDate = LocalDate.now();
		System.out.println(localDate);
		// 获得2014年的第146天
		localDate = LocalDate.ofYearDay(2014, 146);
		System.out.println(localDate); // 2014-05-26
		// 设置为2014年5月21日
		localDate = LocalDate.of(2014, Month.MAY, 21);
		System.out.println(localDate); // 2014-05-21
		// -----下面是关于LocalTime的用法-----
		// 获取当前时间
		LocalTime localTime = LocalTime.now();
		// 设置为22点33分
		localTime = LocalTime.of(22, 33);
		System.out.println(localTime); // 22:33
		// 返回一天中的第5503秒
		localTime = LocalTime.ofSecondOfDay(5503);
		System.out.println(localTime); // 01:31:43
		// -----下面是关于localDateTime的用法-----
		// 获取当前日期、时间
		LocalDateTime localDateTime = LocalDateTime.now();
		// 当前日期、时间加上25小时３分钟
		LocalDateTime future = localDateTime.plusHours(25).plusMinutes(3);
		System.out.println("当前日期、时间的25小时3分之后：" + future);
		// 下面是关于Year、YearMonth、MonthDay的用法示例-----
		Year year = Year.now(); // 获取当前的年份
		System.out.println("当前年份：" + year); // 输出当前年份
		year = year.plusYears(5); // 当前年份再加5年
		System.out.println("当前年份再过5年：" + year);
		// 根据指定月份获取YearMonth
		YearMonth ym = year.atMonth(10);
		System.out.println("year年10月：" + ym); // 输出XXXX-10，XXXX代表当前年份
		// 当前年月再加5年，减3个月
		ym = ym.plusYears(5).minusMonths(3);
		System.out.println("year年10月再加5年、减3个月：" + ym);
		MonthDay md = MonthDay.now();
		System.out.println("当前月日：" + md); // 输出--XX-XX，代表几月几日
		// 设置为5月23日
		MonthDay md2 = md.with(Month.MAY).withDayOfMonth(23);
		System.out.println("5月23日为：" + md2); // 输出--05-23
	}
}
学习笔记 > Java
#Java #类与对象
Java基础类库-2
https://blog.cngo.rr.nu/posts/daa.html
作者
cngo
发布于
2024年7月11日
许可协议