十个Lambda表达式小技巧

进行集合遍历

1
2
3
4
List<String> list = Arrays.asList("apple", "banner", "orange");
for (String s : list) {
    System.out.println(s);
}

这个是一个普通的遍历方法。

之后我们来看经过lambda优化后的

1
2
3
list.forEach(s->{
    System.out.println(s);
});

之后也更加简化：

1
list.forEach(System.out::println);

排序

1
2
3
4
5
6
7
List<String> list = Arrays.asList("apple", "banner", "orange");
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

这个是正常的方法

下面我们来看简化的

1
Collections.sort(list,(o1,o2)->o1.compareTo(o2));

这个就可以看到优化的是非常的多了

过滤

1
2
3
4
5
6
7
8
List<String> list = Arrays.asList("apple", "banner", "orange");
List<String> list2 = new ArrayList<>();

for (String s:list){
    if (s.startsWith("a")) {
        list2.add(s);
    }
}

正常的代码。

经过lambda表达式优化后的代码

1
list.stream().filter(s->s.startsWith("a")).collect(Collectors.toList());

映射

1
2
3
4
5
6
List<String> list = Arrays.asList("apple", "banner", "orange");
List<Integer> list2 = new ArrayList<>();

for (String s : list) {
    list2.add(s.length());
}

下面来看简化

1
List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());

规约

1
2
3
4
5
6
7
8
    List<Integer> list=Arrays.asList(1,2,3,4,5);
    int sum=0;
    for (Integer v : list) {
        sum+=v;
    }
    System.out.println(sum);

}

一个很简单，但是又不能不用for循环

1
list.stream().reduce(0,(a,b)->a+b);

首先第一个参数是初始值，代表着累加器的初始值。

分组

1
2
3
4
5
6
7
8
9
List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer,List<String>> groups=new HashMap<>();
for (String s : list) {
    int length = s.length();
    if (!groups.containsKey(length)){
        groups.put(length,new ArrayList<>());
    }
    groups.get(length).add(s);
}

一个按照长度分组的代码

1
Map<Integer,List<String>> group2=list.stream().collect(Collectors.groupingBy(String::length));

函数式接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.xiaou;

interface MyInterface{
    public void doSomething(String s);
}

public class Test {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething(String s) {
                System.out.println(s);
            }
        };
        myInterface.doSomething("hello world");

    }
}

正常情况下，我们需要重写其方法

我们来看lambda表达式的优化

1
2
MyInterface myInterface1=(s)-> System.out.println(s);
myInterface1.doSomething("hello world");

创建线程

1
2
3
4
5
6
7
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("hello world");
    }
});
thread.start();

这是正常去创建一个线程

下面来看lambda表达式简化

1
2
Thread thread1 = new Thread(() -> System.out.println("hello world"));
thread1.start();

进行optional操作

1
2
3
4
String str="hello world";
if (str!=null){
    System.out.println(str.toUpperCase());
}

进行简化

1
Optional.ofNullable(str).map(String::toUpperCase).ifPresent(System.out::println);

optional有很多的操作。这里就不多说了。

进行stream的流水

1
2
3
4
5
6
7
8
9
List<String> list = Arrays.asList("apple", "orange");
List<String> list2 = new ArrayList<>();
for (String s : list) {
    if (s.startsWith("a")){
        list2.add(s.toUpperCase());
    }
}

Collections.sort(list2);

这是一个普通的写法。下面来看lambda的优化。

1
2
List<String> list3=list.stream().filter(s->s.startsWith("a"))
        .map(String::toUpperCase).sorted().collect(Collectors.toList());

总结

最后我想说，lambda不会提高效率。匿名内部类对性能有损耗，只是会提高一些编码的效率。lambda还是很有必要去进行一个学习的。