JAVA之常用API

Arrays

用来操作数组的工具类。

 

package d3_Arrays;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.function.IntToDoubleFunction;

public class ArraysTest1 {
    public static void main(String[] args) {
        // 1、public static String toString(类型[] arr)  返回数组的内容
        int[] arr = {10, 20, 30, 40, 50, 60};
        System.out.println(Arrays.toString(arr)); // [10, 20, 30, 40, 50, 60]

        // 2、public static intl copyOfRange(类型[arr,起始索引,结束索引)
        // 拷贝数组(指定范围)
        int[] arr2 = Arrays.copyOfRange(arr,1,4);
        System.out.println(Arrays.toString(arr2)); // [20, 30, 40]

        // 3、public static copyOf(类型[]arr,int newLength)  拷贝数组
        int[] arr3 = Arrays.copyOf(arr,10);
        System.out.println(Arrays.toString(arr3)); // [10, 20, 30, 40, 50, 60, 0, 0, 0, 0]

        // 4、public static setAll(doublel array, IntToDoubleFunction generator)
        // 把数组中的原数据改为新数据
        double[] prices = {99.8, 128, 100};
        //把所有的价格都打八折，然后又存进去
        Arrays.setAll(prices, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {
                //value = 0 1 2
                return prices[value] * 0.8;
            }
        });
        System.out.println(Arrays.toString(prices)); // [79.84, 102.4, 80.0]

        //5、public static void sort(类型[] arr)
        // 对数组进行排序(默认是升序排序)
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices)); // [79.84, 80.0, 102.4]
    }
}

 Arrays.sort()不能直接对对象进行排序（不知道针对什么排序）；

方式一：让该对象的类实现Comparable（比较规则）接口，然后重写compareTo方法，自己来制定比较规则。

// 制定比较规则
    // this o
    @Override
    public int compareTo(Student o) {
        // 约定1：认为左边对象 大于 右边对象 请您返回正整数
        // 约定2：认为左边对象 小于 右边对象 请您返回负整数
        // 约定3：认为左边对象 等于 右边对象 请您一定返回0
        // 按照年龄升序排序
//        if(this.age > o.age){
//            return 1;
//        }else if (this.age < o.age){
//            return -1;
//        }
        System.out.println(o);
//        return 0;
//        return this.age - o.age;//升序
        return o.age - this.age;//降序
    }


Arrays.sort(students); //报错
        System.out.println(Arrays.toString(students));

package d3_Arrays;

public class Student  implements Comparable<Student>{
    private String name;
    private double height;
    private int age;

    // 制定比较规则
    // this o
    @Override
    public int compareTo(Student o) {
        // 约定1：认为左边对象 大于 右边对象 请您返回正整数
        // 约定2：认为左边对象 小于 右边对象 请您返回负整数
        // 约定3：认为左边对象 等于 右边对象 请您一定返回0
        // 按照年龄升序排序
//        if(this.age > o.age){
//            return 1;
//        }else if (this.age < o.age){
//            return -1;
//        }
        System.out.println(o);
//        return 0;
//        return this.age - o.age;//升序
        return o.age - this.age;//降序
    }

    public Student() {
    }

    public Student(String name, double height, int 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 int getAge() {
        return age;
    }

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

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

package d3_Arrays;

import java.security.PublicKey;
import java.util.Arrays;

public class ArraysTest2 {
    public static void main(String[] args) {
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精",169.5,23);
        students[1] = new Student("紫霞",163.8,24);
        students[2] = new Student("紫霞",163.8,24);
        students[3] = new Student("至尊宝",167.5,22);

        //1、public static void sort（类型[] arr）：对数组进行排序
        Arrays.sort(students); //报错
        System.out.println(Arrays.toString(students));
        // [Student{name='至尊宝', height=167.5, age=22}, Student{name='蜘蛛精', height=169.5, age=23},
        // Student{name='紫霞', height=163.8, age=24}, Student{name='紫霞', height=163.8, age=24}]

        //

    }
}

方式二：使用下面这个sort方法，创建Comparator比较器接口的匿名内部类对象，然后自己制定比较规则。

public static<T> void sort(T[] arr, Comparator<? super T>c) 
//对数组进行排序(支持自定义排序规则)

//2、public static <T> void sort(T[] arr, Comparator<? super T> c)
        // 参数一：需要排序的数组
        // 参数二：Comparator比较器对象（用来制定对象的比较规则）
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 约定1：认为左边对象 大于 右边对象 请您返回正整数
                // 约定2：认为左边对象 小于 右边对象 请您返回负整数
                // 约定3：认为左边对象 等于 右边对象 请您一定返回0
//                if(o1.getAge() > o2.getAge()){
//                    return 1;
//                }else if(o1.getAge() < o2.getAge()) {
//                    return -1;
//                }return 0;
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        System.out.println(Arrays.toString(students));

 Lambda表达式

 是JDK 8开始新增的一种语法形式； 作用：用于简化匿名内部类的代码写法。（只能简化函数式接口的匿名内部类！！）

函数式接口：有且仅有一个抽象方法的接口。  

格式：
（被重写方法的形参列表）->{
    被重写方法的方法体代码。
}