[Java知识库]【Java】常用类

一、字符串相关的类

1.String的特性

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

2.String的对象的创建

• 方式一：通过字面量定义的方式
  字符串常量存储在字符串常量池，目的是共享。
• 方式二：通过new + 构造器的方式
  字符串非常量对象存储在堆中。
• 结论：
  ?1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
  ?2.只要其中有一个是变量，结果就在堆中。
  ?3.如果拼接的结果调用intern()方法，返回值就在常量池中

/**
 * String的使用
 */
public class StringTest {

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

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

        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(s2);

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

        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }
    /*
    String的实例化方式：
    方式一：通过字面量定义的方式
    方式二：通过new + 构造器的方式

     面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
            两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

     */
    @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(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//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 = "Jerry";
        System.out.println(p2.name);//Tom
    }

    @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

    }

    /*
    结论：
    1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
    2.只要其中有一个是变量，结果就在堆中。
    3.如果拼接的结果调用intern()方法，返回值就在常量池中
     */
    @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true

    }

}

/**
?* 一道面试题
?*/
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
? ? }
}

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()：返回字符串的副本，忽略前导空白和尾部空白
• 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(不包含)的一个子字符串。（左闭右开）
• boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
• boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
• int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引（KMP算法）
• int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
• int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
• int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始 反向搜索

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

4.String与其他类型转换

• 字符串 ?→?基本数据类型、包装类
  • Integer包装类的public static int parseInt(String s)：可以将由“数字”字符组成的字符串转换为整型。
  • 类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串，转化为相应的基本数据类型。
• 基本数据类型、包装类 →?字符串
  • 调用String类的public String valueOf(int n)可将int型转换为字符串
  • 相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(double d)、valueOf(boolean b)可由参数的相应类型到字符串的转换
• 字符数组 →? 字符串
  • String 类的构造器： String(char[]) 和 String(char[] ， int offset ， int length) 分别用字符数组中的全部字符和部分字符创建字符串对象。
• 字符串 →? 字符数组
  • public char[] toCharArray() ： 将字符串中的全部字符存放在一个字符数组中的方法。
  • public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：提供了将指定索引范围内的字符串存放到数组中的方法。
• 字节数组? → 字符串
  • String(byte[]) ： 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String 。
  • String(byte[] ， int offset ， int length) ：用指定的字节数组的一部分，即从数组起始位置offset开始取length个字节构造一个字符串对象。
• 字符串 →? 字节数组
  • public byte[] getBytes() ： 使用平台的默认字符集将此 String 编码为byte 序列，并将结果存储到一个新的 byte 数组中。
  • public byte[] getBytes(String charsetName) ： 使用指定的字符集将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。

import org.junit.Test;

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

/**
 * 涉及到String类与其他结构之间的转换
 *
 */
public class StringTest {

    /*
    String 与基本数据类型、包装类之间的转换。

    String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
    基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)

     */
    @Test
    public void test1(){
        String str1 = "123";
//        int num = (int)str1;//错误的
        int num = Integer.parseInt(str1);

        String str2 = String.valueOf(num);//"123"
        String str3 = num + "";

        System.out.println(str1 == str3);
    }

    /*
    String 与 char[]之间的转换

    String --> char[]:调用String的toCharArray()
    char[] --> String:调用String的构造器
     */
    @Test
    public void test2(){
        String str1 = "abc123";  //题目： a21cb3

        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的构造器

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

    说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。
     */
    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
        System.out.println(Arrays.toString(gbks));

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

        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！

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

    }

}

5.StringBuffer类和StringBuilder类

StringBuffer类

• java.lang.StringBuffer代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象。
• 很多方法与String相同。
  • public int indexOf (String str)
    public String substring (int start,int end)
    public int length ()
    public char charAt (int n )
    public void setCharAt (int n ,char ch)
• 作为参数传递时，方法内部可以改变值。
• StringBuffer 类不同于 String ，其对象必须使用构造器生成。有三个构造器
  • StringBuffer() ：初始容量为 16 的字符串缓冲区
  • StringBuffer(int size) ：构造指定容量的字符串缓冲区
  • StringBuffer(String str) ：将内容初始化为指定字符串内容
• 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 () ：把当前字符序列逆转
  • 当append 和 insert 时，如果原来 value 数组长度不够，可扩容。
    如上这些方法支持方法链操作。
    方法链 的原理：
    

StringBuilder类

• StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且提供相关功能的方法也一样

面试题：对比String、StringBuffer、StringBuilder

• String(JDK1.0)：不可变字符序列
• StringBuffer(JDK1.0)：可变字符序列、效率低、线程安全
• StringBuilder(JDK 5.0)：可变字符序列、效率高、线程不安全

import org.junit.Test;

/**
 * 关于StringBuffer和StringBuilder的使用
 *
 */
public class StringBufferBuilderTest {

    /*
    String、StringBuffer、StringBuilder三者的异同？
    String:不可变的字符序列；底层使用char[]存储
    StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
    StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

    源码分析：
    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());//
    sb1.append('a');//value[0] = 'a';
    sb1.append('b');//value[1] = 'b';

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

    //问题1. System.out.println(sb2.length());//3
    //问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
             默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

            指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)
     */
    @Test
    public void test1(){
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'m');
        System.out.println(sb1);

        StringBuffer sb2 = new StringBuffer();
        System.out.println(sb2.length());//0
    }

    /*
    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)

        总结：
        增：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()
     */
    @Test
    public void test2(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append('1');
        System.out.println(s1);
//        s1.delete(2,4);
//        s1.replace(2,4,"hello");
//        s1.insert(2,false);
//        s1.reverse();
        String s2 = s1.substring(1, 3);
        System.out.println(s1);
        System.out.println(s1.length());
        System.out.println(s2);
    }

    /*
    对比String、StringBuffer、StringBuilder三者的效率：
    从高到低排列：StringBuilder > StringBuffer > String
     */
    @Test
    public void test3(){
        //初始设置
        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));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));

    }
}

二、JDK 8之前的日期时间API

1.java.lang.System类

2.java.util.Date类

import org.junit.Test;
import java.util.Date;

/**
 * JDK 8之前日期和时间的API测试
 *
 */
public class DateTimeTest {

    //1.System类中的currentTimeMillis()
    @Test
    public void test1(){
        long time = System.currentTimeMillis();
        //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。
        //称为时间戳
        System.out.println(time);
    }

    /*
    java.util.Date类
           |---java.sql.Date类

    1.两个构造器的使用
        >构造器一：Date()：创建一个对应当前时间的Date对象
        >构造器二：创建指定毫秒数的Date对象
    2.两个方法的使用
        >toString():显示当前的年、月、日、时、分、秒
        >getTime():获取当前Date对象对应的毫秒数。（时间戳）

    3. java.sql.Date对应着数据库中的日期类型的变量
        >如何实例化
        >如何将java.util.Date对象转换为java.sql.Date对象
     */
    @Test
    public void test2(){
        //构造器一：Date()：创建一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString());//Sat Feb 16 16:35:31 GMT+08:00 2019

        System.out.println(date1.getTime());//1550306204104

        //构造器二：创建指定毫秒数的Date对象
        Date date2 = new Date(155030620410L);
        System.out.println(date2.toString());

        //创建java.sql.Date对象
        java.sql.Date date3 = new java.sql.Date(35235325345L);
        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.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)：从给定字符串的开始解析文本，以生成一个日期。

import org.junit.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * jdk 8之前的日期时间的API测试
 * 1. System类中currentTimeMillis();
 * 2. java.util.Date和子类java.sql.Date
 * 3. SimpleDateFormat
 * 4. Calendar
 *
 */
public class DateTimeTest {
    /*
    SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析

    1.两个操作：
    1.1 格式化：日期 --->字符串
    1.2 解析：格式化的逆过程，字符串 ---> 日期

    2.SimpleDateFormat的实例化

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

        //格式化：日期 --->字符串
        Date date = new Date();
        System.out.println(date);//Sat Feb 18 11:40:31 GMT+08:00 2019

        String format = sdf.format(date);
        System.out.println(format);//19-2-18 上午11:40

        //解析：格式化的逆过程，字符串 ---> 日期
        String str = "19-2-18 上午11:42";//"2019-08-09" 报ParseException异常
        Date date1 = sdf.parse(str);
        System.out.println(date1);//Sat Feb 18 11:42:35 GMT+08:00 2019

        //*************按照指定的方式格式化和解析：调用带参的构造器*****************
//        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);//2019-02-18 11:48:27
        //解析:要求字符串必须是符合SimpleDateFormat识别的格式(通过构造器参数体现),
        //否则，抛异常
        Date date2 = sdf1.parse("2020-02-18 11:48:27");
        System.out.println(date2);
    }

    /*
    练习一：字符串"2020-09-08"转换为java.sql.Date

    练习二："三天打渔两天晒网"   1990-01-01  xxxx-xx-xx 打渔？晒网？

    举例：2020-09-08 ？ 总天数

    总天数 % 5 == 1,2,3 : 打渔
    总天数 % 5 == 4,0 : 晒网

    总天数的计算？
    方式一：( date2.getTime() - date1.getTime()) / (1000 * 60 * 60 * 24) + 1
    方式二：1990-01-01  --> 2019-12-31  +  2020-01-01 -->2020-09-08
     */
    @Test
    public void testExer() throws ParseException {
        String birth = "2020-09-08";

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf1.parse(birth);
//        System.out.println(date);

        java.sql.Date birthDate = new java.sql.Date(date.getTime());
        System.out.println(birthDate);
    }

    /*
    Calendar日历类(抽象类）的使用
     */
    @Test
    public void testCalendar(){
        //1.实例化
        //方式一：创建其子类（GregorianCalendar）的对象
        //方式二：调用其静态方法getInstance()
        Calendar calendar = Calendar.getInstance();//获取当前时间
//        System.out.println(calendar.getClass());//java.util.GregorianCalendar

        //2.常用方法
        //get()
        int days = calendar.get(Calendar.DAY_OF_MONTH);//当前时间是这个月的第几天
        System.out.println(days);//25 (25号)
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));//当前时间是今年的第几天

        //set()
        //calendar可变性
        calendar.set(Calendar.DAY_OF_MONTH,22);//设置当前时间是这个月的第22天
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);//22

        //add()
        calendar.add(Calendar.DAY_OF_MONTH,-3);//设置当前是这个月的天数-3
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days)//19

        //getTime():日历类---> Date
        Date date = calendar.getTime();
        System.out.println(date);//Sat Feb 19 11:55:58 GMT+08:00 2019

        //setTime():Date ---> 日历类
        Date date1 = new Date();
        calendar.setTime(date1);
        days = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(days);
    }
}

4.java.util.Calendar(日历)类

• Calendar是一个抽象基类，主用用于完成日期字段之间相互操作的功能。
• 获取Calendar实例的方法
  • 使用Calendar.getInstance()方法
  • 调用它的子类GregorianCalendar的构造器。
• 一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法来取得想要的时间信息。比如YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND
  • public void set(int field,int value)
  • public void add(int field,int amount)
  • public final Date getTime()
  • public final void setTime(Date date)
• 注意:
  • 获取月份时：一月是0，二月是1，以此类推，12月是11
  • 获取星期时：周日是1，周二是2 ， 。。。。周六是7

三、JDK 8中新日期时间API

• 第三次引入的API是成功的，并且Java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。
• Java 8 吸收了 Joda-Time 的精华，以一个新的开始为 Java 创建优秀的 API。 新的 java.time 中包含了所有关于本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。历史悠久的 Date 类新增了 toInstant() 方法，用于把 Date 转换成新的表示形式。这些新增的本地化时间日期 API 大大简化了日期时间和本地化的管理。
• java.time – 包含值对象的基础包
  java.time.chrono – 提供对不同的日历系统的访问
  java.time.format – 格式化和解析时间和日期
  java.time.temporal – 包括底层框架和扩展特性
  java.time.zone – 包含时区支持的类
• 说明：大多数开发者只会用到基础包和 format 包，也可能会用到 temporal 包。因此，尽

  管有 68 个新的公开类型，大多数开发者，大概将只会用到其中的三分之一。

1.LocalDate、LocalTime、LocalDateTime

• LocalDate、LocalTime、LocalDateTime 类是其中较重要的几个类，它们的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。 它们提供了简单的本地日期或时间，并不包含当前的时间信息，也不包含与时区相关的信息。
  • LocalDate代表IOS格式（yyyy-MM-dd）的日期,可以存储 生日、纪念日等日期。
  • LocalTime表示一个时间，而不是日期。
  • LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一。
  • 注： ISO-8601 日历系统是国际标准化组织制定的现代公民的日期和时间的表示
    法，也就是公历。

?2.瞬时：Instant

?3.格式化与解析日期或时间

• 预定义的标准格式。如： ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
• 本地化相关的格式。如：ofLocalizedDateTime(FormatStyle.LONG)
• 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

4.其它API

• ZoneId：该类中包含了所有的时区信息，一个时区的ID，如 Europe/Paris
• ZonedDateTime：一个在ISO-8601日历系统时区的日期时间，如 2007-12-T10:15:30+01:00 Europe/Paris。
  • 其中每个时区都对应着ID，地区ID都为“{区域}/{城市}”的格式，例如：Asia/Shanghai等
• Clock：使用时区提供对当前即时、日期和时间的访问的时钟。
• 持续时间：Duration，用于计算两个“时间”间隔
• 期间隔：Period，用于计算两个“日期”间隔
• TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下一个工作日”等操作。
• TemporalAdjusters : 该类通过静态方法
  • (firstDayOfXxx()/lastDayOfXxx()/nextXxx())提供了大量的常用
  • TemporalAdjuster 的实现。

四、Java比较器

• 在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。
• Java实现对象排序的方式有两种：
  • 自然排序：java.lang.Comparable
  • 定制排序：java.util.Comparator

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

• Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。
• 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。
• 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
• 对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals一致。建议（虽然不是必需的）最好使自然排序与 equals 一致。
• Comparable 的典型实现 ： ( 默认都是从小到大排列的 )
  ? ? ? ?String ：按照字符串中字符的 Unicode 值进行比较
  ? ? ? ?Character ：按照字符的 Unicode 值来进行比较
  ? ? ? ?数值类型对应的包装类以及 BigInteger 、 BigDecimal ：按照它们对应的数值大小进行比较
  ? ? ? ?Boolean ： true 对应的包装类实例大于 false 对应的包装类实例
  ? ? ? ?Date 、 Time 等：后面的日期时间比前面的日期时间大

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

• 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序，强行对多个对象进行整体排序的比较。
• 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
• 可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。
• 还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

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

?

六、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

1.BigInteger类

• Integer类作为int的包装类，能存储的最大整型值为2 31-1，Long类也是有限的， 最大为2 63-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类都无能为力，更不用说进行运算了。
• java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。 另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、位操作以及一些其他操作。
• 构造器
  • BigInteger(String val)：根据字符串构建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) ：返回其值为 (this exponent ) 的 BigInteger

2.BigDecimal类

• 一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中，要求数字精度比较高，故用到java.math.BigDecimal类。
• BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
• 构造器
  • public BigDecimal(double val)
  • public BigDecimal(String val)
• 常用方法
  • public BigDecimal add(BigDecimal augend)
  • public BigDecimal subtract(BigDecimal subtrahend)
  • public BigDecimal multiply(BigDecimal multiplicand)
  • public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)