小薛博客

Appearance

一、JDK8新特性 ​

1、主要内容 ​

  1. Lambda 表达式
  2. 函数式接口
  3. 方法引用与构造器引用
  4. Stream API
  5. 接口中的默认方法与静态方法
  6. 新时间日期 API
  7. 其他

2、Java 8新特性简介 ​

  • 速度更快
  • 代码更少（增加了新的语法 Lambda 表达式）
  • 强大的 Stream API
  • 便于并行
  • 最大化减少空指针异常 Optional

3、Lambda表达式 ​

1、为什么使用 Lambda 表达式 ​

  • Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
  • 从匿名类到 Lambda 的转换
java
// 匿名内部类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World"); 
    }
};

// lambda表达式
Runnable runnable = () -> System.out.println("Hello World");
java
// 使用匿名内部类作为参数传递
TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
    @Override
    public 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);

2、Lambda 表达式语法 ​

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

两个部分：

  • 左侧：指定了 Lambda 表达式需要的所有参数
  • 右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

1、Lambda 需要两个参数，并且有返回值 ​

  • 无参，无返回值，Lambda 体只需一条语句
java
Runnable runnable = () -> System.out.println("Hello World");

2、Lambda 需要一个参数 ​

  • Lambda 需要一个参数
java
Consumer<String> fun = (arg) -> System.out.println(arg);

3、Lambda 只需要一个参数时，参数的小括号可以省略 ​

  • Lambda 只需要一个参数时，参数的小括号可以省略
java
Consumer<String> fun = arg -> System.out.println(arg);

4、Lambda 需要两个参数，并且有返回值 ​

  • Lambda 需要两个参数，并且有返回值
java
BinaryOperator<Long> binaryOperator = (Long x,Long y) -> {
    return x + y;
};

// 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
BinaryOperator<Long> binaryOperator = (x,y) -> {
    return x + y;
};

5、当 Lambda 体只有一条语句时，return 与大括号可以省略 ​

  • 当 Lambda 体只有一条语句时，return 与大括号可以省略
java
BinaryOperator<Long> binaryOperator = (x,y) -> x + y;

3、类型推断 ​

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

4、案例 ​

1、Employee类 ​

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

2、初始化数据 ​

java
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)
);

3、获取公司中年龄小于 35 的员工信息 ​

java
// 获取公司中年龄小于 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;
}

public void test3(){
    List<Employee> list = filterEmployeeAge(emps);
    for (Employee employee : list) {
        System.out.println(employee);
    }
}

// 获取公司中工资大于 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;
}

4、优化方式一：策略设计模式 ​

java
@FunctionalInterface
public interface MyPredicate<T> {
	public boolean test(T t);
}
java
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;
}
java
public class FilterEmployeeForAge implements MyPredicate<Employee>{
	@Override
	public boolean test(Employee t) {
		return t.getAge() <= 35;
	}
}
java
public class FilterEmployeeForSalary implements MyPredicate<Employee> {
	@Override
	public boolean test(Employee t) {
		return t.getSalary() >= 5000;
	}
}
java
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);
    }
}

5、优化方式二：匿名内部类 ​

java
public void test5(){
    List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
        @Override
        public boolean test(Employee t) {
            return t.getId() <= 103;
        }
    });

    for (Employee employee : list) {
        System.out.println(employee);
    }
}

6、优化方式三：Lambda 表达式 ​

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

7、优化方式四：Stream API ​

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

5、Lambda例子分析 ​

1、优化线程代码 ​

以前我们使用线程可能是这么使用的：

java
new Thread(new Runnable(){
    @Override
    public void run() {
        System.out.println("thread run");
    }
}).start();

使用lambda可以这么使用：

java
new Thread(()->{
     System.out.println("thread run");
}).start();

上面的代码只有一行代码，可以再次进行优化写法：

java
new Thread( ()->System.out.println("thread run")).start();

2、Arrays.sort排序优化 ​

在代码中，我们会使用Arrays.sort对数据进行排序，Arrays.sort是可以对数组、列表集合进行排序的，很多时候会使用的到。那么以前我们的写法是这样子的：

java
Integer[] playerScore = {89, 100, 77, 90,  86};
// 使用匿名内部类根据 分数从低到高进行排序
Arrays.sort(playerScore,new Comparator<Integer>(){
    /**
     *
     * @param o1 o1是后一个数，第一次比较就是100
     * @param o2 o2是前一个数，第一次比较就是89
     * @return 比较的返回值，第一次就是100.compareTo(89),返回值是1
     */
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
});
for(Integer score:playerScore){
//输出结果：77,86,89,90,100,
    System.out.print(score);
}

使用lambda可以这么使用：

java
Arrays.sort(playerScore,(Integer o1,Integer o2)->o1.compareTo(o2) );

类型Integer也可以去掉优化成：

java
Arrays.sort(playerScore,(o1,o2)->o1.compareTo(o2) );

再次优化还可以这么写：

java
Arrays.sort(playerScore,Comparator.comparing(Integer::intValue));

其中Integer::intValue（方法引用使用一对冒号 ::），就是Integer类中的方法intValue：

从高到底呢？

java
Arrays.sort(playerScore,Comparator.comparing(Integer::intValue).reversed());

3、List遍历 ​

在java8之前对于List的遍历使用for循环的方式，在java8之后遍历打印就显得很简单了：

java
List<String> languages = Arrays.asList("java","php","python");
//java8 之前
for(String str:languages){
    System.out.print(str+",");
}

for(int i=0;i<languages.size();i++){
    System.out.print(languages.get(i)+",");
}

//java8之后
languages.forEach(language-> System.out.print(language+","));

4、Map遍历 ​

java
Map<String,Object> map = new HashMap<>();
map.put("author","悟纤");
map.put("age","18");
map.put("blog","微信公众号「SpringBoot」");
map.put("hobby","美女");

//java8之前的方式：方法一 在for-each循环中使用entries来遍历（常用）
System.out.println("方法一 在for-each循环中使用entries来遍历:");
for(Map.Entry<String,Object> entry:map.entrySet()){
    System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

//java8之前的方式：方法二 在for-each循环中遍历keys或values。
System.out.println();
System.out.println("方法二 在for-each循环中遍历keys或values");
//遍历keys and value
for(String key:map.keySet()){
    System.out.println("key:"+key+",value:"+map.get(key));
}
//只遍历values
System.out.println("----------------");
for(Object value:map.values()){
    System.out.println("value:"+value);
}

//java8之前的方式：方法三使用Iterator遍历
System.out.println();
System.out.println("方法三使用Iterator遍历");
Iterator<Map.Entry<String,Object>> entryIterator = map.entrySet().iterator();
while(entryIterator.hasNext()){
    Map.Entry<String,Object> entry =  entryIterator.next();
    System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}

//java8之后的方式
System.out.println("\njava8之后的方式");
map.forEach((key,value)->System.out.println("key:"+key+",value:"+value) );

对于对于Map如果没获取到key的话，我们会有一个默认值的显示，比如显示为“-”或者“无”，在java8这样的需求就简单的一匹：

java
//java8之前没有获取到key显示默认值为"-"
Object birthday = map.get("birthday");
if(birthday == null){
    birthday = "-";
}
System.out.println("birthday:"+birthday);

//java8之后的方式
System.out.println("birthday:"+map.getOrDefault("birthday","-"));

4、函数式接口 ​

1、什么是函数式接口 ​

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

2、自定义函数式接口 ​

java
@FunctionalInterface
public interface MyNumber {
    public double getValue();
}

// 函数式接口中使用泛型
@FunctionalInterface
public interface MyFunc<T> {
    public T getValue(T t);
}

3、作为参数传递 Lambda 表达式 ​

java
public String toUpperString(MyFunc<String> mf,String str){
    return mf.getValue(str);
}

String newStr = toUpperString((str) -> str.toLowerCase(),"abc");

​ 作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。

4、Java 内置四大核心函数式接口 ​

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

5、其他接口 ​

函数式接口参数类型返回类型用途
BiFunction<T, U, R>T, UR对类型为 T, U 参数应用操作，返回 R 类型的结果。包含方法为 R apply(T t, U u);
UnaryOperator<T>
(Function子接口)		TT对类型为T的对象进行一元运算，并返回T类型的结果。包含方法为 T apply(T t);
BinaryOperator<T>
(BiFunction 子接口)		T, TT对类型为T的对象进行二元运算，并返回T类型的结果。包含方法为 T apply(T t1, T t2);
BiConsumer<T, U>T, Uvoid对类型为T, U 参数应用操作。包含方法为 void accept(T t, U u)
ToIntFunction<T>
ToLongFunction<T>
ToDoubleFunction<T>		Tint
long
double		分别计算 int 、 long 、double、值的函数
IntFunction<R>
LongFunction<R>
DoubleFunction<R>		int
long
double		R参数分别为int、long、double 类型的函数

6、Consumer<T> 消费型接口 ​

  • 对类型为T的对象应用操作，包含方法：void accept(T t)
java
public void test1(){
    happy(10000, (m) -> System.out.println("充点券，每次消费：" + m + "元"));
} 

public void happy(double money, Consumer<Double> con){
    con.accept(money);
}

7、Supplier<T> 供给型接口 ​

  • 返回类型为T的对象，包含方法：T get();
java
//需求：产生指定个数的整数，并放入集合中
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;
}

public void test2(){
    List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));

    for (Integer num : numList) {
        System.out.println(num);
    }
}

8、Function<T, R> 函数型接口： ​

  • 对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t);
java
//需求：用于处理字符串
public String strHandler(String str, Function<String, String> fun){
    return fun.apply(str);
}

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

9、Predicate<T> 断言型接口 ​

  • 确定类型为T的对象是否满足某约束，并返回boolean 值。包含方法boolean test(T t);
java
//需求：将满足条件的字符串，放入集合中
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;
}

public void test4(){
    List<String> list = Arrays.asList("Hello", "Lambda", "www", "ok");
    List<String> strList = filterStr(list, (s) -> s.length() > 3);
    
    for (String str : strList) {
        System.out.println(str);
    }
}

5、方法引用与构造器引用 ​

1、方法引用 ​

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

  • 对象::实例方法

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

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

  • 类::静态方法

    java
    public void test4(){
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);

    System.out.println("-------------------------------------");

    Comparator<Integer> com2 = Integer::compare;
}

  • 类::实例方法

java
(x) -> System.out.println(x);
等同于
System.out::println
java
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()));
}

注意：当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引用方法的第二个参数(或无参数)时：ClassName::methodName

2、构造器引用 ​

格式： ClassName::new

​ 与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！

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

public void test7(){
    Function<String, Employee> fun = Employee::new;

    BiFunction<String, Integer, Employee> fun2 = Employee::new;
}

3、数组引用 ​

  • 格式： type[] :: new
java
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);
}

6、Stream API ​

1、了解 Stream ​

​ Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

2、什么是 Stream ​

  • 流(Stream) 到底是什么呢？

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

注意：

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

3、Stream 的操作三个步骤 ​

  • 创建 Stream

    一个数据源（如：集合、数组），获取一个流

  • 中间操作

    一个中间操作链，对数据源的数据进行处理

  • 终止操作(终端操作)

    一个终止操作，执行中间操作链，并产生结果

image-20211107220751868

4、创建 Stream ​

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

  • default Stream<E> stream() : 返回一个顺序流
  • default Stream<E> parallelStream() : 返回一个并行流
java
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //获取一个顺序流
Stream<String> parallelStream = list.parallelStream(); //获取一个并行流

1、由数组创建流 ​

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)
java
Integer[] nums = new Integer[10];
Stream<Integer> stream1 = Arrays.stream(nums);

2、由值创建流 ​

可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。

  • public static<T> Stream<T> of(T... values) : 返回一个流
java
Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);

3、由函数创建流：创建无限流 ​

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

  • 迭代 public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)

    java
    Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
stream3.forEach(System.out::println);

  • 生成 public static<T> Stream<T> generate(Supplier<T> s)

    java
    Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
stream4.forEach(System.out::println);

5、Stream 的中间操作 ​

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

1、筛选与切片 ​

方 法描 述
filter(Predicate p)接收 Lambda ， 从流中排除某些元素。
distinct()筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素
limit(long maxSize)截断流，使其元素不超过给定数量。
skip(long n)跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素
不足 n 个，则返回一个空流。与 limit(n) 互补
java
//内部迭代：迭代操作 Stream API 内部完成
@Test
public void test2(){
    //所有的中间操作不会做任何的处理
    Stream<Employee> stream = emps.stream()
        .filter((e) -> {
            System.out.println("测试中间操作");
            return e.getAge() <= 35;
        });

    //只有当做终止操作时，所有的中间操作会一次性的全部执行，称为“惰性求值”
    stream.forEach(System.out::println);
}

//外部迭代
@Test
public void test3(){
    Iterator<Employee> it = emps.iterator();

    while(it.hasNext()){
        System.out.println(it.next());
    }
}

@Test
public void test5(){
    emps.parallelStream()
        .filter((e) -> e.getSalary() >= 5000)
        .skip(2)
        .forEach(System.out::println);
}

@Test
public void test6(){
    emps.stream()
        .distinct()
        .forEach(System.out::println);
}

2、映射 ​

方 法描 述
map(Function f)接收一个函数作为参数，该函数会被应用到每个元
素上，并将其映射成一个新的元素。
mapToDouble(ToDoubleFunction f)接收一个函数作为参数，该函数会被应用到每个元
素上，产生一个新的 DoubleStream。
mapToInt(ToIntFunction f)接收一个函数作为参数，该函数会被应用到每个元
素上，产生一个新的 IntStream。
mapToLong(ToLongFunction f)接收一个函数作为参数，该函数会被应用到每个元
素上，产生一个新的 LongStream。
flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另
一个流，然后把所有流连接成一个流
java
/*
		映射
		map——接收 Lambda ， 将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
		flatMap——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
	 */
@Test
public void test1(){
    Stream<String> str = emps.stream()
        .map((e) -> e.getName());

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

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

public static Stream<Character> filterCharacter(String str){
    List<Character> list = new ArrayList<>();

    for (Character ch : str.toCharArray()) {
        list.add(ch);
    }
    return list.stream();
}

3、排序 ​

方 法描 述
sorted()产生一个新流，其中按自然顺序排序
sorted(Comparator comp)产生一个新流，其中按比较器顺序排序
java
public void test2(){
    emps.stream()
        .map(Employee::getName)
        .sorted()
        .forEach(System.out::println);

    System.out.println("------------------------------------");

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

6、Stream 的终止操作 ​

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

1、查找与匹配 ​

方 法描 述
allMatch(Predicate p)检查是否匹配所有元素
anyMatch(Predicate p)检查是否至少匹配一个元素
noneMatch(Predicate p)检查是否没有匹配所有元素
findFirst()返回第一个元素
findAny()返回当前流中的任意元素
count()返回流中元素总数
max(Comparator c)返回流中最大值
min(Comparator c)返回流中最小值
forEach(Consumer c)内部迭代(使用 Collection 接口需要用户去做迭
代，称为外部迭代。相反，Stream API 使用内部
迭代——它帮你把迭代做了)
java
/*
		allMatch——检查是否匹配所有元素
		anyMatch——检查是否至少匹配一个元素
		noneMatch——检查是否没有匹配的元素
		findFirst——返回第一个元素
		findAny——返回当前流中的任意元素
		count——返回流中元素的总个数
		max——返回流中最大值
		min——返回流中最小值
	 */
@Test
public void test1(){
    boolean bl = emps.stream()
        .allMatch((e) -> e.getStatus().equals(Status.BUSY));

    System.out.println(bl);

    boolean bl1 = emps.stream()
        .anyMatch((e) -> e.getStatus().equals(Status.BUSY));

    System.out.println(bl1);

    boolean bl2 = emps.stream()
        .noneMatch((e) -> e.getStatus().equals(Status.BUSY));

    System.out.println(bl2);
}

@Test
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("--------------------------------");

    Optional<Employee> op2 = emps.parallelStream()
        .filter((e) -> e.getStatus().equals(Status.FREE))
        .findAny();

    System.out.println(op2.get());
}

@Test
public void test3(){
    long count = emps.stream()
        .filter((e) -> e.getStatus().equals(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());
}

//注意：流进行了终止操作后，不能再次使用
@Test
public void test4(){
    Stream<Employee> stream = emps.stream()
        .filter((e) -> e.getStatus().equals(Status.FREE));

    long count = stream.count();

    stream.map(Employee::getSalary)
        .max(Double::compare);
}

2、归约 ​

方 法描 述
reduce(T iden, BinaryOperator b)可以将流中元素反复结合起来，得到一个值。
返回 T
reduce(BinaryOperator b)可以将流中元素反复结合起来，得到一个值。
返回 Optional<T>
java
@Test
public void test1(){
    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

    Integer sum = list.stream()
        .reduce(0, (x, y) -> x + y);

    System.out.println(sum);

    System.out.println("----------------------------------------");

    Optional<Double> op = emps.stream()
        .map(Employee::getSalary)
        .reduce(Double::sum);

    System.out.println(op.get());
}

//需求：搜索名字中 “六” 出现的次数
@Test
public 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());
}

3、收集 ​

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

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

方法返回类型
作用
代码
toListList<T>把流中元素收集到ListList<Employee> emps= list.stream().collect(Collectors.toList());
toSetSet<T>把流中元素收集到SetSet<Employee> emps= list.stream().collect(Collectors.toSet());
toCollectionCollection<T>把流中元素收集到创建的集合Collection<Employee>emps=list.stream().collect(Collectors.toCollection(ArrayList::new));
countingLong计算流中元素的个数long count = list.stream().collect(Collectors.counting());
summingIntInteger对流中元素的整数属性求和int total=list.stream().collect(Collectors.summingInt(Employee::getSalary));
averagingIntDouble计算流中元素Integer属性的平均值double avg= list.stream().collect(Collectors.averagingInt(Employee::getSalary));
summarizingIntIntSummaryStatistics收集流中Integer属性的和。IntSummaryStatisticsiss= list.stream().collect(Collectors.summarizingInt(Employee::getSalary));
joiningString连接流中每个字符串String str= list.stream().map(Employee::getName).collect(Collectors.joining());
maxByOptional<T>根据比较器选择最大值Optional<Emp>max= list.stream().collect(Collectors.maxBy(comparingInt(Employee::getSalary)));
minByOptional<T>根据比较器选择最小值Optional<Emp> min = list.stream().collect(Collectors.minBy(comparingInt(Employee::getSalary)));
reducing归约产生的类型从一个作为累加器的初始值开始，利用BinaryOperator与流中元素逐个结合，从而归约成单个值int total=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));
collectingAndThen转换函数返回的类型包裹另一个收集器，对其结果转换函数int how= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
groupingByMap<K, List<T>>根据某属性值对流分组，属性为K，结果为VMap<Emp.Status, List<Emp>> map= list.stream().collect(Collectors.groupingBy(Employee::getStatus));
partitioningByMap<Boolean, List<T>>根据true或false进行分区Map<Boolean,List<Emp>>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));
java
public 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);
}
java
public 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);

    System.out.println("--------------------------------------------");

    DoubleSummaryStatistics dss = emps.stream()
        .collect(Collectors.summarizingDouble(Employee::getSalary));

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

    System.out.println(map);
}
java
//多级分组
@Test
public void test6(){
    Map<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 "中年";
            else
                return "成年";
        })));

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

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

    System.out.println(str);
}

@Test
public void test9(){
    Optional<Double> sum = emps.stream()
        .map(Employee::getSalary)
        .collect(Collectors.reducing(Double::sum));

    System.out.println(sum.get());
}

7、并行流与串行流 ​

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

​ Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与顺序流之间进行切换。

java
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("--------------------------------");

    Optional<Employee> op2 = emps.parallelStream()
        .filter((e) -> e.getStatus().equals(Status.FREE))
        .findAny();

    System.out.println(op2.get());
}

8、新时间日期 API ​

1、使用 LocalDate、LocalTime、LocalDateTime ​

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

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

方法
描述示例
now()静态方法，根据当前时间创建对象LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
of()静态方法，根据指定日期/时间创建对象LocalDate localDate = LocalDate.of(2016, 10, 26);
LocalTime localTime = LocalTime.of(02, 22, 56);
LocalDateTime localDateTime = LocalDateTime.of(2016, 10, 26, 12, 10, 55);
plusDays, plusWeeks,
plusMonths, plusYears		向当前 LocalDate 对象添加几天、几周、几个月、几年
minusDays, minusWeeks,minusMonths, minusYears从当前 LocalDate 对象减去几天、几周、几个月、几年
plus, minus添加或减少一个 Duration 或 Period
withDayOfMonth,
withDayOfYear,
withMonth,
withYear		将月份天数、年份天数、月份、年份 修 改 为 指 定 的 值 并 返 回 新 的LocalDate 对象
getDayOfMonth获得月份天数(1-31)
getDayOfYear获得年份天数(1-366)
getDayOfWeek获得星期几(返回一个 DayOfWeek枚举值)
getMonth获得月份, 返回一个 Month 枚举值
getMonthValue获得月份(1-12)
getYear获得年份
until获得两个日期之间的 Period 对象，或者指定 ChronoUnits 的数字
isBefore, isAfter比较两个 LocalDate
isLeapYear判断是否是闰年
java
//1. LocalDate、LocalTime、LocalDateTime
@Test
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);

    LocalDateTime ldt3 = ld2.plusYears(20);
    System.out.println(ldt3);

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

2、Instant 时间戳 ​

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

java
//2. Instant : 时间戳。 （使用 Unix 元年  1970年1月1日 00:00:00 所经历的毫秒值）
@Test
public void test2(){
    Instant ins = Instant.now();  //默认使用 UTC 时区
    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);
}

3、Duration 和 Period ​

  • Duration:用于计算两个“时间”间隔
  • Period:用于计算两个“日期”间隔
java
//3.
//Duration : 用于计算两个“时间”间隔
//Period : 用于计算两个“日期”间隔
@Test
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());
}

4、日期的操纵 ​

  • TemporalAdjuster : 时间校正器。有时我们可能需要获取例如：将日期调整到“下个周日”等操作。
  • TemporalAdjusters : 该类通过静态方法提供了大量的常用 TemporalAdjuster 的实现。
java
//4. TemporalAdjuster : 时间校正器
@Test
public void test4(){
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);

    LocalDateTime ldt2 = ldt.withDayOfMonth(10);
    System.out.println(ldt2);

    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();

        if(dow.equals(DayOfWeek.FRIDAY)){
            return ldt4.plusDays(3);
        }else if(dow.equals(DayOfWeek.SATURDAY)){
            return ldt4.plusDays(2);
        }else{
            return ldt4.plusDays(1);
        }
    });
    System.out.println(ldt5);
}

5、解析与格式化 ​

java.time.format.DateTimeFormatter 类：该类提供了三种格式化方法：

  • 预定义的标准格式
  • 语言环境相关的格式
  • 自定义的格式
java
//5. DateTimeFormatter : 解析和格式化日期或时间
@Test
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);
}

6、时区的处理 ​

  • Java8 中加入了对时区的支持，带时区的时间为分别为：

    ZonedDate、ZonedTime、ZonedDateTime

  • 其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式例如 ：Asia/Shanghai 等

  • ZoneId：该类中包含了所有的时区信息

    getAvailableZoneIds() : 可以获取所有时区时区信息

    of(id) : 用指定的时区信息获取 ZoneId 对象

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

//6.ZonedDate、ZonedTime、ZonedDateTime ： 带时区的时间或日期
@Test
public void test7(){
    LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
    System.out.println(ldt);

    ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Pacific"));
    System.out.println(zdt);
}

9、接口中的默认方法与静态方法 ​

1、接口中的默认方法 ​

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

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

接口默认方法的类优先原则

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

  • 选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。
  • 接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法来解决冲突
java
public interface MyInterface {
	
	default String getName(){
		return "呵呵呵";
	}
}

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

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

2、接口中的静态方法 ​

Java8 中，接口中允许添加静态方法。

java
public interface MyInterface {

    default String getName(){
        return "呵呵呵";
    }

    public static void show(){
        System.out.println("接口中的静态方法");
    }
}

10、其他新特性 ​

1、Optional 类 ​

​ Optional<T> 类(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，否则返回 Optional.empty()
flatMap(Function mapper)与 map 类似，要求返回值必须是Optional
java
public void test1(){
    Optional<Employee> op = Optional.of(new Employee());
    Employee emp = op.get();
    System.out.println(emp);
}

public void test2(){
    /*Optional<Employee> op = Optional.ofNullable(null);
		System.out.println(op.get());*/

    Optional<Employee> op = Optional.empty();
    System.out.println(op.get());
}

public void test3(){
    Optional<Employee> op = Optional.ofNullable(new Employee());

    if(op.isPresent()){
        System.out.println(op.get());
    }

    Employee emp = op.orElse(new Employee("张三"));
    System.out.println(emp);

    Employee emp2 = op.orElseGet(() -> new Employee());
    System.out.println(emp2);
}

public void test4(){
    Optional<Employee> op = Optional.of(new Employee(101, "张三", 18, 9999.99));

    Optional<String> op2 = op.map(Employee::getName);
    System.out.println(op2.get());

    Optional<String> op3 = op.flatMap((e) -> Optional.of(e.getName()));
    System.out.println(op3.get());
}

2、重复注解与类型注解 ​

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

java
@Target({TYPE,
    FIELD,
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE
})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotations {
    MyAnnotation[] value();
}
java
@Repeatable(MyAnnotations.class)
@Target({TYPE,
    FIELD,
    METHOD,
    PARAMETER,
    CONSTRUCTOR,
    LOCAL_VARIABLE,
    ElementType.TYPE_PARAMETER
})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}
java
@MyAnnotation("Hello")
@MyAnnotation("World")
public void show(@MyAnnotation("abc") String str){}