浅谈对Lambda表达式和stream流的理解

Lambda表达式

Lambda表达式是在Jdk1.8之后推出的，Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。Lambda 表达式使用的前提是必须用函数式接口，函数式接口一般用于方法的增强，直接作为方法的参数，实现插件式编程。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

Lambda的基本格式为

(形式参数) -> {执行任务代码块}

Lambada表达式分为四种

1无参数无返回值Lambda

interface A {
    /**
     * 无参数无返回值 Lambda
     */
    void test();
}
public class Demo6 {
    public static void main(String[] args) {
        //匿名内部类 代码效率不高
       test(new A() {
           @Override
           public void test() {
               System.out.println("无参数无返回值 匿名内部类对象方法实现");
           }
       });
       //Lambda表达式
       test(() -> System.out.println("Lambda表达式初体验"));
    }
    public static void test(A a) {
        a.test();
    }
}

2无参数有返回值

@FunctionalInterface //函数式接口声明注解
interface  Supplier<T> {
    /*
    创建一个无参数有返回返回值的方法
     */
    T get();
}
public class Demo1 {
    public static void main(String[] args) {
  
        System.out.println(s);
        //Lambda表达式实现
        //testLambda(() ->{return "这里也是一个字符串";});
        //执行任务代码只有一行时，可以省略 {}
        String s1 = testLambda(() -> "我是一哥自负床");
        System.out.println(s1);
        //Lambda内部使用 使用方法局部变量
        String str = "name=小家银&age=33&country=中国";
        String s3=  testLambda(()->{
         String[] split = str.split("&");
           return split[1];
        });
        System.out.println(s3);
    

    }
    public static  String testLambda(Supplier<String> s) {
        return s.get();
    }

3无参数有返回值

@FunctionalInterface
interface  Supplier<T> {
    /*
    创建一个无参数有返回返回值的方法 生产者方法
     */
    T get();
}
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(s);
        //Lambda表达式实现
        String s1 = testLambda(() -> "我是一哥自负床");
        System.out.println(s1);
        //Lambda内部使用 使用方法局部变量
        String str = "name=小家银&age=33&country=中国";
        String s3=  testLambda(()->{
         String[] split = str.split("&");
           return split[1];
        });
        System.out.println(s3);

    }
    public static  String testLambda(Supplier<String> s) {
        return s.get();
    }

4有参数有返回值

@FunctionalInterface
interface Function<T,R> {
    //任意参数任意返回值的方法
    R apply(T t);
}
public class Demo2 {
    public static void main(String[] args) {
      String str = "信阳是一个不错的城市";
        //Lambda表达式方法参数
        int i = testLambda(str,String::length);
        System.out.println(i);
    }
    public static int testLambda(String str,Function<String,Integer> function) {
        return function.apply(str);
    }

Stream流

Stream（流）是一个来自数据源的元素队列并支持聚合操作

Stream不会存储元素，而是一系列的操作

流的来源：集合、数组、I/O channel、产生器generator 等

聚合操作：filter, map, reduce, find, match, sorted等。

使用.stream()变成流，然后进行一系列聚合操作。

这里我们主要关注用Stream流来操作集合

操作如下

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("卫龙辣条");
        list.add("乐事薯片");
        list.add("哇哈哈AD钙奶");
        list.add("旺仔牛奶");
        list.add("双汇王中王");
        list.add("牛肉干");
        System.out.println(list);
        list.stream() //获取String流对象
                .skip(2)  //忽略前两个的元素
                .limit(8) //限制后面有八个元素
                .filter(s -> s.length() >4) //过滤条件，length大于4
                .sorted(Comparator.comparing(String::length)) //根据字符串长度排序
                .forEach(System.out::println); //打印输出字符串
        ArrayList<Integer> list2 = new ArrayList<>();
        list2.add(100);
        list2.add(200);
        list2.add(300);
        list2.add(400);
        list2.add(400);
        list2.add(600);
        list2.add(700);
        list2.add(800);
        list2.add(800);
        list2.add(900);
        List<Integer> stream = list2
                .stream()
                .skip(1)
                .limit(9)
                .distinct()  //去重
                .sorted()
                .collect(Collectors.toList());
        System.out.println(stream);
        ArrayList<Person> list1 = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            int age = (int) (Math.random() * 50);
                list1.add(new Person(i+1,"张三",age));
            }
            list1
                .stream() //转换为Stream流
                .sorted((p1,p2)-> p2.getAge()- p1.getAge()) //定义排序规则
                .forEach(System.out::println); //输出打印
            //将当前ArrayList集合转换为List集合
        List<String> collect = list.stream().distinct().collect(Collectors.toList());
           //将当前ArrayList集合转换为Set集合
        Set<String> collect1 = list.stream().skip(2).limit(20).collect(Collectors.toSet());
        System.out.println();
        System.out.println(collect);
        System.out.println(collect1);
    }
}