4.Java基础——常用类库篇

1.Object类

java.lang.Object`类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象
实例化的时候，最终找的父类就是Object。如果一个类没有特别指定父类，	那么默认则继承自Object类。
例如：

public class MyClass /*extends Object*/ {
  	// ...
}

在这个Object类中，主要有2个方法。

• public String toString()：返回该对象的字符串表示。
• public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

toString方法：

  	1.public String toString()：返回该对象的字符串表示。
  	2.toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
   	3.由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到
  相应的字符串表现形式，因此也需要重写它。

public class Person {  
    private String name;
    private int age;

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

equals方法:

	1.public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。
	2.调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。
注意：
1.默认地址比较
	如果没有覆盖重写equals方法，那么Object类中默认进行`==`运算符的对象地址比较，只要不是
同一个对象，结果必然为false。
2. 对象内容比较
如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写
equals方法。例如：

import java.util.Objects;

public class Person {	
	private String name;
	private int age;
	
    @Override
    public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
            return true;
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}

2. Math类

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的
工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

public static double abs(double a) ：返回 double 值的绝对值。

double d1 = Math.abs(‐5); //d1的值为5 
double d2 = Math.abs(5); //d2的值为5

public static double ceil(double a) ：返回大于等于参数的最小的整数

double d1 = Math.ceil(3.3); //d1的值为 4.0 
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0 
double d3 = Math.ceil(5.1); //d3的值为 6.0

public static double floor(double a) ：返回小于等于参数最大的整数。

double d1 = Math.floor(3.3); //d1的值为3.0 
double d2 = Math.floor(‐3.3); //d2的值为‐4.0 
double d3 = Math.floor(5.1); //d3的值为 5.0

public static long round(double a)：返回最接近参数的 long。(四舍五入)

long d1 = Math.round(5.5); //d1的值为6.0 
long d2 = Math.round(5.4); //d2的值为5.0
long d3 = Math.round(-100.5)//d3的值为-100   四舍五入

public static long max(double a，double b)：最大值
public static long min(double a，double b)：最小值

3.Arrays类

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。

public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。

public static void main(String[] args) { 
	// 定义int 数组 
	int[] arr = {2,34,35,4,657,8,69,9}; 
	// 打印数组,输出地址值 
	System.out.println(arr); // [I@2ac1fdc4 
	// 数组内容转为字符串 
	String s = Arrays.toString(arr); 
	// 打印字符串,输出内容 
	System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9] 
}

public static void sort(int[] a)：对指定的 int 型数组按数字升序进行排序。

public static void main(String[] args) { 
	// 定义int 数组
	 int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2};
	 System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6, 2]
	 // 升序排序 
	 Arrays.sort(arr); 
	 System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46, 48] 
}

Arrays.binarySearch():二分查找

public static void main(String[] args) {
        // 定义int 数组
        int[] arr = {1,5,7,9,0,3,6,2,8,4};
        System.out.println("排序前:" + Arrays.toString(arr));
        // 排序前:[1,5,7,9,0,3,6,2,8,4]
        // 升序排序
        Arrays.sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
        // 排序后:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        //二分查找内容，比如，数字5在数组中的下标，下列输出为5
        System.out.println(Arrays.binarySearch(arr,5));
    }

Arrays.copyOf():动态扩容

public static void main(String[] args) {
        // 定义int 数组
        int[] arr = {1,5,7,9,0,3,6,2,8,4};
        System.out.println("排序前:" + Arrays.toString(arr));
        // 排序前:[1,5,7,9,0,3,6,2,8,4]
        // 升序排序
        Arrays.sort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
        // 排序后:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

        //二分查找内容，比如，数字5在数组中的下标，下列输出为5
        System.out.println(Arrays.binarySearch(arr,5));
        //未扩容前的长度
        System.out.println(arr.length);
        //扩容为20的长度
        int[] arr1=Arrays.copyOf(arr,20);
        //扩容后的长度
        System.out.println(arr1.length);

    }

4.BigDecimal类

float类型和double类型在运算时都可能会存在误差，为了实现精确运算可借助java.util.BigDecimal
下述所有的运算方法，不会影响参与运算的数据本身，运算结果会被封装成一个新的BigDecimal对象，
这个对象会通过return返回出去。
public BigDecimal add(BigDecimal augend（被加数）);//加法运算
public BigDecimal subtract(BigDecimal augend（被减数）);//减法运算
public BigDecimal multiply(BigDecimal augend（被乘数）);//乘法运算
public BigDecimal divide(BigDecimal augend（被除数）);//除法运算

1.加法

public static void main(String[] args) {
        //比较单纯的double类型相加
        System.out.println(0.1+0.2);//输出0.30000000000000004
        //利用BigDecimal类
        BigDecimal b1 = new BigDecimal("0.1");
        BigDecimal b2 = new BigDecimal("0.2");
        //加法
        BigDecimal b3=b1.add(b2);
        System.out.println(b3);//输出0.3
    }

2.减法

 public static void main(String[] args) {
        //比较单纯的double类型相减
        System.out.println(-0.1-0.2);//输出-0.30000000000000004
        //利用BigDecimal类
        BigDecimal b1 = new BigDecimal("-0.1");
        BigDecimal b2 = new BigDecimal("0.2");
        //减法
        BigDecimal b3=b1.subtract(b2);
        System.out.println(b3);//输出-0.3
    }

3.乘法

 public static void main(String[] args) {
        //比较单纯的double类型相乘
        System.out.println(0.1*0.2);//输出0.020000000000000004
        //利用BigDecimal类
        BigDecimal b1 = new BigDecimal("0.1");
        BigDecimal b2 = new BigDecimal("0.2");
        //乘法
        BigDecimal b3=b1.multiply(b2);
        System.out.println(b3);//输出0.02
    }

4.除法

public static void main(String[] args) {
        //比较单纯的double类型相除
        System.out.println(15.3/0.3);//输出51.00000000000001
        //利用BigDecimal类
        BigDecimal b1 = new BigDecimal("15.3");
        BigDecimal b2 = new BigDecimal("0.3");
        //除法
        BigDecimal b3=b1.divide(b2);
        System.out.println(b3.doubleValue());//输出double类型51.0
    }

5.Date类

表示特定的时刻，精度为毫秒，1秒=1000毫秒

1.常用方法：getTime(),返回一个long类型的值
表示从1970年1月1日00：00：00以来的毫秒数。

public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date.getTime());//输出1608530639982
    }

2.构造方法
Date():当前时间

public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);//输出Mon Dec 21 14:06:14 CST 2020
    }

6.DateFormat类
用于格式化日期的类（抽象类）,因为是抽象类，所以使用其字类进行实例化。

 1.format()方法：将date对象转换为指定格式的字符串

 public static void main(String[] args) {
        //DateFormat
        /**
         * y:年
         * M：月
         * d:日
         * H：时
         * m：分
         * s:秒
         * eg:2020年12月31日 12：12 59
         */
        //使用字类实例化,并写出相应格式
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm ss");
        //将date对象转换为字符串（yyyy年MM月dd日 HH:mm ss）
        String string = format.format(new Date());
        //输出以上格式的当前时间
        System.out.println(string);
    }

2.parse()方法：将一段字符串转成date对象

public static void main(String[] args) throws ParseException {
        //DateFormat
        /**
         * y:年
         * M：月
         * d:日
         * H：时
         * m：分
         * s:秒
         * eg:2020年12月31日 12：12 59
         */
        //使用字类实例化,并写出相应格式
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm ss");
        //方法返回String类型的值
        String string = format.format(new Date());
        //输出以上格式的当前时间
        System.out.println(string);
        //parse:将yyyy年MM月dd日 HH:mm ss 日期字符串转换为date对象
        Date date = format.parse("2020年12月21日 14:29 34");
        System.out.println(date.getTime());
    }

7.Calendar类(抽象类)
Calendar是抽象类，用其getInstance方法来实例化。

 public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
 }

get()方法:获取值

 public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
        //get方法，返回int值,用于取出日历中的数据，比如年月日。
        int text = calendar.get(Calendar.YEAR);
        System.out.println(text);//输出2020
    }

set()方法：设置值

 public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR,2030);
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);//输出2030
  }

add()方法：+"1"操作
    注意：月份：0~11   周：星期日开始

public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR,1);
        System.out.println(calendar.get(Calendar.YEAR));//输出2021
    }

 getTime()方法：获取日历时间，表示Date对象（修改后的时间）

 public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.YEAR,1);//年+1
        System.out.println(calendar.get(Calendar.YEAR));
        Date date = calendar.getTime();
        System.out.println(date);//输出Tue Dec 21 15:14:42 CST 2021
    }

getActualMaximum()方法:获取最大值

public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
        //获取2020年的最大天数
        int i = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);
        System.out.println(i);//输出366
    }

 getActualMinimum()方法:获取最大值

public static void main(String[] args) throws ParseException {
       //Calendar是抽象类，用其getInstance方法来实例化。
        Calendar calendar = Calendar.getInstance();
        //获取2020年最小天数
        int j = calendar.getActualMinimum(Calendar.DAY_OF_YEAR);
        System.out.println(j);
    }