Java8 对集合进行stream操作

墨蓝 2021-09-25 00:30 536阅读 0赞

#### 一. Lambda表达式 ####

左边是参数列表，右边是函数体。

方法引用 ： class::method

静态方法引用： User::combine  
参数方法引用： String::indexOf  
实例方法引用： user::getUserName  
构造器引用： User::new

#### 二. 常用 ####

1.  **集合对象收集器**  
    toList ，toSet，toMap，toCollection
2.  **聚合计算**  
    averagingXXX , 求平均值  
    summingXXX, 求和  
    summarizingXXX 一次性求出平均值，和，记录数，最大值，最小值  
    maxBy ,  
    counting
3.  **分组统计**  
    groupingBy
4.  **排序**  
    简单类型使用sorted  
    sorted可以传入comparator  
    倒序  
    自定义排序
5.  **其他**  
    distinct  
    mapping  
    collectingAndThen  
    joining  
    boxed

#### 三. 代码示例 ####

1.  先创建一个Person类，属性id，姓名，性别，年龄， 用@Data注解生成getset方法

package com.juwei.demo.streamdemo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.io.Serializable;
    
    /** * @Author: juwei * @Date: 2020/12/2 23:57 * @Describe: person类 */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Person implements Serializable { 
    
    	private Integer id;
    	private String name;
    	private Integer sex;
    	private Integer age;
    
    	public Person(Integer key, Person value) { 
    		this.id = key;
    		this.name = value.getName();
    		this.sex = value.getSex();
    		this.age = value.getAge();
    	}
    }

package com.juwei.demo.streamdemo;
    
    import com.alibaba.fastjson.JSON;
    import com.juwei.demo.test.Demo;
    
    import java.nio.file.Path;
    import java.util.*;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    
    /** * @Author: juwei * @Date: 2020/12/3 0:01 * @Describe: java8 stream demo */
    public class StreamTest1 { 
    
    	public static void main(String[] args) { 
    		List<Person> personList = new ArrayList<>();
    		personList.add(new Person(1, "xiaoping", 1, 10));
    		personList.add(new Person(2, "Xiaomi", 1, 13));
    		personList.add(new Person(3, "yangon", 0, 12));
    		personList.add(new Person(4, "liming", 1, 9));
    		personList.add(new Person(5, "lisha", 0, 15));
    		personList.add(new Person(6, "xiaoping", 0, 7));
    		personList.add(new Person(0, "xiaoping", 0, 7));
    
    		System.out.println(personList);
    
    		List<Integer> personList0 = new ArrayList<>();
    		personList0.add(1);
    		personList0.add(2);
    
    		// Lambda表达式
    		// () -> 5 不需要参数 返回5
    		// x -> 2*x 接收一个参数x，返回2倍的值
    		// （x,y） -> x-y 接收两个参数，返回其差值
    		// (int x,int y) -> x+y 接收2个int整型数字，返回其和
    		// (String s) -> System.out.print(s) 接收一个string对象 并打印
    
    		// list——list (提取PersonList中的id）
    		List<Integer> personList1 = personList.stream().map(Person::getId).collect(Collectors.toList());
    		System.out.println("[list-list]: " + personList1);
    
    		// list——map (map<id,Person>) Function.identity()和 a -> a 效果一样
    		Map<Integer, Person> idAndPersonMap = personList.stream()
    				.collect(Collectors.toMap(Person::getId, Function.identity(), (k1, k2) -> k1));
    		System.out.println("[list-map]: " + idAndPersonMap);
    
    		Map<Integer, Person> idAndPersonMap1 = personList.stream()
    				.collect(Collectors.toMap(Person::getId, a -> a, (k1, k2) -> k1));
    
    		Map<Integer, String> idAndNameMap = personList.stream()
    				.collect(Collectors.toMap(Person::getId, Person::getName));
    		Map<Integer, Integer> idAndNameMap1 = personList.stream()
    				.collect(Collectors.toMap(Person::getId, Person::getAge));
    
    
    		// 如果存在相同的key，是否将其value进行替换
    		Map<Integer, Person> idAndPersonMap0 = Stream.concat(personList.stream(), personList.stream())
    				.peek(person -> System.out.print(person.getName() + "--"))
    				.collect(Collectors.toMap(Person::getId, Person -> Person, (existing, replace) -> existing));
    		System.out.println();
    		// 如果存在相同的key，是否将其value进行替换, 并转换成treeMap
    		TreeMap<Integer, Person> idAndPersonTreeMap = Stream.concat(personList.stream(), personList.stream())
    				.peek(person -> System.out.print(person.getName() + "--")).collect(Collectors
    						.toMap(Person::getId, Person -> Person, (existing, replace) -> existing, TreeMap::new));
    		System.out.println();
    
    	
    		// list——set (去重的name)
    		Set<String> sexSet = personList.stream().map(Person::getName).collect(Collectors.toSet());
    		System.out.println("[list-set]: " + sexSet);
    
    
    		// map——list idAndPersonMap-list
    		List<Person> personMapToList = idAndPersonMap1.entrySet().stream()
    				.map(e -> new Person(e.getKey(), e.getValue())).collect(Collectors.toList());
    		System.out.println("[map-list]: " + personMapToList);
    
    		// sorted 通过key（id）排序
    		List<Person> sortedList = idAndPersonMap1.entrySet().stream().sorted(Map.Entry.comparingByKey())
    				.map(e -> new Person(e.getKey(), e.getValue())).collect(Collectors.toList());
    		System.out.println("sortedList: "+sortedList);
    		List<Person> sortedList1 = idAndPersonMap1.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getKey))
    				.map(e -> new Person(e.getKey(), e.getValue())).collect(Collectors.toList());
    		System.out.println("sortedList1: "+sortedList1);
    
    
    		List<String> strings = Arrays.asList("One", "Abc", "Bcd");
    		// 简单类型的sorted
    		String sorted = strings.stream().sorted().collect(Collectors.joining("\n"));
    		System.out.println("sorted:" + sorted);
    		// 传入comparator
    		String sorted1 = strings.stream().sorted(String::compareTo).collect(Collectors.joining("\n"));
    		System.out.println("sorted1:" + sorted1);
    		// 倒序
    		String sorted2 = strings.stream().sorted(Comparator.reverseOrder()).collect(Collectors.joining("\n"));
    		System.out.println("sorted2:" + sorted2);
    		// 自定义排序
    		String sorted3 = strings.stream().sorted(Comparator.comparing(s -> s.length(), (o1, o2) -> o1.compareTo(o2)))
    				.collect(Collectors.joining("\n"));
    		System.out.println("sorted3:"+ sorted3);
    
    
    		//filter
    		// 输出符合表达式的 年龄大于十岁的人
    		personList.stream().filter(p -> p.getAge() > 10).forEach(System.out::println);
    		//Person(id=2, name=Xiaomi, sex=1, age=13)
    		//Person(id=3, name=yangon, sex=0, age=12)
    		//Person(id=5, name=lisha, sex=0, age=15)
    
    		// 从list1过滤掉list2
    		List<Person> filterList1 = personList.stream().filter(e -> !personList0.contains(e.getId()))
    				.collect(Collectors.toList());
    		System.out.println("filterList1"+ filterList1);
    
    		// 从list1过滤list2 打印出name
    		List<String> filterList = personList.stream().filter(e -> !Objects.equals(e.getSex(),1)).map(Person::getName)
    				.collect(Collectors.toList());
    		System.out.println("filterList"+ filterList); //filterList[xiaoMi, sid, sfkdv]
    
    		// 输出所有男生
    		List<Person> boyList = personList.stream().filter(p -> p.getSex().equals(1)).collect(Collectors.toList());
    		System.out.println("[boyList=]" + boyList);
    		//[boyList=][Person(id=1, name=xiaoping, sex=1, age=10), Person(id=2, name=Xiaomi, sex=1, age=13), Person(id=4, name=liming, sex=1, age=9)]
    
    		// 返回符合表达式的第一个对象 返回大于13岁的人
    		Optional<Person> first = personList.stream().filter(p -> p.getAge() > 13).findFirst();
    		System.out.println(first);    //Optional[Person(id=5, name=lisha, sex=0, age=15)]
    
    		// avg
    		Double avgAge = personList.stream().collect(Collectors.averagingInt(Person::getAge));
    		System.out.println("平均年龄：" + avgAge);  //11
    
    		// sum
    		int ageSum = personList.stream().collect(Collectors.summingInt(Person::getAge));
    		System.out.println("年龄总和" + ageSum);  //66
    
    		// 一次性求 总数 平均值 最大 最小 和
    		DoubleSummaryStatistics summm = personList.stream().collect(Collectors.summarizingDouble(Person::getAge));
    		System.out.println(summm.getCount());  //6
    		System.out.println(summm.getAverage());  // 11
    		System.out.println(summm.getMax()); //15
    		System.out.println(summm.getMin());  //7
    		System.out.println(summm.getSum());   //66
    
    		//groupingBy 性别为0和1的分2个组
    		Map<Integer, List<Person>> groupingBySex = personList.stream()
    				.collect(Collectors.groupingBy(Person -> (int) Math.floor(Person.getSex())));
    		System.out.println("[groupingBySex=]" + groupingBySex);
    
    		// 分组统计
    		Map<Integer, IntSummaryStatistics> groupCount = personList.stream().collect(Collectors
    				.groupingBy(Person -> (int) Math.floor(Person.getSex()), Collectors.summarizingInt(Person::getSex)));
    		System.out.println("[groupCount=]" + groupCount);
    
    	}
    }