16--常用类和基础API--06

1、包装类

1.1 包装类概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

1.2 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为【装箱】与【拆箱】：

什么是装箱：从基本类型转换为对应的包装类对象。

什么是拆箱：从包装类对象转换为对应的基本类型。

以Integer与int为例演示他们之间的转换：

基本类型转包装对象(自动装箱)

Integer i = new Integer(4);				// 使用构造函数函数
Integer iii = Integer.valueOf(4);		// 使用包装类中的valueOf方法

包装对象转基本类型(自动拆箱)

int num = i.intValue();

1.3 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;		// 自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;		// 等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
// 加法运算完成后，再次装箱，把基本数值转成对象。

1.4 基本类型与字符串之间的转换

1.4.1 基本类型 ---> String

//基本类型 --> String

int i = 10;
//拼接方式
String s = i +"";

//静态toString(参数)方法
String s =  Integer.toString(10);

//静态方法valueOf(参数)， valueOf()这个方法可以把任意的基本类型转成String类型
String s = String.valueOf(20);

1.4.2 String ---> 基本类型

将字符串的数据转换成int类型的数据

public class Demo18WrapperParse {
    public static void main(String[] args) {
        //字符串 --> int 
        String i = "100";
        int num = Integer.parseInt(i); 
        double v = Double.parseDouble("3.34");
        float v1 = Float.parseFloat("3.3");
        //...所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型
    }
}

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

方法	说明
public static byte parseByte(String s)	将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)	将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)	将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)	将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)	将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)	将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)	将字符串参数转换为对应的boolean基本类型。

如果字符串参数的内容无法正确转换为对应的基本类型,则会抛java.lang.NumberFormatException异常。

1.4.3 Integer 和 int 有什么区别？

Integer 和 int 有什么区别？

int是基本数据类型， Integer是int的包装类

int默认值为0 ， Integer的默认值null

或者什么情况下使用Integer, int?

举例：小明考试，最终得到0分，请问他是去考试还是没去考试？去考试用int

小明考试，最终null，请问他是去考试还是没去考试？没有考试用Integer

2、BigInteger类

2.1 BigInteger类概述

java中long型为最大整数类型,对于超过long型的数据如何去表示呢？在Java的世界中,超过long型的整数已经不能被称为整数了,它们被封装成BigInteger对象.在BigInteger类中,实现四则运算都是方法来实现,并不是采用运算符.

2.2 BigInteger类的构造方法

方法	说明
public BigInteger(String val)	将字符串的数组封装成BigInteger对象

2.3 BigInteger类的常用方法

方法	说明
public BigInteger add(BigInteger val)	两个BigInteger进行相加，并返回BigInteger
public BigInteger subtract(BigInteger val)	两个BigInteger进行相减，并返回BigInteger
public BigInteger multiply(BigInteger val)	两个BigInteger进行相乘，并返回BigInteger
public BigInteger divide(BigInteger val)	两个BigInteger进行相除，并返回BigInteger，整数相除只保留整数部分。
public BigInteger remainder(BigInteger val)	两个BigInteger进行取余数

package com.suyv.math;

import org.junit.Test;

import java.math.BigInteger;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:43
*@Description: TODO
*/
public class BigIntegerDemo01 {
    BigInteger big1 = new BigInteger("12345678912345678912345678");
    BigInteger big2 = new BigInteger("78923456789123456789123456789");

    @Test
    public void Test01(){
        // 加
        System.out.println(big1.add(big2));
        // 减
        System.out.println(big2.subtract(big1));
        // 乘
        System.out.println(big2.multiply(big1));
        // 除
        System.out.println(big2.divide(big1));
        // 取余
        System.out.println(big2.remainder(big1));
    }

}

3、BigDecimal类

3.1 BigDecimal类的引入

在程序中执行下列代码,会出现什么问题?

System.out.println(0.09 + 0.01);
System.out.println(1.0 - 0.32);
System.out.println(1.015 * 100);
System.out.println(1.301 / 100);

double和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供我们BigDecimal类可以实现浮点数据的高精度运算

3.2 BigDecimal类的构造方法

方法名	说明
public BigDecimal(String val)	将String类型的数组封装为BigDecimal对象

建议浮点数据以字符串形式给出,因为参数结果是可以预知的

3.3 BigDecimal类的常用方法

方法名	说明
public BigDecimal add(BigDecimal augend)	浮点类型数据相加操作
public BigDecimal subtract(BigDecimal subtrahend)	浮点类型数据相减操作
public BigDecimal multiply(BigDecimal multiplicand)	浮点类型数据相乘操作
public BigDecimal divide(BigDecimal divisor)	浮点类型数据相除操作
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)	浮点类型数据相除操作，按照指定的模式，保留几位小数

package com.suyv.math;

import org.junit.Test;

import java.math.BigDecimal;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:50
*@Description: TODO
*/
public class BigDecimalDemo01 {

    BigDecimal big1 = new BigDecimal("0.09");
    BigDecimal big2 = new BigDecimal("0.01");

    @Test
    public void Test01(){
        // 加
        System.out.println(big1.add(big2));
        // 减
        System.out.println(big1.subtract(big2));
        // 乘
        System.out.println(big2.multiply(big1));
        // 除
        System.out.println(big1.divide(big2));
    }
}

4. Java比较器

我们知道基本数据类型的数据（除boolean类型外）需要比较大小的话，之间使用比较运算符即可，但是引用数据类型是不能直接使用比较运算符来比较大小的。那么，如何解决这个问题呢？

在Java中经常会涉及到对象数组的排序问题，那么就涉及到对象之间的比较问题。

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

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

4.1 自然排序：java.lang.Comparable

Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

实现 Comparable 的类必须实现 compareTo(Object obj)方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。如果当前对象this大于形参对象obj，则返回正整数，如果当前对象this小于形参对象obj，则返回负整数，如果当前对象this等于形参对象obj，则返回零。

public interface Comparable{
    int compareTo(Object 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等：后面的日期时间比前面的日期时间大

4.1.1 举例1

package com.suyv.comparable;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 15:21
*@Description: TODO
*/
public class Student implements Comparable{

    private int id;
    private String name;
    private int score;
    private int age;

    public Student() {
    }

    public Student(int id, String name, int score, int age) {
        this.id = id;
        this.name = name;
        this.score = score;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public int compareTo(Object o) {
        // 这些需要强制，将o对象向下转型为Student类型的变量，才能调用Student类中的属性
        // 默认按照学号比较大小
        Student stu = (Student) o;
        return this.id - stu.id;
    }
}

测试类

package com.suyv.comparable;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 15:24
*@Description: TODO
*/
public class StudentTest {
    public static void main(String[] args) {
        Student[] arr = new Student[5];
        arr[0] = new Student(3,"张三",90,23);
        arr[1] = new Student(1,"熊大",99,22);
        arr[2] = new Student(5,"王五",75,25);
        arr[3] = new Student(4,"李四",85,24);
        arr[4] = new Student(2,"熊二",85,18);

        //单独比较两个对象
        System.out.println(arr[0].compareTo(arr[1]));   // 2
        System.out.println(arr[1].compareTo(arr[2]));   // -4
        System.out.println(arr[2].compareTo(arr[2]));   //0

        System.out.println("所有学生：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("按照学号排序：");
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length-i; j++) {
                if(arr[j].compareTo(arr[j+1])>0){
                    Student temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

4.1.2 举例2

package com.suyv.comparable;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:05
*@Description: TODO
*/
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) {
        if(o instanceof Goods) {
            Goods other = (Goods) o;
            if (this.price > other.price) {
                return 1;
            } else if (this.price < other.price) {
                return -1;
            }
            return 0;
        }
        throw new RuntimeException("输入的数据类型不一致");
    }
}

测试：

package com.suyv.comparable;

import java.util.Arrays;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:07
*@Description: TODO
*/
public class GoodsTest {
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("《红楼梦》", 100);
        all[1] = new Goods("《西游记》", 80);
        all[2] = new Goods("《三国演义》", 140);
        all[3] = new Goods("《水浒传》", 120);

        Arrays.sort(all);

        System.out.println(Arrays.toString(all));
    }
}

4.2 定制排序：java.util.Comparator

思考

当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码（例如：一些第三方的类，你只有.class文件，没有源文件）
如果一个类，实现了Comparable接口，也指定了两个对象的比较大小的规则，但是此时此刻我不想按照它预定义的方法比较大小，但是我又不能随意修改，因为会影响其他地方的使用，怎么办？

JDK在设计类库之初，也考虑到这种情况，所以又增加了一个java.util.Comparator接口。强行对多个对象进行整体排序的比较。

重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。
可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。

public interface Comparator{
    int compare(Object o1,Object o2);
}

4.2.1 举例1

实体类：

上述Student类--无修改

添加一个StudentScore进行分数排序

package com.suyv.comparable;

import java.util.Comparator;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:16
*@Description: 定义定制比较器类
*/
public class StudentScore implements Comparator {
    @Override
    public int compare(Object o1, Object o2) {
        Student s1 = (Student) o1;
        Student s2 = (Student) o2;
        int result = s1.getScore() - s2.getScore();
        return result != 0 ? result : s1.getId() - s2.getId();
    }
}

测试01：使用自然排序

package com.suyv.comparable;
/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:18
*@Description: TODO
*/
public class StudentTest02 {
    public static void main(String[] args) {

        Student[] arr = new Student[5];
        arr[0] = new Student(3, "张三", 90, 23);
        arr[1] = new Student(1, "熊大", 99, 22);
        arr[2] = new Student(5, "王五", 75, 25);
        arr[3] = new Student(4, "李四", 85, 24);
        arr[4] = new Student(2, "熊二", 85, 18);
        
        System.out.println("所有学生：");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("按照成绩排序");
        StudentScore sc = new StudentScore();
        for (int i = 1; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i; j++) {
                if (sc.compare(arr[j], arr[j + 1]) > 0) {
                    Student temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

测试02：自然排序和定制排序一起使用

package com.suyv.comparable;

import java.util.Arrays;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:22
*@Description: TODO
*/
public class StudentTest03 {
    public static void main(String[] args) {
        Student[] students = new Student[5];
        students[0] = new Student(3, "张三", 90, 23);
        students[1] = new Student(1, "熊大", 99, 22);
        students[2] = new Student(5, "王五", 75, 25);
        students[3] = new Student(4, "李四", 85, 24);
        students[4] = new Student(2, "熊二", 85, 18);

        System.out.println(Arrays.toString(students));

        // 自然排序
        Arrays.sort(students);
        System.out.println("使用自然排序");
        System.out.println(Arrays.toString(students));


        //定制排序
        StudentScore sc = new StudentScore();
        Arrays.sort(students, sc);
        System.out.println("使用定制排序");
        System.out.println(Arrays.toString(students));
    }
}

4.2.2 举例2

实体类：

上述Goods类--无修改

测试类：

package com.suyv.comparable;

import java.util.Arrays;
import java.util.Comparator;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 16:37
*@Description: TODO
*/
public class GoodsTest01 {
    public static void main(String[] args) {
        Goods[] all = new Goods[4];
        all[0] = new Goods("War and Peace", 100);
        all[1] = new Goods("Childhood", 80);
        all[2] = new Goods("Scarlet and Black", 140);
        all[3] = new Goods("Notre Dame de Paris", 120);

        // 使用匿名内部类
        Arrays.sort(all, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Goods g1 = (Goods) o1;
                Goods g2 = (Goods) o2;
                // 根据名字排序
                return g1.getName().compareTo(g2.getName());
            }
        });

        System.out.println(Arrays.toString(all));
    }
}

补充：Java保留两位小数

1、使用String.format()方法

	@Test
    public void Test01(){
        double number = 3.1455926;
        String result = String.format("%.2f", number);
        System.out.println(result);
    }

2、BigDecimal保留两位小数

	@Test
    public void Test02(){
        double number = 3.1455926;
        BigDecimal decimal = new BigDecimal(number);
        BigDecimal rounded = decimal.setScale(2, BigDecimal.ROUND_HALF_UP);
        System.out.println(rounded);
    }

3、使用DecimalFormat类

	@Test
    public void Test03(){
        double number = 3.1455926;
        DecimalFormat decimalFormat = new DecimalFormat("#.00");
        String result = decimalFormat.format(number);
        System.out.println(result);
    }