java8 stream代码
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
public class User implements Serializable {
private static final long serialVersionUID = 1220193146286930256L;
private String id;
private String name;
private String groupId;
private int num;
private int age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGroupId() {
return groupId;
}
public void setGroupId(String groupId) {
this.groupId = groupId;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public User(String id, String name, String groupId, int num, int age) {
this.id = id;
this.name = name;
this.groupId = groupId;
this.num = num;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", groupId='" + groupId + '\'' +
", num=" + num +
", age=" + age +
'}';
}
private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Map<Object, Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
public static void main(String[] args) {
ArrayList<User> list = new ArrayList<>(10);
list.add(new User("1", "1号", "A", 10, 10));
list.add(new User("2", "2号", "A", 20, 10));
list.add(new User("3", "3号", "E", 50, 12));
list.add(new User("4", "4号", "B", 60, 20));
list.add(new User("5", "5号", "C", 80, 40));
list.add(new User("6", "6号", "B", 220, 20));
list.add(new User("7", "7号", "A", 110, 2));
list.add(new User("8", "8号", "D", 110, 68));
//去重复获取组
System.out.println("----------去重复获取组-------------------");
list.stream().filter(distinctByKey(User::getGroupId)).map(User::getGroupId).forEach(s -> {
System.out.println(s);
});
//从第2个开始(下标)
System.out.println("-------------从第2个开始----------------");
list.stream().skip(2).forEach(s -> {
System.out.println(s);
});
//取10以内的
System.out.println("-------------取10以内的----------------");
list.stream().filter(user -> user.getAge() <= 10).forEach(s -> {
System.out.println(s);
});
//取最大
System.out.println("----------------取最大-------------");
User user = list.stream().max(Comparator.comparing(User::getNum)).get();
System.out.println(user);
//分组求合
System.out.println("---------------分组求合--------------");
list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.summingInt(User::getNum))).forEach((k, v) -> {
System.out.println("K:" + k + "-V:" + v);
});
//分组取组内最大
System.out.println("--------------分组取组内最大---------------");
list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.maxBy(Comparator.comparingInt(User::getNum)))).forEach((k, v) -> {
System.out.println("K:" + k + "-V:" + v.get());
});
//分组取组内最小
System.out.println("------------分组取组内最小-----------------");
list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.minBy(Comparator.comparingInt(User::getNum)))).forEach((k, v) -> {
System.out.println("K:" + k + "-V:" + v.get());
});
//分组聚合多列
System.out.println("---------------分组聚合多列计算--------------");
list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.collectingAndThen(Collectors.toList(), users -> {
Double[] ints = new Double[2];
Double asDouble1 = users.stream().mapToInt(User::getNum).average().getAsDouble();
Double asDouble2 = users.stream().mapToInt(User::getAge).average().getAsDouble();
ints[0] = asDouble1;
ints[1] = asDouble2;
return ints;
}))).forEach((k, v) -> {
System.out.println("K:" + k + "-V:" + v[0] + "," + v[1]);
});
//分组后组内排序
System.out.println("---------------分组后组内排序--------------");
list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.collectingAndThen(Collectors.toList(), users -> {
users.sort(Comparator.comparing(User::getNum).reversed());
return users;
}))).forEach((k, v) -> {
System.out.println("k:" + k);
System.out.println("v----->:");
v.forEach(s -> {
System.out.println(s);
});
});
//分组后按某字段取最大值
System.out.println("---------------分组后按某字段取最大值--------------");
Map<String, User> userMap = list.stream().collect(Collectors.groupingBy(User::getGroupId,Collectors.collectingAndThen(Collectors.reducing((o1, o2) ->
Long.valueOf(o1.getId()).compareTo(Long.valueOf(o2.getId())) > 0 ? o1 : o2), Optional::get)));
Map<String, User> userMap = list.stream().collect(Collectors.toMap(User::getGroupId, Function.identity(),
(o1, o2) -> Long.valueOf(o1.getId()).compareTo(Long.valueOf(o2.getId())) > 0 ? o1 : o2));
}
//分组并对某个字段拼接处理
System.out.println("--------------分组并对某个字段拼接处理--------------");
Map<Long, String> longStringMap = list.stream().collect(Collectors.groupingBy(User::getGroupId, Collectors.mapping(User :: getName(), Collectors.joining(","))));
}
运行结果
----------去重复获取组-------------------
A
E
B
C
D
-------------从第2个开始----------------
User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
User{id=‘4’, name=‘4号’, groupId=‘B’, num=60, age=20}
User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
-------------取10以内的----------------
User{id=‘1’, name=‘1号’, groupId=‘A’, num=10, age=10}
User{id=‘2’, name=‘2号’, groupId=‘A’, num=20, age=10}
User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
----------------取最大-------------
User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
---------------分组求合--------------
K:A-V:140
K:B-V:280
K:C-V:80
K:D-V:110
K:E-V:50
--------------分组取组内最大---------------
K:A-V:User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
K:B-V:User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
K:C-V:User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
K:D-V:User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
K:E-V:User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
------------分组取组内最小-----------------
K:A-V:User{id=‘1’, name=‘1号’, groupId=‘A’, num=10, age=10}
K:B-V:User{id=‘4’, name=‘4号’, groupId=‘B’, num=60, age=20}
K:C-V:User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
K:D-V:User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
K:E-V:User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
---------------分组聚合多列计算--------------
K:A-V:46.666666666666664,7.333333333333333
K:B-V:140.0,20.0
K:C-V:80.0,40.0
K:D-V:110.0,68.0
K:E-V:50.0,12.0
---------------分组后组内排序--------------
Disconnected from the target VM, address: ‘127.0.0.1:55118’, transport: ‘socket’
k:A
v----->:
User{id=‘7’, name=‘7号’, groupId=‘A’, num=110, age=2}
User{id=‘2’, name=‘2号’, groupId=‘A’, num=20, age=10}
User{id=‘1’, name=‘1号’, groupId=‘A’, num=10, age=10}
k:B
v----->:
User{id=‘6’, name=‘6号’, groupId=‘B’, num=220, age=20}
User{id=‘4’, name=‘4号’, groupId=‘B’, num=60, age=20}
k:C
v----->:
User{id=‘5’, name=‘5号’, groupId=‘C’, num=80, age=40}
k:D
v----->:
User{id=‘8’, name=‘8号’, groupId=‘D’, num=110, age=68}
k:E
v----->:
User{id=‘3’, name=‘3号’, groupId=‘E’, num=50, age=12}
---------------分组并对某个字段拼接处理--------------
A “1号,7号,2号”
B “6号,4号”