java中Arrays类和Lambda表达式和方法引用

Arrays类：用来操作数组的工具类

public static String toString(int[] a)

Returns a string representation of the contents of the specified array. The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(int). Returns "null" if a is null.

返回数组的内容

public static int[] copyOfRange(int[] original, int from, int to) 

拷贝数组，范围包前不包后 

public static int[] copyOf(int[] original, int newLength) 

 拷贝数组，并指定新数组的长度

public static void setAll(double[] array, IntToDoubleFunction generator)

把数组中的原数据改为新数据又存进去

public static void sort(int[] a) 

对数组进行排序，默认是升序

 

public class test {
    public static void main(String[] args) {
        int []arr=new int[]{11,22,33};
        System.out.println(arr);//打印的是地址
        //[I@b4c966a
        //1:返回数组的数据
        System.out.println(Arrays.toString(arr));//[11, 22, 33]


        //2；拷贝数组
        int []byy=Arrays.copyOfRange(arr,0,arr.length);
        System.out.println(Arrays.toString(byy));//[11, 22, 33]

        int []cyy=Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(cyy));

        //4:setAll
        double []prices={12.5,90.5,34.8};
        //要求每个打八折并返回
        Arrays.setAll(prices, new IntToDoubleFunction() {//内部类
            @Override
            public double applyAsDouble(int value) {
                //把double类型变成BigDecimal类型来计算
                BigDecimal b=BigDecimal.valueOf(prices[value]);
                BigDecimal count=BigDecimal.valueOf(0.8);
                return b.multiply(count).doubleValue();
            }
        });
        System.out.println(Arrays.toString(prices));//[10.0, 72.4, 27.84]
        //5:sort
        Arrays.sort(prices);
        System.out.println(Arrays.toString(prices));//[10.0, 27.84, 72.4]
    }
}

如果数组存储的是对象，改如何排序

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

方法二
参数一：要排序的数组
参数二：Comparator匿名内部类

学生类：

public class Student implements Comparable<Student>{
    private String name;
    private double height;
    private int 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 +
                '}';
    }

    @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;
        }
        return 0;*/
        return this.age-o.age;//升序
        //return o.age-this.age;//降序

    }
}

 测试类：

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

public class test2 {
    public static void main(String[] args) {
        Student[]students=new Student[3];
        students[0]=new Student("aa",168.5,18);
        students[1]=new Student("bb",189.5,20);
        students[2]=new Student("cc",170.0,34);

        //Arrays.sort(students);//直接调用sort报错

        //方法一：让该对象的类实现Comparable(比较规则)接口，然后重写compareTo方法，自己制定比较规则
       Arrays.sort(students);
        System.out.println(Arrays.toString(students));
        //[Student{name='aa', height=168.5, age=18}, Student{name='bb', height=189.5, age=20}, Student{name='cc', height=170.0, age=34}]

        //方法二
        //参数一：要排序的数组
        //参数二：Comparator匿名内部类
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照身高升序
               /* if(o1.getHeight()>o2.getHeight())
                {
                    return  1;
                } else if (o1.getHeight()<o2.getHeight()) {
                    return -1;
                }
                return 0;*/
               // return Double.compare(o1.getHeight(),o2.getHeight());//等同上面
                //身高降序
                return  Double.compare(o2.getHeight(),o1.getHeight());
            }
        });
        System.out.println(Arrays.toString(students));
        //[Student{name='bb', height=189.5, age=20}, Student{name='cc', height=170.0, age=34}, Student{name='aa', height=168.5, age=18}]
    }
}

Lambda表达式

作用：用于简化匿名内部类的代码写法

//注意：Lambda表达式并不是能简化全部匿名内部类的写法，只能简化函数接口的匿名内部类，

且函数接口只有一个抽象函数

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

        go(new Animal() {
            @Override
            public void run() {
                System.out.println(
                        "cat run"
                );
            }
        });
       /* go(()->
        {
            System.out.println(
                    "cat run"
        });*/
        //error Lambda表达式用于接口类的匿名内部类,且函数接口只有一个抽象函数
        Swimming s=new Swimming() {
            @Override
            public void swim() {
                System.out.println("hh is swimming");
            }
        };
        s.swim();
        //用Lambda表达式
        Swimming s2=()->//（括号里面要写上抽象函数的参数，没有就不写）
        {
            System.out.println("xx is swimming");
        };
        s2.swim();
    }


    public static void go(Animal animal)
    {
        animal.run();
    }

}
interface Swimming
{
    public void swim();
}
abstract class Animal
{
    public abstract void  run();
}

 //用Lambda表达式
        Swimming s2=()->//（括号里面要写上抽象函数的参数，没有就不写）
        {
            System.out.println("xx is swimming");
        };

 简化：

 /* Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照身高升序
               *//* if(o1.getHeight()>o2.getHeight())
                {
                    return  1;
                } else if (o1.getHeight()<o2.getHeight()) {
                    return -1;
                }
                return 0;*//*
               // return Double.compare(o1.getHeight(),o2.getHeight());//等同上面
                //身高降序
                return  Double.compare(o2.getHeight(),o1.getHeight());
            }
        });*/
        Arrays.sort(students,(Student o1, Student o2)->
        {
            return Double.compare(o1.getHeight(),o2.getHeight());
        });

Lambda表达式的省略规则

1参数类型可以不写

2如果只有一个参数，参数类型可以省略，同时（）也可以省略

3如果Lambda表达式中方法体代码只有一行代码，可以省略大括号不写，同时要省略分号（这一行代码的分号）。此时，如果这行代码是return 语句，可以省略return 不写

 /*Arrays.sort(students,(Student o1, Student o2)->
        {
            return Double.compare(o1.getHeight(),o2.getHeight());
        });*/
        Arrays.sort(students,(o1,o2)->
             Double.compare(o1.getHeight(),o2.getHeight())
        );

方法引用

静态方法引用

用法：类名::静态方法

使用场景：如果某个Lambda表达式只是调用一个静态方法，并且前后参数一致，就可以使用静态方法引用。

public class compareByData {

    public static int compareByAge(Student o1,Student o2) {
        return o1.getAge()-o2.getAge();
    }
}

public class test {
    public static void main(String[] args) {
        Student[]students=new Student[3];
        students[0]=new Student("aa",168.5,18);
        students[1]=new Student("bb",189.5,20);
        students[2]=new Student("cc",170.0,34);
       /* Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge()-o2.getAge();//按照年龄升序
            }
        });*/
        //Lambda表达式
        //Arrays.sort(students,(o1,o2)-> o1.getAge()- o2.getAge());

       // Arrays.sort(students,(o1,o2)->compareByData.compareByAge(o1,o2));
//前后参数一样，直接使用静态方法引用
        Arrays.sort(students,compareByData::compareByAge);
        System.out.println(Arrays.toString(students));
    }
}

实例方法的引用：
用法：对象名::实例方法

使用场景：如果某个Lambda表达式只是调用一个实例方法，并且前后参数一致，就可以使用实例方法引用。

public class compareByData {

    public static int compareByAge(Student o1,Student o2) {
        return o1.getAge()-o2.getAge();
    }

    public int compareByAgeDesc(Student o1,Student o2)
    {
        return o2.getAge()-o1.getAge();
    }

}

 Arrays.sort(students,(o1,o2)->o2.getAge()- o1.getAge() );
        compareByData compare=new compareByData();
        Arrays.sort(students,(o1, o2) -> compare.compareByAgeDesc(o1,o2));//实现年龄降序
        //前后参数一样，直接用实例方法调用
        Arrays.sort(students,compare::compareByAgeDesc);
        System.out.println(Arrays.toString(students));

特定类型的方法引用：
使用：类型::方法

使用场景：如果某个Lambda表达式只是调用一个实例方法，并且前面参数列表第一个参数是作为方法的主调，后面得到所有参数都是作为该实例方法的入参的，则此时可以使用特定类型的方法引用。

public class test2 {
    public static void main(String[] args) {
        String []names={"Ani","Bc","aa","hh","jj","BB","bb"};

        Arrays.sort(names);
        //按照首字母的编号进行升序
        System.out.println(Arrays.toString(names));
        //[Ani, BB, Bc, aa, bb, hh, jj]

        //要求：忽略大小写
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareToIgnoreCase(o2);
            }
        });
        //Lambda
        Arrays.sort(names,(o1, o2) -> o1.compareToIgnoreCase(o2));
//前面参数列表第一个参数是作为方法的主调，后面得到所有参数都是作为该实例方法的入参的，则此时可以使用特定类型的方法引用。        
        Arrays.sort(names,String::compareToIgnoreCase);
        System.out.println(Arrays.toString(names));//[aa, Ani, BB, bb, Bc, hh, jj]
    }
}

 构造器引用

用法：类名::new

使用场景：如果某个lambda表达式只是在创建对象，并且前后参数一致，就可以使用构造器引用

Car类：
 

public class Car {
    private String name;
    private double price;

    public Car() {
    }

    public Car(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 "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

public class test3 {
    public static void main(String[] args) {
       /* createCar cc=new createCar() {
            @Override
            public Car create(String name, double price) {
                return new Car(name,price);
            }
        };*/

        //Lambda
        //createCar cc=(name,price)->new Car(name,price);
        //Lambda表达式只是在创建一个对象，且前后参数一致，使用构造器引用
        createCar cc=Car::new;
        Car bwm=cc.create("BWM",50.0);
        System.out.println(bwm);
    }
}
interface createCar
{
    Car create(String  name,double price);
}