java基础进阶学习笔记Day05（黑马磊哥课程）_黑马磊哥javaapi文档-优快云博客

day05-常用API(二)：Lambda、方法引用详解

Arrays工具类

用来操作数组的工具类

setAll方法：

    public static void main(String[] args) {

        double[] score = {99.5,54,34.5,33,96};
        //需求：每个加10分
        Arrays.setAll(score, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int value) {//value：索引
                return score[value]+10;//访问方法中的局部变量score
            }
        });
        System.out.println(Arrays.toString(score));//[109.5, 64.0, 44.5, 43.0, 106.0]

    }

要注意，匿名内部类是一种局部内部类，可以访问方法中的局部变量（只能是 final or effectively final（未修改））。如果访问修改后的局部变量，则会报错：

setAll方法源码如下：

上面是典型的对象回调思想。

对数组中的数据进行排序

int[] arr = new int[]{5,4,3,8,6,2};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));//[2, 3, 4, 5, 6, 8]

对数组中的自定义对象进行排序

如果是自定义的类Student，直接使用Arrays.sort(students)会报错：class com.itheima.Student cannot be cast to class java.lang.Comparable。因为sort方法不知道按照什么规则进行比较~~~~

自定义排序规则方式一：实现Comparable接口，重写compareTo

public class Student implements Comparable<Student> {//泛型要填的是：需要和谁比
    String name;
    int age;
    char gender;
    double height;

    //指定大小规则
    //比较者：this
    //被比较者：o
    @Override
    public int compareTo(Student o) {
        /**
         * 官方规则：
         * 如果认为左边大于右边，返回正数
         * 如果认为左边小于右边，返回负数
         * 如果认为左边大等于右边，返回0
         * 只要这么干，默认就是升序排序
         */
        return this.age - o.age; //升序
        // return o.age - this.age; //降序
    }

自定义排序规则方式二：使用sort重载方法，提供比较器对象

        //给存储对象的数组进行排序
        Student[] students = new Student[4];
        students[0] = new Student("aaa",23,'男',156.7);
        students[1] = new Student("bbb",26,'男',166.6);
        students[2] = new Student("ccc",13,'男',178.1);
        students[3] = new Student("ddd",32,'女',145.7);

        // Arrays.sort(students);//报错：class com.itheima.Student cannot be cast to class java.lang.Comparable
        // System.out.println(Arrays.toString(students));

        //自定义排序规则方式一：让对象所在的类实现Comparable接口，重写CompareTo方法，来指定比较规则
        //Arrays.sort(students);
        //System.out.println(Arrays.toString(students));

        //自定义排序规则方式二：使用sort的重载方法，创建Comparator比较器接口的匿名内部类对象，来自己制定比较规则
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

优先级：如果对象所在的类实现Comparable接口，且使用sort的重载方法传入比较器，则优先按照sort重载方法中传入的比较器制定的比较规则

对二维数组中的一维数组排序：

要求：按照第一个元素升序，如果第一个元素相同，就按照第二个元素降序排序

    public static void main(String[] args) {

        int[][] arr = {{2,5},{3,10},{2,4},{1,2},{1,3}};//要求按照第一个元素升序，如果第一个元素相同，就按照第二个元素降序排序

        Arrays.sort(arr, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0]==o2[0]){
                    return o2[1]-o1[1];
                }
                return o1[0]-o2[0];
            }
        });

        for (int i = 0; i < arr.length; i++) {//[1, 3]	[1, 2]	[2, 5]	[2, 4]	[3, 10]	
            System.out.print(Arrays.toString(arr[i]) +"\t");
        }
        
    }

Lambda表达式

Lambda表达式是JDK 8开始新增的一种语法形式； 作用：用于简化匿名内部类的代码写法。

注意：

Lambda表达式只能简化函数式接口的匿名内部类！！！
必须是接口，不能是抽象类！！！

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

例子：

Lambda表达式的省略规则（进一步简化）

参数类型可以不写
如果只有一个参数，参数类型可以省略，同时（）可以省略
如果方法体只有一行代码，那么可以省略大括号，同时要省略方法体中的分号。此时，如果是return语句，return必须省略。

JDK8新特性：方法引用（进一步简化Lambda表达式）

简化没有道理，就是规定

静态方法引用

实例方法引用

特定类型方法引用

使用场景：

可以简化为

构造器引用

二分查找

前提条件：数组中的数据必须是有序的

正则表达式

    public static void main(String[] args) {
        System.out.println(checkQQ("234566"));
        System.out.println(checkQQ("0234566"));
    }

    public static boolean checkQQ(String qq){
        return qq!=null && qq.matches("[1-9]\\d{5,}");
        //"\\" 才表示一个真正的反斜杠 \       所以 \\d 最终变成了 正则里的 \d
        //在java中，\是有特殊用途的，一般作为特殊字符使用(\n  \t)
    }

案例：校验邮箱的合法性

//dawd@134.com.cn

案例：手机号的合法性

//要求:1开头，第二位[3-9]，后面随便

public static void main(String[] args) {
    String phone = "13812345678";
    boolean isValid = phone.matches("1[3-9]\\d{9}");
    System.out.println("手机号合法: " + isValid);
}

正则表达式爬取内容

案例：使用正则表达式查找一段文本中的内容

搜索替换和内容分割

replaceAll()和.split()