Arrays类

学习Arrays目的：有利于lambda

是什么：

操作数组的工具类

Arrays类对数组操作

    //1 toString 循环输出， 原来的数组输出需要循环
        int[] arr = {10, 11, 12, 13};
        System.out.println(Arrays.toString(arr));
        
        //2cpyOfRange
        int[] arr2 = Arrays.copyOfRange(arr, 1, 2);
        System.out.println(Arrays.toString(arr2));

        //3 copyOf 拷贝。后面默认是0，
        int[] arr3 = Arrays.copyOf(arr, 10);
        System.out.println(Arrays.toString(arr3));
        
        //4 sort 升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

如果数组中存的是对象，怎么排序

方式一

升序

package com.ruoyi.project;


//数组里面的对象需要实现Comparable<T>接口
public class Student implements  Comparable<Student>{

    private String name;
    private Double height;
    private Integer age;

    public Student(String name, Double height, Integer age) {
        this.name = name;
        this.height = height;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Double getHeight() {
        return height;
    }

    public void setHeight(Double height) {
        this.height = height;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", age=" + age +
                '}';
    }
//对象需要重写这个方法
    @Override
    public int compareTo(Student o) {
        if(this.age>o.age){
            return 1;
        }else if(this.age<o.age){
            return -1;
        }
        else{
            return 0;
        }

    }
}

其中compareTo还可以简化成如下，int的简化写法如下

@Override
    public int compareTo(Student o) {
//        if(this.age>o.age){
//            return 1;
//        }else if(this.age<o.age){
//            return -1;
//        }
//        else{
//            return 0;
//        }
//这是int类型的写法
return this.age-o.age;
    }

如果比较的是double类型的参数，简化写法如下：

首先先展示一下错误写法，以下写法会精度丢失

 @Override
    public int compareTo(Student o) {


        Double heightExm = this.height - o.height;
        BigDecimal bigDecimal = BigDecimal.valueOf(heightExm);

        return bigDecimal.intValue();
    }

正确写法

 @Override
    public int compareTo(Student o) {


        BigDecimal bigDecimal1 = BigDecimal.valueOf(this.height);
        BigDecimal bigDecimal2 = BigDecimal.valueOf(o.height);
        BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
        BigDecimal bigDecimal3 = subtract.setScale(0, BigDecimal.ROUND_UP);
        return bigDecimal3.intValue();
    }

或者以下写法更简便

 @Override
    public int compareTo(Student o) {

        return Double.compare(this.height,o.height);
    }

关于BigDecimal搞定double精度丢失问题可以参考以下文章
BigDecimal搞定double精度丢失问题

降序

将return反着来，位置颠倒一下

@Override
    public int compareTo(Student o) {
//        if(this.age>o.age){
//            return 1;
//        }else if(this.age<o.age){
//            return -1;
//        }
//        else{
//            return 0;
//        }
//这是int类型的写法
**return o.age-this.age;**
    }

方式二

package com.ruoyi.project;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Comparator;

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


        Student student1 = new Student("小1", 160.1, 13);
        Student student2 = new Student("小2", 189.3000000002, 77);
        Student student3 = new Student("小3", 189.3000000001, 43);

        Student students[] = {student1, student2, student3};
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        System.out.println(Arrays.toString(students));

    }
}