【JAVA】包装类、正则表达式、Arrays类、Lambda表达式

1 包装类

包装类是8种基本数据类型对应的引用类型

作用：后期的集合和泛型不支持基本类型，只能使用包装类

基本数据类型和其对应的引用数据类型的变量可以互相赋值

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

• 包装类的变量默认值可以是null，容错率更高
• 可以把基本类型的数据转换成字符串类型（调用 基本数据类型的变量.toString()或Integer.toString(基本数据类型的变量)得到字符串)
• 可以把字符串类型的数值转换成真实的数据类型

//将字符串类型的整数转为int型
int a = Integer.parseInt("字符串类型的整数");
int a2 = Integer.valueOf("字符串类型的整数");
//将字符串类型的小数转为double型
double b = Double.parseDouble("字符串类型的小数");
double b2 = Double.valueOf("字符串类型的小数");

2 正则表达式

字符类（默认匹配一个字符）

|---------------------|--------------------------|
| [abc] | 只能是a, b, 或c |
| [^abc] | 除了a, b, c之外的任何字符 |
| [a-zA-Z] | a到z A到Z，包括（范围） |
| [a-d[m-p]] | a到d，或m通过p：（[a-dm-p]联合） |
| [a-z&&[def]] | d, e, 或f(交集) |
| [a-z&&[^bc]] | a到z，除了b和c：（[ad-z]减法） |

System.out.println("a".matches("[abc]")); // true
System.out.println("z".matches("[abc]")); // false
System.out.println("ab".matches("[abc]")); // false
System.out.println("ab".matches("[abc]+")); //true

预定义的字符类（默认匹配一个字符）

|----------------------|--------------------------------|
| . | 任何字符 |
| \d | 一个数字： [0-9] |
| \D | 非数字： [^0-9] |
| \s | 一个空白字符： [ \t\n\x0B\f\r] |
| \S | 非空白字符： [^\s] |
| \w 或 [a-zA-Z_0-9] | 英文、数字、下划线 |
| \W 或 [^\w] | 一个非单词字符 |

量词（多个字符）

|---------|------------|
| X? | X一次或根本没有 |
| X* | X零次或多次 |
| X+ | X一次或多次 |
| X {n} | X正好n次 |
| X {n, } | X至少n次 |
| X {n,m} | X至少n但不超过m次 |

// 验证手机号
boolean p = phoneNumber.matches("1[3-9]\\d{9}");

|------------------------------------------------------|--------------------------------|
| public String replaceAll(String regex,String newStr) | 按照正则表达式匹配的内容进行替换 |
| public String[] split(String regex)： | 按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。 |

// 将字符串里的字母替换成a
String name = "昨天lllll再见bye";
String na = name.split("\\w+", 'a')  // 昨天a再见a
// 遇见字符串里的字母分割
String[] naArr = name.split("\\w+") // [昨天,再见]

/* 正则表达式获取信息 */

String rs = "明天你好，我是今天电话123-12322424，邮箱" +
        "123@qq.com,电话13512345678，0203232323" +
        "邮箱123@qq.com，123-123-1234 ，1231231234";

// 需求：从上面的内容中获取电话号码和邮箱。

// 1.规则
String regex = "(\\w{1,}@\\w{2,10}(\\.\\w{2,10}){1,2})|" + "(1[3-9]\\d{9})|(0\\d{2,5}-?\\d{5,15})|400-?\\d{3,8}-?\\d{3,8}";

// 2.编译正则表达式成为一个匹配规则对象
Pattern pattern = Pattern.compile(regex);

// 3.通过匹配规则对象得到一个匹配数据内容的匹配器对象
Matcher matcher = pattern.matcher(rs);

// 4.通过匹配器去内容中爬取出信息
while(matcher.find()){
    System.out.println(matcher.group());
}

3 Arrays类

数组操作工具类，操作数组元素

|--------------------------------------------------------------------|------------------------------------------|
| public static String toString(类型[] a) | 返回数组内容的字符串字符串，形状还是数组形状，类型是字符串 |
| public static void sort(类型[] a) | 对数组进行默认升序排序，无返回值 |
| public static <T> void sort(类型[] a, Comparator<? super T> c) | 使用比较器对象自定义排序 |
| public static int binarySearch(int[] a, int key) | 二分搜索数组中的数据，在排好序的数组a种查找key，存在返回索引，不存在返回-1 |

排序

|--------------------------------------------------------------------|--------------|
| public static void sort(类型[] a) | 对数组进行默认升序排序 |
| public static <T> void sort(类型[] a, Comparator<? super T> c) | 使用比较器对象自定义排序 |

// 自定义数组降序排,仅支持引用数据类型
Integer[] a = [1,3,5,9]
Arrays.sort(a, new Comparator<Integer>(){
    @Override
    public int compare(Integer a1, Integer a2){
        return a2 - a1;
        // 因为返回值必须是整数，若比较的值是浮点型，可以下面这个写法
        // return Double.compare(a2, a1)
    }
});

4 Lambda表达式

简化函数式接口的匿名内部类的写法

(匿名内部类被重写方法的形参列表) -> {
   被重写方法的方法体代码。
}

函数式接口：

• 必须是接口，并且接口中有且仅有一个抽象方法
• 通常我们会在接口上加上一个@FunctionalInterface注解，标记该接口必须是满足函数式接口。

public class LambdaDemo1 {
    public static void main(String[] args) {
        goSwimming( new Swimming() {
            @Override
            public void swim() {
                System.out.println("游泳");
            }
        } );
    }
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

简化后 swim()

public class LambdaDemo1 {
    public static void main(String[] args) {
        goSwimming( () -> {
	System.out.println("游泳") } );
        
    }
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

// 自定义数组降序排,仅支持引用数据类型
Integer[] a = [1,3,5,9]
/**
Arrays.sort(a, new Comparator<Integer>(){   
    @Override
    public int compare(Integer a1, Integer a2){
        return a2 - a1;    
});
**/
// 简化后
Arrays.sort(a,(Integer a1, Integer a2) -> {
        return a2 - a1;    
});

表达式的省略写法

• 参数类型可以省略不写。
• 如果只有一个参数，参数类型可以省略，同时()也可以省略。
• 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写,同时要省略分号
• 如果Lambda表达式的方法体代码只有一行代码。可以省略大括号不写。此时，如果这行代码是return语句，必须省略return不写，同时也必须省略runturn语句的分号

// 简化后
Arrays.sort(a,(a1, a2) -> a2 - a1);