package test9;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamTest {

    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<Integer>();
        list1.add(12);
        list1.add(122);
        list1.add(2);
        list1.add(12);
        list1.add(13);
        List<Integer> list2 = new ArrayList<Integer>();
        list2.add(222);
        list2.add(333);

        int max = list1.parallelStream().max(Comparator.reverseOrder()).get();
        int max2 = list1.parallelStream().max(Comparator.naturalOrder()).get();
        System.out.println("拿取相反值(如果取最大值则拿出最小值，如果拿去最小值则取出最大值):" + max);
        System.out.println("取出最大值：" + max2);

        int max3 = list1.parallelStream().max(Integer::compare).get();
        System.out.println("获取最大值：" + max3);

        List<Integer> l1 = list1.parallelStream().skip(1).collect(Collectors.toList());
        System.out.println("丢弃掉集合中前一个元素：" + l1);

        List<Integer> l2 = Stream.concat(list1.parallelStream(), list2.parallelStream()).collect(Collectors.toList());
        System.out.println("合并两个流，要求第一个流不能是无限流：" + l2);

        List<Integer> l3 = list1.parallelStream().limit(2).collect(Collectors.toList());
        System.out.println("只获取集合中前两个值：" + l3);

        List<Integer> l4 = list1.parallelStream().distinct().collect(Collectors.toList());
        System.out.println("去重，将集合中重复的元素去除掉：" + l4);

        // peek(): 在流操作过程中可以循环打印一些信息，但不能单独使用，需后面有其他函数来触发
        list1.parallelStream().peek(System.out::println).collect(Collectors.toList());

        int element = list1.parallelStream().findAny().orElse(null);
        System.out.println("获取流中任意一个元素：" + element);// 并不是很任意，没有Random好用

        boolean isExist = list1.parallelStream().anyMatch(i -> i.intValue() == 2);
        System.out.println("这个值是否存在于流中：" + isExist);

        boolean isQualified = list1.parallelStream().allMatch(i -> i.intValue() > 1);
        System.out.println("是否此流中的每个元素值都大于1：" + isQualified);

        List<Integer> l5 = list1.parallelStream().sorted((x, y) -> x.compareTo(y)).collect(Collectors.toList());
        System.out.println("排序(正序，如果反序则将x和y的位置一调换即可)：" + l5);

        List<Integer> l6 = list1.parallelStream().sorted(Integer::compare).collect(Collectors.toList());
        System.out.println("排序，正序：" + l6);

        Collections.reverse(l6);// 直接修改集合本身的方式
        System.out.println("Collections.reverse反转(将已经排好的正序反转成反序):" + l6);

        Collections.sort(l6);// 直接修改集合本身的方式
        System.out.println("Collections.sort默认正序：" + l6);

        Collections.shuffle(l6);// 直接修改集合本身的方式
        System.out.println("Collections.shuffle将此集合中的下标次序打乱：" + l6);

        Collections.sort(l6, (x, y) -> x.compareTo(y));// 直接修改集合本身的方式
        System.out.println("指定排序(正序，反序对调x,y即可)：" + l6);

        Collections.rotate(l6, 1);// 直接修改集合本身的方式
        System.out.println("Collections.rotate将已排好序的集合下标统一向后移动一位，最后一个即变成第一位：" + l6);

        Collections.fill(l6, 111);// 直接修改集合本身的方式
        System.out.println("Collections.fill将集合中的所有元素都替换为111：" + l6);

        Map<Boolean, List<Integer>> map1 = list1.parallelStream().collect(Collectors.groupingBy(i -> i > 10));
        System.out.println("分组，大于10的有:" + map1.get(true) + "\t小于10的有:" + map1.get(false));

        Map<Boolean, Long> map2 = list1.parallelStream()
                .collect(Collectors.groupingBy(i -> i > 13, Collectors.counting()));
        System.out.println("统计：大于13的有多少个：" + map2.get(true) + "\t剩下的有多少个：" + map2.get(false));
    }

}