本文介绍了Java Stream API中常用的分组和排序方法，展示了如何先按学生姓名分组，再对每个组内的学生按分数进行排序。同时，文章还提供了单个对象和集合对象复制的实用方法，利用BeanUtils实现属性拷贝。这些技巧对于日常Java开发中处理数据流和对象转换非常有用。
目录
一、前言
记录一下常用方法，好记性不如烂笔头。后续会继续补充一些开发过程中用到过的方法，方便查阅。
参考文章: [1] java Stream流常用方法
二、常用方法
1、过滤（文[1] ）
//根据指定sn,过滤出符合的数据: List<Map<String, Object>> deviceDataList
List<Map<String, Object>> tempDeviceDataList = deviceDataList.stream().filter(map -> map.get("sn").toString().equals(sn)).collect(Collectors.toList());
//筛选出工资大于10000的职员
List<Employee> newList = list.stream().filter(item -> {
return item.getSalary().compareTo(new BigDecimal(10000)) > 0 && !item.getWorkType().equals("项目经理");
}).collect(Collectors.toList());
2、分组（文[1] ）
// 按照sn分组: List<Map<String, Object>> dataList
Map<String, List<Map<String, Object>>> dataMap = dataList.stream().collect(Collectors.groupingBy(e -> e.get("sn") + ""));
//按照职员部分分组: List<Employee> list
Map<String, List<Employee>> collect = list.stream().collect(Collectors.groupingBy(i -> i.getUnitName()));
//多条件分组
Map<String, Map<String,List<Employee>>> collect =list.stream().collect(Collectors.groupingBy(i -> i.getUnitName(),Collectors.groupingBy(i -> i.getWorkType())));
//按年龄分组，年龄相同的是一组
Map<Integer, List<Person>> 分组 = list.stream().collect(Collectors.groupingBy(Person::getAge));
//按年龄分组后按工资分组，多级分组
Map<Integer, Map<String, List<Person>>> 多级分组 = list.stream().collect(Collectors.groupingBy(Person::getAge, Collectors.groupingBy(x -> {
return x.getSalary() > 3000 ? "高" : "低";
})));
// 分组排序 ，拿已经排好序的过来分组
LinkedHashMap<String, List<AttendanceRuleGroup>> groupingByruleGroupList = ruleGroupList.stream().collect(Collectors.groupingBy(AttendanceRuleGroup::getCategory, LinkedHashMap::new, Collectors.toList()));
// 分组排序，集合没排序，我们自己按我们想要的排序
LinkedHashMap<String, List<AttendanceRuleGroup>> groupingByruleGroupList = ruleGroupList.stream().sorted(Comparator.comparingLong(AttendanceRuleGroup::getSort).reversed()).collect(Collectors.groupingBy(AttendanceRuleGroup::getCategory, LinkedHashMap::new, Collectors.toList()));
3、分区（文[1] ）
//List<Employee> list
//单层分区
Map<Boolean, List<Employee>> collect = list.stream().collect(Collectors.partitioningBy(i -> i.getId() == 1));
//分区 满足条件的一个区，不满足条件的一个区
Map<Boolean, List<Person>> collect1 = list.stream().collect(Collectors.partitioningBy(e -> e.getSalary() < 2000));
//多层分区
Map<Boolean, Map<Boolean,List<Employee>>> collect = list.stream().collect(Collectors.partitioningBy(i -> i.getId() == 1,Collectors.partitioningBy(i -> i.getSalary().compareTo(new BigDecimal(20000)) == 0)));
4、拼接（文[1] ）
//将某个字段,按照某个字符串拼接: List<Map<String, Object>> deviceMapList
String sns = deviceMapList.stream()
.map((m)->m.get("sn")+"").collect(Collectors.joining(","));
//使用场景很多,在sql里面用于组织in的值.比如:
SELECT sn,time,value FROM electric_real_time WHERE FIND_IN_SET(sn,?)
List<Map<String, Object>> dataList = JdbcUtil.getJdbcTemplate().queryForList(dataSql, sns)
List<String> strs = Arrays.asList("a","b","cd");
//连接所有内容
String str = strs.stream().collect(Collectors.joining());
System.out.println(str);
//输出：abcd
//连接所有内容,中间加一个逗号隔开
String str1 = strs.stream().collect(Collectors.joining(","));
System.out.println(str1);
//输出：a,b,cd
//连接所有内容,中间加一个逗号隔开，两边加上括号
String str2 = strs.stream().collect(Collectors.joining(",","(",")"));
System.out.println(str2);
//输出：(a,b,cd)5、List map互转（文[1] ）
// (k1,k2)->k2 避免键重复 k1-取第一个数据；k2-取最后一条数据
//key和value,都可以根据传入的值返回不同的Map
Map<String, String> deviceMap = hecmEnergyDevicesList.stream().collect(Collectors.toMap(i -> i.getDeviceNum(), j -> j.getDeviceName(), (k1, k2) -> k1));
//
Map<String, Object> map = list.stream()
.collect(Collectors.toMap(i -> i.getEmpName() + i.getUnitName(), j -> j, (k1, k2) -> k1));
//在.map里面构造数据 return什么数据就转成什么类型的list
List<Employee> collect = map.entrySet().stream().map(item -> {
Employee employee = new Employee();
employee.setId(item.getKey());
employee.setEmpName(item.getValue());
return employee;
}).collect(Collectors.toList());
6、去重（文[1] ）
//去重之后进行拼接: List<String> deviceNodeList
Srting deviceNodeStr = deviceNodeList.stream().distinct().collect(Collectors.joining("','"));
//直接去重返回list
// List<String> deviceIdList
List<String> deviceIdList = deviceIdList.stream().distinct().collect(Collectors.toList());
7、排序（文[1] ）
//按照时间排序 1升 -1降
Collections.sort(listFast, (p1, p2) -> {
return String.valueOf(p1.get("time")).compareTo(p2.get("time") + "");
});
// s1-s2 升序 s2-s1降序
Collections.sort(list,(s1,s2) -> s1.getSalary().compareTo(s2.getSalary()));
//多条件排序: List<Employee> list, s1-s2 升序 s2-s1降序
list.sort(Comparator.comparing(Employee::getSalary).reversed().thenComparing(Employee::getId).reversed());
8、求和/极值（文[1] ）
//在egyList里面求cols的和
public static BigDecimal getSumBig(List<Map<String,Object>> egyList, String cols){
BigDecimal consuBig = egyList.stream()
.filter((Map m)->StringUtils.isNotEmpty(m.get(cols)+"") && !"null".equals(String.valueOf(m.get(cols)))
&& !"-".equals(String.valueOf(m.get(cols))))
.map((Map m)->new BigDecimal(m.get(cols)+""))
.reduce(BigDecimal.ZERO,BigDecimal::add);
return consuBig;
}
//List<Employee> list
//Bigdecimal求和/极值:
BigDecimal sum = list.stream().map(Employee::getSalary).reduce(BigDecimal.ZERO,BigDecimal::add);
BigDecimal max = list.stream().map(Employee::getSalary).reduce(BigDecimal.ZERO,BigDecimal::max);
//基本数据类型求和/极值:
Integer sum = list.stream().mapToInt(Employee::getId).sum();
OptionalInt optionalMax = list.stream().mapToInt(Employee::getId).max();
optionalMax.getAsInt();
9、统计（文[1] ）
//统计：和、数量、最大值、最小值、平均值: List<Employee> list
IntSummaryStatistics collect = list.stream().collect(Collectors.summarizingInt(Employee::getId));
System.out.println("和：" + collect.getSum());
System.out.println("数量：" + collect.getCount());
System.out.println("最大值：" + collect.getMax());
System.out.println("最小值：" + collect.getMin());
System.out.println("平均值：" + collect.getAverage());
10、求最大/最小值的对象（文[1] ）
Optional<Employee> optional = list.stream().collect(Collectors.maxBy(Comparator.comparing(Employee::getId)));
if (optional.isPresent()) { // 判断是否有值
Employee user = optional.get();
}
return optional.orElse(new Employee());
11、平均值（文[1] ）
OptionalDouble average = list.stream().mapToInt(Employee::getId).average();
average.getAsDouble();12、某个值的数量（文[1] ）
//List<Employee> list
Map<BigDecimal, Long> collect = list.stream().collect(Collectors.groupingBy(i -> i.getSalary(),Collectors.counting()));
//List<Map<String,Object>> egyList
long count = egyList.stream()
.filter((Map m)->StringUtils.isNotEmpty(m.get(cols)+""))
.map((Map m)->new BigDecimal(m.get(cols)+""))
.count();
13、收集（文[1] ）
//取出所有年龄放到list集合中
List<Integer> toList = list.stream().map(Person::getAge)
.collect(Collectors.toList());
//取出所有年龄放到set集合中
Set<Integer> toSet = list.stream().map(Person::getAge)
.collect(Collectors.toSet());
//取出所有年龄放到hashSet集合中
HashSet<Integer> toHashSet = list.stream().map(Person::getAge)
.collect(Collectors.toCollection(HashSet::new));
//获取集合中元素总和
Long count = list.stream().collect(Collectors.counting());
//获取年龄平均值
Double avg = list.stream().collect(Collectors.averagingInt(Person::getAge));
//获取工资总和
Double sum = list.stream().collect(Collectors.summingDouble(Person::getSalary));
//获取工资最大值的人
Optional<Person> max = list.stream().collect(Collectors.maxBy((p1, p2) -> Double.compare(p1.getSalary(), p2.getSalary())));
System.out.println(max.get());
//获取工资最小值的人
Optional<Person> min = list.stream().collect(Collectors.minBy((p1, p2) -> Double.compare(p1.getSalary(), p2.getSalary())));
System.out.println(min.get());
//获取元素个数、总和、最小值、平均值、最大值
DoubleSummaryStatistics collect = list.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println(collect);
//输出结果:DoubleSummaryStatistics{count=5, sum=34024.000000, min=99.000000, average=6804.800000, max=9999.000000}
14、全部转大写（文[1] ）
List<String> list = Arrays.asList("a","vvv","ddd");
//中间操作：不会执行任何操作
Stream<String> stream = list.stream().map(x -> x.toUpperCase());
//终止操作：一次性执行全部内容，惰性求值
stream.forEach(System.out::println);
15、查找与匹配（文[1] ）
List<Person> list = Arrays.asList(
new Person(18,3939),
new Person(38,9999),
new Person(17,9999),
new Person(19,9988),
new Person(38,99)
);
//是否匹配所有元素 此处返回false
boolean b = list.stream().allMatch(e -> e.getAge() == 18);
System.out.println(b);
//至少匹配一个元素，此处返回true
boolean b1 = list.stream().anyMatch(e -> e.getAge() == 19);
System.out.println(b1);
//流中是否没有匹配元素，此处返回false
boolean b2 = list.stream().noneMatch(e -> e.getAge() == 19);
System.out.println(b2);
//排序后获取第一个元素
Optional<Person> first = list.stream().sorted((x, y) -> x.getAge().compareTo(y.getAge())).findFirst();
System.out.println(first);
//获取流中任意一个元素
list.stream().findAny();
//返回流中元素的总个数
list.stream().count();
//返回流中最大值 此处根据年龄比较
Optional<Person> max = list.stream().max((x, y) -> x.getAge().compareTo(y.getAge()));
System.out.println(max.get());
//返回流中最小值 此处根据年龄比较
Optional<Person> min = list.stream().min((x, y) -> x.getAge().compareTo(y.getAge()));
System.out.println(min.get());
//获取最小的年龄
Optional<Integer> age = list.stream().map(Person::getAge).min(Integer::compareTo);
System.out.println(age.get());
//获取一个并行流，并行流会使用多个线程操作流，stream()获取的是串行流，单个线程操作流
list.parallelStream();
//查找第一个元素
Optional<Dish> collect = menu.stream().filter(dish -> dish.getCalories() > 1000).findFrist();
16、跳过（文[1] ）
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8);
//中间操作：不会执行任何操作
Stream<Integer> stream = list.stream().skip(5);
//终止操作：一次性执行全部内容，惰性求值
stream.forEach(System.out::println);17、截断（文[1] ）
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8);
//中间操作：不会执行任何操作
Stream<Integer> stream = list.stream()
.filter(e -> {
System.out.println("过滤 中间操作");
return e>3;
})
.limit(2);
//终止操作：一次性执行全部内容，惰性求值
stream.forEach(System.out::println);
18、先分组然后排序
Map<String, List<Student>> map = list.stream().collect(
Collectors.groupingBy(Student::getName, HashMap::new,
Collectors.collectingAndThen(Collectors.toList(),
//正序
l -> l.stream().sorted(Comparator.comparing(Student::getScore))
//倒序
//list -> list.stream().sorted(Comparator.comparing(Student::getScore).reversed())
.collect(Collectors.toList())
)));
19、stream List对象赋值
/** 单个对象*/
public static <V> V copyBean(Object source, Class<V> clazz) {
/** 创建目标对象 实现属性拷贝*/
V result = null;
try {
result = clazz.newInstance();
/** 拷贝*/
Assert.notNull(source, "Source must not be null");
BeanUtils.copyProperties(source, result);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/** 复制集合*/
public static <O, V> List<V> copyBeanList(List<O> list, Class<V> clazz) {
/** 创建目标对象 实现属性拷贝*/
return list.stream()
.map(o -> copyBean(o, clazz))
.collect(Collectors.toList());
}20、统计元素出现次数,筛选只出现一次的,或出现多次的元素
public void main() {
// 初始化流
List<String> list = Stream.of("1","1","2","3","4","4","4","5","6","7")
// 收集 Collectors.toMap(map的key[Function.identity()表示自己本身], map的value, 当key重复值的处理[我这里选择让value相加])
.collect(Collectors.toMap(Function.identity(), s -> 1, Integer::sum))
// map 转 entrySet
.entrySet()
// 继续转流
.stream()
// 筛选只出现一次的元素
.filter(entry -> entry.getValue() == 1)
// 获取key
.map(Map.Entry::getKey)
// 统计只出现一次的元素
.collect(Collectors.toList());
// [2, 3, 5, 6, 7]
System.out.println(list);
List<User> users = new ArrayList<User>();
users.add(new User("小胖", 15, "男", "13812345671"));
users.add(new User("小白", 18, "女", "13812345672"));
users.add(new User("小黑", 38, "男", "13812345673"));
users.add(new User("阿胖", 25, "女", "13812345674"));
users.add(new User("阿12", 25, "女", "13812345674"));
Map<Integer, List<User>> list = users.stream()
.collect(Collectors.toMap(User::getAge, user -> new ArrayList<User>() {{add(user);}}, (list1, list2) ->
{
list1.addAll(list2);
return list1;
}))
.entrySet().stream()
.filter(entry -> entry.getValue().size() > 1)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
System.out.println(list);
//输出结果
// {25=[User{userName='阿胖', age=25, sex='女', phone='13812345674'}, User{userName='阿12', age=25, sex='女', phone='13812345674'}]}
}21、Collectors.mapping()
一般用于多重
map and reduce中。
- 流式操作可进行很多的操作
- 过滤
fliter- 运算
map- 去重
distinct- ……
- 经过N多的运算、筛选、排序、操作……返回我们需要的集合
//第一个参数用于 map ，第二个参数用于 reduce
mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)//Person{name='xxx',age=0}
List<Person> list = new ArrayList<>();
list.add(new Person{name='xxx',age=0}("Ram", 30));
list.add(new Person("Shyam", 20));
list.add(new Person("Shiv", 20));
list.add(new Person("Mahesh", 30));
String nameByAge = list.stream().collect(Collectors.mapping(Person::getName, Collectors.joining(",", "[", "]")));
System.out.println(nameByAge);
nameByAge = list.stream().map(person -> person.getName()).collect(Collectors.joining(",", "[", "]"));
System.out.println(nameByAge);
运行结果：
[Ram,Shyam,Shiv,Mahesh]
[Ram,Shyam,Shiv,Mahesh]
//使用Collectors.groupingBy方法进行分组
List<Person> list = new ArrayList<>();
list.add(new Person("Ram", 30));
list.add(new Person("Shyam", 20));
list.add(new Person("Shiv", 20));
list.add(new Person("Mahesh", 30));
Map<Integer, String> nameByAgeMap = list.stream().collect(
Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.joining(",", "[", "]"))));
nameByAgeMap.forEach((k, v) -> System.out.println("Age:" + k + " Persons: " + v));
运行结果:
Age:20 Persons: [Shyam,Shiv]
Age:30 Persons: [Ram,Mahesh]
未完待续。。。
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
