Lambda、函数式接口、Stream流、序列化

一、Lambda表达式

函数编程思想
（1).不使用Lambda：需要定义类、创建对象；
（2).使用Lambda：不需要定义类，不需要创建对象。
Lambda相对于面向对象编程的优势：写法简单，可读性强。
缺省规则
1).形参相关：形参的数据类型都可以省略。
2).形参相关：如果形参只有一个，可以同时省略：数据类型、一对小括号。
注：如果省略小括号，必须同时省略数据类型
如果省略数据类型，可以不省略小括号。
3).方法体相关：如果方法体中只有一句话，可以同时省略：一对大括号、语句后的分号、最后的return关键字。
要省就全省，要用就全用

二、函数式接口

概述：：有且只有一个“自定义”的抽象方法(可以包含同Object类中声明相同的抽象方法)，这种接口叫：函数式接口。
函数式接口：Consumer接口
demo

	class Zi implements Consumer<String>{
    @Override
    public void accept(String s) {
        //转换为大写输出
        System.out.println(s.toUpperCase());
    }
}
public class Demo {
    public static void main(String[] args) {
        //1.子类形式
        Zi z = new Zi();
        fun(z);
        //2.匿名内部类形式
        fun(new Consumer<String>() {
            @Override
            public void accept(String s) {
                //转换为大写输出
                System.out.println(s.toUpperCase());
            }
        });
        
        //3.Lambda的形式
        fun(s -> System.out.println(s.toUpperCase()));
    }

    public static void fun(Consumer<String> con){
        con.accept("Hello");

    }
}

函数式接口：Predicate接口(判断接口)
demo

	class Zi implements Predicate<Integer> {
    @Override
    public boolean test(Integer integer) {
        return integer > 10;
    }
}
public class Demo {
    public static void main(String[] args) {
        //1.子类的形式
        fun(new Zi());
        //2.匿名内部类的形式
        fun(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer > 10;
            }
        });
        //3.Lambda表达式：
        fun(n -> n > 10);
        
    }
    
    public static void fun(Predicate<Integer> p){
        boolean b = p.test(20);
        System.out.println("判断结果：" + b);
    }
}

三、stream流

常用方法：

获取方式
1).通过Collection集合获取流：Collection接口的：默认方法：stream()获取流：
2).通过Map集合获取流：
3).通过数组(引用类型)获取流：
4).通过数组(基本类型)获取流：
5).通过零散数据获取流：
demo

	public static void main(String[] args) {
    //1).通过Collection集合获取流：Collection接口的：默认方法：stream()获取流：
    List<String> strList = new ArrayList<>();
    Stream<String> stream1 = strList.stream();

    Set<String> strSet = new HashSet<>();
    Stream<String> stream2 = strSet.stream();


    //2).通过Map集合获取流：【Map集合不能直接获取流】
    Map<Integer, String> map = new HashMap<>();
    //2-1:获取键的流
    Stream<Integer> keyStream = map.keySet().stream();
    //2-2:获取值的流
    Stream<String> valueStream = map.values().stream();
    //2-3:获取Entry的流
    Stream<Map.Entry<Integer, String>> entryStream = map.entrySet().stream();


    //3).通过数组(引用类型)获取流：
    Integer[] integerArray = {10, 20, 30};
    Stream<Integer> integerStream1 = Arrays.stream(integerArray);//方式一
    Stream<Integer> integerStream2 = Stream.of(integerArray);//方式二，注意：只能接收引用类型数组

    //4).通过数组(基本类型)获取流：
    int[] intArray = {1, 2, 3, 4};
    IntStream intStream1 = Arrays.stream(intArray);//方式一：
    IntStream intStream2 = IntStream.of(intArray);//方式二：


    //5).通过零散数据获取流：
    Stream<Integer> integerStream = Stream.of(10, 20, 30, 40, 50, 60, 70, 80);

}

综合案例

	public static void main(String[] args) {
    List<String> one = new ArrayList<>();
    one.add("迪丽热巴");
    one.add("宋远桥");
    one.add("苏星河");
    one.add("老子");
    one.add("庄子");
    one.add("孙子");
    one.add("洪七公");

    List<String> two = new ArrayList<>();
    two.add("古力娜扎");
    two.add("张无忌");
    two.add("张三丰");
    two.add("赵丽颖");
    two.add("张二狗");
    two.add("张天爱");
    two.add("张三");

    /*
        1. 第一个队伍只要名字为3个字的成员姓名；
        2. 第一个队伍筛选之后只要前3个人；

        3. 第二个队伍只要姓张的成员姓名；
        4. 第二个队伍筛选之后不要前2个人；

        5. 将两个队伍合并为一个队伍；
        6. 打印整个队伍的姓名信息。
     */
    Stream.concat(one.stream().filter(s -> s.length() == 3).limit(3),
    two.stream().filter(s -> s.startsWith("张")).skip(2))
            .forEach(s -> System.out.println(s));
}

将Stream中的数据提取到集合或数组中

	public static void main(String[] args) {
    List<String> one = new ArrayList<>();
    one.add("迪丽热巴");
    one.add("宋远桥");
    one.add("苏星河");
    one.add("老子");
    one.add("庄子");
    one.add("孙子");
    one.add("洪七公");

    //筛选出名字为三个字的学员，并存储到新集合
    List<String> collect = one.stream().filter(s -> s.length() == 3)
                                .collect(Collectors.toList());

    //转换为数组
    Object[] objArray = one.stream().filter(s -> s.length() == 3)
                            .toArray();
}

四、序列化

“序列化”：将一个“内存中的对象”的“名字” ，以及“属性的值”一起存储到一个“文件”中，这个过程叫：序列化。
“反序列化”：将之前“序列化”的对象，再次的“加载到内存，并创建对象”，这个过程叫：反序列化。