Java8新特性——lambda表达式、函数式接口、方法引用、Stream API与Optional类
目录
一、lambda表达式
(一)lambda相关概念
(二)lambda示例
(三)lambda用法
1.语法格式一：无参，无返回值
2.语法格式二：有参数，无返回值
3.数据类型可以省略，因为可由编译器推断得出，称为”类型推断“
4.语法格式四：lambda若只需要一个参数时，参数的小括号可以省略
5.语法格式五：lambda需要两个或两个以上的参数，多条执行语句，并且可以有返回值
6.语法格式六：当lambda体只有一条语句时，return与大括号可以省略
二、函数式接口
(一)函数式接口概述
(二)函数式接口用法示例
三、方法引用
(一)创建Employee对象
(二)传值
(三)方法引用的使用
1.情况1：对象::实例方法
2.情况二：类 :: 静态方法
3.情况三：类 :: 实例方法
(四)构造器引用
(五)数组引用
四、Stream API
(一)Stream的概念
(二)创建Stream
1.创建Stream方式一：通过集合
2.创建Stream方式二：通过数组
3.创建Stream方式三：通过Stream的of()
4.创建Stream方法四：创建无限流
(三)Stream的中间操作
1.筛选与切片
2.映射
3.排序
(四)Stream的终止操作——匹配、规约、收集
1.匹配
2.规约
3.收集
五、Optional类
(一)Optional概念
(二)Optional常用方法
(三)Optional使用举例
1.创建一个Girl类
2.创建一个Boy类
3.of方法的使用
4.ofNullable方法的使用
5.空指针现象
6.程序中空指针常规优化
7.程序中空指针Optional的优化
一、lambda表达式
(一)lambda相关概念
1.举例： (o1,o2) -> Integer.compare(o1,o2);
2.格式：-> :lambda操作符 或 箭头操作符。
->左边：lambda形参列表，其实就是接口中的抽象方法的形参列表。
->右边：lambda体，其实就是重写的抽象方法的方法体。
3.lambda表达式的使用：6种情况
总结：->左边：lambda形参列表的参数类型可以省略(类型推断)；
如果lambda形参列表只有一个，那么()可以省略；
->右边：lambda体应该使用一对{}包裹；
如果lambda只有一条执行语句(可能是return语句)，省略return和{}。
4.lambda表达式的本质：作为函数式接口的实例(对象)。
5.如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。可以在接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口。
6.所以以前用匿名实现类表示的现在都可以用lambda表达式来写。
(二)lambda示例
@Test
public void test1() {
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
};
r1.run();
System.out.println("----------------------------");
Runnable r2 = () -> System.out.println("hello_lambda");
r2.run();
}@Test
public void test2() {
Comparator com1 = new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
int compare1 = com1.compare(12, 21);
System.out.println(compare1);// -1 前面的数小
System.out.println("----------------------------");
// lambda表达式
Comparator com2 = (o1, o2) -> Integer.compare(o1, o2);
int compare2 = com2.compare(12, 21);
System.out.println(compare2);// -1 前面的数小
System.out.println("----------------------------");
// 方法引用
Comparator com3 = Integer::compare;
int compare3 = com3.compare(12, 21);
System.out.println(compare3);// -1 前面的数小
} (三)lambda用法
1.语法格式一：无参，无返回值
@Test
public void test1() {
// 匿名实现类
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
};
r1.run();
System.out.println("-------------lambda写法一：---------------");
// 因为没有参数，所以()内是空的 右边是方法体
Runnable r2 = () -> {
System.out.println("hello_lambda");
};
r2.run();
}2.语法格式二：有参数，无返回值
@Test
public void test2() {
Consumer con = new Consumer() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("hello");
System.out.println("-------------lambda写法二：---------------");
Consumer con1 = (String s) -> {
System.out.println(s);
};
con1.accept("world");
} 3.数据类型可以省略，因为可由编译器推断得出，称为”类型推断“
@Test
public void test3() {
Consumer con1 = (String s) -> {
System.out.println(s);
};
con1.accept("world");
System.out.println("-------------lambda写法三：---------------");
Consumer con2 = (s) -> {
System.out.println(s);
};
con2.accept("world3");
// 类型推断
ArrayList list = new ArrayList<>();
int[] arr = {1, 2, 3};
} 4.语法格式四：lambda若只需要一个参数时，参数的小括号可以省略
@Test
public void test4() {
Consumer con2 = (s) -> {
System.out.println(s);
};
con2.accept("world3");
System.out.println("-------------lambda写法三：---------------");
Consumer con3 = s -> {
System.out.println(s);
};
con3.accept("world3");
} 5.语法格式五：lambda需要两个或两个以上的参数，多条执行语句，并且可以有返回值
@Test
public void test5() {
Comparator com1 = new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
com1.compare(2, 3);
System.out.println("-------------lambda写法四：---------------");
Comparator com4 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
com4.compare(4, 3);
} 6.语法格式六：当lambda体只有一条语句时，return与大括号可以省略
@Test
public void test6() {
Comparator com4 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
com4.compare(4, 3);
System.out.println("-------------------");
Comparator com5 = (o1, o2) -> o1.compareTo(o2);
com5.compare(4, 31);
} 二、函数式接口
(一)函数式接口概述
(二)函数式接口用法示例
@Test
public void test1() {
System.out.println("------原始写法：代码比较冗余---------");
test01(200, new Consumer() {
@Override
public void accept(Double aDouble) {
System.out.println("学习" + aDouble);
}
});
System.out.println("---------函数式接口，lambda写法--------------");
test01(800, money -> System.out.println(money.compareTo(5003.2)));
test01(200, money -> System.out.println("计算机" + money));
}
public void test01(double money, Consumer con) {
con.accept(money);
} @Test
public void test2() {
// 调用filter方法
List list = Arrays.asList("111", "122", "33");
List filterStr = filter(list, new Predicate() {// 有一个字符串类型的集合，集合中每个字符串经过判定，返回符合条件的
@Override
public boolean test(String s) {
return s.contains("1");// 返回包含1的字符串
}
});
System.out.println(filterStr);
System.out.println("--------------------------");
// 因为在方法中的参数列表中，有一个参数是函数式接口，所以可以使用lambda表达式
// 只有一个参数，省略参数类型、小括号、大括号和return
List filterStr2 = filter(list, s -> s.contains("2"));
System.out.println(filterStr2);
} // 根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
public List filter(List list, Predicate pre) {
ArrayList filterList = new ArrayList<>();
// 遍历传入的集合参数
for (String s : list) {
if (pre.test(s)) {
filterList.add(s);
}
}
return filterList;
} 三、方法引用
(一)创建Employee对象
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() {
}
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;
}
@Override
public String toString() {
return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
}
@Override
public 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;
}
@Override
public 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;
}
}
(二)传值
import java.util.ArrayList;
import java.util.List;
/**
* 提供用于测试的数据
*/
public class EmployeeData {
public static List getEmployees(){
List 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;
}
}
(三)方法引用的使用
方法引用的使用：
* 1.使用情境：当要传递给lambda体的操作，已经有实现的方法了，可以使用方法引用！
* 2.方法引用，本质上就是lambda表达式，而lambda表达式作为函数式接口的实例，所以方法引用，也是函数式接口的实例。
* 3.使用格式： 类(或对象) :: 方法名
* 4.具体分为如下的三种情况：
* 情况一： 对象 :: 非静态方法(实例方法)
* 情况二： 类 :: 静态方法
* 情况三： 类 :: 非静态方法
1.情况1：对象::实例方法
接口中的抽象方法的形参列表和返回值类型，与方法引用的方法的形参列表和返回值类型相同！
// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
System.out.println("-------------原始写法-------------");
Consumer con1 = new Consumer() {
@Override
public void accept(String o) {
System.out.println(o);
}
};
con1.accept("南京");
System.out.println("----------lambda写法------------");
Consumer con2 = s -> System.out.println(s);
con2.accept("北京");
System.out.println("-------------方法引用------------");
PrintStream ps = System.out;
Consumer con3 = ps::println;
con3.accept("上海");
Consumer con4 = System.out::println;
con4.accept("广州");
} //Supplier中的T get()
//Employee中的String getName()
// get方法已经由getName方法实现了，参数列表一致
@Test
public void test2() {
Employee emp = new Employee(1001, "Tom", 24, 8000);
System.out.println("----------------原始写法--------------");
Supplier sup1 = new Supplier() {
@Override
public String get() {
return emp.getName();
}
};
System.out.println(sup1.get());
System.out.println("-----------lambda写法----------------");
Supplier sup2 = () -> emp.getName();
System.out.println(sup2.get());
System.out.println("-----------方法引用+lambda写法--------------");
Supplier sup3 = emp::getName;
System.out.println(sup3.get());
} 2.情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
System.out.println("----------原始写法-------------");
Comparator com1 = new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(45,78));
System.out.println("----------lambda表达式--------------");
Comparator com2 = (o1,o2)->o1.compareTo(o2);
System.out.println(com2.compare(12,74));
System.out.println("---------方法引用------------");
Comparator com3 = Integer::compare;
System.out.println(com3.compare(12, 78));
} //Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
System.out.println("------------原始写法--------------");
Function fun1 = new Function() {
@Override
public Long apply(Double d) {
return Math.round(d);
}
};
System.out.println(fun1.apply(12.3));
System.out.println("------------lambda表达式-------------");
Function func1 = d -> Math.round(d);
System.out.println(func1.apply(12.5));
System.out.println("------------方法引用---------------");
Function func2 = Math::round;
System.out.println(func2.apply(45.9));
} 3.情况三：类 :: 实例方法
当有两个参数时，第一个参数时作为方法的调用者出现的，这种情况也可以使用方法引用，采用类调用方法。
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
System.out.println("---------原始写法-----------");
Comparator com1 = new Comparator() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
};
System.out.println(com1.compare("abc", "xyz"));
System.out.println("----------lambda表达式-----------");
Comparator com2 = (s1, s2) -> s1.compareTo(s2);
System.out.println(com2.compare("aaa", "bbb"));
System.out.println("-----------方法引用-----------");
Comparator com3 = String::compareTo;
System.out.println(com3.compare("a", "l"));
} //BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
System.out.println("-----------原始写法-------------");
BiPredicate pre1 = new BiPredicate() {
@Override
public boolean test(String s1, String s2) {
return s1.equals(s2);
// return s1.contains(s2);
}
};
System.out.println(pre1.test("b", "c"));
System.out.println("-----------lambda表达式------------");
BiPredicate pre2 = (s1, s2) -> s1.equals(s2);
System.out.println(pre2.test("w", "k"));
System.out.println("-----------方法引用------------");
// 传参类型一致，调用方法一致
BiPredicate pre3 = String::equals;
System.out.println(pre3.test("p", "k"));
} // Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {
Employee employee = new Employee(1002, "zs", 25, 10000);
System.out.println("-----------原始写法--------------");
Function fun1 = new Function() {
@Override
public String apply(Employee emp) {
return emp.getName();
}
};
System.out.println(fun1.apply(employee));
System.out.println("----------lambda表达式-----------");
Function fun2 = e -> e.getName();
System.out.println(fun2.apply(employee));
System.out.println("-----------方法引用------------");
Function fun3 = Employee::getName;
System.out.println(fun3.apply(employee));
} (四)构造器引用
//构造器引用
//Supplier中的T get()
// Employee的空参构造器：Employee()
@Test
public void test1() {
System.out.println("------------原始写法--------------");
Supplier sup1 = new Supplier() {
@Override
public Employee get() {
return new Employee();
}
};
System.out.println(sup1.get());
System.out.println("------------lambda写法---------------");
Supplier sup2 = () -> new Employee();
System.out.println(sup2.get());
System.out.println("------------方法引用--------------");
Supplier sup3 = Employee::new;
System.out.println(sup3.get());
} //Function中的R apply(T t)
@Test
public void test2() {
System.out.println("-------------原始写法----------------");
Function fun1 = new Function() {
@Override
public Employee apply(Integer id) {
return new Employee(id);
}
};
System.out.println(fun1.apply(12));
System.out.println("-----------lambda表达式--------------");
Function fun2 = id -> new Employee(id);
System.out.println(fun2.apply(13));
System.out.println("-------------方法引用----------------");
Function fun3 = Employee::new;
System.out.println(fun3.apply(45));
} //BiFunction中的R apply(T t,U u)
@Test
public void test3() {
BiFunction fun1 = new BiFunction() {
@Override
public Employee apply(Integer integer, String s) {
return new Employee(integer, s);
}
};
System.out.println(fun1.apply(12, "李四"));
System.out.println("-----------------------");
BiFunction fun2 = (id, name) -> new Employee(id, name);
System.out.println(fun2.apply(14, "王五"));
System.out.println("--------------------------");
BiFunction fun3 = Employee::new;
System.out.println(fun3.apply(56, "赵六"));
} (五)数组引用
//数组引用
//Function中的R apply(T t)
@Test
public void test4() {
System.out.println("----------原始写法-------------");
Function fun3 = new Function() {
@Override
public String[] apply(Integer integer) {
return new String[integer];
}
};
String[] apply = fun3.apply(5);
System.out.println(Arrays.toString(apply));
System.out.println("----------lambda表达式-------------");
Function fun1 = size -> new String[size];
System.out.println(Arrays.toString(fun1.apply(3)));// 创建长度为3的数组
System.out.println("----------方法引用------------------");
Function fun2 = String[]::new;
System.out.println(Arrays.toString(fun2.apply(7)));
} 四、Stream API
(一)Stream的概念
Stream是数据渠道，用于操作数据源(集合、数组等)所生成的元素序列。
“集合讲的是数据，Stream讲的是计算”
注意：
1.Stream自己不会存储元素。
2.Stream不会改变源对象，相反，他们会返回一个持有记过的新Stream。
3.Stream操作时延迟执行的，这意味着他们会等到需要结果的时候才执行。
(二)创建Stream
说明：
1.一个中间操作链，对数据源的数据进行处理
2.一旦执行终止操作，就执行中间操作，并产生结果。之后，不会再被使用。
1.创建Stream方式一：通过集合
@Test
public void test1() {
List employees = EmployeeData.getEmployees();
// default Stream stream(): 返回一个顺序流，按照集合中数据的顺序拿数据
Stream stream = employees.stream();
// default Stream parallelStream(): 返回一个并行流，不按照顺序拿数据
Stream parallelStream = employees.parallelStream();
}
2.创建Stream方式二：通过数组
@Test
public void test2() {
// 调用Arrays类的static Stream stream(T[] array):返回一个流
int[] arr = new int[]{1, 2, 3, 4, 5, 6};
IntStream stream = Arrays.stream(arr);
String[] strings = new String[]{"A", "B", "V"};
Stream stream1 = Arrays.stream(strings);
Long[] longs = new Long[]{1l, 2l, 3l};
Stream stream2 = Arrays.stream(longs);
// 自定义类型数组
Employee e1 = new Employee(1001, "bb");
Employee e2 = new Employee(1002, "cc");
Employee[] employees = {e1, e2};
Stream stream3 = Arrays.stream(employees);
}
3.创建Stream方式三：通过Stream的of()
@Test
public void test3() {
// 包装类
Stream stream = Stream.of(12, 3, 4, 8);
} 4.创建Stream方法四：创建无限流
@Test
public void test4() {
// 迭代
// 遍历前10个偶数
Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
// 生成
// 遍历前10个随机数
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}(三)Stream的中间操作
1.筛选与切片
@Test
public void test1() {
// filter(Predicate p)——接收lambda，从流中排除某些元素
// 过滤出工资>7000的员工
List list = EmployeeData.getEmployees();
list.stream().filter(e -> e.getSalary() > 7000).forEach(System.out::println);
System.out.println("-----------------------");
// limit(n)——截断流，使其元素不超过给定数量
list.stream().limit(3).forEach(System.out::println);
System.out.println("-----------------------");
// skip(n) ——跳过元素
list.stream().skip(3).forEach(System.out::println);
list.stream().skip(31).forEach(System.out::println);
System.out.println("---------------------");
list.add(new Employee(1010, "诸葛亮", 40, 80000));
list.add(new Employee(1010, "诸葛亮", 40, 80000));
list.add(new Employee(1010, "诸葛亮", 40, 80000));
list.add(new Employee(1010, "诸葛亮", 40, 80000));
list.add(new Employee(1010, "诸葛亮", 40, 80000));
list.stream().distinct().forEach(System.out::println);
System.out.println("++++++++++++++++++++=");
// distinct——去重 注意distinct放入的位置，放在stream后面，和放在条件之后的结果是不一样的
List collect = employees.stream().map(Employee::getAge).distinct().collect(Collectors.toList());
System.out.println(collect);// [34, 12, 33, 26, 65, 42, 35]
} 2.映射
@Test
public void test2() {
List list = Arrays.asList("aa", "bb", "cc");
// 小写转为大写
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
list.stream().map(String::toUpperCase).forEach(System.out::println);
System.out.println("-------------------------");
// 获取员工名字长度>3的员工姓名
List employees = EmployeeData.getEmployees();
Stream nameStream = employees.stream().map(Employee::getName);
nameStream.filter(name -> name.length() > 3).forEach(System.out::println);
System.out.println("------------------------");
// 先拿到名字列
employees.stream().map(Employee::getName).filter(name -> name.length() > 3).forEach(System.out::println);
// 获取工资>7000的员工姓名
System.out.println("-------------获取工资>7000的员工姓名----------------");
// 先过滤，再提取
employees.stream().filter(salary -> salary.getSalary() > 7000).map(Employee::getName).forEach(System.out::println);
System.out.println("-----------------------------");
// 练习2
Stream> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
streamStream.forEach(s -> s.forEach(System.out::println));
// flatMap——将流中的每个值都换成另一个流，然后把所有流连接成一个流
System.out.println("+++++++++++++++++++++++++++++");
list.stream().flatMap(StreamAPITest1::fromStringToStream).forEach(System.out::println);
}
// 将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static Stream fromStringToStream(String str) {
ArrayList list = new ArrayList<>();
for (char c : str.toCharArray()) {
list.add(c);
}
return list.stream();
} 3.排序
@Test
public void test3() {
// sorted
List list = Arrays.asList(45, 47, 12, 35);
list.stream().sorted().forEach(System.out::println);
// 抛出异常原因：Employee没有实现Comparable接口
List employees = EmployeeData.getEmployees();
// employees.stream().sorted().forEach(System.out::println);
System.out.println("-------------------------------");
// sorted(Comparator com)
// 根据年龄进行比较
employees.stream().sorted((e1, e2) -> Integer.compare(e1.getAge(), e2.getAge())).forEach(System.out::println);
System.out.println("++++++++++++++++++++++++");
// 年龄一样的比较薪水
employees.stream().sorted((e1, e2) -> {
int ageValue = Integer.compare(e1.getAge(), e2.getAge());
if (ageValue != 0) {
return ageValue;
} else {
// return Double.compare(e1.getSalary(),e2.getSalary());// 升序
return -Double.compare(e1.getSalary(), e2.getSalary());// 薪资比较降序
}
}).forEach(System.out::println);
// employees.stream().sorted(Comparator.comparingInt(Employee::getAge)).forEach(System.out::println);
} (四)Stream的终止操作——匹配、规约、收集
1.匹配
@Test
public void test1() {
List employees = EmployeeData.getEmployees();
// allMatch
// 是否所有的员工的年龄都>18
boolean b = employees.stream().allMatch(e -> e.getAge() > 18);
System.out.println(b);
// anyMatch——检查是否至少匹配一个元素
// 练习：是否存在员工的工资>10000
System.out.println(employees.stream().anyMatch(e -> e.getSalary() > 10000));
// noneMatch——检查是否没有匹配的元素。返回false说明有匹配的元素
// 练习：是否存在员工姓“雷”
System.out.println(employees.stream().noneMatch(e -> e.getName().startsWith("雷")));
// findFirst——返回第一个元素
Optional first = employees.stream().findFirst();
System.out.println(first);
// findAny——返回当前流中的任意元素
Optional any = employees.parallelStream().findAny();
System.out.println(any);
// count——返回流元素的总个数
long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
System.out.println(count);
// max(Comparator c) —— 返回流中的最大值
// 返回最高工资
Optional max = employees.stream().map(Employee::getSalary).max(Double::compare);
System.out.println(max);
System.out.println("----------------------");
Stream doubleStream = employees.stream().map(Employee::getSalary);// 只取工资
Optional maxSalary = doubleStream.max(Double::compare);// 工资类型中找最大值
System.out.println(maxSalary);
Optional max2 = employees.stream().map(e -> e.getSalary()).max(Double::compareTo);
System.out.println(max2);
// min ——返回流中的最小值
Optional min = employees.stream().map(Employee::getSalary).min(Double::compare);
System.out.println(min);
Optional min1 = employees.stream().map(Employee::getSalary).min((e1, e2) -> e1.compareTo(e2));
System.out.println(min1);
Optional min2 = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(min2);// Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]
Optional min3 = employees.stream().map(Employee::getSalary).min((e1, e2) -> Double.compare(e1, e2));
System.out.println(min3);
Optional min4 = employees.stream().min(Comparator.comparingDouble(Employee::getSalary));
System.out.println(min4);// Optional[Employee{id=1008, name='扎克伯格', age=35, salary=2500.32}]
Optional min5 = employees.stream().map(e -> e.getSalary()).min(Double::compareTo);
System.out.println(min5);// Optional[2500.32]
// forEach——内部迭代
employees.stream().forEach(System.out::println);
System.out.println("-----------------------");
employees.forEach(System.out::println);
} 2.规约
@Test
public void test2() {
// reduce(T identity,BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回一个T
// 练习1：计算1-10自然数的和
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Integer sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum);// 55
// reduce(BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回Optional
// 练习2：计算公司所有员工工资的总和
List employees = EmployeeData.getEmployees();
Optional reduce = employees.stream().map(Employee::getSalary).reduce(Double::sum);
System.out.println(reduce);// Optional[48424.08]
// 下面的写法与scala相似
Optional reduce1 = employees.stream().map(Employee::getSalary).reduce((e1, e2) -> e1 + e2);
System.out.println(reduce1);
} 3.收集
@Test
public void test3(){
// collect(Collector c)——将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
// 练习1：查找工资大于6000的员工，结果返回为一个List或Set
List employees = EmployeeData.getEmployees();
List list = employees.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toList());
for (Employee employee : list) {
System.out.println(employee);
}
System.out.println("-------------------------------");
Set set = employees.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toSet());
set.forEach(System.out::println);
System.out.println("----------------------");
ArrayList collect = employees.stream().filter(e -> e.getSalary() > 5000).collect(Collectors.toCollection(ArrayList::new));
collect.forEach(System.out::println);
} 五、Optional类
(一)Optional概念
Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象，避免空指针异常。
(二)Optional常用方法
(三)Optional使用举例
1.创建一个Girl类
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;
}
@Override
public String toString() {
return "Girl{" +
"name='" + name + '\'' +
'}';
}
}2.创建一个Boy类
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;
}
@Override
public String toString() {
return "Boy{" +
"girl=" + girl +
'}';
}
}3.of方法的使用
@Test
public void test1() {
Girl girl = new Girl();
// girl=null;
// of(T t)：保证t是非空的
Optional optionalGirl = Optional.of(girl);
System.out.println(optionalGirl);// Optional[Girl{name='null'}]
} 4.ofNullable方法的使用
@Test
public void test2() {
Girl girl = new Girl();
girl = null;
// ofNullable(T t): t可以为null
Optional optionalGirl = Optional.ofNullable(girl);
System.out.println(optionalGirl);// 相当于调用Optional.empty方法
// orElse(T t1):如果当前的Optional内部封装的t是非空的，则返回内部的t
// 如果内部的t是空的，则返回orELse()方法中的参数t1
Girl girl1 = optionalGirl.orElse(new Girl("222"));
System.out.println(girl1);
} 5.空指针现象
// 使用Optional之前可能会出现空指针的情况
public String getGirlName(Boy boy) {
return boy.getGirl().getName();
}
@Test
public void test3() {
Boy boy = new Boy();
String girlName = getGirlName(boy);
System.out.println(girlName);// 如果对象内没有参数，会出现空指针异常
}6.程序中空指针常规优化
// 常规优化girlName，避免出现空指针异常
public String getGirlName1(Boy boy) {
if (boy != null) {
Girl girl = new Girl();
if (girl != null) {
return girl.getName();
}
}
return null;
}
@Test
public void test4() {
Boy boy = new Boy();
boy = null;
String girlName1 = getGirlName1(boy);
System.out.println(girlName1);// null
}7.程序中空指针Optional的优化
// 使用Optional类来优化
public String getGirlName2(Boy boy) {
Optional boyOptional = Optional.ofNullable(boy);
// 此时的boy1一定是非空
Boy boy1 = boyOptional.orElse(new Boy(new Girl("boy")));
Girl girl = boy1.getGirl();
Optional girlOptional = Optional.ofNullable(girl);
// girl1一定非空
Girl girl1 = girlOptional.orElse(new Girl("girl"));
return girl1.getName();
}
@Test
public void test5() {
Boy boy = null;
String girlName2 = getGirlName2(boy);
System.out.println(girlName2);// boy
}
@Test
public void test6() {
Boy boy = null;
boy = new Boy();
String girlName2 = getGirlName2(boy);
System.out.println(girlName2);// girl
}
@Test
public void test7() {
Boy boy = null;
boy = new Boy();
boy = new Boy(new Girl("girlName"));
String girlName2 = getGirlName2(boy);
System.out.println(girlName2);// girlName
}