包装类，正则表达式 ，Arrays ，Lambda表达式

包装类

其实就是8种基本数据类型对应的引用类型。

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

Java提供包装类的原因：

1）Java为了实现一切皆对象，为8种基本数据类型提供了对应的引用类型。
2）集合和泛型只能支持包装类型，即引用类型。

基本数据类型和其对应的引用类型（包装类）能够实现自动装箱和自动拆箱

自动装箱：基本类型的数据和变量可以直接赋值给包装类型的变量
自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量

包装类的特有功能

1）包装类的变量的默认值可以是null，容错率更高（也就是比基本数据类型多了一个null值）

2）可以把基本类型的数据转换成字符串类型

①调用 toString() 方法得到字符串结果

        Integer a=5;
        String s= a.toString();
        System.out.println(a+1);   //结果为6
        System.out.println(s+1);  //结果为51

补充：调用 Objects.toString(基本类型的数据) 也可以得到字符串类型

        int a=5;
        String s=Objects.toString(a);

②调用 包装类.toString(基本类型的数据)

        int a=5;
        String s= Integer.toString(a);
        System.out.println(a+1);    //结果为6
        System.out.println(s+1);   //结果为51

3）可以把字符串类型的数值转换成真实的数据类型（很有用）

例子：Integer.parseInt(“字符串类型的整数”）（返回值类型为对应的基本数据类型）

       int a=5;
       String s= Integer.toString(a);
       int i= Integer.parseInt(s);

补充：我们还可以用一种方法把字符串转成对应包装类类型

例子：Integer.valueOf(“字符串类型的整数”）(返回值类型为对应的包装类类型)

        int a=5;
        String s= Integer.toString(a);
        Integer i= Integer.valueOf(s);

由于自动装箱和自动拆箱机制，究竟是用基本数据类型还是其对应的引用类型去接并不需要太考虑

正则表达式

正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。

我给大家几张图

这两张图就是对数据判断的常用规则，但只能判断一个字符

第一张图中的 [abc] 可以用来判断我们所给的字符是否是 a ,b ,c中的其中一个（中括号中的内容是我们可以自己定义）（这样，其他的也好理解了）
第二张图中 预定义的字符类 代表的就是其右边对应的 字符类 中的内容
（仔细想想，很好理解的）

为了解决只能判断一个字符的缺点，Java给出了贪婪的量词用于配合多个字符情况的使用，如下图

X就是字符类

那么我们知道了规则，该如何使用这些规则呢？

字符串对象提供了匹配正则表达式规则的API

public boolean matches(String regex); 判断是否匹配正则表达式，匹配返回true，不匹配返回false

示例代码如下

public static void main(String[] args) {
        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
    }

以上我们可以知道正则表达式可以为字符串对象服务，那么，我给大家两个在字符串方法适用于正则表达式的俩个方法

方法名	说明
①public String replaceAll(String regex,String newStr)；	按照正则表达式匹配的内容进行替换
②public String[] split(String regex)；	按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组

代码展示
①

String name="a1b2";
System.out.println(name.replaceAll("[a-z]+", "\t"));//结果为 1  2

②

String name="a1b2";
        String[] s=  name.split("\\D+") ;
        for (String s1 : s) {
            System.out.println(s1);
        } //结果为 1  2

正则表达式支持爬取信息
这个看看就行，格式是固定的

 String rs = "来黑马程序学习Java,电话020-43422424，或者联系邮箱" +
                "itcast@itcast.cn,电话18762832633，0203232323" +
                "邮箱bozai@itcast.cn，400-100-3233 ，4001003232";
        //需求:从上面的内容中爬取出 电话号码和邮箱。
        // 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());
        }

Arrays

Arrays类概述： 数组操作工具类，专门用于操作数组元素的。
Arrays类常用API：

方法名	说明
①public static String toString(类型[] a)	对数组进行排序
②public static void sort(类型[] a)	对数组进行默认升序排序
③public static < T > void sort(类型[] a,Comparator<? superT>c)	使用比较器对象自定义排序
④public static int binarySearch(int[] a, int key)	二分搜索数组中的数据，存在返回索引，不存在返回-1

（这几个方法都很简单，直接用就行）

第③个方法中提到到了比较器，在自定义排列规则时，设置Comparator接口对应的比较器对象，来定制比较规则，规则如下：

1）如果认为左边数据 大于 右边数据 返回正整数
2）如果认为左边数据 小于 右边数据 返回负整数
3）如果认为左边数据 等于 右边数据 返回0
（这是升序排放，如果想要降序，颠倒一下就行了）

Lambda表达式

Lambda是JDK8开始后的一种新语法形式。

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

Lambda表达式的简化格式

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

注意： Lambda表达式只能简化函数式接口的匿名内部类的写法形式

函数式接口

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

好处

Lambda是一个 匿名函数 ，我们可以把Lambda表达式理解为是一段可以传递的代码，它可以写出 更简洁，更灵活 的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升。

上述我们提到了一个比较器，那个就可以用Lanbda表达式简化
代码如下

        Integer[] a={10,50,32,62,90};
        Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });

简化后如下

        Integer[] a={10,50,32,62,90};
        Arrays.sort(a, ( o1,  o2) -> o1-o2 );

emm，简化多了，不影响，我说一下Lambda表达式的省略写法就都明白了
省略写法（在Lambda表达式的基础上进一步简化）

1）参数类型 可以省略不写。
2）如果只有一个参数，参数类型可以省略，同时 （） 也可以省略。
3）如果Lambda表达式的方法体代码只有一行代码，可以省略 {} 不写，同时要省略分号。
4）如果Lambda表达式的方法体代码只有一行代码，可以省略 {} 不写。此时，如果这行代码是return语句，必须省略return语句不写，同时也必须省略 ； 不写。