lambda常见使用方法
文章目录
-
-
- 前言
- 介绍
- 遍历
- 排序
- 过滤
- 映射
- 归纳
- 分组
- 实现接口
- 线程
- 判空
- 流水线
- 总结
-
前言
之前在携程实习，遇到了lambda表达式，最近逛b站，刚好看到了。顺手整理一下。参考链接
介绍
- lambda是一种提高生产力的一种书写代码的方式。
- 代码中有很多的箭头，箭头左边是参数。例如，遍历的时候，每一个item，然后右边是要进行的操作。
- 代码中用到了很多的“::”其实就是调用这个方法，然后形参跟我传递进来的一样，所以直接不写形参了。例如s -> s.length()可以直接修改为String::length。
遍历
- 需求：打印list中的内容
import java.util.Arrays;
import java.util.List;
public class 遍历 {
public static void main(String[] args) {
List<String> list = Arrays.asList("apple", "banana", "orange");
// 传统方式
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// lambda-非简写
list.forEach(l -> System.out.println(l));
// lambda-简写
// 如果要调用一个方法，并且方法中只有传递一个参数，而参数就是list的item，那么可以不用写传递的参数了
list.forEach(System.out::println);
}
}
排序
- 需求：对list进行排序
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class Num2排序 {
public static void main(String[] args) {
List<String> list = Arrays.asList("banana", "apple", "orange");
// 传统方式
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
// lambda
// 这里面o1,o2就是上面重写的compare的两个参数，而后面的就是return的内容，这里会自动进行return
list.sort((o1, o2) -> o1.compareTo(o2));
}
}
过滤
- 需求：过滤list中首字母是a的元素
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
public class Num3过滤 {
public static void main(String[] args) {
List<String> list = Arrays.asList("banana", "apple", "orange");
// 传统方式
List<String> list2 = new LinkedList<>();
for (String s : list) {
if (s.startsWith("a")) {
list2.add(s);
}
}
// lambda
// 这里需要借助list的stream。并且filter以后，并不是list，需要使用.collect(Collectors.toList())转成list
List<String> list3 = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
}
}
映射
- 统计list中每个元素的长度
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
public class Num4映射 {
public static void main(String[] args) {
List<String> list = Arrays.asList("banana", "apple", "orange");
// 传统方式
List<Integer> list2 = new LinkedList<>();
for (String s : list) {
list2.add(s.length());
}
// lambda
// 与过滤类似，但是这里需要用map。其实map表示我返回的不是之前的元素类型了。之前过滤的时候，返回的还是string，但是这里是要求Integer
// 并且s -> s.length()可以直接修改为String::length
List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());
}
}
归纳
- 需求：对元素进行求和
import java.util.Arrays;
import java.util.List;
public class Num5归纳 {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 传统方式
int sum = 0;
for (Integer i : list) {
sum += i;
}
System.out.println(sum);
// lambda
// 这里依旧需要借助stream，然后使用reduce函数，第一个参数为变量初始值，也就是传统方法中sum的初始值。然后a表示上一次的sum值，b表示当前遍历的值
// 这里(a, b) -> a + b可以直接使用Integer::sum
int sum2 = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum2);
}
}
分组
- 需求：根据元素的长度对元素进行分组
import java.util.*;
import java.util.stream.Collectors;
public class Num6分组 {
public static void main(String[] args) {
List<String> list = Arrays.asList("banana", "apple", "orange");
// 传统方式
Map<Integer, List<String>> groups = new HashMap<>();
for (String s : list) {
int length = s.length();
if (!groups.containsKey(length)) {
groups.put(length, new LinkedList<>());
}
groups.get(length).add(s);
}
// lambda
// 这里用到了Collectors的groupingBy，注意Collectors是stream包中的
Map<Integer, List<String>> groups2 = list.stream().collect(Collectors.groupingBy(String::length));
}
}
实现接口
- 需求：实现一个接口
public class Num7接口 {
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
// 这里可以是(s) -> System.out.println(s)
MyInterface myInterface2 = System.out::println;
myInterface2.doSomething("hello world！");
}
}
interface MyInterface {
void doSomething(String s);
}
线程
- 需求：创建线程，打印hello world！
public class Num8线程 {
public static void main(String[] args) {
// 传统方式
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello world！");
}
});
thread.start();
// lambda
// 其实就是实现接口
Thread thread2 = new Thread(() -> System.out.println("hello World!"));
thread2.start();
}
}
判空
- 需求：将字符串的内容转为大写
import java.util.Optional;
public class Num9判空 {
public static void main(String[] args) {
// 传统方式
String str = "hello world!";
if (str != null) {
System.out.println(str.toUpperCase());
}
// lambda
// 这里用到了Optional，然后进行判空，随后使用map进行类型转换，然后如果存在内容的话，就打印
Optional.ofNullable(str).map(String::toUpperCase).ifPresent(System.out::println);
}
}
流水线
- 需求：过滤出list中字母为a开头的，并且转成大写，然后继续排序
import java.util.*;
import java.util.stream.Collectors;
public class Num10流水线 {
public static void main(String[] args) {
List<String> list = Arrays.asList("banana", "apple", "orange");
// 传统方式
List<String> list2 = new LinkedList<>();
for (String s : list) {
if (s.startsWith("a")) {
list2.add(s.toUpperCase());
}
}
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
// lambda
List<String> list3 =
list.stream().filter(s -> s.startsWith("a")).map(String::toUpperCase).sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.toList());
}
}
总结
- 如果需要用filter是继续过滤的，如果还需要修改这个元素，则需要使用map进行修改。
- 使用“::”的时候是在括号中的，并且之前的形式是由入参和入参传递到右侧方法的，而且顺序和个数一致。