JAVA8 Stream 入门&范例

public static void main(String[] args) {
    List<Person> persionList = new ArrayList<Person>();
    persionList.add(new Person(1,"张三","男",38));
    persionList.add(new Person(2,"小小","女",2));
    persionList.add(new Person(3,"李四","男",65));
    persionList.add(new Person(4, "王五", "女", 20));
    persionList.add(new Person(5, "赵六", "男", 38));
    persionList.add(new Person(6, "大大", "男", 65));

    //datasource --> (filter --> map -->...一系列中间操作形成的流水线) --> collect|toList|findFirst 终端操作

    //map_demo(persionList);

    //filter_demo(persionList);

    //sort_demo();

    sort_demo2(persionList);
}

//map中间件相关例子
private static void map_demo(List<Person> persionList) {

    //1、只取出该集合中所有姓名组成一个新集合
    List<String> names = persionList.stream().map(Person::getName).collect(Collectors.toList());
    System.out.println(names.toString());

    //2、只取出该集合中所有id组成一个新集合
    List<Integer> ids = persionList.stream().mapToInt(Person::getId).boxed().collect(Collectors.toList());
    System.out.println(ids.toString());

    //3、list转map，key值为id，value为Person对象
    Map<Integer, Person> map = persionList.stream().collect(Collectors.toMap(Person::getId, Function.identity()));
    System.out.println(map.toString());

    //4、list转map，key值为id，value为name
    Map<Integer, String> map1 = persionList.stream().collect(Collectors.toMap(Person::getId, Person::getName));
    System.out.println(map1.toString());

    //5、进行map集合存放，key为age值 value为Person对象 它会把相同age的对象放到一个集合中
    Map<Integer, List<Person>> ageMap = persionList.stream().collect(Collectors.groupingBy(Person::getAge));
    System.out.println(ageMap.toString());

    //6、获取最小、大、和的年龄
    Integer ageMin = persionList.stream().mapToInt(Person::getAge).min().getAsInt();

    Integer ageMax = persionList.stream().mapToInt(Person::getAge).max().getAsInt();

    Integer ageSum = persionList.stream().mapToInt(Person::getAge).sum();

    //不确定你的key是否唯一
    Map<Integer, String> map2 = persionList.stream().collect(
            Collectors.toMap(Person::getAge, Person::getName, (key1, key2) -> key1)
    );

    Map<Integer, String> map3 = persionList.stream().collect(
            Collectors.toConcurrentMap(Person::getAge, Person::getName, (key1, key2) -> key1, ConcurrentHashMap::new)
    );

    Map map4 =LongStream.rangeClosed(1, 1000).boxed().collect(Collectors.toConcurrentMap(i -> UUID.randomUUID().toString(), Function.identity(), (o1,o2)->o1, ConcurrentHashMap::new));
    System.out.println(map4);
}

//filter相关例子
private static void filter_demo(List<Person> personsList){
    //1、查找年龄大于20岁的人数
    long count = personsList.stream().filter(person -> person.getAge()>20).count();
    System.out.println(count);

    //2、查找年龄大于20岁，性别为男的List
    List<Person> persons = personsList.stream().filter(person -> person.getAge() > 20).filter(person1 -> person1.getSex().equals("男")).collect(Collectors.toList());
    System.out.println(persons);
}

//sort 相关例子
private static void sort_demo(){
    String[] arr1 = {"abc","a","bc","abcd"};

    //按照字符长度排序
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);

    /**
     * 倒序
     * reversed(),java8泛型推导的问题，所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
     * Comparator.reverseOrder():也是用于翻转顺序，用于比较对象（Stream里面的类型必须是可比较的）
     * Comparator. naturalOrder()：返回一个自然排序比较器，用于比较对象（Stream里面的类型必须是可比较的）
     */
    Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);
    //输出：abcd、abc、bc、a
    Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);
    //输出：bc、abcd、abc、a
    Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);
    //输出：a、abc、abcd、bc

    //先按照首字母排序,之后按照String的长度排序
    new ConcurrentHashMapPerformanceController().testSorted(arr1);
}

public void testSorted(String[] arr1){
    Arrays.stream(arr1).sorted(Comparator.comparing(this::ownComp).thenComparing(String::length)).forEach(System.out::println);
}

//自定义比较器
public char ownComp(String x){
    return x.charAt(0);
}

private static void sort_demo2(List<Person> personList){
    //1、找到年龄最小的岁数
    Collections.sort(personList, (x, y) -> x.getAge().compareTo(y.getAge()));
    Integer age = personList.get(0).getAge();
    System.out.println(age);

    //2、找到年龄最小的姓名
    String name = personList.stream().sorted(Comparator.comparing(x -> x.getAge())).findFirst().get().getName();
    System.out.print(name);
}

private static void distinct_demo(List<Person> personList){
    // 根据id去重
    List<Person> unique = personList.stream().collect(
            collectingAndThen(
                    toCollection(() -> new TreeSet<>(comparingLong(Person::getId))), ArrayList::new)
    );
}