Java高级：新特性：lambda 函数式接口方法引用 StreamAPI Optional类

package com.atguigu.java1;import org.junit.Test;import java.util.Comparator;/*** Lambda表达式使用举例：** @author* @create 2022-07-26 22:04*/
public class LambdaTest {@Testpublic void test1(){Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("我爱北京天安门");}};r1.run();System.out.println("***********************");Runnable r2 = () -> System.out.println("我爱故宫");r2.run();}@Testpublic void test2(){Comparator<Integer> com1 = new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return Integer.compare(o1,o2);}};int compare1 = com1.compare(12, 21);System.out.println(compare1);System.out.println("***********************");//Lambda表达式的写法Comparator<Integer> com2 = ( o1,  o2) -> Integer.compare(o1,o2);int compare2 = com2.compare(12, 21);System.out.println(compare1);System.out.println("***********************");//方法引用：Comparator<Integer> com3 =Integer :: compare;int compare3 = com2.compare(12, 21);System.out.println(compare1);}
}

package com.atguigu.java1;import org.junit.Test;import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;/*** Lambda表达式的使用* 1.举例：（o1 o2） -> Integer.compare(o1,o2);* 2.格式：*      ->:lambda操作符 或者叫箭头操作符*      ->左边：lambda形参列表（其实就是接口中的抽象方法的形参列表）*      ->右边：lambda体（其实就是重写的的抽象方法的方法体）* 3.Lambda表达式的使用：（分为6种情况）* 总结：* ->左边：lambda形参列表的形参类型可以省略（类型推断）；如果参数列表只有一个参数，括号也可以省略。*  ->右边：lambda体应该使用一对{}来包裹；如果lambda体只有一条执行语句（可能是return语句），省略这一对{}和return。** 4.Lambda表达式的本质：就是作为接口（函数式接口）的实例！** 5.函数式接口：如果一个接口中只声明了一个抽象方法，就叫函数式接口。** @author* @create 2022-07-26 22:20*/
public class LambdaTest1 {//语法格式一：无参，无返回值@Testpublic void test1(){Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("我爱北京天安门");}};r1.run();System.out.println("***********************");Runnable r2 = () -> {System.out.println("我爱故宫");};r2.run();}//语法格式二：需要一个参数，无返回值@Testpublic void test2(){Consumer<String> con = new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}};con.accept("谎言和誓言的区别是什么呢？");System.out.println("***********************");Consumer<String> con1 = (String s) -> {System.out.println(s);};con1.accept("一个是听的人当真了");}//语法格式三：数据类型可以省略，因为可以由编译器推断得出，称为”类型推断“。@Testpublic void test3(){Consumer<String> con1 = (String s) -> {System.out.println(s);};con1.accept("一个是听的人当真了");System.out.println("***********************");Consumer<String> con2 = (s) -> {System.out.println(s);};con2.accept("一个是听的人当真了");}@Testpublic void test4(){ArrayList<String> list = new ArrayList<>();//类型推断int[] arr = {1,3,4};//类型推断}//语法格式四：Lmabda若只需要一个参数时，参数的小括号可以省略。@Testpublic void test5(){Consumer<String> con1 = (s) -> {System.out.println(s);};con1.accept("一个是听的人当真了");System.out.println("***********************");Consumer<String> con2 = s -> {System.out.println(s);};con2.accept("一个是听的人当真了");}//语法格式五：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值@Testpublic void test6(){Comparator<Integer> com = new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {System.out.println(o1);System.out.println(o2);return o1.compareTo(o2);}};System.out.println(com.compare(12,21));System.out.println("******************");Comparator<Integer> com1 = (o1,o2) -> {System.out.println(o1);System.out.println(o2);return o1.compareTo(o2);};System.out.println(com1.compare(12,6));}//语法格式六：当Lambda体只有一条语句时，return 与大括号若有，都可以省略@Testpublic void test7() {Comparator<Integer> com1 = (o1,o2) -> {return o1.compareTo(o2);};System.out.println(com1.compare(12,6));System.out.println("******************");Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);System.out.println(com1.compare(12,23));}
}

package com.atguigu.java1;import org.junit.Test;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;/***java内置的4大核心函数式接口：** 消费型接口 Consumer<T> void accept(T t)* 供给型接口 Supplier<T> T get()* 函数型接口 Function<T R> R apply(T t)* 断定型接口 Predication<T> boolean test(T t)** @author* @create 2022-07-27 10:48*/
public class LambdaTest2 {@Testpublic void test(){happyTime(500, new Consumer<Double>() {@Overridepublic void accept(Double aDouble) {System.out.println("学习好啊" + aDouble);}});System.out.println("**************************");happyTime(400, money -> System.out.println("学习好啊" + money));}public void happyTime(double money, Consumer<Double> con){con.accept(money);}@Testpublic void test2(){List<String> list = Arrays.asList("南京","济南");List<String> filterString = filterString(list, new Predicate<String>() {@Overridepublic boolean test(String s) {return s.contains("京");}});System.out.println(filterString);List<String> filterString1 = filterString(list,s -> s.contains("京"));System.out.println(filterString1);}//根据给定的规则去过滤字符串public List<String> filterString (List<String> list, Predicate<String> pre){ArrayList<String> arr = new ArrayList<>();for (String s: list){if(pre.test(s)){arr.add(s);}}return arr;}}

package com.atguigu.java2;import org.junit.Test;import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;/*** 方法引用的使用:** 1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了，就可以使用方法引用。** 2.方法引用本质上就是Lambda表达式，而Lambda表达式是作为函数时接口的s实例。所以* 方法引用也是函数式接口的实例。** 3.使用和格式：  类（对象）:: 方法名** 4 .具体分为如下的三种情况：** 情况一：  对象：：非静态方法（实例方法）* 情况二：  类：：静态方法** 情况三：  类：：非静态方法** 5.方法引用的使用要求：要求接口中的抽象方法的形参列表和返回值类型要和方法引用的方法的* 形参列表和返回值相同。（针对情况一和情况二）*/
public class MethodRefTest {// 情况一：对象 :: 实例方法//Consumer中的void accept(T t)//PrintStream中的void println(T t)@Testpublic void test1() {Consumer<String> con1 = str -> System.out.println(str);con1.accept("北京");System.out.println("*********************");PrintStream ps = System.out;Consumer<String> con2 = ps :: println;con2.accept("北京啊北京");}//Supplier中的T get()//Employee中的String getName()@Testpublic void test2() {Employee emp = new Employee(1001,"Tom",23,5600);Supplier<String> sup1 = () -> emp.getName();System.out.println(sup1.get());System.out.println("*********************");Employee emp2 = new Employee(1001,"Tom",23,5600);Supplier<String> sup2 = emp :: getName;System.out.println(sup2.get());}// 情况二：类 :: 静态方法//Comparator中的int compare(T t1,T t2)//Integer中的int compare(T t1,T t2)@Testpublic void test3() {Comparator<Integer> com1 = (o1, o2) -> Integer.compare(o1, o2);System.out.println(com1.compare(10, 12));System.out.println("*********************");Comparator<Integer> com2 = Integer :: compare;System.out.println(com2.compare(34, 645));}//Function中的R apply(T t)//Math中的Long round(Double d)@Testpublic void test4() {Function<Double, Long> func1 = d -> Math.round(d);System.out.println(func1.apply(200.9));System.out.println("*********************");Function<Double, Long> func2 = Math :: round;System.out.println(func2.apply(2345.5));}// 情况三：类 :: 实例方法 (有难度)// Comparator中的int comapre(T t1,T t2)// String中的int t1.compareTo(t2)@Testpublic void test5() {Comparator<String> com1 = (t1, t2) -> t1.compareTo(t2);System.out.println(com1.compare("adfs", "fwer"));System.out.println("*********************");Comparator<String> com2 = String :: compareTo;System.out.println(com2.compare("sfg", "fsgrw"));}//BiPredicate中的boolean test(T t1, T t2);//String中的boolean t1.equals(t2)@Testpublic void test6() {BiPredicate<String, String> pre1 = (t1, t2) -> t1.equals(t2);System.out.println(pre1.test("abc","abc"));System.out.println("*********************");BiPredicate<String, String> pre2 = String :: equals;System.out.println(pre2.test("abc","abc"));}// Function中的R apply(T t)// Employee中的String getName();@Testpublic void test7() {Function<Employee, String> func1 = e -> e.getName();System.out.println(func1.apply(new Employee(1234,"Tom")));System.out.println("*********************");Function<Employee, String> func2 = Employee :: getName;System.out.println(func2.apply(new Employee(1234,"Tom")));}
}

package com.atguigu.java2;import org.junit.Test;import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;/*** 一、构造器引用**       和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。*       抽象方法的返回值类型即为构造器所属类的类型。** 二、数组引用**      大家可以把数组看成是一个特殊的类，则写法就与构造器引用一致。***/
public class ConstructorRefTest {//构造器引用//Supplier中的T get()//Employee的空参构造器：Employee,没有参数有返回值@Testpublic void test1(){Supplier<Employee> sup1 = new Supplier<Employee>() {@Overridepublic Employee get() {return new Employee();}};System.out.println("**************************");Supplier<Employee> sup2 = () -> new Employee();System.out.println(sup2.get());System.out.println("**************************");Supplier<Employee> sup3 = Employee :: new;System.out.println(sup3.get());}//Function中的R apply(T t)@Testpublic void test2(){Function<Integer, Employee> fun1 = id -> new Employee(id);Employee apply = fun1.apply(123);System.out.println(apply);System.out.println("**************************");Function<Integer, Employee> fun2 = Employee :: new;Employee apply1 = fun1.apply(123);System.out.println(apply1);}//BiFunction中的R apply(T t,U u)@Testpublic void test3(){BiFunction<Integer,String,Employee> fun1 = (name,id) -> new Employee(name,id);Employee tom = fun1.apply(12, "Tom");System.out.println(tom);System.out.println("**************************");BiFunction<Integer,String,Employee> fun2 = Employee :: new;Employee tom1 = fun1.apply(12, "Tom");System.out.println(tom1);}//数组引用：//Function中的R apply(T t)@Testpublic void test4(){Function<Integer,String[]> fun1 = length -> new String[length];String[] apply = fun1.apply(10);System.out.println(Arrays.toString(apply));Function<Integer,String[]> fun2 = String[] :: new;String[] apply2 = fun1.apply(10);System.out.println(Arrays.toString(apply2));}
}

package com.atguigu.java2;/*** @author*/
public class Employee {private int id;private String name;private int age;private double salary;public int getId() {return id;}public void setId(int id) {this.id = id;}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;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}public Employee(String s, String tom, int i) {}public Employee(String s, String tom, int age, int id) {this.id = id;}public Employee() {}public Employee(int id) {this.id = id;}public Employee(int id, String name) {this.id = id;this.name = name;}public Employee(int id, String name, int age, double salary) {this.id = id;this.name = name;this.age = age;this.salary = salary;}@Overridepublic String toString() {return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';}@Overridepublic boolean equals(Object o) {if (this == o)return true;if (o == null || getClass() != o.getClass())return false;Employee employee = (Employee) o;if (id != employee.id)return false;if (age != employee.age)return false;if (Double.compare(employee.salary, salary) != 0)return false;return name != null ? name.equals(employee.name) : employee.name == null;}@Overridepublic int hashCode() {int result;long temp;result = id;result = 31 * result + (name != null ? name.hashCode() : 0);result = 31 * result + age;temp = Double.doubleToLongBits(salary);result = 31 * result + (int) (temp ^ (temp >>> 32));return result;}
}

package com.atguigu.java2;import java.util.ArrayList;
import java.util.List;
/*** 提供用于测试的数据* * @author**/
public class EmployeeData {public static List<Employee> getEmployees(){List<Employee> list = new ArrayList<>();list.add(new Employee(1001, "马化腾", 34, 6000.38));list.add(new Employee(1002, "马云", 12, 9876.12));list.add(new Employee(1003, "刘强东", 33, 3000.82));list.add(new Employee(1004, "雷军", 26, 7657.37));list.add(new Employee(1005, "李彦宏", 65, 5555.32));list.add(new Employee(1006, "比尔盖茨", 42, 9500.43));list.add(new Employee(1007, "任正非", 26, 4333.32));list.add(new Employee(1008, "扎克伯格", 35, 2500.32));return list;}
}

package com.atguigu.java3;import com.atguigu.java2.Employee;
import com.atguigu.java2.EmployeeData;
import org.junit.Test;import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;/*** 1.Stream API关注的是对数据的运算，与CPU打交道*   Collection集合关注的是数据的存储，与内存打交道** 2.* ①Stream 自己不会存储元素。* ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream。* ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。** 3.Stream执行流程* ①Stream实例化* ②一系列中间操作（过滤 映射。。。）* ③终止操作**4.说明：* 4.1一个中间操作链对数据源的数据进行处理。* 4.2一旦执行终止操作，就执行中间操作链，并产生结果。之后，就不会再被使用。**** 测试：Stream实例化** @author* @create 2022-07-27 19:05*/
public class StreamAPITest {//创建Stream方式一：通过集合@Testpublic void test1(){List<Employee> employees = EmployeeData.getEmployees();//         default Stream<E> stream() : 返回一个顺序流Stream<Employee> stream = employees.stream();//         default Stream<E> parallelStream() : 返回一个并行流Stream<Employee> parallelStream = employees.parallelStream();}//创建 Stream方式二：通过数组@Testpublic void test2(){int[] arr = new int[]{1,23,4};//static <T> Stream<T> stream(T[] array): 返回一个流IntStream intStream = Arrays.stream(arr);Employee e1 = new Employee(1001,"Tom");Employee e2 = new Employee(1003,"Jerry");Employee[] arr1 = new Employee[]{e1, e2};Stream<Employee> stream = Arrays.stream(arr1);}//创建 Stream方式三：通过Stream的of()@Testpublic void test3(){Stream<Integer> integerStream = Stream.of(1, 2, 3, 44, 3);}//创建 Stream方式四：创建无限流:@Testpublic void test4(){
//         迭代
//        public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out :: println);//         生成
//        public static<T> Stream<T> generate(Supplier<T> s)Stream.generate(Math :: random).limit(10).forEach(System.out :: println);}
}

package com.atguigu.java3;import com.atguigu.java2.Employee;
import com.atguigu.java2.EmployeeData;
import org.junit.Test;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;/*** 测试Stream的中间操作** @author* @create 2022-07-27 20:11*/
public class StreamAPITest1 {@Testpublic void test1(){List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p) 接收 Lambda ，从流中排除某些元素Stream<Employee> stream = list.stream();//练习：查询员工表中薪资大于7000的员工信息stream.filter(e -> e.getSalary() > 7000).forEach(System.out :: println);System.out.println();//        limit(long maxSize) 截断流，使其元素不超过给定数量List<Employee> list1 = EmployeeData.getEmployees();Stream<Employee> stream1 = list1.stream();stream1.limit(3).forEach(System.out :: println);System.out.println();//        skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补list.stream().skip(2).forEach(System.out :: println);//        distinct() 筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素list.add(new Employee(1010,"刘强东",40,8000));list.add(new Employee(1010,"刘强东",40,8000));list.add(new Employee(1010,"刘强东",40,8000));list.add(new Employee(1010,"刘强东",40,8000));list.add(new Employee(1010,"刘强东",40,8000));//        System.out.println(list);list.stream().distinct().forEach(System.out :: println);}//映射@Testpublic void test2(){
//  map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。List<String> list = Arrays.asList("AA", "BB", "CC");list.stream().map(str -> str.toUpperCase()).forEach(System.out :: println);
// 练习1：获取姓名长度大于三的员工的姓名List<Employee> employees = EmployeeData.getEmployees();Stream<Employee> stream = employees.stream();Stream<String> namesStream = stream.map(e -> e.getName());namesStream.filter(name -> name.length() > 3).forEach(System.out :: println);System.out.println();//练习2：Stream<Stream<Character>> streamStream = list.stream().map(str -> fromStringToStream(str));streamStream.forEach(s -> {s.forEach(System.out :: println);});// flatMap(Function f) 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流Stream<Character> characterStream = list.stream().flatMap(str -> fromStringToStream(str));characterStream.forEach(System.out :: println);}//将字符串中的多个字符构成的集合，转换为对应的Stream的实例。public Stream<Character> fromStringToStream(String str){//aaArrayList<Character> list = new ArrayList<>();//a,afor(Character c :str.toCharArray()){list.add(c);}return list.stream();}@Testpublic void test3(){ArrayList list1 = new ArrayList();list1.add(1);list1.add(2);list1.add(3);ArrayList list2 = new ArrayList();list2.add(4);list2.add(5);list2.add(6);list1.add(list2);list1.addAll(list2);System.out.println(list1);}//3-排序@Testpublic void test4(){
//        sorted() 产生一个新流，其中按自然顺序排序List<Integer> list = Arrays.asList(231, 423, 5, 345, 352);list.stream().sorted().forEach(System.out::println);//会抛出异常：因为Employee没有实现Comparable接口
//        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);//        sorted(Comparator com) 产生一个新流，其中按比较器顺序排序List<Employee> employees = EmployeeData.getEmployees();employees.stream().sorted((e1,e2) -> Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);}
}

package com.atguigu.java3;import com.atguigu.java2.Employee;
import com.atguigu.java2.EmployeeData;
import org.junit.Test;import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;/*** 测试Stream的终止操作** @author* @create 2022-07-27 23:17*/
public class StreamAPITest2 {//1-匹配与查找：@Testpublic void test(){
//        allMatch(Predicate p) 检查是否匹配所有元素List<Employee> employees = EmployeeData.getEmployees();//是否所有员工的年龄都大于18boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);System.out.println(allMatch);//        anyMatch(Predicate p) 检查是否至少匹配一个元素//是否有员工工资大于10000boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);System.out.println(anyMatch);//        noneMatch(Predicate p) 检查是否没有匹配所有元素boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));System.out.println(noneMatch);//        findFirst() 返回第一个元素Optional<Employee> first = employees.stream().findFirst();System.out.println(first);
//        findAny() 返回当前流中的任意元素Optional<Employee> any = employees.parallelStream().findAny();System.out.println(any);
//
//        count() 返回流中元素总数long count = employees.stream().filter(s -> s.getSalary() > 13000).count();System.out.println(count);
//        max(Comparator c) 返回流中最大值//返回最高的工资：Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
//        Optional<Double> max = salaryStream.max((Double::compare));Optional<Double> max = salaryStream.max((d1, d2) -> {double do1 = d1;double do2 = d2;int i1 = (int)do1;int i2 = (int)do2;return i1 - i2;});System.out.println(max);
//        min(Comparator c) 返回流中最小值//返回最低的工资的员工Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));System.out.println(employee);//        forEach(Consumer c) -内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭 代——它帮你把迭代做了)employees.stream().forEach(System.out :: println);//使用集合的遍历操作employees.forEach(System.out :: println);}//2-归约@Testpublic void test1(){
//        reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 T//计算1-10的总和：List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);Integer reduce = list.stream().reduce(0, Integer::sum);System.out.println(reduce);//        reduce(BinaryOperator b) 可以将流中元素反复结合起来，得到一个值。返回 Optional<T>List<Employee> employees = EmployeeData.getEmployees();Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
//        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);Optional<Double> sumMoney = salaryStream.reduce((d1, d2) -> d1 + d2);System.out.println(sumMoney);}//3-收集@Testpublic void test2(){
//        collect(Collector c) 将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法//练习：查找工资大于6000的员工，结果返回一个List或者SetList<Employee> employees = EmployeeData.getEmployees();Stream<Employee> employeeStream = employees.stream().filter(e -> e.getSalary() > 6000);List<Employee> collect = employeeStream.collect(Collectors.toList());collect.forEach(System.out :: println);Stream<Employee> employeeStream1 = employees.stream().filter(e -> e.getSalary() > 6000);Set<Employee> collect1 = employeeStream1.collect(Collectors.toSet());collect1.forEach(System.out :: println);}
}

package com.atguigu.java4;import org.junit.Test;import java.util.Optional;/****Optional类：为了在程序中出现空指针异常而创建的。**  常用的方法：ofNullable(T t)*             orElse(T t)** @author* @create 2022-07-28 13:44*/
public class OptionalTest {/*创建Optional类对象的方法： Optional.of(T t) : 创建一个 Optional实例，t必须非空； Optional.empty() : 创建一个空的 Optional 实例 Optional.ofNullable(T t)：t可以为null*/@Testpublic void test(){Girl girl = new Girl();//of(T t)：必须保证t是非空的Optional<Girl> girl1 = Optional.of(girl);}@Testpublic void test1(){Girl girl = new Girl();girl = null;//ofNullable(T t):可以是空的Optional<Girl> girl1 = Optional.ofNullable(girl);System.out.println(girl1);//orElse(T t1):如果当前的Optional类封装的是非空的，则返回内部的T，如果内部的t是空的，// 则返回orElse(T t1)方法中的参数t1.Girl girl2 = girl1.orElse(new Girl("赵丽颖"));System.out.println(girl2);}public String getGirlName(Boy boy){return boy.getGirl().getName();}@Testpublic void test3(){Boy boy = new Boy();String girlName = getGirlName(boy);System.out.println(girlName);}//优化方法public String getGirlName1(Boy boy){if(boy != null){Girl girl = boy.getGirl();if (girl != null){return girl.getName();}}return null;}@Testpublic void test4(){Boy boy = new Boy();String girlName = getGirlName1(boy);System.out.println(girlName);}//优化方法2:使用Optional类public String getGirlName2(Boy boy){Optional<Boy> boyOptional = Optional.ofNullable(boy);//此时的boy1一定非空：Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));Girl girl = boy1.getGirl();Optional<Girl> girlOptional = Optional.ofNullable(girl);//此时的girl1一定非空：Girl girl1 = girlOptional.orElse(new Girl("古力娜扎"));return girl1.getName();}@Testpublic void test5(){Boy boy = null;boy = new Boy();boy = new Boy(new Girl("杨幂"));String girlName = getGirlName2(boy);System.out.println(girlName);}
}

package com.atguigu.java4;/*** @author* @create 2022-07-28 13:41*/
public class Girl {private String name;public Girl() {}public Girl(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Girl{" +"name='" + name + '\'' +'}';}
}

package com.atguigu.java4;/*** @author* @create 2022-07-28 13:41*/
public class Boy {private Girl girl;public Boy() {}public Boy(Girl girl) {this.girl = girl;}public Girl getGirl() {return girl;}public void setGirl(Girl girl) {this.girl = girl;}@Overridepublic String toString() {return "Boy{" +"girl=" + girl +'}';}
}

package com.atguigu.java;import org.junit.Test;import java.util.Optional;/*** @author* @create 2022-07-28 16:16*/
public class OptionalTest {@Testpublic void test(){Optional<Object> op1 = Optional.empty();if (!op1.isPresent()) {System.out.println("数据为空");}System.out.println(op1);}@Testpublic void test1(){Optional<String> op1 = Optional.of("Hello");String s = op1.get();System.out.println(s);}@Testpublic void test2(){Optional<String> optional = Optional.ofNullable(null);
//        Optional<String> optional = Optional.ofNullable("beijing");String orElse = optional.orElse("上海");System.out.println(orElse);}
}

Java高级：新特性：lambda 函数式接口方法引用 StreamAPI Optional类相关推荐

lambda函数式接口方法引用Sream
Lambda表达式的使用 (o1, o2) -> Integer.compare(o1, o2); 格式: ->:lambda操作符或箭头操作符 ->左边:lambda形参列表(即接 ...
jdk8新特性-Lambda表达式，方法引用
Lambda方法引用的概念 1).什么是"方法引用":当我们使用Lambda实现一些功能时,发现已有的类库中已经有方法实现了这样的功能,这时,我们就可以引用已实现的方法来代替Lam ...
JAVA8的新特性之函数式接口
JAVA8的新特性之函数式接口 1.Lambda表达式使用的前提,就是接口必须是一个函数式接口 2.定义在接口中,只有一个抽象方法 3.检查是否是函数式接口用的注解 @FunctionalInter ...
Java 8 新特性 lambda表达式
/ Created by Manager on 2021/4/1. Java 8 新特性 lambda表达式 StreamAPI 新日期新注解 */ 视频连接 1https://www.bilibi ...
Java 8 新特性Lambda 表达式
Java 8 新特性Lambda 表达式一.常用循环二.匿名内部类三.排序集合四.循环打印对象五.根据条件修改六.排序七.求和八.统计方法九.材料一.常用循环 public cla ...
JDK8新特性之函数式接口
转载自 JDK8新特性之函数式接口什么是函数式接口先来看看传统的创建线程是怎么写的 Thread t1 = new Thread(new Runnable() {@Overridepublic v ...
java8新特性（2）--- 方法引用
java8新特性(2)- 方法引用新增语法双冒号(::) package com.common.jdk8;import java.util.Arrays; import java.util.List ...
【JavaSE】JDK新特性(二)————接口新特性，函数式接口(Suppier,Comsumer,Predicate,Function)
文章目录 1.接口新特性 1.1 接口组成更新概述 1.2 接口中的默认方法 1.3 接口中的静态方法 1.4 接口中的私有方法 2. 函数式接口 2.1 函数式接口概述 2.2 函数式接口作为方法的 ...
fundamentals\java\java8新特性-Lambda（译自oracle官网）
Java8 Lambda Expressions 目录 Java8 Lambda Expression 典型使用场景:Ideal Use Case for Lambda Expressions 问题提 ...

Java高级：新特性：lambda 函数式接口方法引用 StreamAPI Optional类

Java高级：新特性：lambda 函数式接口方法引用 StreamAPI Optional类相关推荐

最新文章

热门文章

Java高级：新特性：lambda 函数式接口 方法引用 StreamAPI Optional类

Java高级：新特性：lambda 函数式接口 方法引用 StreamAPI Optional类相关推荐

最新文章

热门文章

Java高级：新特性：lambda 函数式接口方法引用 StreamAPI Optional类

Java高级：新特性：lambda 函数式接口方法引用 StreamAPI Optional类相关推荐