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.  map 从一个包含多个对象的List集合中，提取这些对象的某个属性，并返回一个新的List集合

// 使用lambda表达式
// 目的从 List<UserInfo> 提取用户名属性值，并组成 List<String> 返回
// map里的UserInfo是对象，getUsername是get方法命
List<String> username =
list.stream().map(UserInfo::getUsername).collect(Collectors.toList());

7. 根据字符串长度进行分组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);

8. 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));

9. 创建新线程

  // 普通写法
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();