一、Arrays类

数组操作工具，专门操作数组元素；

1.Arrays类常用API

`Arrays.toString(数组)`	返回数组内容
`Arrays.sort();`	排序
`Arrays.binarySearch(数组, 目标值);`	二分搜索

/**
 * 返回数组内容toString(数组)
 * 排序Arrays.sort();
 * 二分搜索：Arrays.binarySearch(arr, 55);
 */
public class ArraysDemo01 {
    public static void main(String[] args) {
        int[] arr = {10,5,66,34,55,88};
        //[I@1b6d3586
        System.out.println(arr);
        //返回数组内容toString(数组)
        //[10, 5, 66, 34, 55, 88]
        System.out.println(Arrays.toString(arr));

        //排序API，默认数组升序
        Arrays.sort(arr);
        //[5, 10, 34, 55, 66, 88]
        System.out.println(Arrays.toString(arr));

        //二分搜素技术，（前提是排序完成，否则bug）
        int i = Arrays.binarySearch(arr, 55);
        //3
        System.out.println(i);
        //-7; 数组中找不到该元素 - （应当插入索引位+1）
        System.out.println(Arrays.binarySearch(arr, 555));
    }
}

2.自定义比较器

/**
 * Comparator比较器
 */
public class ArraysDemo02 {
    public static void main(String[] args) {
        Integer[] arr = {10,5,66,34,55,88};
        //[10, 5, 66, 34, 55, 88]
        System.out.println(Arrays.toString(arr));

        //自定义比较器对象，只能用引用类型；
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                //return o1-o2;//默认升序
                return o2-o1;//降序
            }
        });

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

        System.out.println("==========排序学生信息============");
        Student[] students = new Student[3];
        students[0] = new Student("a",20,173.3);
        students[1] = new Student("b",19,163.4);
        students[2] = new Student("c",24,163.3);
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //return o1.getAge() - o2.getAge();//根据年龄正序排列
                return Double.compare(o1.getHeight(), o2.getHeight());//根据身高正排，专门处理浮点型
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

二、常见算法

1.选择排序

1.1选择排序思想

每轮选择当前位置，找后面比他小的交换位置；
第一轮先找出最小的放在开始，与冒泡相反（找最大）

1.2关键

选择轮次：数组长度-1；
控制每轮开始位置，与后面元素选择次数；

/**
 * 选择排序
 */
public class Test {
    public static void main(String[] args) {
        int[] arr = {10,5,66,34,55,88};
        //选择排序;a[i]锁定每次循环开始位置
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length ; j++) {
                if (arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));

        //冒泡排序
        int[] arr2 = {10,5,66,34,55,88};
        for (int i = 0; i < arr2.length-1; i++) {
            //j < arr2.length - i - 1;每次循环排出最大值后，下一次排序-1
            for (int j = 0; j < arr2.length - i - 1; j++) {
                if (arr2[j]>arr2[j+1]){
                    int temp = arr2[j];
                    arr2[j] = arr2[j+1];
                    arr2[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr2));
    }

}

2.二分查找

2.1概述

二分查找查询性能好，但前提是必须排好序；
找数组中间位置值和变量比较；
- 大，向右+1，和最后位取中间位置比较；
- 小，向左-1和最初位取中间位置比较，
- 重复直到查到
- 最大最小索引相等，还没找到，失败；

/**
 * 二分查找，效率高
 */
public class Test02 {
    public static void main(String[] args) {
        int[] arr = {5, 10, 34, 55, 66, 88,98,99};
        System.out.println(binarySearch(arr,99));
        System.out.println(binarySearch(arr,34));
        System.out.println(binarySearch(arr,35));

    }
    public static int binarySearch(int[] arr,int data){
        //定义左右起始索引
        int left = 0;
        int right = arr.length-1;

        while (left <= right){
            int middleIndex = (left + right)/2;
            if (data > arr[middleIndex]){
                left = middleIndex+1;
            }else if (data < arr[middleIndex]){
                right = middleIndex-1;
            }else {
                return middleIndex;
            }
        }
        return -1;
    }
}

三、正则表达式

1.概述

用规定字符制定规则，检验数据格式合法性

124正则表达式规则.png

2.正则表达式的匹配规则

/**
 * Regex用法演示
 *  public boolean matches(String regex)
 */
public class RegexDemo02 {
    public static void main(String[] args) {
        /**
         * 以下都是判断单字符
         */
        //只能是abc
        System.out.println("a".matches("[abc]"));//true
        System.out.println("z".matches("[abc]"));
        //不能是abc
        System.out.println("a".matches("[^abc]"));
        System.out.println("z".matches("[^abc]"));//true

        //第一个\是转义字符;  \d只能是一个数字
        System.out.println("a".matches("\\d"));
        System.out.println("3".matches("\\d"));//true
        System.out.println("33".matches("\\d"));
        
        // \w数字字符下划线都可；  \W非上述
        System.out.println("a".matches("\\w"));//true
        System.out.println("2".matches("\\w"));//true
        System.out.println("23".matches("\\w"));
        System.out.println("你".matches("\\w"));
        //  \W大W一个非单词字符
        System.out.println("你".matches("\\W"));//true

        /**
         * 以下都是判断字符串
         */
        //密码，必须是数字字母下划线，至少6位
        System.out.println("fsafwefw454_55".matches("\\w{6,}"));//true
        System.out.println("fsaf".matches("\\w{6,}"));
        
        //验证码，必须4位，只能是数字和字符
        System.out.println("fd34".matches("[a-zA-Z0-9]{4}"));//true
        System.out.println("fd_4".matches("[a-zA-Z0-9]{4}"));
        System.out.println("fd34".matches("[\\w&&[^_]]{4}"));//true
        System.out.println("fd_4".matches("[\\w&&[^_]]{4}"));
    }
}

3.常见验证

/**
 * 验证手机号码，邮箱，电话
 */
public class RegexDemoTest03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
//        checkPhone(scanner);
//        checkEmail(scanner);
        checkTel(scanner);
    }

    public static void checkTel(Scanner scanner){
        while (true) {
            System.out.println("请输入电话：");
            String tel = scanner.next();
            //0开头；2-6位区号， - 隔开； 5-20位电话号
            if (tel.matches("0\\d{2,6}-?\\d{5,20}")){
                System.out.println("电话格式正确");
                break;
            }else {
                System.out.println("电话格式有误");
            }
        }
    }

    public static void checkEmail(Scanner scanner){
        while (true) {
            System.out.println("请输入邮箱：");
            String email = scanner.next();
            //1476361615@qq.com
            //1476361615@163.com
            //666_cxkcoder@pci.com.cn
            //前面任意字符1-30个; @ ; 非下划线后缀1-20；（\\.需要转义;非下划线后缀1-20）{至少1次，至多2}
            if (email.matches("\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2}")){
                System.out.println("邮箱正确");
                break;
            }else {
                System.out.println("邮箱有误");
            }
        }
    }

    public static void checkPhone(Scanner scanner){
        while (true) {
            System.out.println("请输入手机号码");
            String phone = scanner.next();
            //第一位必须是1;第二位是3-9;剩下九位必须是数字
            if (phone.matches("1[3-9]\\d{9}")){
                System.out.println("手机号正确");
                break;
            }else {
                System.out.println("手机号有误");
            }
        }
    }
}

4.正则表达式应用在方法中

/**
 * 正则表达式应用在方法中
 */
public class RegexDemo04 {
    public static void main(String[] args) {
        String names = "杨过fasdfasw过儿fsadf小果果";
        //以字母为分割依据
        String[] arrs = names.split("\\w+");
        System.out.println(Arrays.toString(arrs));

        String names2 = names.replaceAll("\\w+", "  ");
        //杨过  过儿  小果果
        System.out.println(names2);
    }
}

5.爬虫搜索

/**
 * 爬取信息
 */
public class RegexDemo05 {
    public static void main(String[] args) {
        String rs = "报名新东方，联系电话020-859664235，" +
                "或者发送邮箱xindognfang@163.com,电话13299889654，" +
                "或者邮箱666@qq.com,电话052999154854,手机19866563223" +
                ",电话400-520-99988";
        //1.定义爬取规则，字符串形式
        String regex = "(1[3-9]\\d{9})" +
                "|(\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2})" +
                "|(0\\d{2,6}-?\\d{5,20})" +
                "|(400-?\\d{2,6}-?\\d{3,9})";

        //2.爬取规则编译成匹配对象
        Pattern pattern = Pattern.compile(regex);
        //3.得到内容匹配器对象
        Matcher matcher = pattern.matcher(rs);
        //4.开始匹配
        while (matcher.find()){
            String data = matcher.group();
            System.out.println(data);
        }

    }
}

四、Lambda表达式

1.概述

JDK 8后开始的一种新语法；
作用：简化匿名内部类的代码写法；
注意：只能简化函数式接口的匿名内部类的写法形式

简化格式：

  (匿名内部类被重写方法的形参列表) ->{
  	被重写方法体的代码
  }
  注：->是语法形式，无实际含义

2.函数式接口

首先是必须是接口，其次接口中有且仅有一个抽象方法的形式；
通常接口上加一个@Functionallnterface注解，标记该接口必须是满足函数式接口；
- 一旦加上@Functionallnterface注解，只能有一个抽象方法

/**
 * Lambda表达式
 */
public class LambdaDemo01 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("游泳s");
            }
        };
        go(s);

        //Lambda表达式简化
        Swimming ss = () -> { System.out.println("游泳ss"); };
        go(ss);
        //Lambda表达式简化2
        go(() -> { System.out.println("游泳sss"); });
    }

    public static void go(Swimming swimming){
        System.out.println("start");
        swimming.swim();
    }
}


//一旦加上@Functionallnterface注解，必须是函数式接口，只能有一个抽象方法
@FunctionalInterface
interface Swimming {
    void swim();
}

3.简化常见函数接口

/**
 * Lambda表达式简化比较器
 */
public class LambdaDemo02 {
    public static void main(String[] args) {
        Integer[] arr = {10,5,66,34,55,88};
        //自定义比较器对象，只能用引用类型；
        Arrays.sort(arr, (Integer o1, Integer o2) ->{
                return o2-o1;//降序
            });

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

        Student[] students = new Student[3];
        students[0] = new Student("a",20,173.3);
        students[1] = new Student("b",19,163.4);
        //根据double身高排序
        Arrays.sort(students, Comparator.comparingDouble(Student::getHeight));
        //原型
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());//根据身高正排，专门处理浮点型
            }
        });
    }
}

4.Lambda表达式省略写法

参数类型可省略；
只有一个参数，()可以省略；
方法体代码只有一行，省略大括号不写，同时省略分号；
- 如果这行代码是return语句，必须省略return

/**
 * Lambda表达式简化
 * 进一步省略
 */
public class LambdaDemo03 {
    public static void main(String[] args) {
        Integer[] arr = {10,5,66,34,55,88};
        Arrays.sort(arr, (Integer o1, Integer o2) ->{
                return o2-o1;//降序
            });
        //参数类型可省略
        Arrays.sort(arr, (o1,o2) ->{
            return o2-o1;//降序
        });
        //方法体代码只有一行，省略大括号不写，同时省略分号
        //如果这行代码是return语句，**必须省略return**
        Arrays.sort(arr, (o1,o2) -> o2-o1 );
        
        //只有一个参数，()可以省略；
        Swimming ss = ( (name) ->  System.out.println("游泳ss"));
        Swimming ss2 = (name ->  System.out.println("游泳ss"));
    }
}

RecordDate：2021/08/13

JavaSE进阶笔记：05 （Arrays类、正则表达式、Lambda表达式）

一、Arrays类

1.Arrays类常用API

2.自定义比较器

二、常见算法

1.选择排序

1.1选择排序思想

1.2关键

2.二分查找

2.1概述

三、正则表达式

1.概述

2.正则表达式的匹配规则

3.常见验证

4.正则表达式应用在方法中

5.爬虫搜索

四、Lambda表达式

1.概述

2.函数式接口

3.简化常见函数接口

4.Lambda表达式省略写法