Java字符串相关的类

字符串相关的类

String的特性

• String类：代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
• String是一个final类，代表不可变的字符序列
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改
• String对象的字符内容是存储在一个字符数组value[]中的。
  

1. String实现了Serializable接口：表示字符串是支持序列化的。

   ​ 实现了Comparable接口：表示String可以比较大小

2. String内部定义了final char[] value用于存储字符串数据

3. String:代表不可变的字符序列。简称：不可变性。

   • 当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值。
   • 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
   • 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

4. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

5. 字符串常量池中是不会存储相同内容的字符串的。

举例代码

	@Test
    public void test1(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        System.out.println(s1 == s2);//比较s1和s2的地址值（true）
        s1 = "hello";	//重新赋值

        System.out.println(s1); //hello
        System.out.println(s2); //abc

        System.out.println("**************************");

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

        System.out.println("**************************");
        String s4 = "abc";
        String s5 = s4.replace('a', 'A');	//将'a'改成'A'
        System.out.println(s5); //Abc
        System.out.println(s4); //abc
        System.out.println(s2); //abc

    }

String的实例化方式

• 方式一：通过字面量定义的方式
• 方式二：通过new + 构造器的方式

举例代码

public class Person {
    String name;
    int age;

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

    public Person() {
    }
}

@Test
public void test2(){
    //通过字面量定义的方式：此时的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(s3 == s4);   //false
    System.out.println(s1 == s3);   //false

    System.out.println("********************************");
    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

    p1.name = "qwe";
    System.out.println(p2.name);    //Tom

}

内存解析

面试题

String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？

两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

字符串常量池和堆

1. 常量（字面量）与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2. 只要其中有一个是变量，结果就在堆中。
3. 如果拼接的结果调用intern()方法，返回值就在常量池中

@Test
public void test3(){
    String s1 = "javaEE";
    String s2 = "hadoop";

    String s3 = "javaEEhadoop";	//这样直接赋值的就是字面量
    String s4 = "javaEE" + "hadoop";	//字面量
    String s5 = s1 + "hadoop";
    String s6 = "javaEE" + 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使用的常量值中已经存在的“javaEEhadoop”
    System.out.println(s3 == s8);//true


}

只要是字面量的赋值方式就一定在常量池中声明，地址指向常量池，而且相同的字符串地址值一定相同

只要声明时涉及到变量的连接，就一定要在堆空间声明，地址指向堆空间，而且堆空间没一个new的地址都不可能相同

内存解析

String s1 = "hello";
s1 += "world";	//s1 = s1 + "world";

这里注意第二行的s1是在堆空间创建的，因为有变量的参与

面试题

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);
        System.out.println(ex.ch);
    }
}

输出如下：

good
best

这里是将StringTest里面的str的地址值（OX1122）传给了change方法形参的str（OX1122），然后把形参的str地址改成字符串"tesk ok"的地址（OX1122 —> OX2233），原来的StringTest里面的str地址没变（OX1122），方法结束时，堆空间的地址OX2233以及对应的字符串都被回收 ----->这里也体现了String的不可变性

String常用方法1

方法名	返回值类型	说明
length()	int	返回字符串的长度
charAt(int index)	char	返回某索引处的字符
isEmpty()	boolean	判断是否是空字符串
toLowerCase()	String	使用默认语言环境，将String中的所有字符转换为小写
toUpperCase()	String	使用默认语言环境，将String中的所有字符转换为大写
trim()	String	返回字符串的副本，忽略前导空白和尾部空白
equals(Object obj)	boolean	比较字符串的内容是否相同
equalsIsIgnoreCase(String anotherString)	boolean	与equlas方法类似，忽略大小写
concat(String str)	String	将指定字符串连接到此字符串的结尾。等价于用“+”
compareTo(String anotherString)	int	比较两个字符串的大小
subString(int beginIndex)	String	返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串
substring(int beginIndex, int endIndex)	String	返回一个新的字符串，它是此字符串从beginIndex开始截取到endIndex（不包含）的一个子字符串

举例代码：

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

compareTo()方法就是比较两个字符串对应的ASCLL码的大小，将调用方法的码减去形参的码作为返回值

String s8 = "Java核心技术";
String s9 = s8.substring(4);
System.out.println(s9); //核心技术
//左闭右开
String s10 = s8.substring(4, 6);	//[4,6)
System.out.println(s10);   //核心

String常用方法2

方法名	返回值类型	说明
endsWith(String suffix)	boolean	测试此字符串是否以指定的后缀结束
startsWith(String prefix)	boolean	测试此字符串是否以指定的前缀开始
startsWith(String prefix,int toffset)	boolean	测试此字符串从指定索引开始的子字符串是否以指定前缀开始
contains(CharSequence s)	boolean	当且仅当此字符串包含指定的char值序列时，返回true
indexOf(String str)	int	返回指定子字符串在此字符串中第一次出现处的索引
indexOf(String str,int fromIndex)	int	返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
lastIndexOf(String str)	int	返回指定子字符串在此字符串中最右边出现的索引
lastIndexOf(String str,int fromIndex)	int	返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

indexOf和lastIndexOf方法如果未找到都是返回-1

什么情况下，indexOf(str)和lastIndexOf(str)返回值相同？

• 存在唯一的一个str
• 不存在str

String常用方法3

替换：

方法名	返回值类型	说明
replace(char oldChar,char newChar)	String	返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的
replace(CharSequence target,CharSequence replacement)	String	使得用指定的字面量值替换序列替换此字符串所有匹配字面值目标序列的子字符串
replaceAll(String regex,String replacement)	String	使得给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串
replaceFirst(String regex,String replacement)	String	使得给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串

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

匹配：

• boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式

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

切片：

• String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串
• String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

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]);
}

输出如下：

hello
world
java

hello
world
java

String与字符数组转换

字符串 —> 字符数组

• public char[] toCharArray()：将字符串中的全部字符存放在一个字符数组中的方法

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

输出如下：

h
e
l
l
o
J
a
v
a

• public void getChars(int start,int end,char c[],int offset)：该方法的作用是将当前字符串从start到end-1位置上的字符复制到字符数组c中，并从c的offset处开始存放

public class StringTest {
    public static void main(String[] args) {

        String str1 = "关于我转生变成史莱姆这档事";
        char[] chars = new char[str1.length()];
        char[] chars1 = new char[str1.length()];

        str1.getChars(3,10,chars,0);
        System.out.println(chars);

        str1.getChars(2,11,chars,3);
        System.out.println(chars);

        str1.getChars(2,11,chars1,3);
        System.out.println(chars1);
    }
}

输出如下：

转生变成史莱姆      
转生变我转生变成史莱姆这 
   我转生变成史莱姆这

字符数组 —> 字符串

• String类的构造器：String(char[])和String(char[],int offset,int count)分别用字符数组中的全部字符和部分字符创建字符串对象

public class StringTest {
    public static void main(String[] args) {
        char[] chars = new char[]{'h','e','l','l','0'};

        String s = new String(chars);
        System.out.println(s);

        String s1 = new String(chars, 2, 3);
        System.out.println(s1);
    }
}

输出如下：

hell0
ll0

这里的offset是开始截取的索引位，count表示截取的个数而不是最后的索引位，截取多了就会报StringIndexOutOfBoundsException（字符串索引超出范围）

String与字节数组转换

字符串 —> 字节数组

• public byte[] getBytes()：使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中

import java.util.Arrays;

public class StringTest {
    public static void main(String[] args) {
        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-8，可以看到一个汉字要用三个字节表示

• public byte[] getBytes(String charsetName)：使用指定的字符集将此String编码到byte序列，并将结果存储到新的byte数组

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringTest {
    public static void main(String[] args) {
        String str1 = "abc123中国";
        try {
            byte[] bytes = str1.getBytes("gbk");
            System.out.println(Arrays.toString(bytes));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }
}

输出如下：

[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]

这里使用的gbk编码集，一个汉字用两个字节表示

字节数组 —> 字符串

• String(byte[])：通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

String str1 = "abc123中国";
byte[] bytes = str1.getBytes();

String s = new String(bytes);
System.out.println(s);  //abc123中国

• String(byte[] bytes,String charsetName)：使用指定的字符编码集将byte序列解码到String，并将结果给到新new的String对象中

@Test
public void test() throws UnsupportedEncodingException {
    String str1 = "abc123中国";

    byte[] gbks = str1.getBytes("gbk");

    String s = new String(gbks);
    System.out.println(s);  //abc123�й�

    String s1 = new String(gbks, "gbk");
    System.out.println(s1); //abc123中国
}

解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

• String(byte[]，int offset，int length) ：用指定的字节数组的一部分， 即从数组起始位置offset开始取length个字节构造一个字符串对象

@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]

    String s = new String(bytes, 3, 9);
    System.out.println(s);  //123中国
}

上面从第三个往后取九位：49, 50, 51, -28, -72, -83, -27, -101, -67

补充：

• 编码：字符串 —> 字节 （看得懂的 —> 看不懂的二进制数据）
• 解码：编码的逆过程，字节 —> 字符串 （看不懂的二进制数据 —> 看得懂的）

常见算法题目

其他答案见文件夹String常用类下的StringExer.java

• 模拟一个trim方法，去除字符串两端的空格。

• 将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反 转为”abfedcg”

//方式一：转换为char[]
public String reverse(String str,int startIndex,int endIndex){

    if(str != null){
        char[] arr = str.toCharArray();
        for(int x = startIndex,y = endIndex;x < y;x++,y--){
            char temp = arr[x];
            arr[x] = arr[y];
            arr[y] = temp;
        }

        return new String(arr);
    }
    return null;
}

//方式二：使用String的拼接
public String reverse1(String str,int startIndex,int endIndex){
    if(str != null){
        //第1部分
        String reverseStr = str.substring(0,startIndex);
        //第2部分
        for(int i = endIndex;i >= startIndex;i--){
            reverseStr += str.charAt(i);
        }
        //第3部分
        reverseStr += str.substring(endIndex + 1);

        return reverseStr;

    }
    return null;
}
//方式三：使用StringBuffer/StringBuilder替换String
public String reverse2(String str,int startIndex,int endIndex){
    if(str != null){
        StringBuilder builder = new StringBuilder(str.length());

        //第1部分
        builder.append(str.substring(0,startIndex));
        //第2部分
        for(int i = endIndex;i >= startIndex;i--){

            builder.append(str.charAt(i));
        }
        //第3部分
        builder.append(str.substring(endIndex + 1));

        return builder.toString();
    }
    return null;

}

• 获取一个字符串在另一个字符串中出现的次数。 比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数

public int getCount(String mainStr,String subStr){
    int mainLength = mainStr.length();
    int subLength = subStr.length();
    int count = 0;
    int index = 0;
    if(mainLength >= subLength){
        //方式一：
//            while((index = mainStr.indexOf(subStr)) != -1){
//                count++;
//                mainStr = mainStr.substring(index + subStr.length());
//            }
        //方式二：对方式一的改进
        while((index = mainStr.indexOf(subStr,index)) != -1){
            count++;
            index += subLength;
        }

        return count;
    }else{
        return 0;
    }
}

• **获取两个字符串中最大相同子串。比如： str1 = "abcwerthelloyuiodef“;str2 = “cvhellobnm” **
  • 提示：将短的那个串进行长度依次递减的子串与较长的串比较。

//前提：两个字符串中只有一个最大相同子串
public String getMaxSameString(String str1, String str2) {
    if (str1 != null && str2 != null) {
        String maxStr = (str1.length() >= str2.length()) ? str1 : str2;
        String minStr = (str1.length() < str2.length()) ? str1 : str2;
        int length = minStr.length();

        for (int i = 0; i < length; i++) {
            for (int x = 0, y = length - i; y <= length; x++, y++) {
                String subStr = minStr.substring(x, y);
                if (maxStr.contains(subStr)) {
                    return subStr;
                }
            }
        }
    }

    return null;
}

// 如果存在多个长度相同的最大相同子串
// 此时先返回String[]，后面可以用集合中的ArrayList替换，较方便
public String[] getMaxSameString1(String str1, String str2) {
    if (str1 != null && str2 != null) {
        StringBuffer sBuffer = new StringBuffer();
        String maxString = (str1.length() > str2.length()) ? str1 : str2;
        String minString = (str1.length() > str2.length()) ? str2 : str1;

        int len = minString.length();
        for (int i = 0; i < len; i++) {
            for (int x = 0, y = len - i; y <= len; x++, y++) {
                String subString = minString.substring(x, y);
                if (maxString.contains(subString)) {
                    sBuffer.append(subString + ",");
                }
            }
//                System.out.println(sBuffer);
            if (sBuffer.length() != 0) {
                break;
            }
        }
        String[] split = sBuffer.toString().replaceAll(",$", "").split("\\,");
        return split;
    }

    return null;
}

• 对字符串中字符进行自然顺序排序。提示：
  1. 字符串变成字符数组。
  2. 对数组排序，选择，冒泡，Arrays.sort();
  3. 将排序后的数组变成字符串。

自己写的：

package java0;

public class StringTest {
    public static void main(String[] args) {
        String str0 = null;
        String str = "     abc   cde s   ";
        String s = StringTool.simulateTrim(str);
        System.out.println("---" + s + "---");  //---abc   cde s---
        String s1 = StringTool.simulateTrim(str0);
        System.out.println(s1); //null

        System.out.println("**************************************************");

        String string = "abcdefghijklmn";
        String s2 = StringTool.simulateReversal(string, 3, 7);
        System.out.println(s2); //abchgfedijklmn

        System.out.println("*****************************************************");

        String s3 = "abkkcadkabkebfkabkskab";
        String s4 = "ab";
        int i = StringTool.method3(s3, s4);
        System.out.println(i);  //4

        System.out.println("******************************************************");

    }
}

class StringTool {

    //模拟一个trim方法，去除字符串两端的空格
    public static String simulateTrim(String str) {
        if (str == null) {
            return null;
        }
        String string = null;
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] != ' ') {
                string = str.substring(i);
                break;
            }
        }
        char[] chars1 = string.toCharArray();
        for (int i = chars1.length - 1; i > 0; i--) {
            if (chars1[i] != ' ') {
                string = string.substring(0, i + 1);
                break;
            }
        }

        return string;
    }

    //    将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反 转为”abfedcg”
    public static String simulateReversal(String string, int start, int end) {
        if (start > end) {
            throw new RuntimeException("输入的start必须不大于end！！！！");
        }

        if (string == null | start == end) {
            return string;
        }

        char[] chars = string.toCharArray();
        while (true) {
            if (start < end) {
                char temp = chars[start];
                chars[start] = chars[end];
                chars[end] = temp;
                start++;
                end--;
            } else {
                break;
            }
        }
        return new String(chars);
    }

    //获取一个字符串在另一个字符串中出现的次数。
    // 比如：获取“ ab”在 “abkkcadkabkebfkabkskab” 中出现的次数
    public static int method3(String subjectString, String subString) {
        if (subjectString.length() < subString.length()) {
            return 0;
        }

        int total = 0;
        while (true) {
            int i = subjectString.indexOf(subString);
            if (i >= 0) {
                total++;
                String substring = subjectString.substring(i + subString.length());
                subjectString = substring;
            } else {
                break;
            }
        }


        return total;
    }

    //获取两个字符串中最大相同子串。比如： str1 = "abcwerthelloyuiodef“;str2 = "cvhellobnm"
    //提示：将短的那个串进行长度依次递减的子串与较长的串比较。
    public static String maxString(String str1, String str2) {
        if (str1 == null || str2 == null) {
            return null;
        }

        String shortString = (str1.length() >= str2.length()) ? str2 : str1;
        String longString = (str1.length() >= str2.length()) ? str1 : str2;

        int length = shortString.length();

        for (int i = 0;i < length;i++){

        }

        return null;
    }
}

StringBuffer类

• java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象
• 很多方法与String相同
• 作为参数传递时，方法内部可以改变值

String与StringBuffer、StringBuilder之间的转换

String —> StringBuffer、StringBuilder：调用StringBuffer、StringBuilder的构造器

StringBuffer、StringBuilder —> String：① 调用String构造器 ② 调用StringBuffer、StringBuilder的toString()方法

源码分析：

String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//0
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

StringBuffer构造器：

    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

提前设置好底层char数组的容量

length()：

    @Override
    public synchronized int length() {
        return count;
    }

这里的length()返回的不是数组的长度（value.length()），而是返回实际存储的个数count

---

面试题：

String、StringBuffer、StringBuilder三者的异同？

• **相同点：**底层使用char[]存储
• 不同点
  1. String:不可变的字符序列
  2. StringBuffer:可变的字符序列；线程安全的，效率低
  3. StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高

**三者的效率：**从高到低排列：StringBuilder > StringBuffer > String

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() ：把当前字符序列反转

以上方法支持方法链操作：例如str.append(abc).append(def).delete(3,5)

有返回值的：

• 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)

总结：

• 增：append(xxx)
• 删：delete(int start,int end)
• 改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
• 查：charAt(int n )
• 插：insert(int offset, xxx)
• 长度：length();
• *遍历：for() + charAt() / toString()

面试题：

String str = null; 
StringBuffer sb = new StringBuffer(); 
sb.append(str);
System.out.println(sb.length());//
System.out.println(sb);//
StringBuffer sb1 = new StringBuffer(str); 
System.out.println(sb1);//

输出如下：

4
null
Exception in thread "main" java.lang.NullPointerException

如下图可知方法append的源码对于添加空字符串做了特殊处理，会将null这四个字符存放在数组中，所以长度增加4，数组中的内容为‘n’ ‘u’ ‘l’ ‘l’，构造器StringBuffer(str)中执行的操作为super(str.length()+16) 此时的str是空，用空来调用length()方法，所以会出现空指针异常

JDK8之前日期时间API

java.lang.System类

System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。 ----> 此方法适于计算时间差。

• 计算世界时间的主要标准有：
  • UTC(Coordinated Universal Time)
  • GMT(Greenwich Mean Time)
  • CST(Central Standard Time)

long time = System.currentTimeMillis();	//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
//称为时间戳
System.out.println(time);   //1611804185655

---

java.util.Date类

表示特定的瞬间，精确到毫秒

• 构造器：
  • Date()：使用无参构造器创建的对象可以获取本地当前时间。
  • Date(long date) ：创建指定毫秒数的Date对象
• 常用方法 ：
  • toString():把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准。 (默认方法)
  • getTime():返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

Date date = new Date();
System.out.println(date.toString());    //Sat Mar 27 23:11:58 CST 2021
System.out.println(date.getTime());		//1616857918641

---

java.sql.Date类

是java.util.Date的子类

• 在同时有util下的Date对象和sql下的Date对象，需要写全类名

java.sql.Date date = new java.sql.Date(1611814587077L);
System.out.println(date);   //2021-01-28

• 将java.util.Date对象转换为java.sql.Date对象

Date date6 = new Date();
java.sql.Date date7 = new java.sql.Date(date6.getTime());

• 将一个字符串转换成Java.sql.Date对象
  1. 先将字符串转成util下的Date
  2. 再将util转成sql下的Date

String birth = "2020-09-08";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf.parse(birth);   //util下的Date

java.sql.Date birthDate = new java.sql.Date(date.getTime());
System.out.println(birthDate);  //sql下的Date

---

java.text.SimpleDateFormat类

Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat 类是一个不与语言环境有关的方式来格式化和解析日期的具体类

• **格式化：**日期 —> 字符串
  • SimpleDateFormat() ：默认的模式和语言环境创建对象
  • public SimpleDateFormat(String pattern)：该构造方法可以用**参数pattern** 指定的格式创建一个对象，该对象调用
  • public String format(Date date)：方法格式化时间对象date
• 解析： 字符串 —> 日期
  • public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。

代码举例：

@Test
public void testSimpleDateFormat() throws ParseException {
    //实例化SimpleDateFormat:使用默认的构造器
    SimpleDateFormat sdf = new SimpleDateFormat();

    Date date = new Date();
    System.out.println(date);   //Sat Jan 30 10:52:17 CST 2021

    //格式化：日期 ---> 字符串
    String format = sdf.format(date);
    System.out.println(format); //21-1-30 上午10:52

    //解析：格式化的逆过程，字符串 ---> 日期
    String str = "21-1-30 上午10:52";
    Date date1 = sdf.parse(str);
    System.out.println(date1);  //Sat Jan 30 10:52:00 CST 2021

    //********************按照指定的方式进行格式化和解析：调用带参数的构造器******************
    //格式化
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss aaa");
    String format1 = sdf1.format(date);
    System.out.println(format1);    //2021-01-30 12:28:18 下午

    //解析:要求字符串必须是符合SimpleDateFormat识别的格式（通过构造器参数体现），否则就会抛异常
    Date date2 = sdf1.parse("2021-01-30 12:28:18 下午");
    System.out.println(date2);  //Sat Jan 30 12:28:18 CST 2021
}

参数pattern：

三天打鱼两天晒网

public class DateTest {
    public static void main(String[] args) {
        try {
            Date.getShow("2020-09-09");
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

class Date{

    public static void getShow(String string) throws ParseException {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        java.util.Date parse = simpleDateFormat.parse(string);
        System.out.println("string = " + parse.getTime());

        java.util.Date parse1 = simpleDateFormat.parse("1990-01-01");
        System.out.println("1990-01-01 = "+ parse1.getTime());

        int allDay = (int)((parse.getTime() - parse1.getTime())/(1000 * 60 * 60 * 24) + 1);

        switch (allDay % 5){
            case 0:
                System.out.println("晒网");
                break;
            case 1:
                System.out.println("打鱼");
                break;
            case 2:
                System.out.println("打鱼");
                break;
            case 3:
                System.out.println("打鱼");
                break;
            case 5:
                System.out.println("晒网");
                break;
        }
    }
}

java.util.Calendar(日历)类

• Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。

• 实例化Calendar的方法

  • 使用Calendar.getInstance()方法 —>其实使用这种方法返回的是Calendar对象，但是实际还是new的子类GregorianCalendar对象
  • 调用它的子类GregorianCalendar的构造器

• 常用方法

  • publc int get(int field)：获取想要的时间信息
  • public void set(int field,int value)：修改时间信息
  • public void add(int field,int amount)：在已有的时间信息进行加减操作
  • public final Date getTime()：Calendar类 —> Date
  • public final void setTime(Date date)：Date —> Calendar类

• 获取的常用信息有：

  • YEAR：返回当前的年
  • MONTH：返回当前的月
  • DAY_OF_WEEK：返回本日在这周的第几天
  • HOUR_OF_DAY ：返回现在是今天的第几个小时
  • MINUTE：返回当前的分钟数
  • SECOND：返回当前的秒数

package java0;

import java.util.Calendar;
import java.util.Date;

/**
 * @author YANG
 * @create 2021-04-01 11:03
 */
public class CalendarTest {
    public static void main(String[] args) {
        //实例化
        Calendar instance = Calendar.getInstance();

        //这里说明了用Calendar.getInstance()方式返回的对象是GregorianCalendar
        System.out.println(instance.getClass());    //class java.util.GregorianCalendar

        int date = instance.get(Calendar.DATE);
        System.out.println("今天是这个月的第" + date + "天");

        int dayMonth = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println("今天是这个月的第" + date + "天(和DATE一个意思)");

        int dayWeek = instance.get(Calendar.DAY_OF_WEEK);
        System.out.println("今天是这周的第" + dayWeek + "天");

        int dayWeekMonth = instance.get(Calendar.DAY_OF_WEEK_IN_MONTH);
        System.out.println("这个星期是这个月的第" + dayWeekMonth + "周");

        int dayYear = instance.get(Calendar.DAY_OF_YEAR);
        System.out.println("今天是今年的第" + dayYear + "天");

        int hourDay = instance.get(Calendar.HOUR_OF_DAY);
        System.out.println("现在是今天的第" + hourDay + "个小时");

        int year = instance.get(Calendar.YEAR);
        System.out.println("今年是" + year + "年");

        int millisecond = instance.get(Calendar.MILLISECOND);
        System.out.println("获取当前毫秒数：" + millisecond);

        int month = instance.get(Calendar.MONTH);
        System.out.println("获取当前月份：" + month);

        int second = instance.get(Calendar.SECOND);
        System.out.println("获取当前的秒数："+second);

        int minute = instance.get(Calendar.MINUTE);
        System.out.println("返回当前的分钟："+minute);

        //******************************************************
        instance.set(Calendar.MONTH,2);
        int month1 = instance.get(Calendar.MONTH);
        System.out.println("修改后的月份为："+month1);

        //******************************************************
        Date time = instance.getTime();
        System.out.println(time);   //Mon Mar 01 11:47:07 CST 2021

        Date date1 = new Date();
        instance.setTime(date1);
        int i = instance.get(Calendar.MONTH);
        System.out.println(i);  //3

    }
}

• 注意
  • 获取月份时：一月是0，二月是1，以此类推，12月是11
  • 获取星期时：周日是1，周二是2 ， 。。。。周六是7

JDK8中新日期时间API

• 引入新的API的原因：原来的API的缺陷

  • 可变性：像日期和时间这样的类应该是不可变的
  • 偏移性：Date中的年份是从1900开始的，而月份都从0开始
  • 格式化：格式化只对Date有用，Calendar则不行。
  • 此外，它们也不是线程安全的；不能处理闰秒等

• 新时间日期API

  • java.time – 包含值对象的基础包 （常用）
  • java.time.chrono – 提供对不同的日历系统的访问
  • java.time.format – 格式化和解析时间和日期 （常用）
  • java.time.temporal – 包括底层框架和扩展特性
  • java.time.zone – 包含时区支持的类

LocalDate、LocalTime、LocalDateTime类

• LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。 它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。
  • LocalDate代表IOS格式（yyyy-MM-dd）的日期
  • LocalTime表示一个时间，而不是日期
  • LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。

常用方法：

方法名	描述
now()/*now(Zoneld zone)	静态方法，根据当前时间创建对象/指定时区的对象
of()	静态方法，根据指定日期/时间创建对象
getDayOfMonth()/getDayOfYear()	获取月份天数（1-31）/获取年份天数（1-366）
getDayOfWeek()	获取星期几（返回一个DayOfWeek枚举类）
getMonth()	获取月份，返回一个Month枚举值
getMonthValue()/getYear()	获取月份（1-12）/获取年份
getHour()/getMinute()/getSecond()	获取当前对象对应的小时、分钟、秒
withDayOfMonth()/withDayOfYear()/withMonth()/withYear()	将月份天数、年数天数、月份、年份修改为指定的值并返回新的对象
plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()	向当前对象添加几天、几周、几个月、几年、几小时
minusMonths() / minusWeeks()/ minusDays()/minusYears()/minusHours()	从当前对象减去几月、几周、几天、几年、几小时

代码举例：

//now():获取当前的日期、时间、时间+日期
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();

System.out.println(localDate);  //2021-02-20
System.out.println(localTime);  //15:53:38.542
System.out.println(localDateTime);  //2021-02-20T15:53:38.542

//of():设置指定的年、月、日、时、分、秒。没有偏移量
LocalDateTime localDateTime1 = LocalDateTime.of(1999, 2, 20, 15, 58, 58);
System.out.println(localDateTime1); //1999-02-20T15:58:58

//getXxx()：获取相关属性
System.out.println(localDateTime.getDayOfMonth());  //20
System.out.println(localDateTime.getDayOfWeek());   //SATURDAY
System.out.println(localDateTime.getDayOfYear());   //51
System.out.println(localDateTime.getMinute());      //4

//体现了LocalDate、LocalTime、LocalDateTime的不可变性
//withXxx():设置相关属性
LocalDate localDate1 = localDate.withDayOfMonth(21);
System.out.println(localDate);  //2021-02-20
System.out.println(localDate1); //2021-02-21

LocalTime localTime1 = localTime.withHour(2);
System.out.println(localTime);  //16:14:07.550
System.out.println(localTime1); //02:14:07.550

//不可变性
LocalDateTime localDateTime2 = localDateTime.plusMonths(1);
System.out.println(localDateTime);  //2021-02-20T16:17:50.190
System.out.println(localDateTime2); //2021-03-20T16:17:50.190

---

瞬时：Instant

• Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳
• 在处理时间和日期的时候，我们通常会想到年,月,日,时,分,秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，或者说是连续的。在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机处理。在UNIX中，这个数从1970年开始，以秒为的单位；同样的，在Java中，也是从1970年开始，但以毫秒为单位。
• **java.time包通过值类型Instant提供机器视图，不提供处理人类意义上的时间单位。**Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。 概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。因为java.time包是基于纳秒计算的，所以Instant的精度可以达到纳秒级。

方法名	描述
now()	静态方法，返回默认UTC时区的Instant类的对象
ofEpochMilli(long epochMilli)	静态方法，返回在1970-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象
atOffset(ZoneOffset offset)	结合即时的偏移来创建一个 OffsetDateTime
toEpochMilli()	返回1970-01-01 00:00:00到当前时间的毫秒数，即为时间戳

代码举例：

//now():获取本初子午线对应的标准时间
Instant instant = Instant.now();
System.out.println(instant);    //2021-04-01T08:07:41.997Z

//添加时间的偏移量
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime); //2021-04-01T16:07:41.997+08:00

//toEpochMilli():获取当前时间的毫秒数
long milli = instant.toEpochMilli();
System.out.println(milli);  //1617264461997
long l = offsetDateTime.toEpochSecond();
System.out.println(l);  //1617264461

//ofEpochMilli(long epochMilli)
Instant instant1 = Instant.ofEpochMilli(milli);
System.out.println(instant1);   //2021-04-01T08:07:41.997Z

---

java.time.format.DateTimeFormatter类

• 功能：格式化与解析日期或时间
• 三种格式化方法
  • 预定义的标准格式。如： ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
  • 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
  • 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”) —> 常用

常用方法：

方法	描述
ofPattern(String pattern)	静态方法， 返 回 一 个 指 定 字 符 串 格 式 的 DateTimeFormatter
format(TemporalAccessor t)	格式化一个日期、时间，返回字符串
parse(CharSequence text)	将指定格式的字符序列解析为一个日期、时间

代码举例：

//      实例化方式一：
//        预定义的标准格式。如： ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
DateTimeFormatter isoLocalDateTime = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

LocalDateTime now = LocalDateTime.now();
//格式化：日期 ---> 字符串
String format = isoLocalDateTime.format(now);
System.out.println("格式化前："+ now);   //格式化前：2021-04-01T16:25:23.458
System.out.println("格式化后："+ format);    //格式化后：2021-04-01T16:25:23.458

//解析：字符串 ---> 日期
TemporalAccessor parse = isoLocalDateTime.parse("2021-04-01T16:25:23.458");
System.out.println(parse);  //{},ISO resolved to 2021-04-01T16:25:23.458



//          实例化方式二：
//        本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
//FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDateTime
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
DateTimeFormatter dateTimeFormatter3 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
LocalDateTime now1 = LocalDateTime.now();
//格式化
String format1 = dateTimeFormatter.format(now1);
String format2 = dateTimeFormatter2.format(now1);
String format3 = dateTimeFormatter3.format(now1);
System.out.println("格式化前：" + now1); //格式化前：2021-04-01T18:48:18.278
System.out.println("FormatStyle.MEDIUM格式化后：" + format1);    //FormatStyle.MEDIUM格式化后：2021-4-1 18:48:18
System.out.println("FormatStyle.SHORT格式化后：" + format2);    //FormatStyle.SHORT格式化后：21-4-1 下午7:07
System.out.println("FormatStyle.LONG格式化后：" + format3);    //FormatStyle.LONG格式化后：2021年4月1日 下午07时07分07秒

//解析
TemporalAccessor parse1 = dateTimeFormatter.parse(format1);
System.out.println(parse1); //{},ISO resolved to 2021-04-01T18:49:42


//      本地化相关的格式。如：ofLocalizedDate()
//      FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
//格式化
String format4 = dateTimeFormatter1.format(LocalDate.now());
System.out.println(format4);    //2021年4月1日 星期四
//解析
TemporalAccessor parse2 = dateTimeFormatter1.parse(format4);
System.out.println(parse2); //{},ISO resolved to 2021-04-01


//      重点：  自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)
DateTimeFormatter dateTimeFormatter4 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
String format5 = dateTimeFormatter4.format(LocalDateTime.now());
System.out.println(format5);    //2021-04-01 07:55:27
//解析
TemporalAccessor parse3 = dateTimeFormatter4.parse(format5);
System.out.println(parse3); //{SecondOfMinute=54, NanoOfSecond=0, MicroOfSecond=0, HourOfAmPm=8, MinuteOfHour=15, MilliOfSecond=0},ISO resolved to 2021-04-01

Java比较器

• Java实现对象排序的方式有两种

  • 自然排序：java.lang.Comparable
  • 定制排序：java.util.Comparator

• Comparable接口与Comparator的使用的对比：

  • Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
  • Comparator接口属于临时性的比较。

---

方式一：自然排序：java.lang.Comparable

• 像String、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式：进行了从小到大的排列

String代码举例：

String[] arr = new String[]{"AA","QQ","WW","RR","TT","aa","ss","BB"};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));   //[AA, BB, QQ, RR, TT, WW, aa, ss]

• 对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo(obj)方法在compareTo(obj)方法中指明如何排序
• 重写compareTo(obj)的规则：
  • 如果当前对象this大于形参对象obj，则返回正整数，
  • 如果当前对象this小于形参对象obj，则返回负整数，
  • 如果当前对象this等于形参对象obj，则返回零。

自定义类代码举例：

public class Goods implements Comparable{

    //按价格从低到高排序,再按照产品名称从高到低排序
    @Override
    public int compareTo(Object o) {
        if (o instanceof Goods){
            Goods o1 = (Goods)o;

            //方式一
            if (this.price > o1.price){
                return 1;
            }else if (this.price < o1.price){
                return -1;
            }else {
//                return 0;
                //这里加-号就是反向排序
                return -this.name.compareTo(o1.name);//这里没有递归是因为name是String类型的，所以使用的是String类里面的compare方法
            }

            //方式二
//            return Integer.compare(this.price,o1.price);
        }
        throw new RuntimeException("输入的类型不匹配！！！");
    }

    private String name;
    private int price;

    public Goods() {
    }

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

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

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

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }

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


}

Goods[] goods = new Goods[5];
goods[0] = new Goods("lenovoMonse",34);
goods[1] = new Goods("dellMonse",43);
goods[2] = new Goods("xiaomiMonse",12);
goods[3] = new Goods("huaweiMonse",65);
goods[4] = new Goods("zuaweiMonse",43);

Arrays.sort(goods);

System.out.println(Arrays.toString(goods)); //自定义类里没有重写compareTo()方法前：java.lang.ClassCastException
//重写了compareTo()方法后输出：[Goods{name='xiaomiMonse', price='12'}, Goods{name='lenovoMonse', price='34'},
// Goods{name='zuaweiMonse', price='43'}, Goods{name='dellMonse', price='43'},
// Goods{name='huaweiMonse', price='65'}]

• Comparable 的典型实现：(默认都是从小到大排列的)
  • String：按照字符串中字符的Unicode值进行比较
  • Character：按照字符的Unicode值来进行比较
  • 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值 大小进行比较
  • Boolean：true 对应的包装类实例大于 false 对应的包装类实例
  • Date、Time等：后面的日期时间比前面的日期时间大

方式二：定制排序：java.util.Comparator

• 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码， 或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那 么可以考虑使用Comparator 的对象来排序，强行对多个对象进行整体排序的比较。

  • 这里没有实现Comparable接口的类型是除了String和包装类以外的

• 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：

  • 如果方法返回正整数，则表示o1大于o2；
  • 如果返回0，表示相等；
  • 返回负整数，表示o1小于o2。

• 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort）， 从而允许在排序顺序上实现精确控制。

• 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的 顺序，或者为那些没有自然顺序的对象 collection 提供排序。

代码举例：

Goods[] goods = new Goods[6];
goods[0] = new Goods("lenovoMonse",34);
goods[1] = new Goods("dellMonse",43);
goods[2] = new Goods("xiaomiMonse",12);
goods[3] = new Goods("huaweiMonse",65);
goods[4] = new Goods("huaweiMonse",224);
goods[5] = new Goods("zuaweiMonse",43);

Arrays.sort(goods, new Comparator() {
    //指明商品比较大小的方式：按照产品名称从低到高排序，再按照价格从高到低排序
    @Override
    public int compare(Object o1, Object o2) {
        if (o1 instanceof Goods && o2 instanceof Goods){
            Goods goods1 = (Goods)o1;
            Goods goods2 = (Goods)o2;
            if (goods1.getName().equals(goods2.getName())){
                return -Integer.compare(goods1.getPrice(), goods2.getPrice());
            }else{
                return goods1.getName().compareTo(goods2.getName());
            }

        }
        throw new RuntimeException("输入的类型不匹配！！！");
    }

});

System.out.println(Arrays.toString(goods)); //[Goods{name='dellMonse', price='43'},
// Goods{name='huaweiMonse', price='224'}, Goods{name='huaweiMonse', price='65'},
// Goods{name='lenovoMonse', price='34'}, Goods{name='xiaomiMonse', price='12'},
// Goods{name='zuaweiMonse', price='43'}]

上面重写的compare()一定要注意不能递归调用：在compare里又调用了compare方法

-Integer.compare：这里是用的Integer包装类里的compare()方法

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的属性对应的值。系统中常见 的属性名以及属性的作用如下表所示：

代码举例：

String javaVersion = System.getProperty("java.version"); 
System.out.println("java的version:" + javaVersion);
String javaHome = System.getProperty("java.home"); 
System.out.println("java的home:" + javaHome);
String osName = System.getProperty("os.name"); 
System.out.println("os的name:" + osName);
String osVersion = System.getProperty("os.version"); 
System.out.println("os的version:" + osVersion);
String userName = System.getProperty("user.name"); 
System.out.println("user的name:" + userName);
String userHome = System.getProperty("user.home"); 
System.out.println("user的home:" + userHome);
String userDir = System.getProperty("user.dir"); 
System.out.println("user的dir:" + userDir);

输出如下：

java的version:1.8.0_131
java的home:E:\developTools\Java\jdk1.8.0_131\jre
os的name:Windows 10
os的version:10.0
user的name:17527
user的home:C:\Users\17527
user的dir:E:\Project\java\IdeaProjects\workspace_idea1\JavaSenior\day04

Math类

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回值类型一般为double型。

• abs 绝对值
• acos,asin,atan,cos,sin,tan 三角函数
• sqrt 平方根
• pow(double a,doble b) a的b次幂
• log 自然对数
• exp e为底指数
• max(double a,double b)
• min(double a,double b)
• random() 返回0.0到1.0的随机数
• long round(double a) double型数据a转换为long型（四舍五入）
• toDegrees(double angrad) 弧度—>角度
• toRadians(double angdeg) 角度—>弧度

BigInteger与BigDecimal

• java.math包的BigInteger可以表示不可变的任意精度的整数。

• 常用方法

  • public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger
  • BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
  • BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
  • BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
  • BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数 相除只保留整数部分。
  • BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger
  • BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
  • BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

• BigDecimal类支持不可变的、任意精度的有符号十进制定点数。

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中， 要求数字精度比较高，故用到java.math.BigDecimal类。

BigInteger bi = new BigInteger("1243312314254325364364765241123");
BigDecimal bd = new BigDecimal("12435.351");
BigDecimal bd2 = new BigDecimal("11");
System.out.println(bi); //1243312314254325364364765241123
// System.out.println(bd.divide(bd2));	//报错
 System.out.println(bd.divide(bd2, BigDecimal.ROUND_HALF_UP));  //1130.486
 System.out.println(bd.divide(bd2, 15, BigDecimal.ROUND_HALF_UP));  //1130.486454545454545

上面的ROUND_HALF_UP表示四舍五入