Lambda

public class SwingTest {

    public static void main(String[] args) {
        JFrame jframe = new JFrame("My JFrame");
        JButton jButton = new JButton("My JButton");

        jButton.addActionListener(event -> {//(ActionEvent event)完整写法应该为这样，但是由于java里面的类型推断，所以可以省略写event 就可以。
            System.out.println("Button Pressed!");
            System.out.println("hello world");
            System.out.println("executed");
        });

        jframe.add(jButton);
        jframe.pack();
        jframe.setVisible(true);
        jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

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

可以通过lambda、方法引用和构造引用来实例
需要满足：①该类型是接口类型，而不是注释类型、枚举或类。②经过处理的类型满足功能性接口的要求。

@FunctionInterface的用法：


疑问：为什么改了个myString就可以。
解释：原因是如果一个函数式接口中重写了一个Object中的方法，那么函数式接口不会默认的往其中加1，如果往函数式接口中多加1个方法，那么就违背了函数式接口有且仅有一个方法的定义。【除重写Object里面的方法。】
原理：因为Object是所有类的父类。该接口会通过直接或者间接的形式继承Object，从而实现toString，也就是Object中的方法。

public class Main {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1,23,4);
        //        for(int i = 0; i < list.size(); ++i) {
//            System.out.println(list.get(i));
//        }
//
//        System.out.println("----------");
//
//        for(Integer i : list) {
//            System.out.println(i);
//        }
//
//        System.out.println("----------");

        // method reference
        list.forEach(System.out::println);
        list.forEach(integer -> {
            System.out.println(integer);
        });
        list.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}

传统写法：行为已经存在，我们去调用这个行为

public int method(int a){
	return a + 4;
}
public int method1(int a){
	return a * a;
}
//调用时：有很大局限性，方法已经写好了，我们只能跟着方法里面的代码走
method(2);

Lambda：行为刚开始是不存在，我们通过Function的apply方法，这样就可以让我们自己定义行为。

public int method(int a,Function<Integer,Integer> function){//高阶函数
	int result = function.apply(a);
	return result;
}

//调用：大大摆脱了原先方法，我们可以自己传递我们想要的行为进去给方法。
//方法一
Function<Integer,Integer> function = vaue -> value * value;
method(2,function);
//方法二
method(2,value -> value * value);

总结：Lambda我们可以自己自定义方法体，通过Function传递我们想要的行为给含有Function参数的方法。

public class FunctionTest2 {

    public static void main(String[] args) {
        FunctionTest2 test = new FunctionTest2();
        System.out.println(test.compute(2, value -> value * 3, value -> value * value)); // 12
      	System.out.println(test.compute2(2, value -> value * 3, value -> value * value)); // 36
		System.out.println(test.compute4(2, 3, (value1, value2) -> value1 + value2, value -> value * value)); //25
    }
    public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
        return function1.compose(function2).apply(a);//先算参数的function2，再算外面（function1）的参数
    }

    public int compute2(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2) {
        return function1.andThen(function2).apply(a);
    }
    public int compute3(int a, int b, BiFunction<Integer, Integer, Integer> biFunction) {
        return biFunction.apply(a, b);
    }

    public int compute4(int a, int b, BiFunction<Integer, Integer, Integer> biFunction,
                        Function<Integer, Integer> function) {
        return biFunction.andThen(function).apply(a, b);
    }

注意点：为什么BiFunction里面没有compose方法。
原因：compose会先调用参数里面的function，而不管function还是Bifunction它都只有一个返回值，然而bifunction是接收两个值的方法。
BiFunction可以用andThen的原因是：andThen里面是先执行apply方法外边的function，所以，我们只需要将Bifunction方法定义在apply方法外边，让其返回一个值到function里面即可。（代码解释： return biFunction.andThen(function).apply(a, b);）

BiFunction实例

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> persons = Arrays.asList(person1, person2, person3);

        PersonTest test = new PersonTest();

//        List<Person> personResult = test.getPersonsByUsername("zhangsan", persons);
//        personResult.forEach(person -> System.out.println(person.getUsername()));

//        List<Person> personResult = test.getPersonsByAge(20, persons);
//        personResult.forEach(person -> System.out.println(person.getAge()));

        List<Person> personResult2 = test.getPersonsByAge2(20, persons, (age, personList) -> {
            return personList.stream().filter(person -> person.getAge() <= age).collect(Collectors.toList());
        });

        personResult2.forEach(person -> System.out.println(person.getAge()));


    }
==================================================方法==================================================

    public List<Person> getPersonsByUsername(String username, List<Person> persons) {
        return persons.stream().filter(person -> person.getUsername().equals(username)).
                collect(Collectors.toList());
    }

    public List<Person> getPersonsByAge(int age, List<Person> persons) {
        BiFunction<Integer, List<Person>, List<Person>> biFunction = (ageOfPerson, personList) -> {
            return personList.stream().filter(person -> person.getAge() > ageOfPerson).collect(Collectors.toList());
        };

        return biFunction.apply(age, persons);
    }

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

Predicate：给定一个参数，判断这个参数是否符合我们设定的条件，返回值类型：Boolean。

例子

public static void main(String[] args) {

        Predicate<String> predicate = p -> p.length() > 5;

        System.out.println(predicate.test("hello1"));
}

例子

public class PredicateTest2 {

    public static void main(String[] args) {

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

        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 -> item < 3);
        System.out.println("---------");
        predicateTest2.conditionFilter(list, item -> true);//打印集合中所有的值
        System.out.println("---------");
        predicateTest2.conditionFilter(list, item -> false);//不打印任何数据
        System.out.println("---------");

        predicateTest2.conditionFilter2(list, item -> item > 5, item -> item % 2 == 0);
        System.out.println("---------");

        System.out.println(predicateTest2.isEqual(new Date()).test(new Date()));



    }


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

//    public void findAllEvens(List<Integer> list) {
//        for(Integer integer : list) {
//            if(integer % 2 == 0) {
//                System.out.println(integer);
//            }
//        }
//    }

}

前提知识：&&前面的数是false则整个不执行。||如果前面有true，后面不执行。

    public void conditionFilter2(List<Integer> list, Predicate<Integer> predicate,
                                 Predicate<Integer> predicate2) {
        for(Integer integer : list) {
            if(predicate.and(predicate2).test(integer)) {//含义：字面意思，“和”。
                System.out.println(integer);
            }
            if(predicate.and(predicate2).negate().test(integer)) {//含义：取反，如：item -> item > 5, item -> item % 2 == 0例子结果为1,2，3,4，5,7，9原先值为6,8，10。
                System.out.println(integer);
            }
            /*if(predicate.and(predicate2).test(integer)) {//含义：字面意思，“或”。
                System.out.println(integer);
            }*/
            
        }

    }

    public Predicate<Date> isEqual(Object object) {
        return Predicate.isEqual(object);
    }

    public static void main(String[] args) {
        predicateTest2.conditionFilter2(list, item -> item > 5, item -> item % 2 == 0);
        System.out.println("---------");

        System.out.println(predicateTest2.isEqual(new Date()).test(new Date()));

    }

Supplier：不接收参数，返回一个结果。

public class SupplierTest {

    public static void main(String[] args) {
        Supplier<String> supplier = () -> "hello world";
        System.out.println(supplier.get());//结果：hello world
    }
}

例子

//以前获取名字的方法。
public static void main(String[] args) {
        Student student = new Student();
        student.getName();
}
//Supplier
public static void main(String[] args) {
        Supplier<Student> supplier = () -> new Student(); 
        //Supplier<Student> supplier = Student::new;
      	System.out.println(supplier.get().getName());
}

代码准备

public class Student {

    private String name = "zhangsan";

    private int age = 20;

    public Student() {

    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

【注意点：Student符合Supplier的原因是因为构造方法中没有参数，（当构造方法有空参也有传参的时候，编译不报错，当只有有参的构造方法，没有无参的构造方法时，程序Supplier supplier = Student::new;则会报错。）而且可以返回一个Student对象。而使用Supplier的前提是不接收参数，返回一个结果。】

BinaryOperator（接收两个值，返回一个参数，且该函数继承BiFunction，它与BiFunction不同的是，参数类型都一样。）

例子

public class BinaryOperatorTest {

    public static void main(String[] args) {
        BinaryOperatorTest binaryOperatorTest = new BinaryOperatorTest();
	}
        System.out.println(binaryOperatorTest.compute(1, 2, (a, b) -> a + b));
    public int compute(int a, int b, BinaryOperator<Integer> binaryOperator) {
        return binaryOperator.apply(a, b);
    }
}

调用BinaryOperator中的minBy方法。（通过Comparator comparator将我们要的行为传进去，且行为需要通过对比长度或者大小返回一个正负值给minBy方法。maxBy同上）

public class BinaryOperatorTest {

    public static void main(String[] args) {
        BinaryOperatorTest binaryOperatorTest = new BinaryOperatorTest();
        System.out.println(binaryOperatorTest.getShort("hello123", "world", (a, b) -> a.length() - b.length()));//返回world通过对长度的值正负来
        System.out.println(binaryOperatorTest.getShort("hello123", "world", (a, b) -> a.charAt(0) - b.charAt(0)));//返回hello23，第一个字符的数小于第二个，又因为该方法是minBy，前往minBy源代码即可以知道。
        

    }
    public String getShort(String a, String b, Comparator<String> comparator) {
        return BinaryOperator.minBy(comparator).apply(a, b);
    }
}

Optional

明确对象不为 null 的时候使用 of()。
如果对象即可能是 null 也可能是非 null，你就应该使用 ofNullable() 方法：

=============================================================
没学Optional之前我们这样做：

String str = null;
if(null != str){
	str...
}

学完后
方法一：

Optional<String> optional = Optional.of(str);
if(optional.isPresent()){
	optional.get();
}

方法二：【推荐】

Optional<String> optional = Optional.ofNullable("hello");
optional.ifPresent(item -> System.out.println(item)); //推荐的Optional使用方式

System.out.println(optional.orElse(“world”));//判断optional这个容器中有没有值，如果有，则不打印orElse方法里面的值，没有则打印该方法里面的值
System.out.println(optional.orElseGet(() -> “world”));
上面两个语句输出结果一样。

public class OptionalTest2 {

    public static void main(String[] args) {
        Employee employee = new Employee();
        employee.setName("zhangsan");

        Employee employee2 = new Employee();
        employee2.setName("lisi");

        Company company = new Company();
        company.setName("company1");

        List<Employee> employees = Arrays.asList(employee, employee2);
//        company.setEmployees(employees);

		//判断集合中是否有空的Employee，如果没有，则返回空集合，如果有，则返回集合。
		/*
		//传统写法
		List<Employee> list = company.getEmployees();
		if(null != list){
			return list;
		}else
			return new ArrayList<Employee>();
		*/
        Optional<Company> optional = Optional.ofNullable(company);

        System.out.println(optional.map(theCompany -> theCompany.getEmployees()).
                orElse(Collections.emptyList()));


    }

    public void test(Optional optional) {

    }
}

代码准备

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

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

public class Company {

    private String name;

    private List<Employee> employees;

    public String getName() {
        return name;
    }

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

    public List<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(List<Employee> employees) {
        this.employees = employees;
    }
}