java8Stream流的使用2--终止操作(分组，分区)

实体类和集合数据在上一篇，对与分组和分区进行了结果展示

 /**
     * 判断所有元素是否符合条件
     */
    @Test
    public void streamAllMatch(){
        boolean b = employeeList.stream()
                .allMatch(item -> item.getAge() > 0);
        System.out.println(b);
    }

    /**
     * 判断是否存在符合条件的元素
     */
    @Test
    public void streamAnyMatch(){
        boolean b = employeeList.stream()
                .anyMatch(item -> item.getAge() > 0);
        System.out.println(b);
    }

    /**
     * 判断所有元素是否全不符合条件
     */
    @Test
    public void streamNoneMatch(){
        boolean b = employeeList.stream()
                .noneMatch(item -> item.getAge() > 0);
        System.out.println(b);
    }

    /**
     * 获取第一个元素
     */
    @Test
    public void streamFindFirst(){
        Optional<Employee> first = employeeList.stream().filter(item->item.getAge()>10000)
                            .findFirst();
        System.out.println(first.get());
    }

    /**
     * 随机获取一个(串行流一般为第一个，并行为随机)
     */
    @Test
    public void streamFindAny(){
        Optional<Employee> any = employeeList.parallelStream().findAny();
        System.out.println(any.get());
    }

    /**
     * 最大值,最小值，数量
     */
    @Test
    public void streamMax(){
        Optional<Employee> max = employeeList.stream().max((item1, item2) -> Integer.compare(item1.getAge(), item2.getAge()));
        System.out.println(max.get());
        Optional<Integer> max1 = employeeList.stream().map(Employee::getAge).max(Integer::compare);
        System.out.println(max1.get());
        long count = employeeList.stream().count();
        System.out.println(count);
    }

    /**
     * 归约，元素反复结合
     */
    @Test
    public void streamReduce(){
        List<Integer> list = Arrays.asList(1, 2, 34, 5, 6, 7);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);
        Optional<Integer> reduce1 = list.stream().reduce(Integer::sum);
        System.out.println(reduce1.get());
    }

收集操作collect

	@Test
    public void streamCollect1(){
        //list
        List<String> list = employeeList.stream().map(Employee::getName)
        								.collect(Collectors.toList());
        list.forEach(System.out::println);
        //set
        Set<String> set = employeeList.stream().map(Employee::getName)
        							  .collect(Collectors.toSet());
        set.forEach(System.out::println);
        //其他集合
        HashSet<String> hashSet = employeeList.stream().map(Employee::getName)
           									  .collect(Collectors.toCollection(HashSet::new));
        hashSet.forEach(System.out::println);
    }

计算数量，平均值，最大值，最小值，总和

@Test
    public void streamCollect2(){
        //数量
        Long collect = employeeList.stream().collect(Collectors.counting());
        System.out.println(collect);
        //年龄平均值
        Double avg = employeeList.stream()
        						 .collect(Collectors.averagingDouble(Employee::getAge));
        System.out.println(avg);
        //年龄总和
        Double sum = employeeList.stream()
        						 .collect(Collectors.summingDouble(Employee::getAge));
        System.out.println(sum);
        //年龄最大值
        Optional<Employee> employee = employeeList.stream()
        		.collect(Collectors.maxBy((item1, item2) -> 
        		Integer.compare(item1.getAge(),item2.getAge())));
        System.out.println(employee.get());
    }

分组，分区，分组加分区

单条件分组

		//单条件分组
        Map<Employee.Bm, List<Employee>> collect = employeeList.stream().
        					collect(Collectors.groupingBy(Employee::getBm));
        Set<Employee.Bm> bms = collect.keySet();
        System.out.println(collect);
        -----------------------------------结果-------------------------------------
		{BM1=[Employee(name=张龙, age=52, value=5656.3, bm=BM1),
			  Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
			  Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
			  Employee(name=zl, age=42, value=5656.3, bm=BM1), 
			  Employee(name=mh, age=63, value=7656.3, bm=BM1)], 
	     BM2=[Employee(name=赵虎, age=22, value=9999.3, bm=BM2), 
	     	  Employee(name=zh, age=12, value=9999.3, bm=BM2)], 
	     BM3=[Employee(name=王朝, age=75, value=77776.3, bm=BM3), 
	          Employee(name=wc, age=75, value=77776.3, bm=BM3)]}

多条件分组

		//多条件分组,先按部门再按年龄分
        Map<Employee.Bm,Map<String,List<Employee>>> e=employeeList.stream().collect(
                Collectors.groupingBy(Employee::getBm,
                        Collectors.groupingBy(item->item.getAge()>50?"老人":"年轻人")));
        System.out.println(e);
        -----------------------------------结果-------------------------------------
		{
		BM1={
		     老人=[Employee(name=张龙, age=52, value=5656.3, bm=BM1), 
				  Employee(name=mh, age=63, value=7656.3, bm=BM1)], 
			 年轻人=[Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
			        Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
			        Employee(name=zl, age=42, value=5656.3, bm=BM1)]}, 
		 BM2={
		     年轻人=[Employee(name=赵虎, age=22, value=9999.3, bm=BM2), 
		            Employee(name=zh, age=12, value=9999.3, bm=BM2)]}, 
		 BM3={
		     老人=[Employee(name=王朝, age=75, value=77776.3, bm=BM3), 
		          Employee(name=wc, age=75, value=77776.3, bm=BM3)]}
		 }

单次分区

		//单次分区,两个区，符合条件和不符合条件的
        Map<Boolean, List<Employee>> collect1 = employeeList.stream().
        					collect(Collectors.partitioningBy(item -> item.getAge() > 50));
        System.out.println(collect1);
        -----------------------------------结果-------------------------------------
        {
        false=[Employee(name=赵虎, age=22, value=9999.3, bm=BM2), 
        	   Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
        	   Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
        	   Employee(name=zl, age=42, value=5656.3, bm=BM1), 
        	   Employee(name=zh, age=12, value=9999.3, bm=BM2)], 
        true=[Employee(name=张龙, age=52, value=5656.3, bm=BM1), 
        	  Employee(name=王朝, age=75, value=77776.3, bm=BM3), 
        	  Employee(name=wc, age=75, value=77776.3, bm=BM3), 
        	  Employee(name=mh, age=63, value=7656.3, bm=BM1)]
        }

两次分区

		//两次分区，新人和老人，以及是否是bm1
        Map<Boolean, Map<Boolean, List<Employee>>> collect2 = employeeList.stream().
        				collect(Collectors.partitioningBy(item -> item.getAge() > 50, 
        					Collectors.partitioningBy(item -> 
        						item.getBm().equals(Employee.Bm.BM1))));
        System.out.println(collect2);
        -----------------------------------结果-------------------------------------
		{
		false={
			false=[Employee(name=赵虎, age=22, value=9999.3, bm=BM2),
				   Employee(name=zh, age=12, value=9999.3, bm=BM2)], 
			true=[Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
				  Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
				  Employee(name=zl, age=42, value=5656.3, bm=BM1)]}, 
		true={
			false=[Employee(name=王朝, age=75, value=77776.3, bm=BM3), 
				   Employee(name=wc, age=75, value=77776.3, bm=BM3)], 
			true=[Employee(name=张龙, age=52, value=5656.3, bm=BM1), 
				  Employee(name=mh, age=63, value=7656.3, bm=BM1)]}
		}

先分区在分组

		//分区与分组结合，先分区，再分组,先按年龄分区，在按部门分组
        Map<Boolean,Map<Employee.Bm,List<Employee>>> collect3=employeeList.stream()
        		.collect(Collectors.partitioningBy(item->item.getAge()>50,
        				Collectors.groupingBy(Employee::getBm)));
        System.out.println(collect3);
        -----------------------------------结果-------------------------------------
        {
        false={
        	BM1=[Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
        		 Employee(name=马汉, age=33, value=7656.3, bm=BM1), 
        		 Employee(name=zl, age=42, value=5656.3, bm=BM1)], 
        	BM2=[Employee(name=赵虎, age=22, value=9999.3, bm=BM2), 
        		 Employee(name=zh, age=12, value=9999.3, bm=BM2)]}, 
        true={
        	BM1=[Employee(name=张龙, age=52, value=5656.3, bm=BM1), 
        		 Employee(name=mh, age=63, value=7656.3, bm=BM1)], 
        	BM3=[Employee(name=王朝, age=75, value=77776.3, bm=BM3), 
        		 Employee(name=wc, age=75, value=77776.3, bm=BM3)]}
        }

总结来说对与流的操作跟数据库的操作基本相同