java8—day01笔记

一：1.8开始引入函数式接口，接口里面可以有实现的方法，用关键字default（例如forEach循环）。

二：关于函数式接口：

• 如果一个接口只有一个抽象方法，那么这个接口就是一个函数式接口。
• 如果我们在某个接口上声明了@FunctionalInterface注解，那么编译器就会按照函数式接口的定义来要求该接口
• 如果某个接口只有一个抽象方法，但是我并没有给接口声明@FunctionalInterface注解，那么编译器依旧会将该接口看作是函数式接口。

流：

• stream：单线程的流
• parallelStream：多线程流。

java.util.function解析

          compose和andthen分析

import java.util.function.Function;

public class FunctionTest2 {
    public static void main(String[] args) {
        FunctionTest2 functionTest = new FunctionTest2();

        functionTest.compute(2,value->value * 3,value -> value*value);  //12
        functionTest.compute2(2,value->value * 3,value -> value*value); //36 

    }
    
    public int compute(int a, Function<Integer,Integer> function1,Function<Integer,Integer> function2){
        return function1.compose(function2).apply(a);
    }
    public int compute2(int a, Function<Integer,Integer> function1,Function<Integer,Integer> function2){
        return function1.andThen(function2).apply(a);
    }
}

predicate

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class PredicateTest2 {
    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);

        PredicateTest2 predicateTest2 = new PredicateTest2();
        predicateTest2.conditionFilter(list,item ->item % 2 == 0);
        System.out.println("---------------------------------");
        predicateTest2.conditionFilter(list,item ->item % 2 != 0);
        System.out.println("---------------------------------");
        predicateTest2.conditionFilter(list,item ->item > 5);
        System.out.println("---------------------------------");
        predicateTest2.conditionFilter(list,item -> true);
    }

    public void conditionFilter(List<Integer> list,Predicate<Integer> predicate){
        for (Integer integer:list){
            if (predicate.test(integer)){
                System.out.println(integer);
            };
        }
    }
}

集合中位值置换：StringCompator 

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class StringCompator {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("zhangsan","lisi","wangwu","zhaoliu");
        /*Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });*/
        /*
            comparator方法在Java8以后声明为接口，有default修饰的已经实现的方法。
        */
        Collections.sort(names,(o1,o2)->{
            return o2.compareTo(o1);
        });
        Collections.sort(names, Comparator.reverseOrder());
        System.out.println(names);
        
    }
}

BiFunction用于传入两个参数，代码示例：

public class Person {
    private String username;
    private Integer age;
    public Person() { }
    public Person(String username, Integer age) {
        this.username = username;
        this.age = age;
    }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.stream.Collectors;

public class PersonTest {
    public static void main(String[] args) {
        Person person1 = new Person("zhangsan",20);
        Person person2 = new Person("lisi",30);
        Person person3 = new Person("wangwu",40);
        List<Person> list = Arrays.asList(person1,person2,person3);
        PersonTest personTest = new PersonTest();
       /* List<Person> personresult = personTest.getPersonByUsername("zhangsan", list);
        personresult.forEach(person -> System.out.println(person.getUsername()));
*/
       /* List<Person> personByAge = personTest.getPersonByAge(20, list);
        personByAge.forEach(person -> System.out.println(person.getUsername()));
*/
        List<Person> personByAge = personTest.getPersonByAge2(20, list,(age,personList)->{
           return personList.stream().filter(person -> person.getAge()>age).collect(Collectors.toList());
        });
        personByAge.forEach(person -> System.out.println(person.getUsername()));
    }
    public List<Person> getPersonByUsername(String username,List<Person> Persons){

        return Persons.stream().filter(person -> person.getUsername().equals(username))
                .collect(Collectors.toList());
    }
    public List<Person> getPersonByAge(Integer age,List<Person> persons) {
        BiFunction<Integer, List<Person>, List<Person>> biFunction =
                (ageOfPerson, personslist) ->
                    personslist.stream().filter(person -> person.getAge() > ageOfPerson)
                            .collect(Collectors.toList());
        return biFunction.apply(age, persons);
    }

    public List<Person> getPersonByAge2(Integer age,List<Person> persons,BiFunction<Integer,List<Person>,List<Person>> biFunction){
        return biFunction.apply(age,persons);
    }
}