lambda表达式和Stream流式处理

---

Lambda表达式

lambda表达式 ，把代码变的更加简单。可读性比较差。

1. 简化匿名内部类的编写。
2. 直接实现接口中的函数
3. 函数实现用"->" 表示实现。{ }表示实现的具体逻辑。
4. 用接口去声明使用
5. 用声明的变量调用实现 的方法

interface Inter{
    int c();
}
interface Inter1{
    int c(int x);
}

interface A{
    int c(int a,int b);
}

interface B{
    void b(String str);
}

public class Lambda {
    // 函数传递的形式。parm1=数值1  ，parm2=数值2 ，parm3=运算方式
    private static int test(int x,int y,A a) {
        return a.c(x,y);
    }

    public static void main(String[] args) {
        new B() {
            @Override
            public void b(String str) {
                System.out.println(str);
            }
        }.b("hello");

        //
        B b1 = (String str) -> { System.out.println(str);};
        b1.b("ptao");
        B b2 = (s) -> System.out.println(s);
        b2.b("gege");

        //lambda表达式 ；实现接口A。
        A a1 = (x,y) -> {return x - y;};
        a1.c(25,20);          // 没有声明具体类型

        //接收声明 类型参数
        A a2 = (int a,int b) -> {return a / b;};
        A a3 = (int a,int b) -> a + b;

        a2.c(12,6);
        a3.c(15,3);
        A a4 = (a,b) -> a*b;

        //传递接口，实现不同业务的访问
        int s = test(5,7,a4);
        System.out.println(s);
        System.out.println(test(6,8,a3));

        // 匿名内部类：（无参）
        new Inter() {
            @Override
            public int c() {
                return 5;
            }
        }.c();
        //lambda表达式
        Inter i = () -> 6;
        i.c();

        //匿名内部类：（有参）
        new Inter1() {
            @Override
            public int c(int x) {
                return x * 5;
            }
        }.c(6);
        //lambda表达式
        Inter1 in = (x) -> x * 3;
        in.c(6);
    }
}

---

Stream流式处理

把一个数据集中的元素 并行聚会处理，stream的使用，就是实现一个filter-map-reduce过程。

public class Stream {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(100, 200, 400, 500, 300);
        // stream（）为list集合，去创建串行流
        java.util.stream.Stream<Integer> stream = list.stream();
        java.util.stream.Stream<Integer> map = stream.map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer t) {
                return t / 2;
            }
        });
        //遍历数组
        map.forEach(System.out::println);
        //简化
        Arrays.asList(100,200,400,500,300).stream().map((i) -> i/2).forEach(System.out::println);

        
        Integer num[] = {1,2,3,4,5,6,7,8,9};
        // Stream.of();管道流     / 从123456789中取奇数偶数。 filter过滤方法（）
        // 过滤 转化的过程： 归并操作。将转化的数据流放到集合或集合元素中。 Collectors返回列表或字符串。
        java.util.stream.Stream.of(num).filter(n -> n%2==0).forEach(x -> System.out.print(x + " "));
        java.util.stream.Stream.of(num).filter(n -> n%2!=0).forEach(x -> System.out.print(x + " "));
        
        // 取偶数，然后把取到的偶数放到一个数组中
        Integer[] t = java.util.stream.Stream.of(num).filter(n -> n%2==0).toArray(Integer[]::new);
        for (Integer integer : t) {
            System.out.println(integer);
        }
        
        // 把奇数放到集合容器中 list中。
        java.util.stream.Stream.of(num).filter(n -> n%2!=0).collect(Collectors.toList());


        //reduce: 求和   求最大  求最小  聚会操作
        Integer[] nums = {1,2,3,4,5,6,7};
        int sum = java.util.stream.Stream.of(nums).reduce(0,(a,b) -> a + b);
        java.util.stream.Stream.of(nums).reduce(0, Integer::sum);
        java.util.stream.Stream.of(nums).reduce(0, Integer::max);
        System.out.println(sum);


        java.util.stream.Stream<List<Integer>> inputStream = java.util.stream.Stream.of(Arrays.asList(1), Arrays.asList(2, 3), Arrays.asList(4, 5, 6));
        //flatMap扁平化处理
        java.util.stream.Stream<Integer> outputStream = inputStream.flatMap(x -> x.stream());
        outputStream.forEach(a -> System.out.print(a+" "));

        //把字符串转化成大写，并转化成一个list容器。“ ”隔开的每一个单词
        String str = "a bc s f as afa fafas fa f e";
        List<String> stringList = Arrays.asList(str.split(" ")).stream().map(String::toUpperCase).collect(Collectors.toList());
        stringList.forEach(System.out::println);
    }
}

---