Java8.stream流 分组 去重 类型转换 排序 常用方法 文件读取

参考博客
以下代码基于List<Map<String,Object>> 进行转换，对象转换加载更为灵活规范

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.IntSummaryStatistics;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamExample {

	private static List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
	
	@SuppressWarnings("serial")
	public static void main(String[] args) {
        list =  Arrays.asList(
        		new HashMap<String, Object>(){{put("id", 1);put("name", "v1");put("age", 12);}},
        		new HashMap<String, Object>(){{put("id", 1);put("name", "v1");put("age", 12);}},
        		new HashMap<String, Object>(){{put("id", 3);put("name", "v3");put("age", 11);}},
        		new HashMap<String, Object>(){{put("id", 5);put("name", "v6");put("age", 18);}},
        		new HashMap<String, Object>(){{put("id", 2);put("name", "v2");put("age", 15);}},
        		new HashMap<String, Object>(){{put("id", 4);put("name", "v3");put("age", 16);}},
        		new HashMap<String, Object>(){{put("id", 6);put("name", "v6");put("age", 18);}},
        		new HashMap<String, Object>(){{put("id", 7);put("name", "v6");put("age", 20);}}
                );
        long start = System.currentTimeMillis();
        
        flatMap();
        
        println(String.format("耗时[%s]毫秒", (System.currentTimeMillis() - start)));
	}

//--------------------------------------------分组-begin--------------------------------------------
    /**
     * >>>>groupingBy分组
     */
    public static void group() {
        Map<Object, List<Map<String, Object>>> collect = list.stream().collect(Collectors.groupingBy(s -> s.get("name")));
        collect.forEach((k,v) -> System.out.println("key:"+k+"	value:"+v));
    }
	
    /**
     * >>>>groupingBy分组并对分组结果做处理
     */
    public static void groupAndDeal() {
        Map<Object, Integer> collect = list.stream().collect(Collectors.groupingBy(s -> s.get("name"), Collectors.summingInt(s -> (Integer)s.get("age"))));
        collect.forEach((k,v) -> System.out.println("key:"+k+"	value:"+v));
    }
    
    /**
     * >>>>groupingBy二级分组
     */
    public static void group2() {
    	Map<Object, Map<Object, List<Map<String, Object>>>> collect = list.stream().collect(Collectors.groupingBy(s -> s.get("name"),Collectors.groupingBy(s -> s.get("age"))));
    	collect.forEach((k,v) -> System.out.println("key:"+k+"	value:"+v));
    }
    /**
     * >>>>Collectors.partitioningBy分区
     */
    public static void partitioningBy() {
		Map<Boolean, List<Map<String, Object>>> map = list.stream()
                .collect(Collectors.partitioningBy(s -> (Integer)s.get("age") <= 12));
		map.forEach((k,v) -> System.out.println("key:"+k+"	value:"+v));
    }
//--------------------------------------------分组-end--------------------------------------------
    
//--------------------------------------------去重-begin--------------------------------------------
    /**
     * >>>>distinct去重，适合单数据去重
     * 个性化去重需要重写比较对象的hashCode() 和 eqauls()
     */
    public static void distinct() {
        list.stream().distinct().collect(Collectors.toList()).forEach(u -> println(u));
    }
    
    /**
     * filterRepeat内 Stream.filter() 的参数方法
     * 其返回类型为 Predicate，原理就是判断一个元素能否加入到 Set 中去
     * @param keyExtractor
     * @return
     */
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Set<Object> seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(keyExtractor.apply(t));
    }
    
    /**
     * >>>>单条件/多条件filter去重
     */
    public static void filterRepeat() {
        list.stream().filter(distinctByKey(o -> o.get("name") + ";" + o.get("age"))).collect(Collectors.toList()).forEach(u -> println(u));
    }
    
    /**
     * >>>>多条件去重(单条件亦可，修改Comparator.comparing()内Function)
     * @param list
     * 这里我们引入了两个静态方法，以及通过 TreeSet<> 来达到获取不同元素的效果
     * 1. import static java.util.stream.Collectors.collectingAndThen;2. import static java.util.stream.Collectors.toCollection;
     */
    public static void repeat() {
        list.stream().collect(Collectors.collectingAndThen(
                Collectors.toCollection(() -> new TreeSet<>(
                        Comparator.comparing(o -> o.get("name") + ";" + o.get("age")))), ArrayList::new)).forEach(u -> println(u));
    }
//--------------------------------------------去重-end--------------------------------------------
    
//--------------------------------------------排序/限制数目/最大最小值获取/统计/map/flatMap/查找与匹配-begin--------------------------------------------
    /**
     * >>>>sorted排序
     * 需保证比较对象为Integer类型-ps:u.get("age")
     */
    public static void stord() {
    	list.stream().sorted(Comparator.comparing(u-> (Integer)u.get("age"))).collect(Collectors.toList()); 
    }
    /**
     * >>>>limit方法限制最多返回多少元素
     */
    public static void limit() {
        list.stream().limit(2).forEach(u -> println(u));
    }
    /**
     * >>>>不要前多n个元素，n大于满足条件的元素个数就返回空的流
     */
    public static void skip() {
        list.stream().skip(2).forEach(u -> println(u));
    }
    /**
     * >>>>最大值 最小值
     */
    public static void statistics() {
        Optional<Map<String,Object>> min = list.stream().min(Comparator.comparing(o -> (Integer)o.get("age")));
        println(min);
        Optional<Map<String,Object>> max = list.stream().max(Comparator.comparing(o -> (Integer)o.get("age")));
        println(max);
    }
    /**
     * >>>>统计
     */
    public static void summarizingInt(){
        IntSummaryStatistics statistics = list.stream().collect(Collectors.summarizingInt(o -> (Integer)o.get("age")));
        double average = statistics.getAverage();
        long count = statistics.getCount();
        int max = statistics.getMax();
        int min = statistics.getMin();
        long sum = statistics.getSum();
        println(average);
        println(count);
        println(min);
        println(sum);
        println(max);
        
    }
    /**
     *>>>>类型转换map
     *mapToInt/mapToDouble/mapToLong可以减少装箱的成本，直接转换成Stream<Integer>/Stream<Double>/Stream<Long>类型
     */
    public static void map() {
        list.stream().map(o -> o.get("id")).forEach(userId -> println(userId));
        list.stream().mapToInt(o -> (Integer)o.get("age")).forEach(age -> println(age));
        list.stream().mapToDouble(o -> (Double)o.get("id")).forEach(userId -> println(userId));
        list.stream().mapToLong(o -> (Long)o.get("id")).forEach(userId -> println(userId));
    }
    /**
     * >>>>将类型转换后的每个元素转换成流flatMap
     */
    public static void flatMap() {
    	List<String> list = new ArrayList<String>();
		list.add("aaa bbb ccc");
		list.add("ddd eee fff");
		list.add("ggg hhh iii");

		//flatMap(T -> Stream<R>):将流中的每一个元素 T 映射为一个流，再把每一个流连接成为一个流(将list<list<String>>转换成list<String>)
		//list = list.stream().map(s -> s.split(" ")).flatMap(s -> Arrays.stream(s)).collect(Collectors.toList());
		list = list.stream().map(s -> s.split(" ")).flatMap(Arrays::stream).collect(Collectors.toList());
		System.out.println(list);
    }
    /**
     * >>>>查找与匹配
     * allMatch方法与anyMatch差不多，表示所有的元素都满足才返回true。noneMatch方法表示没有元素满足
     */
    public static void anyMatch() {
        boolean anyMatch = list.stream().anyMatch(u -> (Integer)u.get("age") == 12);
        boolean allMatch = list.stream().allMatch(u -> (Integer)u.get("id") == 7);
        boolean noneMatch = list.stream().noneMatch(u -> (Integer)u.get("id") == 7);
        println(anyMatch);
        println(allMatch);
        println(noneMatch);
    }
    /**
     * >>>>reduce操作
     */
    public static void reduce() {
        Optional<Integer> sum = list.stream().map(u -> (Integer)u.get("age")).reduce(Integer::sum);
        Optional<Integer> max = list.stream().map(u -> (Integer)u.get("age")).reduce(Integer::max);
        Optional<Integer> min = list.stream().map(u -> (Integer)u.get("age")).reduce(Integer::min);
        println(sum);
        println(max);
        println(min);
    }
//--------------------------------------------排序/限制/最大最小值获取/统计/map/flatMap/查找与匹配-end--------------------------------------------
    
//--------------------------------------------类型转换-begin--------------------------------------------
    /**
     * >>>>转set
     */
    public static void toSet() {
        Set<Map<String,Object>> collect = list.stream().collect(Collectors.toSet());
        Iterator<Map<String,Object>> iterator = collect.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next().get("id"));
        }
    }
    /**
     * >>>>转map
     * toMap取出对象类型注意与结构泛型保持一致
     */
    public static void toMap() {
    	//(1)key值不能重复，否则会提示异常：java.lang.IllegalStateException: Duplicate key ......
/*    	System.out.println("(1)");
        Map<Integer, Map<String,Object>> collect1 = list.stream().collect(Collectors.toMap(k -> (Integer)k.get("id"), u -> u));
        collect1.forEach((k,v) -> System.out.println(v));*/
    	
    	//(2)如果 Map 的 Key 重复了，保留第一个值
    	System.out.println("(2)");
        Map<Integer, Map<String,Object>> collect2 = list.stream().collect(Collectors.toMap(k -> (Integer)k.get("id"), u -> u,(n1, n2) -> n1));
        collect2.forEach((k,v) -> System.out.println(v));
        //(2.1)如果 Map 的 Key 重复了，保留第一个值;结果进行排序
        System.out.println("(2.1)");
        Map<Integer, Map<String,Object>> collect21 = list.stream().collect(Collectors.toMap(k -> (Integer)k.get("id"), u -> u,(n1, n2) -> n1,TreeMap::new));
        collect21.forEach((k,v) -> System.out.println(v));
        
    	//(3)如果Map 的 Key 重复了,把两个map合并成一个list --等同于groupingBy
    	//n1/n2的类型受返回类型影响
        System.out.println("(3)");
    	Map<Integer, Object> collect3 = list.stream().collect(Collectors.toMap(k -> (Integer)k.get("id"), u -> u,(n1, n2) -> {
			List<Object> result = new ArrayList<>();
			result.add(n1);
			result.add(n2);
			return result;
		}));
    	collect3.forEach((k,v) -> System.out.println(v));
    	
    }
//--------------------------------------------转换-end--------------------------------------------
    /**
     * >>>>Stream直接读取文件，每个元素是给定文件的其中一行
     * 需要关闭流否则会造成内存溢出
     */
    public static void readFile() {
    	Stream<String> stream = null;
		try {
			stream = Files.lines(Paths.get("/Users/xielijie/Desktop/csv/test.csv"));
			stream.forEach(System.out::println);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(stream!=null)stream.close();
		}
	}
    /**
     * 输出
     * @param c
     */
    public static void println(Object c) {
        System.out.println(c.toString());
    }
}