JAVA8新特性的总结

java8的改变

Lambda 表达式
函数式接口
方法引用 / 构造器引用
Stream API
接口中的默认方法 / 静态方法
新时间日期 API
其他新特性

新特性

速度更快
代码更少
强大的 Stream API
便于并行
最大化减少空指针异常 Optional (Kotlin ?)

java8部分新特特性的演进

实例：Employee类（方便排序，重写了equals,hashcode方法）

package JTang.lambda.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 "测试方法引用！";}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic String toString() {return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";}}

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 的员工信息

方法一：增强for循环求出结果

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;}

方案二：（优化）策略设计模式

2.1 定义函数式接口（MyPredicate）

@FunctionalInterface
public interface MyPredicate<T> {public boolean test(T t);}

2.2 定义具体实现策略（FilterEmployeeForAge ）

public class FilterEmployeeForAge implements MyPredicate<Employee>{@Overridepublic boolean test(Employee t) {return t.getAge() <= 35;}}

2.3 测试

List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());for (Employee employee : list) {System.out.println(employee);}

方案三：匿名内部类

public void test5plus(){List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {@Overridepublic boolean test(Employee employee) {return employee.getAge() <= 35;}});for (Employee employee : list) {System.out.println(employee);}}

方案四：（优化）匿名内部类

     List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35);for (Employee employee : list) {System.out.println(employee);}

方案五：stream流

         emps.stream().filter((e) -> e.getAge() <= 35).forEach(System.out::println);

Lambda 表达式

Lambda是一个匿名函数，可以理解为一段可以传递的代码（将代码像数据一样传递）；可以写出更简洁、更灵活的代码；作为一种更紧凑的代码风格，是Java语言表达能力得到提升。

匿名内部类的转变

Comparator<String> com = new Comparator<String>(){@Overridepublic int compare(String o1, String o2) {return Integer.compare(o1.length(), o2.length());}};TreeSet<String> ts = new TreeSet<>(com);TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){@Overridepublic int compare(String o1, String o2) {return Integer.compare(o1.length(), o2.length());}});

通过lambda表示

Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());TreeSet<String> ts = new TreeSet<>(com);

Lambda 语法

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分

左侧：指定了 Lambda 表达式需要的所有参数

右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

语法格式一：无参数，无返回值() -> System.out.println("Hello Lambda!");

@Testpublic void test1(){int num = 0;//jdk 1.7 前，必须是 finalRunnable r = new Runnable() {@Overridepublic 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)(注意：若只有一个参数，小括号可以省略不写）

public void test2(){Consumer<String> con = x -> System.out.println(x);con.accept("这是输出的语句！！！");}

语法格式三：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

 Comparator<Integer> com = (x, y) -> {System.out.println("函数式接口");return Integer.compare(x, y);};

语法格式四：若 Lambda 体中只有一条语句， return 和大括号都可以省略不写 Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

语法格式五：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
(Integer x, Integer y) -> Integer.compare(x, y);

计算

@FunctionalInterface
public interface MyFun {public Integer getValue(Integer num);}

定义函数策略

public Integer operation(Integer num, MyFun mf){return mf.getValue(num);}

测试

public void test6(){Integer num = operation(100, (x) -> x * x);System.out.println(num);System.out.println(operation(200, (y) -> y + 200));}

注意：传参类型省略也是编译器的一种策略：“类型推断”

类型推断：编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “类型推断”

函数式接口(@FunctionalInterface )

⚫ 只包含一个抽象方法的接口，称为函数式接口。
⚫ 可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda
表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
⚫ 我们可以在任意函数式接口上使用
@FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包
含一条声明，说明这个接口是一个函数式接口。

java内置函数式接口

函数式类型	参数类型	返回类型	用途
Consumer< T> 消费型接口	T	void	对类型为T的对象应用操作，（用于那种只进不出的）包含方法：void accept(T t)
Supplier< T >供给型接口	无	T	返回类型为T的对象，包含方法T get()
Function<T, R> 函数型接口	T	R	对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t);
Predicate 断定型接口	T	boolean	确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法boolean test(T t);

实例演示

Consumer< T> 消费型接口

public void testConsumer(){Consumer<Integer> consumer = (X) -> System.out.println("我今年"+X+"岁了");consumer.accept(18);}

@Testpublic void test1(){consumer(10000, (m) -> System.out.println("人均每年消费：" + m + "元"));} public void consumer(double money, Consumer<Double> con){con.accept(money);}

Supplier< T >供给型接口

@Testpublic void testSupplier(){List<Integer> list = new ArrayList<>();Supplier<Integer> sup ;for (int i = 0; i < 10; i++) {sup = () -> (int) (Math.random() * 100);list.add(sup.get());}for (Integer integer : list) {System.out.print(integer+" ");}}

@Testpublic 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;}

Function<T, R> 函数型接口

@Testpublic void testFunction(){Function<String,String> fun = (x) -> x.substring(1,5);String apply = fun.apply("abcnsbs");System.out.println(apply);Function<String,Integer> funnew = (x) -> (int)x.charAt(5);Integer num = funnew.apply("abcnsbs");System.out.println(num);}

//Function<T, R> 函数型接口：@Testpublic 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);}

Predicate 断定型接口

 @Testpublic void testPredicate(){Predicate<Integer> pre = (x) -> x > 10;boolean flag = pre.test(86);System.out.println(flag);Predicate<String> pre1 = (x) -> x.compareTo("new") > 1;boolean old = pre1.test("old");System.out.println(old);}

//Predicate<T> 断言型接口：@Testpublic 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;}

其他

方法引用与构造器引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）
方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。如下三种主要使用情况：
⚫ 对象::实例方法
⚫ 类::静态方法
⚫ 类::实例方法

⚫ 对象::实例方法

Consumer<String> consum = (x) -> System.out.println(x);consum.accept("this is chose");System.out.println("对象的引用 :: 实例方法名");PrintStream out = System.out;Consumer<String> consu = out::println;consu.accept("this is chose");

@Testpublic 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());}

⚫ 类::静态方法

 @Testpublic void test4(){Comparator<Integer> com = (x, y) -> Integer.compare(x, y);Comparator<Integer> com2 = Integer::compare;}

 @Testpublic void test3(){BiFunction<Double, Double, Double> fun = (x, y) -> Math.max(x, y);System.out.println(fun.apply(1.5, 22.2));BiFunction<Double, Double, Double> fun2 = Math::max;System.out.println(fun2.apply(1.2, 1.5));}

⚫ 类::实例方法

 @Testpublic 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()));}

注意：
①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

构造器引用

构造器的参数列表，需要与函数式接口中参数列表保持一致！

类名 :: new

@Testpublic 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());}

数组引用

类型[] :: new

@Testpublic 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);}

Stream API

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一
个则是 Stream API(java.util.stream.*)。

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

使用 Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数
据库查询。

可以使用 Stream API 来并行执行操作。简而言之，

Stream API 提供了一种高效且易于使用的处理数据的方式。

流的定义：是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。 “集合讲的是数据，流讲的是计算！”

注意：

①Stream 自己不会存储元素。
②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

Stream 的操作三个步骤

⚫ 创建 Stream
一个数据源（如：集合、数组），获取一个流
⚫ 中间操作
一个中间操作链，对数据源的数据进行处理
⚫ 终止操作(终端操作)
一个终止操作，执行中间操作链，并产生结果

创建Stream

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：

⚫ default Stream< E> stream() : 返回一个顺序流
⚫ default Stream< E> parallelStream() : 返回一个并行流

     //1. Collection 提供了两个方法  stream() 与 parallelStream()List<String> list = new ArrayList<>();Stream<String> stream = list.stream(); //获取一个顺序流Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

并行流和串行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。 Java 8 中将并行进行了优化，我们可以很容易的对数据进行并
行操作。Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

由数组创建流

Java8 中的 Arrays 的静态方法 stream() 可
以获取数组流：
⚫ static < T> Stream< T> stream(T[] array): 返回一个流
重载形式，能够处理对应基本类型的数组：
⚫ public static IntStream stream(int[] array)
⚫ public static LongStream stream(long[] array)
⚫ public static DoubleStream stream(double[] array)

     //2. 通过 Arrays 中的 stream() 获取一个数组流Integer[] nums = new Integer[10];Stream<Integer> stream1 = Arrays.stream(nums);

由值创建流

可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。
⚫ public static< T > Stream< T> of(T… values) : 返回一个流

     //3. 通过 Stream 类中静态方法 of()Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);

由函数创建流：创建无限流

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流。

⚫ 迭代
public static< T> Stream< T> iterate(final T seed, final UnaryOperator< T> f)
⚫ 生成
public static< T> Stream< T> generate(Supplier< T> s) :

     //4. 创建无限流//迭代Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);stream3.forEach(System.out::println);//生成Stream<Double> stream4 = Stream.generate(Math::random).limit(2);stream4.forEach(System.out::println);

Stream 的中间操作

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

筛选与切片

方法	描述
filter(Predicate p)	接收 Lambda ，从流中排除某些元素。
distinct()	筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)	截断流，使其元素不超过给定数量。
skip(long n)	跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素

不足 n 个，则返回一个空流。与 limit(n) 互补

实例（中间操作）

//2. 中间操作List<Employee> emps = Arrays.asList(new Employee(102, "李四", 59, 6666.66),new Employee(101, "张三", 18, 9999.99),new Employee(103, "王五", 28, 3333.33),new Employee(104, "赵六", 8, 7777.77),new Employee(104, "赵六", 8, 7777.77),new Employee(104, "赵六", 8, 7777.77),new Employee(105, "田七", 38, 5555.55));

filter和limit

// 求出工资小于5000的前三人
@Testpublic void test4(){emps.stream().filter((e) -> {System.out.println("短路！"); // &&  ||return e.getSalary() >= 5000;}).limit(3).forEach(System.out::println);}

skip()

@Test
// 求出工资大于5000的并且从第三个开始算public void test5(){emps.parallelStream().filter((e) -> e.getSalary() >= 5000).skip(2).forEach(System.out::println);}

distinct()

注意：distinct去重需要，重写hashcode与equals方法

// 去重@Testpublic void test6(){emps.stream().distinct().forEach(System.out::println);}

映射

方法	描述
map(Function f)	接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)	接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 LongStream。
flatMap(Function f)	接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流

map()/ flatmap()用法

// 求出名字的集合Stream<String> str = emps.stream().map((e) -> e.getName());str.forEach(System.out::println);// 将所给的字符串转换为大写List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");Stream<String> stream = strList.stream().map(String::toUpperCase);stream.forEach(System.out::println);

public static Stream<Character> filterCharacter(String str){List<Character> list = new ArrayList<>();for (Character ch : str.toCharArray()) {list.add(ch);}return list.stream();
}public void testFlatMap(){Stream<Stream<Character>> stream2 = strList.stream().map(TestStreamAPI1::filterCharacter);stream2.forEach((sm) -> {sm.forEach(System.out::println);});System.out.println("---------------------------------------------");Stream<Character> stream3 = strList.stream().flatMap(TestStreamAPI1::filterCharacter);stream3.forEach(System.out::println);
}

Stream 的中间操作

方法	描述
sorted()	产生一个新流，其中按自然顺序排序
sorted(Comparator comp)	产生一个新流，其中按比较器顺序排序

sorted()——自然排序

emps.stream().map(Employee::getName).sorted().forEach(System.out::println);

sorted(Comparator com)——定制排序

emps.stream().sorted((x, y) -> {if(x.getAge() == y.getAge()){return x.getName().compareTo(y.getName());}else{return Integer.compare(x.getAge(), y.getAge());}}).forEach(System.out::println);

终止操作

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void 。

查找与匹配

方法	描述
allMatch(Predicate p)	检查是否匹配所有元素
anyMatch(Predicate p)	检查是否至少匹配一个元素
noneMatch(Predicate p)	检查是否没有匹配所有元素
findFirst()	返回第一个元素
findAny()	返回当前流中的任意元素
count()	返回流中元素总数
max(Comparator c)	返回流中最大值
min(Comparator c)	返回流中最小值
forEach(Consumer c)	内部迭代(使用 Collection 接口需要用户去做迭代，称为外部迭代。相反，Stream API 使用内部迭代——它帮你把迭代做了)

实例详解

package JTang.Day2.java8;public class Employee {private int id;private String name;private int age;private double salary;private Status status;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 Employee(int id, String name, int age, double salary, Status status) {this.id = id;this.name = name;this.age = age;this.salary = salary;this.status = status;}public Status getStatus() {return status;}public void setStatus(Status status) {this.status = status;}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 "测试方法引用！";}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic String toString() {return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status+ "]";}public enum Status {FREE, BUSY, VOCATION;}}

测试样例

List<Employee> emps = Arrays.asList(new Employee(102, "李四", 59, 6666.66, Employee.Status.BUSY),new Employee(101, "张三", 18, 9999.99, Employee.Status.FREE),new Employee(103, "王五", 28, 3333.33, Employee.Status.VOCATION),new Employee(104, "赵六", 8, 7777.77, Employee.Status.BUSY),new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),new Employee(104, "赵六", 8, 7777.77, Employee.Status.FREE),new Employee(105, "田七", 38, 5555.55, Employee.Status.BUSY));

测试allMatch、anyMatch、noneMatch

@Testpublic void test1(){// 是否所有的元素都满足 Employee.Status.BUSY boolean bl = emps.stream().allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));System.out.println(bl);//  是否有一个元素满足 Employee.Status.BUSYboolean bl1 = emps.stream().anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));System.out.println(bl1);// 是否没有一个元素满足 Employee.Status.BUSYboolean bl2 = emps.stream().noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));System.out.println(bl2);}

findFirst、findAny

public void test2(){// 找到工资最低的人，（工资升序排列，找出第一个元素）Optional<Employee> op = emps.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).findFirst();System.out.println(op.get());System.out.println("--------------------------------");// 随机找一个满足Employee.Status.FREE 的人Optional<Employee> op2 = emps.parallelStream().filter((e) -> e.getStatus().equals(Employee.Status.FREE)).findAny();System.out.println(op2.get());}

public void test3(){// 求出满足Employee.Status.FREE 的人数long count = emps.stream().filter((e) -> e.getStatus().equals(Employee.Status.FREE)).count();System.out.println(count);// 映射工资，求出最大值Optional<Double> op = emps.stream().map(Employee::getSalary).max(Double::compare);System.out.println(op.get());// 求出工资最低的人Optional<Employee> op2 = emps.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));System.out.println(op2.get());}

规约操作

操作	描述
reduce(T iden, BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 T
reduce(BinaryOperator b)	可以将流中元素反复结合起来，得到一个值。返回 Optional

public void test1(){List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);// 求出累加和Optional<Integer> reduce = list.stream().reduce(Integer::sum);System.out.println(reduce.get());// 求出累加和 + 10 的结果Integer sum = list.stream().reduce(10, (x, y) -> x + y);System.out.println(sum);// 求出累乘结果Integer reduce1 = list.stream().reduce(1, (x, y) -> x * y);System.out.println(reduce1);// 求出所有人的工资和Optional<Double> op = emps.stream().map(Employee::getSalary).reduce(Double::sum);System.out.println(op.get());}

     List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);// 求出累加和Optional<Integer> reduce = list.stream().reduce(Integer::sum);System.out.println(reduce.get());// 求出累加和 + 10 的结果Integer sum = list.stream().reduce(10, (x, y) -> x + y);System.out.println(sum);// 求出累乘结果Integer reduce1 = list.stream().reduce(1, (x, y) -> x * y);System.out.println(reduce1);// 求出所有人的工资和Optional<Double> op = emps.stream().map(Employee::getSalary).reduce(Double::sum);System.out.println(op.get());

求出数列偶数个数

 long count = list.stream().filter((x) -> x % 2 == 0).count();System.out.println("偶数有"+count+"个");Optional<Integer> reduce2 = list.stream().map((x) -> {if (x % 2 == 0) {return 1;} else {return 0;}}).reduce(Integer::sum);System.out.println("偶数有"+reduce2.get()+"个");

搜索名字中 “六” 出现的次数

//需求：搜索名字中 “六” 出现的次数// 方案一：过滤，求出countlong es = emps.stream().map(Employee::getName).filter((x) -> {if (x.contains("六")) {return true;} else {return false;}}).count();System.out.println("包含6的有"+ es+"次");// 方案二：映射求出满足条件的sumOptional<Integer> e = emps.stream().map(Employee::getName).map((x) -> {if (x.contains("六")) {return 1;} else {return 0;}}).reduce(Integer::sum);System.out.println("包含6的有"+ e.get()+"次");// 方案三：遍历@Testpublic void test2(){Optional<Integer> sum = emps.stream().map(Employee::getName).flatMap(TestStreamAPI1::filterCharacter).map((ch) -> {if(ch.equals('六'))return 1;else return 0;}).reduce(Integer::sum);System.out.println(sum.get());}//collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法@Testpublic void test3(){List<String> list = emps.stream().map(Employee::getName).collect(Collectors.toList());list.forEach(System.out::println);System.out.println("----------------------------------");Set<String> set = emps.stream().map(Employee::getName).collect(Collectors.toSet());set.forEach(System.out::println);System.out.println("----------------------------------");HashSet<String> hs = emps.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));hs.forEach(System.out::println);}

备注：map 和 reduce 的连接通常称为map-reduce 模式，因 Google 用它
来进行网络搜索而出名。

收集

方法	描述
collect(Collector c)	将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

Collector 接口中方法的实现决定了如何对流执行收集操作(如收集到 List、Set、Map)。但是 Collectors 实用类提供了很多静态方法，可以方便地创建常见收集器实例，具体方法与实例如下表：

方法	返回类型	作用
toList	List	\|把流中元素收集到List
List < Employee> emps= list.stream().collect(Collectors.toList());
toSet	Set	\|把流中元素收集到Set
Set emps= list.stream().collect(Collectors.toSet());
toCollection	Collection	把流中元素收集到创建的集合
Collectionemps=list.stream().collect(Collectors.toCollection(ArrayList::new));
counting	Long	计算流中元素的个数
List emps= Set emps= long count = list.stream().collect(Collectors.counting());
summingInt	Integer	对流中元素的整数属性求和
inttotal=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingInt	Double	计算流中元素Integer属性的平均值
doubleavg= list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingInt	IntSummaryStatistics	收集流中Integer属性的统计值。如：平均值
IntSummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joining	String	连接流中每个字符串
String str= list.stream().map(Employee::getName).collect(Collectors.joining());
maxBy	Optional< T>	根据比较器选择最大值
Optional< Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
minBy	Optional< T>	根据比较器选择最小值
Optional< Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
reducing	归约产生的类型< T>	从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值
inttotal=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));
collectingAndThen	转换函数返回的类型< T>	包裹另一个收集器，对其结果转换函数
inthow= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
groupingBy	Map < K, List < T >>< T>	根据某属性值对流分组，属性为K，结果为V
Map < Emp.Status, List> map= list.stream() .collect(Collectors.groupingBy(Employee::getStatus));
partitioningBy	Map< Boolean, List>	根据true或false进行分区
Map < Boolean,List>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));

@Testpublic void test4(){// 求出最高的工资Optional<Double> max = emps.stream().map(Employee::getSalary).collect(Collectors.maxBy(Double::compare));System.out.println(max.get());// 求出最低的工资Optional<Employee> op = emps.stream().collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));System.out.println(op.get());// 求出工资总和Double sum = emps.stream().collect(Collectors.summingDouble(Employee::getSalary));System.out.println(sum);// 求出工资的平均值Double avg = emps.stream().collect(Collectors.averagingDouble(Employee::getSalary));System.out.println(avg);// 求出样例个数Long count = emps.stream().collect(Collectors.counting());System.out.println(count);// 求出工资的最大值DoubleSummaryStatistics dss = emps.stream().collect(Collectors.summarizingDouble(Employee::getSalary));System.out.println(dss.getMax());System.out.println(dss.getMin());System.out.println(dss.getCount());System.out.println(dss.getAverage());System.out.println(dss.getSum());}

分组（按照状态值）

 public void test5(){Map<Employee.Status, List<Employee>> map = emps.stream().collect(Collectors.groupingBy(Employee::getStatus));System.out.println(map);}

多级分组

 public void test6(){Map<Employee.Status, Map<String, List<Employee>>> map = emps.stream().collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {if(e.getAge() >= 60)return "老年";else if(e.getAge() >= 35)return "中年";elsereturn "成年";})));System.out.println(map);}

分区

public void test7(){Map<Boolean, List<Employee>> map = emps.stream().collect(Collectors.partitioningBy((e) -> e.getSalary() >= 5000));System.out.println(map);}

"C:\Program Files\Java\jdk1.8.0_131\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=8585:D:\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath "D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar;D:\IntelliJ IDEA 2019.3.3\plugins\junit\lib\junit5-rt.jar;D:\IntelliJ IDEA 2019.3.3\plugins\junit\lib\junit-rt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar;D:\Java开发\Current\out\production\Current;C:\Users\唐昊\.m2\repository\junit\junit\4.12\junit-4.12.jar;C:\Users\唐昊\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 JTang.Day2.java8.TestStreamAPI3,test7
{false=[Employee [id=103, name=王五, age=28, salary=3333.33, status=VOCATION]], true=[Employee [id=102, name=李四, age=79, salary=6666.66, status=BUSY], Employee [id=101, name=张三, age=18, salary=9999.99, status=FREE], Employee [id=104, name=赵六, age=8, salary=7777.77, status=BUSY], Employee [id=104, name=赵六, age=8, salary=7777.77, status=FREE], Employee [id=104, name=赵六, age=8, salary=7777.77, status=FREE], Employee [id=105, name=田七, age=38, salary=5555.55, status=BUSY]]}Process finished with exit code 0

Collectors.joining用法

public void test8(){String str = emps.stream().map(Employee::getName).collect(Collectors.joining("," , "----", "----"));System.out.println(str);}

Collectors.reducing用法

public void test9(){Optional<Double> sum = emps.stream().map(Employee::getSalary).collect(Collectors.reducing(Double::sum));System.out.println(sum.get());}

Fork/join框架

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.

package JTang.Day2.java8;import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;import org.junit.Test;public class TestForkJoin {@Testpublic void test1(){long start = System.currentTimeMillis();ForkJoinPool pool = new ForkJoinPool();ForkJoinTask<Long> task = new ForkJoinCalculate(0L, 10000000000L);long sum = pool.invoke(task);System.out.println(sum);long end = System.currentTimeMillis();System.out.println("耗费的时间为: " + (end - start)); //112-1953-1988-2654-2647-20663-113808}@Testpublic void test2(){long start = System.currentTimeMillis();long sum = 0L;for (long i = 0L; i <= 10000000000L; i++) {sum += i;}System.out.println(sum);long end = System.currentTimeMillis();System.out.println("耗费的时间为: " + (end - start)); //34-3174-3132-4227-4223-31583}@Testpublic void test3(){long start = System.currentTimeMillis();Long sum = LongStream.rangeClosed(0L, 10000000000L).parallel().sum();System.out.println(sum);long end = System.currentTimeMillis();System.out.println("耗费的时间为: " + (end - start)); //2061-2053-2086-18926}}

test1
test2

test3

Fork/Join 框架与传统线程池的区别

采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。
相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间,提高了性能

新时间日期API

使用LocalDate、LocalTime、LocalDateTime

⚫ LocalDate、LocalTime、LocalDateTime 类的实例是不可变的对象，分别表示使用 ISO-8601日历系统的日期、时间、日期和时间。它们提供了简单的日期或时间，并不包含当前的时间信息。也不包含与时区相关的信息。

注：ISO-8601日历系统是国际标准化组织制定的现代公民的日期和时间的表示法

public void test1(){// 获取当前时间LocalDateTime ldt = LocalDateTime.now();System.out.println(ldt);// 时间转换LocalDateTime ld2 = LocalDateTime.of(2016, 11, 21, 10, 10, 10);System.out.println(ld2);// 年份 + 20LocalDateTime ldt3 = ld2.plusYears(20);System.out.println(ldt3);// 月份往前退2个月LocalDateTime ldt4 = ld2.minusMonths(2);System.out.println(ldt4);// 输出详细的年月日时分秒System.out.println(ldt.getYear());System.out.println(ldt.getMonthValue());System.out.println(ldt.getDayOfMonth());System.out.println(ldt.getHour());System.out.println(ldt.getMinute());System.out.println(ldt.getSecond());}

Instant 时间戳

⚫ 用于“时间戳”的运算。它是以Unix元年(传统的设定为UTC时区1970年1月1日午夜时分)开始所经历的描述进行运算
（使用 Unix 元年 1970年1月1日 00:00:00 所经历的毫秒值）

public void test2(){// 默认使用 UTC 时区 ，获取该时区的时间Instant ins = Instant.now();  System.out.println(ins);// 获取东八区的时间OffsetDateTime odt = ins.atOffset(ZoneOffset.ofHours(8));System.out.println(odt);System.out.println(ins.getNano());Instant ins2 = Instant.ofEpochSecond(5);System.out.println(ins2);}

Duration 和 Period

⚫ Duration:用于计算两个“时间”间隔
⚫ Period:用于计算两个“日期”间隔

 public void test3(){Instant ins1 = Instant.now();System.out.println("--------------------");try {Thread.sleep(1000);} catch (InterruptedException e) {}Instant ins2 = Instant.now();// 时间间隔System.out.println("所耗费时间为：" + Duration.between(ins1, ins2));System.out.println("----------------------------------");LocalDate ld1 = LocalDate.now();LocalDate ld2 = LocalDate.of(2011, 1, 1);// 两个日期间隔Period pe = Period.between(ld2, ld1);System.out.println(pe.getYears());System.out.println(pe.getMonths());System.out.println(pe.getDays());}

日期的操纵

⚫ TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
⚫TemporalAdjusters: 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现

public void test4(){// 获取当前时间LocalDateTime ldt = LocalDateTime.now();System.out.println(ldt);// 设置该月内的28号的日期LocalDateTime ldt2 = ldt.withDayOfMonth(28);System.out.println(ldt2);// 设置该年内的31号日期LocalDateTime localDateTime = ldt.withDayOfYear(31);System.out.println(localDateTime);// 获取下一个星期日的日期LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));System.out.println(ldt3);//自定义：下一个工作日LocalDateTime ldt5 = ldt.with((l) -> {LocalDateTime ldt4 = (LocalDateTime) l;// 获取当前为星期几DayOfWeek dow = ldt4.getDayOfWeek();// 如果当前为星期五 那么 +3if(dow.equals(DayOfWeek.FRIDAY)){return ldt4.plusDays(3);// 如果当前为星期六那么 +2}else if(dow.equals(DayOfWeek.SATURDAY)){return ldt4.plusDays(2);// 其余时间都 +1}else{return ldt4.plusDays(1);}});System.out.println(ldt5);}

解析与格式化

java.time.format.DateTimeFormatter类：该类提供了三种格式化方法：
⚫ 预定义的标准格式
⚫语言环境相关的格式
⚫ 自定义的格式

DateTimeFormatter默认的规范

public void test5(){// 使用内置规范
//      DateTimeFormatter dtf = DateTimeFormatter.ISO_LOCAL_DATE;// 自定义规范DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");// 获取当前时间，规范化LocalDateTime ldt = LocalDateTime.now();String strDate = ldt.format(dtf);System.out.println(strDate);// 格式转换LocalDateTime newLdt = ldt.parse(strDate, dtf);System.out.println(newLdt);}

时区的处理

⚫ Java8 中加入了对时区的支持，带时区的时间为分别为：
ZonedDate、ZonedTime、ZonedDateTime其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式
⚫ 例如：

Asia/Shanghai 等
ZoneId：该类中包含了所有的时区信息
1. getAvailableZoneIds() : 可以获取所有时区时区信息
2. of(id) : 用指定的时区信息获取ZoneId 对象

获取所有的时区

public void test6(){Set<String> set = ZoneId.getAvailableZoneIds();set.forEach(System.out::println);}

"C:\Program Files\Java\jdk1.8.0_131\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=11236:D:\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath "D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar;D:\IntelliJ IDEA 2019.3.3\plugins\junit\lib\junit5-rt.jar;D:\IntelliJ IDEA 2019.3.3\plugins\junit\lib\junit-rt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar;D:\Java开发\Current\out\production\Current;C:\Users\唐昊\.m2\repository\junit\junit\4.12\junit-4.12.jar;C:\Users\唐昊\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 JTang.Day2.java8.TestLocalDateTime,test6
Asia/Aden
America/Cuiaba
Etc/GMT+9
Etc/GMT+8
Africa/Nairobi
America/Marigot
Asia/Aqtau
Pacific/Kwajalein
America/El_Salvador
Asia/Pontianak
Africa/Cairo
Pacific/Pago_Pago
Africa/Mbabane
Asia/Kuching
Pacific/Honolulu
Pacific/Rarotonga
America/Guatemala
Australia/Hobart
Europe/London
America/Belize
America/Panama
Asia/Chungking
America/Managua
America/Indiana/Petersburg
Asia/Yerevan
Europe/Brussels
GMT
Europe/Warsaw
America/Chicago
Asia/Kashgar
Chile/Continental
Pacific/Yap
CET
Etc/GMT-1
Etc/GMT-0
Europe/Jersey
America/Tegucigalpa
Etc/GMT-5
Europe/Istanbul
America/Eirunepe
Etc/GMT-4
America/Miquelon
Etc/GMT-3
Europe/Luxembourg
Etc/GMT-2
Etc/GMT-9
America/Argentina/Catamarca
Etc/GMT-8
Etc/GMT-7
Etc/GMT-6
Europe/Zaporozhye
Canada/Yukon
Canada/Atlantic
Atlantic/St_Helena
Australia/Tasmania
Libya
Europe/Guernsey
America/Grand_Turk
US/Pacific-New
Asia/Samarkand
America/Argentina/Cordoba
Asia/Phnom_Penh
Africa/Kigali
Asia/Almaty
US/Alaska
Asia/Dubai
Europe/Isle_of_Man
America/Araguaina
Cuba
Asia/Novosibirsk
America/Argentina/Salta
Etc/GMT+3
Africa/Tunis
Etc/GMT+2
Etc/GMT+1
Pacific/Fakaofo
Africa/Tripoli
Etc/GMT+0
Israel
Africa/Banjul
Etc/GMT+7
Indian/Comoro
Etc/GMT+6
Etc/GMT+5
Etc/GMT+4
Pacific/Port_Moresby
US/Arizona
Antarctica/Syowa
Indian/Reunion
Pacific/Palau
Europe/Kaliningrad
America/Montevideo
Africa/Windhoek
Asia/Karachi
Africa/Mogadishu
Australia/Perth
Brazil/East
Etc/GMT
Asia/Chita
Pacific/Easter
Antarctica/Davis
Antarctica/McMurdo
Asia/Macao
America/Manaus
Africa/Freetown
Europe/Bucharest
Asia/Tomsk
America/Argentina/Mendoza
Asia/Macau
Europe/Malta
Mexico/BajaSur
Pacific/Tahiti
Africa/Asmera
Europe/Busingen
America/Argentina/Rio_Gallegos
Africa/Malabo
Europe/Skopje
America/Catamarca
America/Godthab
Europe/Sarajevo
Australia/ACT
GB-Eire
Africa/Lagos
America/Cordoba
Europe/Rome
Asia/Dacca
Indian/Mauritius
Pacific/Samoa
America/Regina
America/Fort_Wayne
America/Dawson_Creek
Africa/Algiers
Europe/Mariehamn
America/St_Johns
America/St_Thomas
Europe/Zurich
America/Anguilla
Asia/Dili
America/Denver
Africa/Bamako
Europe/Saratov
GB
Mexico/General
Pacific/Wallis
Europe/Gibraltar
Africa/Conakry
Africa/Lubumbashi
Asia/Istanbul
America/Havana
NZ-CHAT
Asia/Choibalsan
America/Porto_Acre
Asia/Omsk
Europe/Vaduz
US/Michigan
Asia/Dhaka
America/Barbados
Europe/Tiraspol
Atlantic/Cape_Verde
Asia/Yekaterinburg
America/Louisville
Pacific/Johnston
Pacific/Chatham
Europe/Ljubljana
America/Sao_Paulo
Asia/Jayapura
America/Curacao
Asia/Dushanbe
America/Guyana
America/Guayaquil
America/Martinique
Portugal
Europe/Berlin
Europe/Moscow
Europe/Chisinau
America/Puerto_Rico
America/Rankin_Inlet
Pacific/Ponape
Europe/Stockholm
Europe/Budapest
America/Argentina/Jujuy
Australia/Eucla
Asia/Shanghai
Universal
Europe/Zagreb
America/Port_of_Spain
Europe/Helsinki
Asia/Beirut
Asia/Tel_Aviv
Pacific/Bougainville
US/Central
Africa/Sao_Tome
Indian/Chagos
America/Cayenne
Asia/Yakutsk
Pacific/Galapagos
Australia/North
Europe/Paris
Africa/Ndjamena
Pacific/Fiji
America/Rainy_River
Indian/Maldives
Australia/Yancowinna
SystemV/AST4
Asia/Oral
America/Yellowknife
Pacific/Enderbury
America/Juneau
Australia/Victoria
America/Indiana/Vevay
Asia/Tashkent
Asia/Jakarta
Africa/Ceuta
Asia/Barnaul
America/Recife
America/Buenos_Aires
America/Noronha
America/Swift_Current
Australia/Adelaide
America/Metlakatla
Africa/Djibouti
America/Paramaribo
Europe/Simferopol
Europe/Sofia
Africa/Nouakchott
Europe/Prague
America/Indiana/Vincennes
Antarctica/Mawson
America/Kralendijk
Antarctica/Troll
Europe/Samara
Indian/Christmas
America/Antigua
Pacific/Gambier
America/Indianapolis
America/Inuvik
America/Iqaluit
Pacific/Funafuti
UTC
Antarctica/Macquarie
Canada/Pacific
America/Moncton
Africa/Gaborone
Pacific/Chuuk
Asia/Pyongyang
America/St_Vincent
Asia/Gaza
Etc/Universal
PST8PDT
Atlantic/Faeroe
Asia/Qyzylorda
Canada/Newfoundland
America/Kentucky/Louisville
America/Yakutat
Asia/Ho_Chi_Minh
Antarctica/Casey
Europe/Copenhagen
Africa/Asmara
Atlantic/Azores
Europe/Vienna
ROK
Pacific/Pitcairn
America/Mazatlan
Australia/Queensland
Pacific/Nauru
Europe/Tirane
Asia/Kolkata
SystemV/MST7
Australia/Canberra
MET
Australia/Broken_Hill
Europe/Riga
America/Dominica
Africa/Abidjan
America/Mendoza
America/Santarem
Kwajalein
America/Asuncion
Asia/Ulan_Bator
NZ
America/Boise
Australia/Currie
EST5EDT
Pacific/Guam
Pacific/Wake
Atlantic/Bermuda
America/Costa_Rica
America/Dawson
Asia/Chongqing
Eire
Europe/Amsterdam
America/Indiana/Knox
America/North_Dakota/Beulah
Africa/Accra
Atlantic/Faroe
Mexico/BajaNorte
America/Maceio
Etc/UCT
Pacific/Apia
GMT0
America/Atka
Pacific/Niue
Canada/East-Saskatchewan
Australia/Lord_Howe
Europe/Dublin
Pacific/Truk
MST7MDT
America/Monterrey
America/Nassau
America/Jamaica
Asia/Bishkek
America/Atikokan
Atlantic/Stanley
Australia/NSW
US/Hawaii
SystemV/CST6
Indian/Mahe
Asia/Aqtobe
America/Sitka
Asia/Vladivostok
Africa/Libreville
Africa/Maputo
Zulu
America/Kentucky/Monticello
Africa/El_Aaiun
Africa/Ouagadougou
America/Coral_Harbour
Pacific/Marquesas
Brazil/West
America/Aruba
America/North_Dakota/Center
America/Cayman
Asia/Ulaanbaatar
Asia/Baghdad
Europe/San_Marino
America/Indiana/Tell_City
America/Tijuana
Pacific/Saipan
SystemV/YST9
Africa/Douala
America/Chihuahua
America/Ojinaga
Asia/Hovd
America/Anchorage
Chile/EasterIsland
America/Halifax
Antarctica/Rothera
America/Indiana/Indianapolis
US/Mountain
Asia/Damascus
America/Argentina/San_Luis
America/Santiago
Asia/Baku
America/Argentina/Ushuaia
Atlantic/Reykjavik
Africa/Brazzaville
Africa/Porto-Novo
America/La_Paz
Antarctica/DumontDUrville
Asia/Taipei
Antarctica/South_Pole
Asia/Manila
Asia/Bangkok
Africa/Dar_es_Salaam
Poland
Atlantic/Madeira
Antarctica/Palmer
America/Thunder_Bay
Africa/Addis_Ababa
Asia/Yangon
Europe/Uzhgorod
Brazil/DeNoronha
Asia/Ashkhabad
Etc/Zulu
America/Indiana/Marengo
America/Creston
America/Punta_Arenas
America/Mexico_City
Antarctica/Vostok
Asia/Jerusalem
Europe/Andorra
US/Samoa
PRC
Asia/Vientiane
Pacific/Kiritimati
America/Matamoros
America/Blanc-Sablon
Asia/Riyadh
Iceland
Pacific/Pohnpei
Asia/Ujung_Pandang
Atlantic/South_Georgia
Europe/Lisbon
Asia/Harbin
Europe/Oslo
Asia/Novokuznetsk
CST6CDT
Atlantic/Canary
America/Knox_IN
Asia/Kuwait
SystemV/HST10
Pacific/Efate
Africa/Lome
America/Bogota
America/Menominee
America/Adak
Pacific/Norfolk
Europe/Kirov
America/Resolute
Pacific/Tarawa
Africa/Kampala
Asia/Krasnoyarsk
Greenwich
SystemV/EST5
America/Edmonton
Europe/Podgorica
Australia/South
Canada/Central
Africa/Bujumbura
America/Santo_Domingo
US/Eastern
Europe/Minsk
Pacific/Auckland
Africa/Casablanca
America/Glace_Bay
Canada/Eastern
Asia/Qatar
Europe/Kiev
Singapore
Asia/Magadan
SystemV/PST8
America/Port-au-Prince
Europe/Belfast
America/St_Barthelemy
Asia/Ashgabat
Africa/Luanda
America/Nipigon
Atlantic/Jan_Mayen
Brazil/Acre
Asia/Muscat
Asia/Bahrain
Europe/Vilnius
America/Fortaleza
Etc/GMT0
US/East-Indiana
America/Hermosillo
America/Cancun
Africa/Maseru
Pacific/Kosrae
Africa/Kinshasa
Asia/Kathmandu
Asia/Seoul
Australia/Sydney
America/Lima
Australia/LHI
America/St_Lucia
Europe/Madrid
America/Bahia_Banderas
America/Montserrat
Asia/Brunei
America/Santa_Isabel
Canada/Mountain
America/Cambridge_Bay
Asia/Colombo
Australia/West
Indian/Antananarivo
Australia/Brisbane
Indian/Mayotte
US/Indiana-Starke
Asia/Urumqi
US/Aleutian
Europe/Volgograd
America/Lower_Princes
America/Vancouver
Africa/Blantyre
America/Rio_Branco
America/Danmarkshavn
America/Detroit
America/Thule
Africa/Lusaka
Asia/Hong_Kong
Iran
America/Argentina/La_Rioja
Africa/Dakar
SystemV/CST6CDT
America/Tortola
America/Porto_Velho
Asia/Sakhalin
Etc/GMT+10
America/Scoresbysund
Asia/Kamchatka
Asia/Thimbu
Africa/Harare
Etc/GMT+12
Etc/GMT+11
Navajo
America/Nome
Europe/Tallinn
Turkey
Africa/Khartoum
Africa/Johannesburg
Africa/Bangui
Europe/Belgrade
Jamaica
Africa/Bissau
Asia/Tehran
WET
Europe/Astrakhan
Africa/Juba
America/Campo_Grande
America/Belem
Etc/Greenwich
Asia/Saigon
America/Ensenada
Pacific/Midway
America/Jujuy
Africa/Timbuktu
America/Bahia
America/Goose_Bay
America/Virgin
America/Pangnirtung
Asia/Katmandu
America/Phoenix
Africa/Niamey
America/Whitehorse
Pacific/Noumea
Asia/Tbilisi
America/Montreal
Asia/Makassar
America/Argentina/San_Juan
Hongkong
UCT
Asia/Nicosia
America/Indiana/Winamac
SystemV/MST7MDT
America/Argentina/ComodRivadavia
America/Boa_Vista
America/Grenada
Asia/Atyrau
Australia/Darwin
Asia/Khandyga
Asia/Kuala_Lumpur
Asia/Famagusta
Asia/Thimphu
Asia/Rangoon
Europe/Bratislava
Asia/Calcutta
America/Argentina/Tucuman
Asia/Kabul
Indian/Cocos
Japan
Pacific/Tongatapu
America/New_York
Etc/GMT-12
Etc/GMT-11
Etc/GMT-10
SystemV/YST9YDT
Europe/Ulyanovsk
Etc/GMT-14
Etc/GMT-13
W-SU
America/Merida
EET
America/Rosario
Canada/Saskatchewan
America/St_Kitts
Arctic/Longyearbyen
America/Fort_Nelson
America/Caracas
America/Guadeloupe
Asia/Hebron
Indian/Kerguelen
SystemV/PST8PDT
Africa/Monrovia
Asia/Ust-Nera
Egypt
Asia/Srednekolymsk
America/North_Dakota/New_Salem
Asia/Anadyr
Australia/Melbourne
Asia/Irkutsk
America/Shiprock
America/Winnipeg
Europe/Vatican
Asia/Amman
Etc/UTC
SystemV/AST4ADT
Asia/Tokyo
America/Toronto
Asia/Singapore
Australia/Lindeman
America/Los_Angeles
SystemV/EST5EDT
Pacific/Majuro
America/Argentina/Buenos_Aires
Europe/Nicosia
Pacific/Guadalcanal
Europe/Athens
US/Pacific
Europe/MonacoProcess finished with exit code 0

获取单个时区的时间

public void test7(){// 获取上海的时间LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss E");System.out.println(dtf.format(ldt));}

与传统日期处理的转换

接口中的默认方法与静态方法

接口中的默认方法

Java 8中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用 default 关键字修饰。

public interface MyFun {default String getName(){return "哈哈哈";}
}

接口中的默认方法

”类优先”原则:若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时

⚫ 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
⚫ 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突

MyInterface

public interface MyInterface {default String getName(){return "呵呵呵";}}

public class SubClass implements MyFun, MyInterface{@Overridepublic String getName() {return MyInterface.super.getName();}}

测试

public static void main(String[] args) {SubClass sc = new SubClass();System.out.println(sc.getName());}

接口中的静态方法

在java8，接口中允许添加静态方法

public interface MyInterface {default String getName(){return "呵呵呵";}public static void show(){System.out.println("接口中的静态方法");}}

测试

MyInterface.show();

Optional类

Optional 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

常用方法

方法	描述
Optional.of(T t)	创建一个 Optional 实例
Optional.empty()	创建一个空的 Optional 实例
Optional.ofNullable(T t)	若 t 不为 null,创建 Optional 实例,否则创建空实例
isPresent()	判断是否包含值
orElse(T t)	如果调用对象包含值，返回该值，否则返回t
orElseGet(Supplier s)	如果调用对象包含值，返回该值，否则返回 s 获取的值
map(Function f):	如果有值对其处理，并返回处理后的Optional，否则返回
flatMap(Function mapper)	与 map 类似，要求返回值必须是Optional

Optional.of()

public void test1(){Optional<Employee> op = Optional.of(new Employee());Employee emp = op.get();System.out.println(emp);}

ofNullable、empty

public void test2(){Optional<Employee> op = Optional.ofNullable(new Employee());System.out.println(op.get());Optional<Employee> op1 = Optional.empty();System.out.println(op1.get());}

"C:\Program Files\Java\jdk1.8.0_131\bin\java.exe" -ea -Didea.test.cyclic.buffer.size=1048576 "-javaagent:D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=12252:D:\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath "D:\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar;D:\IntelliJ IDEA 2019.3.3\plugins\junit\lib\junit5-rt.jar;D:\IntelliJ IDEA 2019.3.3\plugins\junit\lib\junit-rt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar;D:\Java开发\Current\out\production\Current;C:\Users\唐昊\.m2\repository\junit\junit\4.12\junit-4.12.jar;C:\Users\唐昊\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar" com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 JTang.Day2.java8.TestOptional,test2
Employee [id=0, name=null, age=0, salary=0.0, status=null]java.util.NoSuchElementException: No value presentat java.util.Optional.get(Optional.java:135)at JTang.Day2.java8.TestOptional.test2(TestOptional.java:52)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at java.lang.reflect.Method.invoke(Method.java:498)at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)at org.junit.runners.ParentRunner.run(ParentRunner.java:363)at org.junit.runner.JUnitCore.run(JUnitCore.java:137)at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)Process finished with exit code -1

ofNullable、isPresent、orElse、orElseGet

public void test3(){Optional<Employee> op = Optional.ofNullable(new Employee());if(op.isPresent()){System.out.println(op.get());}Optional<Employee> o = Optional.ofNullable(null);
//      如果调用对象包含值，返回该值，否则返回tEmployee emp = op.orElse(new Employee("张三"));System.out.println(emp);//        如果调用对象包含值，返回该值，否则返回 s 获取的值Employee emp2 = o.orElseGet(() -> new Employee("zs",89));System.out.println(emp2);}

map()

public void testMap(){Optional<Employee> op = Optional.ofNullable(new Employee("zs", 98));System.out.println(op.map(Employee::getName).get());}

重复注解与类型注解

Java 8对注解处理提供了两点改进：可重复的注解及可用于类型的注解。

package JTang.Day2.java8;import java.lang.annotation.*;@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.PARAMETER,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE,ElementType.METHOD})
public @interface MyAnnotation {String value();
}

package JTang.Day2.java8;import java.lang.annotation.*;@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE,ElementType.PARAMETER,ElementType.METHOD})
public @interface MyAnnotations {MyAnnotation[] value();
}

测试方法

package JTang.Day2.java8;import org.junit.Test;import java.lang.reflect.Method;public class TestFuncitoin {public static void main(String[] args) throws NoSuchMethodException {}@Testpublic void show() throws NoSuchMethodException, ClassNotFoundException {Class<TestFuncitoin> aClass = TestFuncitoin.class;System.out.println(aClass);Method test = aClass.getMethod("test");MyAnnotation[] type   = test.getAnnotationsByType(MyAnnotation.class);for (MyAnnotation myFirst : type) {System.out.println(myFirst.value());}}@MyAnnotation("FIRST")@MyAnnotation("SECOND")public void test(){}}