Java8--Lambada表达式对List的操作
实体类：
public class Apple {
private Integer id;
private String name;
private BigDecimal money;
private Integer num;
public Apple(Integer id, String name, BigDecimal money, Integer num) {
this.id = id;
this.name = name;
this.money = money;
this.num = num;
}
public Integer getId() {
return id;
}
public String getName() {
return name;
}
public BigDecimal getMoney() {
return money;
}
public Integer getNum() {
return num;
}
@Override
public String toString() {
return "Apple{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
", num=" + num +
'}';
}
}public class User {
private String name;
//age
private int age;
//分数
private double fraction;
public String getName() {
return name;
}
public int getAge() {
return age;
}
public double getFraction() {
return fraction;
}
public User(String name, int age, double fraction) {
this.name = name;
this.age = age;
this.fraction = fraction;
}
}填充List:
List<Apple> appleList = new ArrayList<>();//存放apple对象集合
Apple apple1 = new Apple(1, "苹果1", new BigDecimal("3.25"), 10);
Apple apple12 = new Apple(1, "苹果2", new BigDecimal("1.35"), 20);
Apple apple2 = new Apple(2, "香蕉", new BigDecimal("2.89"), 30);
Apple apple3 = new Apple(3, "荔枝", new BigDecimal("9.99"), 40);
appleList.add(apple1);
appleList.add(apple12);
appleList.add(apple2);
appleList.add(apple3);
List<User> userList = new ArrayList<>();
userList.add(new User("a1", 22, 2.2));
userList.add(new User("a2", 22, 2.5));
userList.add(new User("a3", 40, 2.7));
userList.add(new User("a4", 45, 2.8));
List<String> list1 = new ArrayList<>();
list1.add("111");
list1.add("222");
list1.add("333");
List<String> list2 = new ArrayList<>();
list2.add("111");
list2.add("333");
list2.add("444");
List -> Map:
//List 以ID分组 Map<Integer,List<Apple>>
Map<Integer, List<Apple>> groupBy = appleList.stream().collect(Collectors.groupingBy(Apple::getId));
System.out.println("groupBy:" + groupBy);
/**
* List -> Map
* 需要注意的是：
* toMap 如果集合对象有重复的key，会报错Duplicate key ....
* apple1,apple12的id都为1。
* 可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
*/
Map<Integer, Apple> map = appleList.stream().collect(Collectors.toMap(Apple::getId, a -> a, (k1, k2) -> k1));
for (Map.Entry<Integer, Apple> entry : map.entrySet()) {
System.out.println("key：" + entry.getKey() + "\nvalue:" + entry.getValue());
}过滤、去重、计算、定位取、取某个元素重新组成List：
//计算 总金额
BigDecimal totalMoney = appleList.stream().map(Apple::getMoney).reduce(BigDecimal.ZERO, BigDecimal::add);
System.out.println("totalMoney:" + totalMoney); //totalMoney:17.48
//去重
List<Apple> appleDistinctList = appleList.stream()
.collect(Collectors.collectingAndThen
(Collectors.toCollection(() ->
new TreeSet<>(Comparator.comparing(t -> t.getId()))),
ArrayList::new
)
);
System.out.println("appleDistinctList:" + appleDistinctList);
//取出属性中的某个值 重新组成list
List<String> appleNameList = appleList.stream()
.map(Apple::getName).collect(Collectors.toList());
System.out.println("appleNameList："+appleNameList);
//过滤名字为苹果的元素
List<Apple> appleList1 = appleList.stream().filter(x -> x.getName().equals("苹果1"))
.collect(Collectors.toList());
System.out.println("appleList1:"+appleList1);
//取前两位元素
List<Apple> limitList = appleList.stream().limit(2).collect(Collectors.toList());
System.out.println("limitList:"+limitList);
//取后两位元素
List<Apple> skipList = appleList.stream().skip(2).collect(Collectors.toList());
System.out.println("skipList:"+skipList);
//取第三位元素
List<Apple> collectList = appleList.stream().limit(3).skip(2).collect(Collectors.toList());
System.out.println("collectList:"+collectList);排序(升序、降序、多条件排序)：
//返回 对象集合以UsergetAge升序排序:年龄 --默认升序
userList.stream().sorted(Comparator.comparing(User::getAge));
//返回 对象集合以UsergetAge降序排序 ===这里写在前面 和写在后面要看清楚，弄明白
userList.stream().sorted(Comparator.comparing(User::getAge).reversed()); //排序结果后再排序,
userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()));//是直接进行排序
//返回 对象集合以UsergetAge升序排序:**年龄并返回前n个元素** --默认升序 ==下面同样写法
userList.stream().sorted(Comparator.comparing(User::getAge)).limit(2);
//返回 对象集合以UsergetAge升序排序:**年龄并去除前 n 个元素** --默认升序 ==下面同样写法
userList.stream().sorted(Comparator.comparing(User::getAge)).skip(2);
//返回 对象集合以UsergetAge升序 getFraction升序
userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getFraction));
//先以getAge升序,升序结果进行getAge降序,再进行getFraction升序
userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getFraction));
//先以getAge降序,再进行getFraction升序
userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getFraction));
//先以getAge升序,升序结果进行getAge降序,再进行getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getFraction, Comparator.reverseOrder()));
//先以getAge降序,再进行getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge, Comparator.reverseOrder()).thenComparing(User::getFraction, Comparator.reverseOrder()));
//先以getAge升序,升序结果进行getAge降序,再进行getFraction升序,结果进行getAge降序getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getFraction).reversed());
//先以getAge升序,再进行getFraction降序
userList.stream().sorted(Comparator.comparing(User::getAge).thenComparing(User::getFraction, Comparator.reverseOrder()));取交集、差集、并集：
// 交集
List<String> intersection = list1.stream().filter(item -> list2.contains(item)).collect(Collectors.toList());
System.out.println("---得到交集 intersection---");//333 111
intersection.parallelStream().forEach(System.out :: println);
// 差集 (list1 - list2)
List<String> reduce1 = list1.stream().filter(item -> !list2.contains(item)).collect(Collectors.toList());
System.out.println("---得到差集 reduce1 (list1 - list2)---");//222
reduce1.parallelStream().forEach(System.out :: println);
// 差集 (list2 - list1)
List<String> reduce2 = list2.stream().filter(item -> !list1.contains(item)).collect(Collectors.toList());
System.out.println("---得到差集 reduce2 (list2 - list1)---");//444
reduce2.parallelStream().forEach(System.out :: println);
// 并集
List<String> listAll = list1.parallelStream().collect(Collectors.toList());
List<String> listAll2 = list2.parallelStream().collect(Collectors.toList());
listAll.addAll(listAll2);
System.out.println("---得到并集 listAll---");//111 222 333 111 333 444
listAll.parallelStream().forEach(System.out :: println);
// 去重并集
List<String> listAllDistinct = listAll.stream().distinct().collect(Collectors.toList());
System.out.println("---得到去重并集 listAllDistinct---");//111 222 333 444
listAllDistinct.parallelStream().forEach(System.out :: println);
// 去重并集
Set<String> set = listAll.stream().collect(Collectors.toSet());
System.out.println("---得到去重并集 set---");//111 222 333 444
set.parallelStream().forEach(System.out :: println);
System.out.println("---原来的List1---");//111 222 333
list1.parallelStream().forEach(System.out :: println);
System.out.println("---原来的List2---");//111 333 444
list2.parallelStream().forEach(System.out :: println);鸣谢：
https://www.cnblogs.com/john8169/p/9780524.html
https://www.cnblogs.com/miaoying/p/13042091.html
https://blog.csdn.net/gzt19881123/article/details/78327465/
- 上一篇 »Java匹配正则表达式汇总
- 下一篇 »Java匹配正则表达式汇总