lambda表达式和Stream流式处理

清疚 2022-11-30 05:42 173阅读 0赞

--------------------

## 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);
        }
    }

--------------------