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 personResult = test.getPersonsByUsername("zhangsan", persons);
// personResult.forEach(person -> System.out.println(person.getUsername()));
// List 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 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 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 list = company.getEmployees();
if(null != list){
return list;
}else
return new ArrayList();
*/
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;
}
}