Java常用类

Posted on Edited on In , Views: Word count in article: 25k Reading time ≈ 23 mins.

1、String类

  • String声明为final的，不可被继承。
  • String实现了Serializable接口：表示字符串是支持序列化的；实现了Comparable接口：表示String可以比较大小。
  • String内部定义了final char[] value用于存储字符串数据。
  • String:代表不可变的字符序列。简称：不可变性。
    • 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
    • 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
    • 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
  • 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
  • 字符串常量池中是不会存储相同内容的字符串的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Test
public void test1(){
    String s1 = "abc";//字面量的定义方式
    String s2 = "abc";

    System.out.println(s1 == s2);//比较s1和s2的地址值,true

    String s3 = "abc";
    s3 += "def";
    System.out.println(s3);//abcdef

    String s4 = "abc";
    String s5 = s4.replace('a', 'm');
    System.out.println(s4);//abc
    System.out.println(s5);//mbc
}

体会不可变性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class StringTest {
    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

1.1 String的实例化方式

  • 通过字面量定义的方式。
  • 通过new + 构造器的方式。
    • 通过String s = new String(“abc”)创建了两个对象，一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：”abc”。
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
@Test
public void test(){
    //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
    String s1 = "javaEE";
    String s2 = "javaEE";
    //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
    String s3 = new String("javaEE");
    String s4 = new String("javaEE");

    System.out.println(s1 == s2);//true
    System.out.println(s1 == s3);//false
    System.out.println(s1 == s4);//false
    System.out.println(s3 == s4);//false
        
    Person p1 = new Person("Tom",12);
    Person p2 = new Person("Tom",12);

    System.out.println(p1.name.equals(p2.name));//true
    System.out.println(p1.name == p2.name);//true
}

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

图解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Test
public void test3(){
    String s1 = "abc";
    String s2 = "def";
    //常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
    String s3 = "abcdef";
    String s4 = "abc" + "def";
    //有其它变量名参与则在堆中开辟空间，此时c5,c6,c7记录的是堆中的地址。
    String s5 = s1 + "def";
    String s6 = "abc" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4);//true
    System.out.println(s3 == s5);//false
    System.out.println(s3 == s6);//false
    System.out.println(s3 == s7);//false
    System.out.println(s5 == s6);//false
    System.out.println(s5 == s7);//false
    System.out.println(s6 == s7);//false

    String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“abcdef”
    System.out.println(s3 == s8);//true
}

1.2 字符串拼接

  • 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
  • 只要其中有一个是变量，结果就在堆中。
  • 如果拼接的结果调用intern()方法，返回值就在常量池中。
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
@Test
public void test3(){
    String s1 = "abc";
    String s2 = "def";
    //常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
    String s3 = "abcdef";
    String s4 = "abc" + "def";
    //有其它变量名参与则在堆中开辟空间，此时c5,c6,c7记录的是堆中的地址。
    String s5 = s1 + "def";
    String s6 = "abc" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4);//true
    System.out.println(s3 == s5);//false
    System.out.println(s3 == s6);//false
    System.out.println(s3 == s7);//false
    System.out.println(s5 == s6);//false
    System.out.println(s5 == s7);//false
    System.out.println(s6 == s7);//false

    String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“abcdef”
    System.out.println(s3 == s8);//true
    
    //特别地
    String s9="abcdef";
    final String s10 = "abc";//s10:常量
    String s11 = s10 + "def";
    System.out.println(s9 == s11);//true
}

1.3 String常用方法

  • int length()：返回字符串的长度： return value.length。
  • char charAt(int index)： 返回某索引处的字符return value[index]。
  • boolean isEmpty()：判断是否是空字符串：return value.length == 0。
  • String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写。
  • String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写。
  • String trim()：返回字符串的副本，忽略前导空白和尾部空白。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public void test() {
    String s1 = "HelloWorld";
    System.out.println(s1.length());//10
    System.out.println(s1.charAt(0));//H
    System.out.println(s1.charAt(9));//d
    //System.out.println(s1.charAt(10));//java.lang.StringIndexOutOfBoundsException: String index out of range: 10
    System.out.println(s1.isEmpty());//false

    String s2 = s1.toLowerCase();
    System.out.println(s1);//s1不可变的，仍然为原来的字符串,HelloWorld
    System.out.println(s2);//改成小写以后的字符串,helloworld

    String s3 = "   he  llo   world   ";
    String s4 = s3.trim();
    System.out.println("-" + s3 + "-");//-   he  llo   world   -
    System.out.println("-" + s4 + "-");//-he  llo   world-
}
  • boolean equals(Object obj)：比较字符串的内容是否相同。
  • boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写。
  • String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”。
  • int compareTo(String anotherString)：比较两个字符串的大小。
  • String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
  • String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Test
public void test() {
    String s1 = "HelloWorld";
    String s2 = "helloworld";
    System.out.println(s1.equals(s2));//false
    System.out.println(s1.equalsIgnoreCase(s2));//true

    String s3 = "abc";
    String s4 = s3.concat("def");
    System.out.println(s4);//abcdef

    String s5 = "abc";
    String s6 = new String("abe");
    System.out.println(s5.compareTo(s6));//涉及到字符串排序,99-101=-2

    String s7 = "abcdef";
    String s8 = s7.substring(2);
    System.out.println(s7);//abcdef
    System.out.println(s8);//cdef

    String s9 = s7.substring(2, 5);
    System.out.println(s9);//cde
}
  • boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束。
  • boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始。
  • boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
  • boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true。
  • int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引。
  • int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
  • int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引。
  • int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
    • indexOf和lastIndexOf方法如果未找到都是返回-1。
    • 如果存在唯一的一个str，则indexOf和lastIndexOf返回的值也相同。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Test
public void test(){
    String str1 = "hellowworld";
    boolean b1 = str1.endsWith("rld");
    System.out.println(b1);////true

    boolean b2 = str1.startsWith("He");
    System.out.println(b2);//false

    boolean b3 = str1.startsWith("ll",2);
    System.out.println(b3);//true

    String str2 = "wor";
    System.out.println(str1.contains(str2));//true

    System.out.println(str1.indexOf("lol"));//-1

    System.out.println(str1.indexOf("lo",5));//-1

    String str3 = "hellorworld";

    System.out.println(str3.lastIndexOf("or"));//7
    System.out.println(str3.lastIndexOf("or",6));//4
}
  • String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
  • String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
  • String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
  • String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
  • boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
  • String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
  • String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
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
@Test
public void test(){
    String str1 = "abcdef";
    String str2 = str1.replace('a', 'l');
    System.out.println(str1);//abcdef
    System.out.println(str2);//lbcdef

    String str3 = str1.replace("ab", "cd");
    System.out.println(str3);//cdcdef

    String str = "12hello34world5java7891mysql456";
    //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
    String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
    System.out.println(string);//hello,world,java,mysql

    str = "12345";
    //判断str字符串中是否全部有数字组成，即有1-n个数字组成
    boolean matches = str.matches("\\d+");
    System.out.println(matches);//true
    String tel = "0571-4534289";
    //判断这是否是一个固定电话
    boolean result = tel.matches("0571-\\d{7,8}");
    System.out.println(result);//true
    
    str = "hello|world|java";
    String[] strs = str.split("\\|");
    for (int i = 0; i < strs.length; i++) {
        System.out.println(strs[i]);
    }
    System.out.println();
    str2 = "hello.world.java";
    String[] strs2 = str2.split("\\.");
    for (int i = 0; i < strs2.length; i++) {
        System.out.println(strs2[i]);
    }
}

1.4 String与其它结构的转换

  • String 与基本数据类型、包装类之间的转换。
    • String –> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)。
    • 基本数据类型、包装类 –> String:调用String重载的valueOf(xxx)。
1
2
3
4
5
6
@Test
public void test(){
    String str1 = "123";
    int num = Integer.parseInt(str1);
    String str2 = String.valueOf(num);
}
  • String 与 char[]之间的转换。
    • String –> char[]:调用String的toCharArray()。
    • char[] –> String:调用String的构造器。
1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public void test(){
    String str1 = "abc123";

    char[] charArray = str1.toCharArray();
    for (int i = 0; i < charArray.length; i++) {
        System.out.println(charArray[i]);
    }

    char[] arr = new char[]{'h','e','l','l','o'};
    String str2 = new String(arr);
    System.out.println(str2);
}
  • String 与 byte[]之间的转换
    • 编码：String –> byte[]:调用String的getBytes()。
    • 解码：byte[] –> String:调用String的构造器。（解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void test() throws UnsupportedEncodingException {
    String str1 = "abc123中国";
    byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
    System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67],UTF编码三个字节一个汉字

    for (int i = 0; i < bytes.length; i++) {
        System.out.println(bytes[i]);
    }

    byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
    System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6],GBK编码两个字节一个汉字
    
    String str2 = new String(bytes);//使用默认的字符集，进行解码。
    System.out.println(str2);//abc123中国

    String str3 = new String(gbks);
    System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！abc123�й�
    
    String str4 = new String(gbks, "gbk");
    System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！abc123中国
}

2、StringBuffer与StringBuilder类

  • String、StringBuffer、StringBuilder三者的异同：

    • String:不可变的字符序列；底层使用char[]存储。（String str = new String();//char[] value = new char[0];）
    • StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储。（StringBuffer sb1 = new StringBuffer();//char[] value = new char[16]底层创建了一个长度是16的数组；StringBuffer sb2 = new StringBuffer(“abc”);//char[] value = new char[“abc”.length() + 16];）
    • StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储。
    • 效率从高到低排列：StringBuilder > StringBuffer > String
    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
    @Test
    public void test(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        //开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));//StringBuffer的执行时间：17
      
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));//StringBuilder的执行时间：6
      
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));//String的执行时间：1857
    }

2.1 StringBuffer的常用方法

  • StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接。
  • StringBuffer delete(int start,int end)：删除指定位置的内容。
  • StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str。
  • StringBuffer insert(int offset, xxx)：在指定位置插入xxx。
  • StringBuffer reverse() ：把当前字符序列逆转。
  • public int indexOf(String str)。
  • public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串。
  • public int length()
  • public char charAt(int n)
  • public void setCharAt(int n ,char ch)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void test(){
    StringBuffer s1 = new StringBuffer("abc");
    s1.append(1);
    s1.append('1');
    System.out.println(s1);//abc11
    //s1.delete(2,4);//ab1
    //s1.replace(2,4,"hello");//abhello1
    //s1.insert(2,false);//abfalsec11
    //s1.reverse();//11cba
    String s2 = s1.substring(1, 3);
    System.out.println(s1);//abc11
    System.out.println(s1.length());//5
    System.out.println(s2);//bc
}

3、日期类

  • JDK8之前日期时间API
  • JDK8之后日期时间API
    • java.time – 包含值对象的基础包。
    • java.time.chrono – 提供对不同的日历系统的访问。
    • java.time.format – 格式化和解析时间和日期。
    • java.time.temporal – 包括底层框架和扩展特性。
    • java.time.zone – 包含时区支持的类。
  • 出现变化的原因：
    • 可变性：像日期和时间这样的类应该是不可变的。
    • 偏移性：Date中的年份是从1900开始的，而月份都从0开始。
    • 格式化：格式化只对Date有用，Calendar则不行。
    • 此外，它们也不是线程安全的；不能处理闰秒等。

3.1 java.util.Date类和java.sql.Date类

  • java.util.Date类
    • java.sql.Date类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Test
public void test(){
    //构造器一：Date()：创建一个对应当前时间的Date对象
    Date date1 = new Date();
    System.out.println(date1);//Sat Nov 21 16:56:49 CST 2020
    //显示当前的年、月、日、时、分、秒
    System.out.println(date1.toString());//Sat Nov 21 16:56:49 CST 2020
    //获取当前Date对象对应的毫秒数。（时间戳）
    System.out.println(date1.getTime());//1605949009952
    //构造器二：创建指定毫秒数的Date对象
    Date date2 = new Date(155030620410L);
    System.out.println(date2.toString());//Sat Nov 30 16:03:40 CST 1974
    //创建java.sql.Date对象
    java.sql.Date date3 = new java.sql.Date(35235647845L);
    System.out.println(date3);//1971-02-13
    //将java.util.Date对象转换为java.sql.Date对象
    //情况一：
    Date date4 = new java.sql.Date(2343243242323L);
    java.sql.Date date5 = (java.sql.Date) date4;
    //情况二：
    Date date6 = new Date();
    java.sql.Date date7 = new java.sql.Date(date6.getTime());
}

3.2 SimpleDateFormat类

  • SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析。
    • 格式化：日期 —>字符串
    • 解析：格式化的逆过程，字符串 —> 日期
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
@Test
public void testSimpleDateFormat() throws ParseException {
    //实例化SimpleDateFormat:使用默认的构造器
    SimpleDateFormat sdf = new SimpleDateFormat();

    //格式化：日期 --->字符串
    Date date = new Date();
    System.out.println(date);//Sat Nov 21 21:08:53 CST 2020
    String format = sdf.format(date);
    System.out.println(format);//20-11-21 下午9:08

    //解析：格式化的逆过程，字符串 ---> 日期
    String str = "20-11-21 下午9:08";
    Date date1 = sdf.parse(str);
    System.out.println(date1);//Sat Nov 21 21:08:00 CST 2020

    //按照指定的方式格式化和解析：调用带参的构造器
    //SimpleDateFormat sdf1 = new SimpleDateFormat("yyyyy.MMMMM.dd GGG hh:mm aaa");
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    //格式化
    String format1 = sdf1.format(date);
    System.out.println(format1);//2020-11-21 09:10:35
    //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),否则抛异常
    Date date2 = sdf1.parse("2020-11-21 09:10:35");
    System.out.println(date2);//Sat Nov 21 09:10:35 CST 2020
}

3.3 Calendar日历类(抽象类）

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
@Test
public void testCalendar(){
    //1.实例化
    //方式一：创建其子类（GregorianCalendar）的对象
    //方式二：调用其静态方法getInstance()
    Calendar calendar = Calendar.getInstance();
    //System.out.println(calendar.getClass());//class java.util.GregorianCalendar

    //2.常用方法
    //get()
    int days = calendar.get(Calendar.DAY_OF_MONTH);//获取当前日期是当前月的第几天
    System.out.println(days);
    System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//获取当前日期是当前年的第几天

    //set()
    //calendar可变性
    calendar.set(Calendar.DAY_OF_MONTH,22);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);//22

    //add()
    calendar.add(Calendar.DAY_OF_MONTH,-3);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);//22-3=19

    //getTime():日历类---> Date
    Date date = calendar.getTime();
    System.out.println(date);//Thu Nov 19 21:18:33 CST 2020

    //setTime():Date ---> 日历类
    Date date1 = new Date();
    calendar.setTime(date1);
    days = calendar.get(Calendar.DAY_OF_MONTH);
    System.out.println(days);//21
}
  • 获取月份时：一月是0，二月是1，以此类推，12月是11。
  • 获取星期时：周日是1，周二是2 ， 。。。。周六是7。

3.4 LocalDate、LocalTime、LocalDateTime类

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
@Test
public void test(){
    //now():获取当前的日期、时间、日期+时间
    LocalDate localDate = LocalDate.now();
    LocalTime localTime = LocalTime.now();
    LocalDateTime localDateTime = LocalDateTime.now();

    System.out.println(localDate);//2020-11-21
    System.out.println(localTime);//21:32:09.528
    System.out.println(localDateTime);//2020-11-21T21:32:09.528

    //of():设置指定的年、月、日、时、分、秒。没有偏移量
    LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 6, 13, 23, 43);
    System.out.println(localDateTime1);//2020-10-06T13:23:43

    //getXxx()：获取相关的属性
    System.out.println(localDateTime.getDayOfMonth());//21
    System.out.println(localDateTime.getDayOfWeek());//SATURDAY
    System.out.println(localDateTime.getMonth());//NOVEMBER
    System.out.println(localDateTime.getMonthValue());//11
    System.out.println(localDateTime.getMinute());//32

    //体现不可变性
    //withXxx():设置相关的属性
    LocalDate localDate1 = localDate.withDayOfMonth(22);
    System.out.println(localDate);//2020-11-21
    System.out.println(localDate1);//2020-11-22

    LocalDateTime localDateTime2 = localDateTime.withHour(4);
    System.out.println(localDateTime);//2020-11-21T21:32:09.528
    System.out.println(localDateTime2);//2020-11-21T04:32:09.528

    //不可变性
    LocalDateTime localDateTime3 = localDateTime.plusMonths(3);//添加三个月
    System.out.println(localDateTime);//2020-11-21T21:32:09.528
    System.out.println(localDateTime3);//2021-02-21T21:32:09.528

    LocalDateTime localDateTime4 = localDateTime.minusDays(6);//减去六天
    System.out.println(localDateTime);//2020-11-21T21:32:09.528
    System.out.println(localDateTime4);//2020-11-15T21:32:09.528
}

3.5 Instant类

  • Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。
  • 在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public void test(){
    //now():获取本初子午线对应的标准时间
    Instant instant = Instant.now();
    System.out.println(instant);//2020-11-21T13:39:19.745Z

    //添加时间的偏移量
    OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(offsetDateTime);//2020-11-21T21:39:19.745+08:00

    //toEpochMilli():获取自1970年1月1日0时0分0秒（UTC）开始的毫秒数  ---> Date类的getTime()
    long milli = instant.toEpochMilli();
    System.out.println(milli);//1605965959745

    //ofEpochMilli():通过给定的毫秒数，获取Instant实例  -->Date(long millis)
    Instant instant1 = Instant.ofEpochMilli(1605965959745L);
    System.out.println(instant1);//2020-11-21T13:39:19.745Z
}

3.6 DateTimeFormatter类

  • 用来格式化或解析日期、时间，类似SimpleDateFormat。
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
@Test
public void test(){
    //方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
    DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    //格式化:日期-->字符串
    LocalDateTime localDateTime = LocalDateTime.now();
    String str1 = formatter.format(localDateTime);
    System.out.println(localDateTime);//2020-11-21T21:52:29.945
    System.out.println(str1);//2020-11-21T21:52:29.945

    //解析：字符串 -->日期
    TemporalAccessor parse = formatter.parse("2020-11-21T21:52:29.945");
    System.out.println(parse);//{},ISO resolved to 2020-11-21T21:52:29.945

    //方式二：
    //本地化相关的格式。如：ofLocalizedDateTime()
    //FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
    DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
    //格式化
    String str2 = formatter1.format(localDateTime);
    System.out.println(str2);//2020年11月21日 下午09时52分46秒

    //本地化相关的格式。如：ofLocalizedDate()
    //FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
    DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM);
    //格式化
    String str3 = formatter2.format(LocalDate.now());
    System.out.println(str3);//2020-11-21

    //重点： 方式三：自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
    DateTimeFormatter formatter3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
    //格式化
    String str4 = formatter3.format(LocalDateTime.now());
    System.out.println(str4);//2020-11-21 09:52:46

    //解析
    TemporalAccessor accessor = formatter3.parse("2020-11-21 09:52:46");
    System.out.println(accessor);//{MicroOfSecond=0, MilliOfSecond=0, HourOfAmPm=9, SecondOfMinute=46, MinuteOfHour=52, NanoOfSecond=0},ISO resolved to 2020-11-21
}

4、Java比较器

4.1 自然排序：java.lang.Comparable

  • Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
  • 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。
  • 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
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
    @Test
    public void test(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr);//String类实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
        System.out.println(Arrays.toString(arr));//[AA, CC, DD, GG, JJ, KK, MM]
        
        Goods[] arr = new Goods[5];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("microsoftMouse",43);
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        //[Goods{name='xiaomiMouse', price=12.0}, Goods{name='lenovoMouse', price=34.0},Goods{name='microsoftMouse', price=43.0}, Goods{name='dellMouse', price=43.0},Goods{name='huaweiMouse', price=65.0}]
    }

public class Goods implements  Comparable{
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }

    //指明商品比较大小的方式:按照价格从低到高排序,再按照产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
//        System.out.println("**************");
        if(o instanceof Goods){
            Goods goods = (Goods)o;
            //方式一：
            if(this.price > goods.price){
                return 1;
            }else if(this.price < goods.price){
                return -1;
            }else{
//                return 0;
               return -this.name.compareTo(goods.name);
            }
            //方式二：
//           return Double.compare(this.price,goods.price);
        }
//        return 0;
        throw new RuntimeException("传入的数据类型不一致！");
    }
}

4.2 定制排序：java.util.Comparator

  • 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序。
  • 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
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
    @Test
    public void test(){
        Goods[] arr = new Goods[6];
        arr[0] = new Goods("lenovoMouse",34);
        arr[1] = new Goods("dellMouse",43);
        arr[2] = new Goods("xiaomiMouse",12);
        arr[3] = new Goods("huaweiMouse",65);
        arr[4] = new Goods("huaweiMouse",224);
        arr[5] = new Goods("microsoftMouse",43);

        Arrays.sort(arr, new Comparator() {
            //指明商品比较大小的方式:按照产品名称从低到高排序,再按照价格从高到低排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Goods && o2 instanceof Goods){
                    Goods g1 = (Goods)o1;
                    Goods g2 = (Goods)o2;
                    if(g1.getName().equals(g2.getName())){
                        return -Double.compare(g1.getPrice(),g2.getPrice());
                    }else{
                        return g1.getName().compareTo(g2.getName());
                    }
                }
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));
        //[Goods{name='dellMouse', price=43.0}, Goods{name='huaweiMouse', price=224.0}, Goods{name='huaweiMouse', price=65.0}, Goods{name='lenovoMouse', price=34.0}, Goods{name='microsoftMouse', price=43.0}, Goods{name='xiaomiMouse', price=12.0}]
    }

    @Test
    public void test(){
        String[] arr = new String[]{"AA","CC","KK","MM","GG","JJ","DD"};
        Arrays.sort(arr,new Comparator(){

            //按照字符串从大到小的顺序排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof  String){
                    String s1 = (String) o1;
                    String s2 = (String) o2;
                    return -s1.compareTo(s2);
                }
//                return 0;
                throw new RuntimeException("输入的数据类型不一致");
            }
        });
        System.out.println(Arrays.toString(arr));//[MM, KK, JJ, GG, DD, CC, AA]
    }

5、System类

  • System类代表系统，系统级的很多属性和控制方法都放置在该类的内部。该类位于java.lang包。
  • 由于该类的构造器是private的，所以无法创建该类的对象，也就是无法实例化该类。其内部的成员变量和成员方法都是static的，所以也可以很方便的进行调用。
  • 成员变量
    • System类内部包含in、out和err三个成员变量，分别代表标准输入流(键盘输入)，标准输出流(显示器)和标准错误输出流(显示器)。
  • 成员方法
    • native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
    • void exit(int status)：该方法的作用是退出程序。其中status的值为0代表正常退出，非零代表异常退出。使用该方法可以在图形界面编程中实现程序的退出功能等。
    • void gc()：该方法的作用是请求系统进行垃圾回收。至于系统是否立刻回收，则取决于系统中垃圾回收算法的实现以及系统执行时的情况。
    • String getProperty(String key)：该方法的作用是获得系统中属性名为key的属性对应的值。系统中常见
      的属性名以及属性的作用如下表所示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Test
public void test() {
    String javaVersion = System.getProperty("java.version");
    System.out.println("java的version:" + javaVersion);//java的version:1.8.0_202

    String javaHome = System.getProperty("java.home");
    System.out.println("java的home:" + javaHome);//java的home:/opt/jdk1.8.0_202/jre

    String osName = System.getProperty("os.name");
    System.out.println("os的name:" + osName);//os的name:Linux

    String osVersion = System.getProperty("os.version");
    System.out.println("os的version:" + osVersion);//os的version:4.15.0-30deepin-generic

    String userName = System.getProperty("user.name");
    System.out.println("user的name:" + userName);//user的name:zhu

    String userHome = System.getProperty("user.home");
    System.out.println("user的home:" + userHome);//user的home:/home/zhu

    String userDir = System.getProperty("user.dir");
    System.out.println("user的dir:" + userDir);
}