Java8Stram

package stream;

import org.junit.Test;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @ClassName TestStream
 * @Description: TODO
 * @Author 汤永红
 * @Date 2020/8/14 0014-15:14
 * @Version V1.0
 **/
public class TestStream {
    @Test
    public void testListToMap() {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(5);
        list.add(1);
        list.add(0);
        System.out.println(list);
        List<Integer> list1 = list.stream().sorted().collect(Collectors.toList());
        List<Integer> list2 = list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        List<Integer> integerList = list.stream().distinct().collect(Collectors.toList());
        //通过对象的属性排序和去重：
        List<Student> students = new ArrayList<>();
        Student stu1 = new Student();
        Student stu2 = new Student();
        Student stu3 = new Student();
        Student stu4 = new Student();
        stu1.setId(1);
        stu1.setName("第1");
        stu2.setId(2);
        stu2.setName("第2");
        stu3.setId(5);
        stu3.setName("第3");
        stu4.setId(4);
        stu4.setName("第4");
        students.add(stu1);
        students.add(stu2);
        students.add(stu3);
        students.add(stu4);
        System.out.println(list);

        //根据对象属性排序：
        /*Comparator.comparing((Student)->{
            getage方法的实现
        })
        Comparator.comparing(new Student({
                getage方法的实现
        }))*/
        List<Student> orderList =
                students.stream()
                        .sorted(Comparator.comparing(Student::getId))
                        .collect(Collectors.toList());

    }

    //根据对象属性去重最优雅的写法：
    public <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    public static void main(String[] args) {


    }

    //粘贴一个java8的stream()串行写法，parallelStream()并行写法和传统for写法的处理时间对比
    @Test
    public void contextLoads() {
        //初始化一个list
        long first = new Date().getTime();
        List<Student> list = new ArrayList<>();
        for (int i = 1; i < 5000; i++) {
            Student listToMap = new Student();
            listToMap.setId(i);
            listToMap.setName("name" + i);
            listToMap.setAge(i + 20);
            list.add(listToMap);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("传统所用时间" + (new Date().getTime() - first));
        long startTime = new Date().getTime();
        list.stream().forEach(f -> {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("串行所用时间" + (new Date().getTime() - startTime));


        long endTime = new Date().getTime();
        list.parallelStream().forEach(f -> {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("并行所用时间" + (new Date().getTime() - endTime));
    }
}

class Student {
    private Integer id;
    private String name;
    private Integer age;

    public Student() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}