Lambda表达式、Stream流式处理

---

一、Lambda表达式是什么？

二、Lambda表达式语法

@FunctionalInterface   //通知编译器这是函数式接口，进行抽象方法检查
public interface MathOperation {
    public Float operate(Integer a,Integer b);
}

public class LambdaSample {
    public static void main(String[] args) {
        //1.标准使用方式
        //2.约束条件:Lambda表达式只能实现有且只有一个抽象方法的接口，java称为"函数式接口"
        MathOperation addition = (Integer a,Integer b)->{
            System.out.println("加法");
            return a+b+0f;
        };
        System.out.println(addition.operate(5, 3));

        //2.Lambda允许忽略参数类型
        MathOperation substraction=(a,b)->{
            return a-b+0f;
        };
        System.out.println(substraction.operate(5, 3));

        //3.单行实习代码可以省略大括号和return
        MathOperation multiplication = (a,b)->a*b+0f;
        System.out.println(multiplication.operate(5, 3));
    }
}

三、函数式编程

1.Consumer函数式接口

public class ConsumerSample {
    public static void main(String[] args) {
        outout(s-> System.out.println(s));
    }
    public static void outout(Consumer<String> consumer){
        String text="锄禾日当午";
        consumer.accept(text);
    }
}

2.Function函数式接口

public class FunctionSample {
    public static void main(String[] args) {
        Function<Integer,String> randomStringFunction = l->{
            String chars="abcdefghijklmnopqrstuvwsyz";
            StringBuilder stringBuilder=new StringBuilder();
            Random random=new Random();
            for(int i=0;i<l;i++){
                int i1 = random.nextInt(chars.length());
                stringBuilder.append(chars.charAt(i1));
            }
            return stringBuilder.toString();
        };
        String apply = randomStringFunction.apply(16);
        System.out.println(apply);
    }
}

3.Predicate函数式接口

public class PredicateSample {
    public static void main(String[] args) {
        Predicate<Integer> predicate = n->n>4;
        boolean res = predicate.test(5);
        System.out.println(res);
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        filter(list, n->n%2==1);
        filter(list, n->n%2==0);
        filter(list, n->n%2==0&&n>5);
    }
    public static void filter(List<Integer> list,Predicate<Integer> predicate){
        for(Integer num:list){
            if(predicate.test(num)){
                System.out.print(num+" ");
            }
        }
        System.out.println("");
    }
}

4.函数式编程和面向对象编程比较

四、Stream流式处理

1.Stream流的五种创建方式

public class StreamGenerator {
    //1.基于数组进行创建
    @Test
    public void generator1(){
        String[] arr={"Lily","Andy","Jackson"};
        Stream<String> stream=Stream.of(arr);
        stream.forEach(s-> System.out.println(s));
    }
    //2.基于集合进行创建
    @Test
    public void generator2(){
        List<String> list = new ArrayList<>();
        list.add("Lily");
        list.add("Andy");
        list.add("Jackson");
        Stream<String> stream = list.stream();
        stream.forEach(s-> System.out.println(s));
    }
    //3.利用generate方法创建无限长度流
    @Test
    public void generator3(){
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100000));
        stream.limit(10).forEach(i-> System.out.println(i));
    }
    //4.基于迭代器创建流
    @Test
    public void generator4(){
        Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
        stream.limit(100).forEach(i-> System.out.println(i));
    }
    //5.基于字符序列创建流
    @Test
    public void generator5(){
        String str="Abcdefg";
        IntStream stream = str.chars();
        stream.forEach(c-> System.out.println((char)c));
    }
}

2.stream常用方法

public class StreamMethod {
    //提取集合中所有偶数并求和
    @Test
    public void case1(){
        List<String> list = Arrays.asList("1", "2", "3", "4", "5");
        int sum = list.stream().mapToInt(s -> Integer.parseInt(s)).filter(n -> n % 2 == 0).sum();
        System.out.println(sum);
    }

    //所有名字首字母大写
    @Test
    public void case2(){
        List<String> list = Arrays.asList("lily", "smith", "jackson");
        List<String> collect = list.stream().map(s -> s.substring(0, 1).toUpperCase() + s.substring(1)).collect(Collectors.toList());
        System.out.println(collect);
    }

    //将所有奇数从小到大排序
    @Test
    public void case3(){
        List<Integer> list = Arrays.asList(1, 60, 38, 21, 51, 60, 51, 73);
        List<Integer> collect = list.stream().distinct().filter(n -> n % 2 == 1).sorted((a, b) -> b - a).collect(Collectors.toList());
        System.out.println(collect);
    }
}