Java8新特性--lambda表达式

lambda表达式本质上是一个匿名函数，在lambda表达式中我们只需要关心参数列表以及方法体。优点是可以减少代码量。

1.语法

基本语法：(参数)->表达式 或 (参数) -> {语句;}

2.函数式接口

要了解lambda表达式，首先要了解什么是函数式接口，其定义是：一个接口有且只有一个抽象方法。

如下代码

@FunctionalInterface //用于声明该接口是一个函数式接口，即该接口中有且只有一个抽象方法
public interface Mytest {

    void test(int a,int b);

}

对比普通写法，可以看出使用lambda表达式代码量会减少许多。

// 普通写法
Mytest mytest = new Mytest() {
    @Override
    public void test(int a, int b) {
          System.out.println(a+b);
    }
};
mytest.test(1,2);

// 使用lambda表达式
Mytest mytest1 = (a,b) -> System.out.println(a+b);
mytest1.test(1,2);

使用lambda的几个新写法：

1.List列表打印foreach

List<String> list = Arrays.asList("aaa","bbb","ccc");
// 普通写法
for (String str: list) {
     System.out.println(str);
}
// 使用lambda表达式
list.forEach(str -> System.out.println(str)); //只需要关心参数列表和方法体
// 方法体只有一行语句可以省略大括号
list.forEach(str -> {
     System.out.println(str);
});

2.排序sort

List<String> list = Arrays.asList("aaa","aa","cde","a");
// 普通写法
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
           return o1.compareTo(o2);
    }
});
// 打印
list.forEach(s -> System.out.println(s));

// 使用lambda表达式
Collections.sort(list,(o1,o2) -> o1.compareTo(o2)); //只需要关心参数列表和方法体
// 打印
list.forEach(s -> System.out.println(s));

3.过滤filter

List<String> list = Arrays.asList("aaa","aa","cde","a");
// 普通写法
List<String> list1 = new ArrayList<>();
for (String str: list) {
 if(str.startsWith("a")) {
       list1.add(str);
 }
}
// 打印 
list1.forEach(s -> System.out.println(s));

// lambda新写法 使用stream流
list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
// 打印
list.forEach(s -> System.out.println(s));

4.求和操作reduce

List<Integer> list = Arrays.asList(1,2,3,4,5);
// 普通写法
int num = 0;
for (int i: list) {
    num += i;
}
System.out.println(num);

// 使用lambda表达式
Integer ret = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(ret);

5.计算每个字符串的长度map

List<String> list = Arrays.asList("aaa","aa","cde","a");
        //普通写法
        List<Integer> num = new ArrayList<>();
        for (String str: list) {
            num.add(str.length());
        }
        num.forEach( n -> System.out.println(n));


        // 使用lambda表达式
        List<Integer> num1 = list.stream().map(n -> n.length()).collect(Collectors.toList());
        num1.forEach(n -> System.out.println(n));

6.根据字符串长度进行分组groupingBy

 List<String> list = Arrays.asList("aaa","aa","cde","a");
        //普通写法
        Map<Integer,List<String>> map = new HashMap<>();
        for (String str : list) {
            if(!map.containsKey(str.length())) {
                map.put(str.length(),new ArrayList<>());
            }
            map.get(str.length()).add(str);
        }
        System.out.println(map);

        // 使用lambda表达式
        Map<Integer, List<String>> map1 = list.stream().collect(Collectors.groupingBy(s -> s.length()));
        System.out.println(map1);

7.List列表去重distinct

// 普通写法1
List<String> list = Arrays.asList("111","111","222","333","222");
List<String> tmp = new ArrayList<>();
for (String str: list) {
      if(!tmp.contains(str)) {
           tmp.add(str);
      }
}
tmp.forEach((s) -> System.out.println(s));
// 普通写法2
List<String> tmp1 = new ArrayList<>(new HashSet<>(list));
tmp1.forEach(s -> System.out.println(s));

// 使用stream流
List<String> ret = list.stream().distinct().collect(Collectors.toList());
ret.forEach(s -> System.out.println(s));

8.创建新线程

  // 普通写法
Thread thread = new Thread(new Runnable() {
      @Override
      public void run() {
          System.out.println("abc");
      }
});
thread.start();

// 使用lambda表达式
Thread thread1 = new Thread(() -> System.out.println("abc"));
thread1.start();