JDK8流和lambda应用

1. String类型List集合排序

List<String> stringList = Arrays.asList("java", "python", "golang", "C#", "Julia", "shell");
List<String> collect = stringList.stream().sorted().collect(Collectors.toList());
collect.forEach(System.out::println);

2. 字符串数组拼接

List<String> stringList = Arrays.asList("abc", "spring", "java", "python");
// 单纯拼接
String result = stringList.stream().collect(Collectors.joining(""));
System.out.println(result); // 输出 abcspringjavapython
// 拼接间加入分隔符
String result1 = stringList.stream().collect(Collectors.joining("--"));
System.out.println(result1); // 输出 abc--spring--java--python
// 加大括号
String result2 = stringList.stream().collect(Collectors.joining("--", "{", "}"));
System.out.println(result2); // 输出 {abc--spring--java--python}

3. List<Map<String, String>> 数据去重

List<Map<String, String>> list = new ArrayList<>(16) ;
Map<String,String> map1 = new HashMap<>(16);
map1.put("key1", "val1");
Map<String,String> map2 = new HashMap<>(16);
map2.put("key1", "val1");
list.add(map1);
list.add(map2);

ArrayList<Map<String, String>> data = list.stream().collect(
	Collectors.collectingAndThen(Collectors.toCollection(
		() -> new TreeSet<>(Comparator.comparing(m -> m.get("key1")))), ArrayList::new));

4. List对象去重后进行排序操作

BookBo bookBo1 = new BookBo("1", "语文");
BookBo bookBo2 = new BookBo("2", "数学");
BookBo bookBo3 = new BookBo("3", "英语");
BookBo bookBo4 = new BookBo("4", "地理");
BookBo bookBo5 = new BookBo("5", "生物");
BookBo bookBo6 = new BookBo("1", "语文");
List<BookBo> bookBoList = Arrays.asList(bookBo1, bookBo2, bookBo3, bookBo4, bookBo5, bookBo6);

List<BookBo> distinctList = bookBoList.stream().collect(
	Collectors.collectingAndThen(Collectors.toCollection(
		()->new TreeSet<>(Comparator.comparing(o-> o.getName()))), ArrayList::new))
			.stream().sorted(Comparator.comparing(BookBo::getName)).collect(Collectors.toList());

5. partitioningBy 函数 分组

// 将list中字符串长度大于4的为一组，其他为另一组
List<String> stringList = Arrays.asList("abc", "spring", "java", "python");
Map<Boolean, List<String>> result = stringList.stream().collect(Collectors.partitioningBy(obj -> obj.length() > 4));
System.out.println(result); // 输出 {false=[abc, java], true=[spring, python]}

// 根据学生所在的省份进行分组
List<Student> students = Arrays.asList(new Student("辽宁", 18), new Student("吉林", 19),
		new Student("辽宁", 23), new Student("吉林", 20),
		new Student("辽宁", 24), new Student("吉林", 23));
Map<String, List<Student>> result2 = students.stream().collect(Collectors.groupingBy(obj -> obj.getProvince()));

 6. 统计各省份人数

List<Student> students2 = Arrays.asList(new Student("辽宁", 18), new Student("吉林", 19),
		new Student("辽宁", 23), new Student("吉林", 20),
		new Student("黑龙江", 24), new Student("北京", 23));
Map<String, Long> result2 = students2.stream().collect(Collectors.groupingBy(Student::getProvince,Collectors.counting()));
System.out.println(JSONUtil.parseObj(result2)); // 输出 {"黑龙江":1,"吉林":2,"辽宁":2,"北京":1}

 7. 统计一些人的年龄信息，如平均年龄，人数，最小，最大

List<Student> students = Arrays.asList(new Student("辽宁", 18), new Student("吉林", 19),
		new Student("辽宁", 23), new Student("吉林", 20),
		new Student("辽宁", 24), new Student("吉林", 23));
IntSummaryStatistics result = students.stream().collect(Collectors.summarizingInt(Student::getAge));
System.out.println("人数："+result.getCount());
System.out.println("年龄总和："+result.getSum());
System.out.println("最小年龄："+result.getMin());
System.out.println("最大年龄："+result.getMax());
System.out.println("平均年龄："+result.getAverage());

 8. Stream实现递归查询树形结构

// 构造父级节点
List<User> listUser = list.stream().filter(user -> user.getLevelId().equals("0"))
	.peek(user -> user.setChildList(getChildrens(user,list))).collect(Collectors.toList());

// 构造子级节点
public List<User> getChildrens(User user,List<User> userList){
	List<User> childrens = userList.stream().filter(u -> Objects.equals(u.getLevelId(),user.getId())).map(
			u -> {
			   u.setChildList(getChildrens(u,userList));
			   return u;
			}
	).collect(Collectors.toList());
	return childrens;
}

 9. Stream实现根据age进行排序

List<Map<String, Object>> homePageViewList = CollUtil.newArrayList();

Map<String, Object> paramMap = new HashMap();
paramMap.put("name", "张三");
paramMap.put("age", "2");
homePageViewList.add(paramMap);

Map<String, Object> paramMap1 = new HashMap();
paramMap1.put("name", "李四");
paramMap1.put("age", "1");
homePageViewList.add(paramMap1);

homePageViewList = homePageViewList.stream().sorted((o1, o2) ->{
	Integer v1 = Integer.parseInt(o1.get("orderby").toString());
	Integer v2 = Integer.parseInt(o2.get("orderby").toString());
	return Integer.compare(v1, v2);
}).collect(Collectors.toList());

 

 10. Stream实现根据ID，将相同的数据进行合并

List<Map<String,Object>> newList = new ArrayList<Map<String,Object>>();
Map<String,Object> map3 = new HashMap<String,Object>();
map3.put("name","張三");
map3.put("id","1");
newList.add(map3);

Map<String,Object> map4 = new HashMap<String,Object>();
map4.put("name","李四");
map4.put("id","1");
newList.add(map4);

Map<String,Object> map1 = new HashMap<String,Object>();
map1.put("name","王三");
map1.put("id","2");
newList.add(map1);

Map<Object, List<Map<String, Object>>> result = newList.stream().collect(Collectors.groupingBy(m -> m.get("id")));

 10.Stream实现根据分组，去重，求count

List<Map<String, Object>> resultList = nativeQueryUpdate.getDataResultNativeQuery(SQL).getResultList();
Map<Object, Map<Object, Long>> resultDataMap = resultList.stream().distinct().collect(Collectors.groupingBy(m -> m.get("tar_ip")
       , Collectors.groupingBy(m -> m.get("tar_domain"), Collectors.counting())));

 11.Stream实现根据下标实现偶数和奇数进行归类

List list = Arrays.asList(1, 3, 5, 7, 9);
Map<Boolean, List<Object>> collect = IntStream.rangeClosed(1, list.size())
   .boxed()
   .map(i -> new AbstractMap.SimpleEntry<>(i, list.get(i - 1))) // 把数字和下标绑定起来
   .collect(Collectors.partitioningBy(simpleEntry -> Integer.parseInt(simpleEntry.getKey().toString()) % 2 == 0
       , Collectors.mapping(Map.Entry::getValue, Collectors.toList()))); // 按照下标是否能被2整除进行分组

 12.Stream实现List字符串数据转成Map

List<String> list = new ArrayList<>();
list.add("Mohan");
list.add("Sohan");
list.add("Mahesh");
Map<String, Object> map = list.stream().collect(Collectors.toMap(Function.identity(),s->0));

 13.Stream实现List对象数据转成Map

/**
 * List -> Map
 * 需要注意的是：
 * toMap 如果集合对象有重复的key，会报错Duplicate key ....
 *  apple1,apple12的id都为1。
 *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
 */
List<User> users
Map<String, User> maps = users.stream().collect(Collectors.toMap(User::getName, a -> a,(k1,k2)->k1));

 14.Stream实现Map转List，接上

Map<Long, User> maps = users.stream().collect(Collectors.toMap(User::getId, Function.identity()));
List<User> userList = maps.entrySet().stream().map(Map.Entry::getValue).collect(Collectors.toList());

 15.根据名称获取产品

Map<String, Integer> resultMap3 = list.stream()
    .collect(Collectors.toMap(Product::getName, x -> x.getId()));        
System.out.println(resultMap3);

 16.List和数组互转

//List转数组
String[] arrays = list.toArray(new String[0]);
//或
String[] arrays = list.stream().toArray(String[]::new);
//数组转List
List<String> stringList = Arrays.asList(array);
//或者
List<String> list = Stream.of(arrays).collect(Collectors.toList());

 17.Set和数组互转

//Set转数组
String[] array=set.toArray(new String[0]);
//或
String[] array= set.stream().toArray(String[]::new);
//数组转Set
Set<String> set = new HashSet<>(Arrays.asList(array));
//或
Set<String> set = Stream.of(array).collect(Collectors.toSet());

 18.Set和List互转

//Set转List
List<String> list=new ArrayList<>(set);
或
List list=Stream.of(set.toArray(new String[0])).collect(Collectors.toList());
//List转Set
Set<String> set=new HashSet<>(list);
//或
Set<String> set = list.stream().collect(Collectors.toSet());

19.List转Map

Map<Long, 对象> sheetBoMap = sheetBoList.stream().collect(Collectors.toMap(对象::getId, Function.identity(), (k1, k2)->k2)));
//(k1, k2)->k2) 若出现Id重复的，则替换为第2个对象；少了这一句也可以，但是会抛出异常