Java8 新特性_SGG
Posted 绍耕
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java8 新特性_SGG相关的知识,希望对你有一定的参考价值。
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("\\t\\t\\t 我们程序员很威武 ", (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("\\t\\t\\t 我大尚硅谷威武 ", (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(JavaSE基础入门_019_Java8特性