lambda表达式学习笔记

目录

1.匿名内部类

2.lambda表达式

2.1没被其他的方法调用实现方法

2.2被其他方法调用了实现方法

3.创建Stream流

4.中间操作

4.1filter 筛选

4.2Map 投影

4.3distinct 去重

4.4sorted 排序

4.5limit 

4.6skip

---

1.匿名内部类

说明：不关注继承/实现的类/接口的子类，只关注与传递的参数和重写/实现的方法

实现的接口：

public interface Hello {
    abstract void hello();
}

 创建的内部类：

new Hello() {
            @Override
            public void hello() {
                System.out.println("你好我是匿名内部类");
            }
        };

2.lambda表达式

2.1没被其他的方法调用实现方法

匿名内部类写法：

new Hello() {
            @Override
            public void hello() {
                System.out.println("你好我是匿名内部类");
            }
        }.hello();//.hello()是调用这个实现方法

lambda表达式：

((Hello) () -> System.out.println("你好我是匿名内部类")).hello();//没被其他方法调用时，必须指定类名

2.2被其他方法调用了实现方法

function接口：

调用的方法：

 public static  <R>R typeC (Function<String,R> function){
        String str="123";
        R apply = function.apply(str);
        return apply;

    }

匿名内部类写法：

Integer c = typeC(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });//被其他方法调用时，只需写参数和重写的方法

lambda表达式：

 Integer c = typeC(s -> Integer.valueOf(s));//被其他方法调用时，只需写参数和重写的方法

String s1 = typeC(s -> s + "sang");

3.创建Stream流

 注：entrySet把Map集合转换成Set集合

4.中间操作

准备工作：创建一个LIst<User>集合并赋值

  List<User> users = new ArrayList<>();
        User user1= new User("libai", 1001);
        User user2 = new User("lisi", 1002);
        users.add(user1);
        users.add(user2);

4.1filter 筛选

内部类形式：

        users.stream().filter(new Predicate<User>() {
            @Override
            public boolean test(User user) {
                return user.getId()>1001;
            }
        }).forEach(
                new Consumer<User>() {
                    @Override
                    public void accept(User user) {
                        System.out.println(user.getId());
                    }
                }
        );

lambda：

       users.stream().filter(user -> user.getId()>1001).forEach(
                user -> System.out.println(user.getId())
        );

注：filter参数为一个泛型，返回值为Boolean，即可以做判断并返回为true的流

4.2Map 投影

users.stream().map(new Function<User, String>() {
            @Override
            public String apply(User user) {
                return user.getName();
            }
        }).map(new Function<String, String>() {
            @Override
            public String apply(String name) {
                return name + "附加";
            }
        }).forEach(name-> System.out.println(name));

users.stream().map(user -> user.getName()).map(name->name+"附加").forEach(name-> System.out.println(name));

注：参数类型为：参数为一个泛型，返回值也是一个泛型，第一个Map跟SQL里的投影类似，第二个则可以对取到的投影值进行操作。

投影后，后续传递的参数就是投影的name。

4.3distinct 去重

注：distinct依赖equals方法，不重写就会调用Object的equals方法，但是Object的只能比对地址值，但是实际生产时，我们要比对地址or属性

users.stream().distinct().forEach(user -> System.out.println(user));

4.4sorted 排序

users.stream().distinct().sorted(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o2.getId() - o1.getId();
            }
        }).forEach(user -> System.out.println(user.getId()));

 users.stream().distinct().sorted((o1, o2) -> o2.getId()-o1.getId()).forEach(user -> System.out.println(user.getId()));

注：排序不能由重复的元素，所以提前去重

使用空参构造方法bean类要实现Comparator接口

传递的参数是两个一样的泛型，返回值是下面两种形式：

o2.getId()-o1.getId()：降序

o1.getId()-o2.getId()：升序

4.5limit 

        users.stream().distinct().sorted((o1, o2) -> o2.getId() - o1.getId()).limit(1).forEach(user -> System.out.println(user.getId()));

注：跟SQL的limit类似

4.6skip

 users.stream().distinct().sorted((o1, o2) -> o2.getId() - o1.getId()).skip(1).forEach(user -> System.out.println(user.getId()));

注：跟limit相反，取第n位之后的流