5.Java常用类

1. Object类

Object类是所有Java类的根父类，其内的属性和方法具有通用性。
1.1 equals(Object)方法：比较两个对象是否相等。
==和equals的区别：

• ==既可以比较基本数据类型也可以比较引用数据类型。对于基本数据类型就是比较值，对于引用数据类型就是比较内存地址。
• equals是Object类中的方法，如果没有被重写过默认就是==（String类中的equals方法是被重写过的，比较字符串值是否相等），IDE可以自动生成重写的equals方法。

1.2 toString()方法：返回值为String类型，返回类名和它的引用地址。

• 当输出一个对象的引用时，就是在调用当前对象的toString方法。
• 在进行String与其他类型数据的链接操作时，自动调用toString方法。
• 根据需要在用户自定义类中重写toString方法（String类重写了toString方法，返回字符串的值），IDE可以自动生成重写的toString方法。
• 基本类型数据转换为String类型时，调用了对应包装类的toString方法。

1.3 Object类中其他方法

• clone()方法：创建并返回当前对象的一个复制品。
• finalize()方法：当没有引用指向该对象时，调用该对象的finalize方法进行垃圾回收。永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。
• getClass()：获取当前对象的所属类。
• hashCode()：返回当前对象的哈希值。
• notify()、notifyAll()、wait()：与多线程相关的方法。

2. JUnit单元测试类

• 在当前工程中导入JUnit类库：右键选择当前工程 → build path → add libraries → JUnit → 下一步
• 创建Java类进行单元测试，该Java类要求：① 此类是public的；② 此类提供公共无参构造器
• 在类中声明单元测试方法，要求改方法权限是public，没有返回值，没有形参
• 在该单元测试方法上加上注解@Test，并在单元测试类中导入JUnit的Test类
• 运行单元测试方法：双击单元测试方法名 → 右键 → run as → JUnit Test

3. 包装类（Wrapper）

3.1 包装类的定义
包装类是针对8种基本数据类型定义的相应引用类型。有了类的特点，就可以调用类中的方法。

基本数据类型	byte	short	int	long	float	double	boolean	char
包装类	Byte	Short	Integer	Long	Float	Double	Boolean	Character

表中前6类基本数据类型为数值型，它们对应的包装类有一个共同父类Number。

3.2 包装类的使用
基本数据类型、包装类、String类之间的转换

3.2.1 基本数据类型&包装类

• 基本数据类型 → 包装类：称为装箱。调用包装类的构造器，构造器内可放相应基本数据类型，也可以放对应字符串。

Integer in1 = new Integer(10);
Integer in2 = new Integer("10");

• 包装类 → 基本数据类型：称为拆箱。调用包装类的xxxVaule() 方法

int i1 = in1.intValue();

JDK5.0以后，自动拆箱和装箱，不用再调用方法或构造器，直接赋值即可转换，此时两者可同等对待。

3.2.2 基本数据类型、包装类&String类

• 基本数据类型、包装类 → String类：可用连接运算，或调用String类的valueOf方法

String str1 = num1 + "";
String str2 = String.valueOf(num2)

• String类 → 基本数据类型、包装类：调用包装类的parseXxx() 方法

int i1 = Integer.parseInt(Str1);

4. 字符串相关的类

4.1 String类
4.1.1 String的基本特性

• String是一个final类，代表不可变的字符序列。
• 字符串是常量，用双引号引起来。它们的值在创建后不能更改。
• String对象的字符内容是存储在一个字符数组value[]中的。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

• String实现了Serializable、Comparable接口，表示可序列化、可比较大小。
• 通过字面量的方式给一个字符串赋值（区别于new），此时的字符串声明在字符串常量池中。
• 通过new的方式创建的字符串对象声明在堆空间中。
• 字符串常量池中不会存储相同内容的字符串。

4.1.2 String的不同实例化方式

String s = "hello";

//本质上为 this.value = new char[0];
String s1 = new String();

//this.value = original.value;
String s2 = new String(String original);
//该方式会在内存中创建两个对象，一个是堆空间中的String对象，一个是常量池中的数据

//this.value = Arrays.copyOf(value, value.length);
String s3 = new String(char[] a);

String s4 = new String(char[] a, int startIndex, int count);

4.1.3 String不同拼接操作“+”的对比

• 常量和常量的拼接结果在常量池中。
• 只要其中一个是变量，结果就在堆中。
• 如果拼接的结果调用intern()方法，返回值就在常量池中。

4.1.4 String的常用方法

• int length()：返回字符串长度
• char charAt(int index)：返回某索引处的字符
• boolean isEmpty()：判断是否为空字符串
• String toLowerCase()：将String中的所有字符转换为小写
• String toUpperCase()：将String中的所有字符转换为大写
• String trim()：返回字符串的副本，忽略前后空白
• boolean equals(Object obj)：比较字符串的内容是否相同
• boolean eaualsIgnoreCases(String str)：比较时忽略大小写
• String concat(String str)：字符串连接，等价于“+”
• int compareTo(String str)：比较两个字符串大小
• String substring(int beginIndex)：从beginIndex开始截取该字符串
• String substring(int beginIndex, int endIndex)：从beginIndex开始截取该字符串到endIndex（不包含）
• boolean endsWith(String suffix)：判断该字符串是否以指定的后缀结束
• boolean startsWith(String prefix)：判断该字符串是否以指定的前缀开始
• boolean startsWith(String prefix, int toffset)：判断该字符串指定索引处是否以指定的前缀开始
• boolean contains(CharSequence s)：当且仅当该字符串包含指定char值序列时，返回true
• int indexOf(String str)：返回子字符串在该字符串中第一次出现的索引，未找到返回-1
• int indexOf(String str, int fromIndex)：返回子字符串在该字符串指定索引处中第一次出现的索引
• int lastIndexOf(String str)：返回子字符串在该字符串最右侧第一次出现的索引，未找到返回-1
• 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)：用新值替换所有正则表达式匹配的子字符串
• String replaceFirst(String regex, String replacement)：用新值替换正则表达式匹配的第一个字符串
• boolean matches(String regex)：判断该字符串是否匹配给定的正则表达式
• String[] split(String regex)：根据给定正则表达式的匹配拆分该字符串
• String[] split(String regex, int limit)：根据给定正则表达式的匹配拆分该字符串，最多拆分limit个，超过部分都放在最后一个元素中

4.1.5 String与char型数组、byte型数组之间的转换

char[] charArray = str.toCharArray();
String str = new String(charArray);

byte[] bytes = str.getBytes();	//使用默认的字符集进行转换，编码
byte[] bytes2 = str.getBytes(“gbk”);//使用指定字符集进行转换
//UTF-8中一个汉字占3个字节，GBK中一个汉字占2个字节
String str = new String(bytes);	//使用默认字符集转换，解码
String str2 = new String(bytes2, "gbk");	//使用指定字符集转换

4.2 StringBuffer和StringBuilder
4.2.1 三者的异同
三者底层都用char型数组存储，在效率上StringBuilder > StringBuffer > String。

• String：不可变的字符序列。
• StringBuffer：可变的字符序列。线程安全的，效率低。
• StringBuilder：可变的字符序列。线程不安全，效率高。其他与StringBuffer相同。

4.2.2 底层实现
创建String对象时，根据字符串长度新建等长的char型数组。创建StringBuffer对象时，可自定义char型数组的容量，通过空参构造器创建时，默认容量为16，通过非空参构造器创建时，容量为16+字符串长度。若往字符串中append的子串长度大于char型数组剩余容量，则会对数组进行扩容，默认扩容至原来容量的2倍+2。

String str = new String();//new char[0];
StringBuffer sb = new StringBuffer();//new char[16];

4.2.3 常见方法（在String基础上多出来的方法）

• 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()：逆序当前字符串
• void setCharAt(int n, char ch)：将指定位置的字符改为新字符

4.2.4 String与两者间的转换

• String → StringBuffer：调用StringBuffer的构造器
• StringBuffer → String：① 调用String的构造器；② 调用StringBuffer的toString()方法

5. 日期时间类

5.1 JDK8之前的日期时间API
5.1.1 System类
提供了public static long currentTimeMillis()方法返回当前时间与1970年1月1日0时0分0秒之间的时间差，单位为毫秒，又称时间戳。

5.1.2 java.util.Date类：表示特定的瞬间，精确到毫秒

• Date()：使用无参构造器创建对象获取本地当前时间
• Date(long date)：根据时间戳创建Date对象
• getTime()：返回1970.1.1,00:00:00以来该Date对象表示的毫秒数
• toString()：把Date对象转换为以下形式的String

dow mon dd hh:mm:ss zzz yyyy
其中，dow为星期几，zzz为时间标准

java.sql.Date：对应数据库中的日期类型的变量，为 java.util.Date的子类。
如何将java.util.Date对象转换为java.sql.Date对象：

Date date = new Date();
java.sql.Date date2 = new java.sql.Date(date.getTime());

5.1.3 java.text.SimpleDateFormat类
Date类的API不易于国际化，大部分被废弃了，SimpleDateFormate类是一个不与语言环境有关的对Date类进行格式化和解析的类。

• SimpleDateFormat()：该构造器用默认的模式和语言环境创建对象
• public SimpleDateFormat(String pattern)：该构造方法用参数pattern指定的格式创建一个对象
• public String format(Date date)：格式化时间对象date（日期 → 字符串）
• public Date parse(String source)：从给定字符串的开始解析问题，以生产一个日期（字符串 → 日期）

5.1.4 java.util.Calendar类
Calendar是一个抽象基类，主要用于完成日期字段之间相互操作的功能。一个Calendar类的实例是系统时间的抽象表示。

• Calendar.getInstance()：通过静态方法创建一个子类GregorianCalendar的对象
• get(int field)：取得Calendar对象的时间信息，如年月日、星期、时分秒。获取月份时一月是0，获取星期时周日是1
• set(int field, int value)：设置Calendar对象的信息
• add(int field, int amount)：修改Calendar对象的信息
• getTime()：Calendar类对象 → Date类对象
• setTime()：Date类对象 → Calendar类对象

5.2 JDK8中新日期时间API
5.2.1 LocalDate、LocalTime、LocalDateTime类
这3个类的实例是不可变对象。LocalDate代表以（yyyy-MM-dd）的日期；LocalTime表示一个时间；LocalDateTime用于表示日期时间，是最常用的类之一。类似于Calendar类。

//通过now()和of()方法进行实例化
LocalDateTime localDateTime = LocalDateTime.now();
LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 1, 20, 10, 10);
System.out.println(localDateTime);
System.out.println(localDateTime1);

//getXxx()方法
System.out.println(localDateTime.getDayOfMonth());
System.out.println(localDateTime.getDayOfWeek());
System.out.println(localDateTime.getMonth());
System.out.println(localDateTime.getMonthValue());
System.out.println(localDateTime.getMinute());

//不可变性，更改属性需新建变量
LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(22);
LocalDateTime localDateTime3 = localDateTime.plusMonths(2);
System.out.println(localDateTime2);
System.out.println(localDateTime3);
System.out.println(localDateTime);

5.2.2 Instant类
表示时间线上的一个瞬时点，可以被用来记录应用程序中的事件时间戳。类似于Date类。

//now()方法获取本初子午线对应的标准时间
Instant instant = Instant.now();
System.out.println(instant);

//添加时区偏移量
OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
System.out.println(offsetDateTime);

//获取从1970.01.01 00:00:00开始对应的毫秒数
long epochMilli = instant.toEpochMilli();
System.out.println(epochMilli);

//通过给定毫秒数创建Instant实例
Instant instant1 = Instant.ofEpochMilli(1598959788038L);
System.out.println(instant1);

5.2.3 DateTimeFormatter类
用于格式化或解析日期时间，有3种实例化的方式。类似于SimpleDateFormat类。

//1.预定义的标准格式
DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
LocalDateTime localDateTime = LocalDateTime.now();
//格式化：日期 → 字符串
String format = formatter.format(localDateTime);
System.out.println(localDateTime);
System.out.println(format);
//解析：字符串 → 日期
TemporalAccessor parse = formatter.parse("2020-09-01T19:39:02.149");
System.out.println(parse);

//2.本地化相关的格式
DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
String format1 = formatter1.format(localDateTime);
System.out.println(format1);

//3.自定义的格式（主要使用）
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
String format2 = formatter2.format(localDateTime);
System.out.println(format2);

6. Java比较器

6.1 Comparable接口

• String类、包装类等实现了Comparable接口，重写了compareTo(obj)方法，给出了比较两个对象大小的方式。
• 自定义类如果需要排序，可以实现Comparable接口，重写compareTo(obj)方法，并在该方法中指明如何排序（自然排序）。
• 重写compareTo(obj)的规则：如果当前对象this大于形参对象obj，则返回正整数；如果当前对象this小于形参对象obj，则返回负整数；如果相等，则返回零。

public class CompareTest {
    @Test
    public void test() {
        Goods[] goods = new Goods[4];
        goods[0] = new Goods("xiaomi", 12);
        goods[1] = new Goods("huawei", 24);
        goods[2] = new Goods("dell", 32);
        goods[3] = new Goods("luoji", 45);
        Arrays.sort(goods);
        System.out.println(Arrays.toString(goods));
    }
}

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

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

    public Goods() {
    }

    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) {
        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;
            }
        }
        throw new RuntimeException("传入的数据类型不一致！");
    }
}

6.2 Comparator接口

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

//指定将String从大到小排序
 String[] arr = new String[]{"AA","CC","KK","MM"};
 Arrays.sort(arr, new Comparator<String>() {
     @Override
     public int compare(String o1, String o2) {
         if (o1 instanceof String && o2 instanceof String){
             String s1=(String)o1;
             String s2=(String)o2;
             return -s1.compareTo(s2);
         }
         throw new RuntimeException("输入的数据类型不一致");
     }
 });
 System.out.println(Arrays.toString(arr));

7. System类、Math类、BigInetger&BigDecimal类

7.1 System类

• System类的构造器是private的，所以无法创建该类的对象。其内部的成员变量和成员方法都是static的，可以很方便的进行调用。
• System类内部包含in、out、err三个成员变量，分别代表标准输入流（键盘输入）、标准输出流（显示器）、标准错误输出流（显示器）。

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

7.3 BigInetger&BigDecimal类
BigInteger可以表示不可变的任意精度的整数。BigDecimal类支持不可变的、任意精度的有符号十进制定点数，对精度要求高时使用。