1. Java8新特性_简介
- Lambda 表达式
- 函数式接口
- 方法引用与构造器引用
- Stream API
- 接口中的默认方法与静态方法
- 新时间日期 API
- 减少空指针异常的容器 Optional
2. Java8新特性_为什么使用 Lambda 表达式
减少实现功能的代码行数,增加源码的可读性。
导入项目代码后,发现有感叹号提示丢失jdk依赖的解决。
导入项目代码后,发现有源码中文注释乱码的解决。
Employee是一个实体类,具有id、name、age、salary成员属性,需求是实现根据一些限定条件对容器进行检索并打印输出。
package com.atguigu.java8; public class Employee { private int id; private String name; private int age; private double salary; public Employee() { } public Employee(String name) { this.name = name; } public Employee(String name, int age) { this.name = name; this.age = age; } public Employee(int id, String name, int age, double salary) { this.id = id; this.name = name; this.age = age; this.salary = 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 String show() { return "测试方法引用!"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + id; result = prime * result + ((name == null) ? 0 : name.hashCode()); long temp; temp = Double.doubleToLongBits(salary); result = prime * result + (int) (temp ^ (temp >>> 32)); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Employee other = (Employee) obj; if (age != other.age) return false; if (id != other.id) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary)) return false; return true; } @Override public String toString() { return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]"; } }
public class TestLambda1
使用 Arrays.asList(…数组元素…)方法返回一个List接口的对象
//需求:获取公司中年龄小于 35 的员工信息
public List<Employee> filterEmployeeAge(List<Employee> emps){
public void test3(){
List<Employee> emps = Arrays.asList( new Employee(101, "张三", 18, 9999.99), new Employee(102, "李四", 59, 6666.66), new Employee(103, "王五", 28, 3333.33), new Employee(104, "赵六", 8, 7777.77), new Employee(105, "田七", 38, 5555.55) ); //需求:获取公司中年龄小于 35 的员工信息 public List<Employee> filterEmployeeAge(List<Employee> emps){ List<Employee> list = new ArrayList<>(); for (Employee emp : emps) { if(emp.getAge() <= 35){ list.add(emp); } } return list; } @Test public void test3(){ List<Employee> list = filterEmployeeAge(emps); //增强for循环遍历集合 for (Employee employee : list) { System.out.println(employee); } }
//需求:获取公司中工资大于 5000 的员工信息
可以先对需求1调用方法得到结果list,然后在把结果list作为参数传到实现需求2的方法里。
新的需求产生后,又得重复大量的代码,这谁顶得住啊。组合数。
//需求:获取公司中工资大于 5000 的员工信息 public List<Employee> filterEmployeeSalary(List<Employee> emps){ List<Employee> list = new ArrayList<>(); for (Employee emp : emps) { if(emp.getSalary() >= 5000){ list.add(emp); } } return list; }
//优化方式一:策略设计模式
创建一个函数式接口 public interface MyPredicate<T> {
package com.atguigu.java8; //抽象方法有且仅有一个 @FunctionalInterface public interface MyPredicate<T> { boolean test(T t); }
public class FilterEmployeeForAge implements MyPredicate<Employee>{
package com.atguigu.java8; public class FilterEmployeeForAge implements MyPredicate<Employee>{ @Override public boolean test(Employee t) { return t.getAge() <= 35; } }
public class FilterEmployeeForSalary implements MyPredicate<Employee> {
package com.atguigu.java8; public class FilterEmployeeForSalary implements MyPredicate<Employee> { @Override public boolean test(Employee t) { return t.getSalary() >= 5000; } }
编写一个抽取冗余代码的方法 public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
用接口实例化对象的方法,替换硬编码在if(###)小括号里的判断条件。
//优化方式一:策略设计模式 public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){ List<Employee> list = new ArrayList<>(); for (Employee employee : emps) { if(mp.test(employee)){ list.add(employee); } } return list; } @Test public void test4(){ List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge()); for (Employee employee : list) { System.out.println(employee); } System.out.println("------------------------------------------"); List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary()); for (Employee employee : list2) { System.out.println(employee); } }
//优化方式二:匿名内部类
//需求:获取公司中id小于等于 103 的员工信息
不用创建类.java文件,更进一步优化编码。
//优化方式二:匿名内部类 @Test public void test5(){ List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() { @Override public boolean test(Employee t) { //需求:获取公司中id小于等于 103 的员工信息 return t.getId() <= 103; } }); for (Employee employee : list) { System.out.println(employee); } }
//优化方式三:Lambda 表达式
//优化方式三:Lambda 表达式 @Test public void test6(){ List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35); list.forEach(System.out::println); System.out.println("------------------------------------------"); List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000); list2.forEach(System.out::println); }
//优化方式四:Stream API
//优化方式四:Stream API @Test public void test7(){ emps.stream() .filter((e) -> e.getAge() <= 35) .forEach(System.out::println); System.out.println("----------------------------------------------"); emps.stream() .map(Employee::getName) .limit(3) .sorted() .forEach(System.out::println); }
3. Java8新特性_Lambda 基础语法
一、Lambda 表达式的基础语法:Java8中引入了一个新的操作符 "->"
Lambda 表达式的参数列表的数据类型可以省略不写,因为JVM编译器通过上下文推断出数据类型,即“类型推断”
语法格式一:无参数,无返回值
() -> System.out.println("Hello Lambda!");
@Test public void test1(){ int num = 0;//jdk 1.7 前,必须是 final的,现在可以省略 Runnable r = new Runnable() { @Override public void run() { System.out.println("Hello World!" + num); } }; r.run(); System.out.println("-------------------------------"); Runnable r1 = () -> System.out.println("Hello Lambda!"); r1.run(); }
语法格式二:有一个参数,并且无返回值
(x) -> System.out.println(x);
语法格式三:若只有一个参数,小括号可以省略不写
x -> System.out.println(x);
@Test public void test2(){ Consumer<String> con = x -> System.out.println(x); con.accept("我们程序员很威武!"); }
语法格式四:有两个以上的参数,有返回值,并且 Lambda 体中有多条语句
->右侧需要有大括号方法体
@Test public void test3(){ Comparator<Integer> com = (x, y) -> { System.out.println("函数式接口"); return Integer.compare(x, y); }; }
语法格式五:若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
@Test public void test4(){ Comparator<Integer> com = (x, y) -> Integer.compare(x, y); }
二、Lambda 表达式需要“函数式接口”的支持
函数式接口:接口中只有一个抽象方法的接口,称为函数式接口。 可以使用注解 @FunctionalInterface 修饰
可以检查是否是函数式接口
//需求:对一个数进行运算
先创建一个函数式接口
package com.atguigu.java8; @FunctionalInterface public interface MyFun { Integer getValue(Integer num); }
再用Lambda表达式实现接口
//需求:对一个数进行运算 @Test public void test6(){ Integer num = operation(100, (x) -> x * x); System.out.println(num); System.out.println(operation(200, (y) -> y + 200)); } public Integer operation(Integer num, MyFun mf){ return mf.getValue(num); }
4. Java8新特性_Lambda 练习
public class Employee {
package com.atguigu.java8; public class Employee { private int id; private String name; private int age; private double salary; public Employee() { } public Employee(String name) { this.name = name; } public Employee(String name, int age) { this.name = name; this.age = age; } public Employee(int id, String name, int age, double salary) { this.id = id; this.name = name; this.age = age; this.salary = 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 String show() { return "测试方法引用!"; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + id; result = prime * result + ((name == null) ? 0 : name.hashCode()); long temp; temp = Double.doubleToLongBits(salary); result = prime * result + (int) (temp ^ (temp >>> 32)); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Employee other = (Employee) obj; if (age != other.age) return false; if (id != other.id) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary)) return false; return true; } @Override public String toString() { return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]"; } }
问题1解答
List<Employee> emps = Arrays.asList(
Collections.sort(emps,实现了接口的Lambda表达式);
List<Employee> emps = Arrays.asList( new Employee(101, "张三", 18, 9999.99), new Employee(102, "李四", 59, 6666.66), new Employee(103, "王五", 28, 3333.33), new Employee(104, "赵六", 8, 7777.77), new Employee(105, "田七", 38, 5555.55) ); @Test public void test1(){ Collections.sort(emps, (e1, e2) -> { //成员变量age是基本数据类型 if(e1.getAge() == e2.getAge()){ return e1.getName().compareTo(e2.getName()); }else{ //return Integer.compare(e1.getAge(), e2.getAge()); return -Integer.compare(e1.getAge(), e2.getAge()); } }); for (Employee emp : emps) { System.out.println(emp); } }
问题2解答
先创建一个函数式接口
package com.atguigu.exer; @FunctionalInterface public interface MyFunction { public String getValue(String str); }
写一个方法输入上面的接口作第二个形参
@Test public void test2(){ String trimStr = strHandler(" 我们程序员很威武 ", (str) -> str.trim()); System.out.println(trimStr); String upper = strHandler("abcdef", (str) -> str.toUpperCase()); System.out.println(upper); String newStr = strHandler("我们程序员很威武", (str) -> str.substring(2, 5)); System.out.println(newStr); } //需求:用于处理字符串 public String strHandler(String str, MyFunction mf){ return mf.getValue(str); }
问题3解答
public interface MyFunction2<T, R> {
package com.atguigu.exer; public interface MyFunction2<T, R> { public R getValue(T t1, T t2); }
public void op(Long l1, Long l2, MyFunction2<Long, Long> mf){
@Test public void test3(){ op(100L, 200L, (x, y) -> x + y); op(100L, 200L, (x, y) -> x * y); } //需求:对于两个 Long 型数据进行处理 public void op(Long l1, Long l2, MyFunction2<Long, Long> mf){ System.out.println(mf.getValue(l1, l2)); }
5. Java8新特性_四大内置核心函数式接口
public class TestLambda3 {
package com.atguigu.java8; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Predicate; import java.util.function.Supplier; import org.junit.Test; /* * Java8 内置的四大核心函数式接口 * * Consumer<T> : 消费型接口 * void accept(T t); * * Supplier<T> : 供给型接口 * T get(); * * Function<T, R> : 函数型接口 * R apply(T t); * * Predicate<T> : 断言型接口 * boolean test(T t); * */ public class TestLambda3 { //Predicate<T> 断言型接口: @Test public void test4(){ List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok"); List<String> strList = filterStr(list, (s) -> s.length() > 3); for (String str : strList) { System.out.println(str); } } //需求:将满足条件的字符串,放入集合中 public List<String> filterStr(List<String> list, Predicate<String> pre){ List<String> strList = new ArrayList<>(); for (String str : list) { if(pre.test(str)){ strList.add(str); } } return strList; } //Function<T, R> 函数型接口: @Test public void test3(){ String newStr = strHandler(" 我大尚硅谷威武 ", (str) -> str.trim()); System.out.println(newStr); String subStr = strHandler("我大尚硅谷威武", (str) -> str.substring(2, 5)); System.out.println(subStr); } //需求:用于处理字符串 public String strHandler(String str, Function<String, String> fun){ return fun.apply(str); } //Supplier<T> 供给型接口 : @Test public void test2(){ List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100)); for (Integer num : numList) { System.out.println(num); } } //需求:产生指定个数的整数,并放入集合中 public List<Integer> getNumList(int num, Supplier<Integer> sup){ List<Integer> list = new ArrayList<>(); for (int i = 0; i < num; i++) { Integer n = sup.get(); list.add(n); } return list; } //Consumer<T> 消费型接口 : @Test public void test1(){ happy(10000, (m) -> System.out.println("你们刚哥喜欢大宝剑,每次消费:" + m + "元")); } public void happy(double money, Consumer<Double> con){ con.accept(money); } }
6. Java8新特性_方法引用与构造器引用
* 一、方法引用:若 Lambda 体中的功能,已经有方法提供了实现,可以使用方法引用
* (可以将方法引用理解为 Lambda 表达式的另外一种表现形式)
*
* 1. 对象的引用 :: 实例方法名
*
* 2. 类名 :: 静态方法名
*
* 3. 类名 :: 实例方法名
package com.atguigu.java8; import java.io.PrintStream; import java.util.Comparator; import java.util.function.BiFunction; import java.util.function.BiPredicate; import java.util.function.Consumer; import java.util.function.Function; import java.util.function.Supplier; import org.junit.Test; /* * 一、方法引用:若 Lambda 体中的功能,已经有方法提供了实现,可以使用方法引用 * (可以将方法引用理解为 Lambda 表达式的另外一种表现形式) * * 1. 对象的引用 :: 实例方法名 * * 2. 类名 :: 静态方法名 * * 3. 类名 :: 实例方法名 * * 注意: * ①方法引用所引用的方法的参数列表与返回值类型,需要与函数式接口中抽象方法的参数列表和返回值类型保持一致! * ②若Lambda 的参数列表的第一个参数,是实例方法的调用者,第二个参数(或无参)是实例方法的参数时,格式: ClassName::MethodName * * 二、构造器引用 :构造器的参数列表,需要与函数式接口中参数列表保持一致! * * 1. 类名 :: new * * 三、数组引用 * * 类型[] :: new; * * */ public class TestMethodRef { //数组引用 @Test public void test8(){ Function<Integer, String[]> fun = (args) -> new String[args]; String[] strs = fun.apply(10); System.out.println(strs.length); System.out.println("--------------------------"); Function<Integer, Employee[]> fun2 = Employee[] :: new; Employee[] emps = fun2.apply(20); System.out.println(emps.length); } //构造器引用 @Test public void test7(){ Function<String, Employee> fun = Employee::new; BiFunction<String, Integer, Employee> fun2 = Employee::new; } @Test public void test6(){ Supplier<Employee> sup = () -> new Employee(); System.out.println(sup.get()); System.out.println("------------------------------------"); Supplier<Employee> sup2 = Employee::new; System.out.println(sup2.get()); } //类名 :: 实例方法名 @Test public void test5(){ BiPredicate<String, String> bp = (x, y) -> x.equals(y); System.out.println(bp.test("abcde", "abcde")); System.out.println("-----------------------------------------"); BiPredicate<String, String> bp2 = String::equals; System.out.println(bp2.test("abc", "abc")); System.out.println("-----------------------------------------"); Function<Employee, String> fun = (e) -> e.show(); System.out.println(fun.apply(new Employee())); System.out.println("-----------------------------------------"); Function<Employee, String> fun2 = Employee::show; System.out.println(fun2.apply(new Employee())); } //类名 :: 静态方法名 @Test public void test4(){ Comparator<Integer> com = (x, y) -> Integer.compare(x, y); System.out.println("-------------------------------------"); Comparator<Integer> com2 = Integer::compare; } @Test public void test3(){ BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y); System.out.println(fun.apply(1.5, 22.2)); System.out.println("--------------------------------------------------"); BiFunction<Double, Double, Double> fun2 = Math::max; System.out.println(fun2.apply(1.2, 1.5)); } //对象的引用 :: 实例方法名 @Test public void test2(){ Employee emp = new Employee(101, "张三", 18, 9999.99); Supplier<String> sup = () -> emp.getName(); System.out.println(sup.get()); System.out.println("----------------------------------"); Supplier<String> sup2 = emp::getName; System.out.println(sup2.get()); } @Test public void test1(){ PrintStream ps = System.out; Consumer<String> con = (str) -> ps.println(str); con.accept("Hello World!"); System.out.println("--------------------------------"); Consumer<String> con2 = ps::println; con2.accept("Hello Java8!"); Consumer<String> con3 = System.out::println; } }