JDK 1.8 lambda的用法

public class Student {

    private String id;
    private String name;
    private String age;
    private String address;

    public Student(String id, String name, String age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

public class TestStrean {

    public static void main(String[] args){
        Student stuA = new Student("1", "A", "M", "184");
        Student stuB = new Student("2", "B", "G", "163");
        Student stuC = new Student("3", "C", "M", "175");
        Student stuD = new Student("4", "D", "G", "158");
        Student stuE = new Student("5", "E", "M", "175");
        List<Student> list = new ArrayList<>();
        list.add(stuA);
        list.add(stuB);
        list.add(stuC);
        list.add(stuD);
        list.add(stuE);

        /*-----------forEach-----------------------*/
//        list.forEach(item -> item.setId(item.getAddress()+"test") );

        /*-----------filter-----------------------*/
//        List<Student> newList=list.stream().filter(item -> item.getAge().contains("G")).collect(Collectors.toList());

        /*-----------filter的复杂应用-----------------------*/
//        list.stream().filter(new Predicate<Student>(){
//
//            @Override
//            public boolean test(Student student) {
//                if(student.getName() !=null){
//                    return student.getName().contains("30");
//                }else{
//                    return true;
//                }
//            }
//        }).collect(Collectors.toList());

        /*-----------分页-----------------------*/
//        List<Student> newList=list.stream().skip(4).limit(3).collect(Collectors.toList());


        /*-----------map 返回一个新的list<Object>-----------------------*/
//        List<Student> newList=list.stream().map(item ->{
//            return new Student(
//                    item.getAddress(),
//                    item.getAge(),
//                    item.getName(),
//                    item.getId()
//            );
//        }).collect(Collectors.toList());

        /*-----------map 返回一个原来的的list<Student>并赋值-----------------------*/
//        List<Student> newList=list.stream().map(item ->{
//            item.setId("1");
//            return  item;
//        }).collect(Collectors.toList());

        /*-----------flatMap-----------------------*/
//        List<Student> newList= list.stream().flatMap(item ->{
//            String[] split =item.getAddress().split("");
//            String[] s2  = (String[]) Arrays.stream(split).filter(s -> s.contains("1")).toArray();
//            return  s2;
//                });

        /*-----------sorted compareTo排序-----------------------*/
//        List<Student> newList=list.stream().sorted((o1,o2)->{
//            if(o1.getAddress().equals(o2.getAddress())){
//                return  Integer.parseInt(o1.getId())-Integer.parseInt(o2.getId());
//            }else{
//                return o1.getAddress().compareTo(o2.getAddress());
//            }
//        }).collect(Collectors.toList());

        /*-----------sorted Comparator排序-----------------------*/
//        List<Student> newList=list.stream().sorted(
//                Comparator.comparing(Student::getAddress).reversed()
//        ).collect(Collectors.toList());

        /*-----------sorted3 多条件排序-----------------------*/
//        List<Student> newList=list.stream().sorted(
//                Comparator.comparing(Student::getAddress).thenComparing(Comparator.comparing(Student::getId).reversed())
//        ).collect(Collectors.toList());

//        boolean b=list.stream().anyMatch(item -> item.getAge().contains("G"));
//        System.out.println(b);


        /*-----------Collector  tomap----------------------*/
//        Map<String, String>  newList=list.stream().sorted(
//                Comparator.comparing(Student::getAddress).thenComparing(Comparator.comparing(Student::getId).reversed())
//        ).collect(Collectors.toMap(Student::getId,Student::getAddress));



        /*-----------Collector  groupingBy----------------------*/
        Map<String, List<Student>> ageMap = list.stream().collect(Collectors.groupingBy(Student::getAddress));

       System.out.println(ageMap );

     //------------------输出acc和其他三个值交集---------/
        Optional accResult = Stream.of(1, 2, 3,1).reduce((acc, item) -> {
            System.out.println("acc : " + acc);
            System.out.println("item: " + item);
            System.out.println("--------");
            return acc;
        });
        System.out.println(accResult.orElse(""));

        //-------------------------求多个集合的交集-------------
//        List<List<String>>  elementLists = null;
//        Optional<List<String>> result = elementLists.parallelStream()
//                .reduce((listA, listB) -> {
//                    listA.retainAll(listB);
//                    return listA;
//                });
//         result.orElse(new ArrayList<>());   
    }
}