为什么使用 Lambda 表达式

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

基本案例

Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");      
            }
        };

//等效于上面
Runnable runnable= () -> System.out.println("hello");

TreeSet<String> treeSet=new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(),o2.length());
            }
        });

TreeSet<String> treeSet=new TreeSet<>((o1, o2) -> Integer.compare(o1.length(),o2.length()));

TreeSet<String> treeSet=new TreeSet<>(Comparator.comparingInt(String::length));

final相关

public static void main(String[] args) {
        int num=0;
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println(num);      
            }
        };
    }

jdk1.7之前，匿名内部类使用外部变量则外部变量必须变为final，即不可变化
在1.8之后，final可省略，但是实际上final还是存在的，在runable内部++num还是报错。

Lambda 表达式语法

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

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

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

Lambda 表达式的内部实现

public static void main(String[] args) {
    //一个参数，小括号可省略
    Consumer<String> conn=x-> System.out.println(x);
    conn.accept("hello");
}

> Lambda表达式其实就是Consumer接口的accept函数的实现

Lambda表达式的其他格式

public static void main(String[] args) {
    //当Lambda 体只有一条语句时，return 与大括号可以省略
    BinaryOperator<Long> bo=(x,y)->x+y;
    //数据类型可以省 略，因为可由编 译器推断得出， 称为"类型推断"
    BinaryOperator<Long> bo1=(Long x,Long y)->x+y;
}

函数式接口

• 只包含一个抽象方法的接口，称为函数式接口。
• 可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda
  表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方
  法上进行声明）。
• 可以在任意函数式接口上使用 @FunctionalInterface 注解，
  这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包
  含一条声明，说明这个接口是一个函数式接口。
• 之所以Lambda必须和函数式接口配合是因为，接口如果多个函数，则Lambda表达式无法确定实现的是哪个

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

@FunctionalInterface
public interface MyNumber<T> {
     T getValue(T t);
}

Lambda 表达式作为参数

public static void main(String[] args) {
    System.out.println(toUpperString(str->str.toUpperCase(),"abc")); //ABC
}

public static String toUpperString(MyNumber<String> mn, String str) {
    return mn.getValue(str);
}

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

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

其他接口

使用场景

重要：之前MyNumber这种接口配合Lambda使用，可以发现必须先声明接口，很麻烦，而内置的几个接口就是解决这种问题的;<h5>而这些内置的接口也存在大量的内部实现，或者编程者自己定义的类，只要符合对应的参数类型和返回值类型的，都可以使用。例如：定义MyClass只要符合参数T返回R，则都可以使用Function<T, R> 函数型接口对应形式，包含下面的构造器引用，方法引用等等形式</h5>

//原始案例
public class java8 {
    public static void main(String[] args) {
        System.out.println(toUpperString(str->str.toUpperCase(),"abc"));
    }

    public static String toUpperString(MyNumber<String> mn, String str) {
        return mn.getValue(str);
    }
}

//使用Function<T, R> 函数型接口 
public class java8 {
    public static void main(String[] args) {
        System.out.println(toUpperString(str->str.toUpperCase(),"abc"));
    }

    public static String toUpperString(Function<String,String> mn, String str) {
        return mn.apply(str);
    }
}
//效果等效，而且省略了之前定义的MyNumber接口

方法引用与构造器引用

方法引用

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

• 对象::实例方法
• 类::静态方法
• 类::实例方法

//例如：此时Consumer参数类型和返回值和println方法一致
//对象::实例方法名
PrintStream printStream=System.out;
Consumer<String> con= printStream::println;
con.accept("haha");


//类::静态方法名
Comparator<Integer> com=Integer::compare;
Comparator<Integer> com1=(x,y)->Integer.compare(x,y);

//类::实例方法
//注意：当需要引用方法的第一个参数是调用对象，并且第二个参数是需要引
//用方法的第二个参数(或无参数)时：ClassName::methodName
BiPredicate<String,String> biPredicate=(x,y)->x.equals(y);
BiPredicate<String,String> biPredicate1= String::equals;
biPredicate.test("a","b");
biPredicate1.test("a","b");
//BiPredicate是Predicate 断言型接口的一个具体实现

构造器引用

格式： ClassName::new

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

Function<Integer,Integer[]> fun=n->new MyClass();
Function<Integer,Integer[]> fun1=MyClass::new;
fun.apply(args...)

如果存在多个构造器，会自动匹配对应参数或者无参的构造器,取决于apply传递的参数。

数组引用

格式： type[] :: new

Function<Integer,Integer[]> fun=n->new Integer[n];
Function<Integer,Integer[]> fun1=Integer[]::new;
fun.apply(10);

Stream

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

什么是 Stream

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

注意：

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

Stream 的操作三个步骤

• 创建 Stream
  一个数据源（如：集合、数组），获取一个流
• 中间操作
  一个中间操作链，对数据源的数据进行处理

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

  
  
  图一.png

创建 Stream

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

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

由数组创建流

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)

由值创建流

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

• public static<T> Stream<T> of(T... values) : 返回一个流

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

可以使用静态方法 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) :

public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        Stream<String> stream = list.stream();

        int[] ints=new int[10];
        IntStream stream1 = Arrays.stream(ints);


        Stream<String> stream2 = Stream.of("aa", "bb");


        //创建无限流，但是无限流只是在终止时候才创建，而不是定义就创建
        //迭代
        Stream<Integer> stream3 =Stream.iterate(0,x->x+2);//此时不创建
        stream3.forEach(System.out::println);//此时才创建，输出0开始的偶数，而且不停止

        //生成
        Stream<Double> stream4 =Stream.generate(()->Math.random());
        //如果添加limit中间操作，则此时只输出5个。虽然还是无限流
        stream4.limit(5).forEach(System.out::println);
    }

Stream 的中间操作

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

筛选和切片

映射

flatMap是解决流中嵌套流比如{{a,a,a},{b,b,b}},它会把这些流转换成一个流{a,a,a,b,b,b}方便处理

排序

查找与匹配

归约

Stream 的终止操作

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

<pre>
方法 返回类型 作用
toList List<T> 把流中元素收集到List
List<Employee> emps= list.stream().collect(Collectors.toList());
toSet Set<T> 把流中元素收集到Set
Set<Employee> emps= list.stream().collect(Collectors.toSet()); toCollection Collection<T> 把流中元素收集到创建的集合
Collection<Employee>emps=list.stream().collect(Collectors.toCollection(ArrayList::new));
counting Long 计算流中元素的个数
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 归约产生的类型 从一个作为累加器的初始值 开始，利用BinaryOperator与 流中元素逐个结合，从而归 约成单个值
inttotal=list.stream().collect(Collectors.reducing(0, Employee::getSalar, Integer::sum));
collectingAndThen 转换函数返回的类型 包裹另一个收集器，对其结 果转换函数
inthow= list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), List::size));
groupingBy Map<K, List<T>> 根据某属性值对流分组，属 性为K，结果为V
Map<Emp.Status, List<Emp>> map= list.stream() .collect(Collectors.groupingBy(Employee::getStatus));
partitioningBy Map<Boolean, List<T>> 根据true或false进行分区
Map<Boolean,List<Emp>>vd= list.stream().collect(Collectors.partitioningBy(Employee::getManage));
</pre>

并行流与串行流

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

了解 Fork/Join 框架(jdk1.7就存在)

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行 join 汇总.但是使用很麻烦，所以没有流行起来

图二.png

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

采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线
程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现,fork/join框架的优势体现在对其中包含的任务的
处理方式上.在一般的线程池中,如果一个线程正在执行的任务由于某些原因
无法继续运行,那么该线程会处于等待状态.而在fork/join框架实现中,如果
某个子问题由于等待另外一个子问题的完成而无法继续运行.那么处理该子
问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程
的等待时间,提高了性能.

并行流在大量数据处理时候才有优势，而且处理越多优势越大，因为其需要任务拆分，也是很耗费时间的，少量数据可能还没有串行流快

LongStream.rangeClosed(0,1000000000000L)
.parallel()  //并行流,如果不加则默认是串行流
.reduce(0,Long::sum);

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

public static void main(String[] args) {
        /**
         * of接收的参数，可能外部传入，可能为空，但是之前的方式真正报空指针还不知道在哪里
         * 但是如果Optional.of则始终都会报在这里，方便快速确定空指针的位置
         */
        Optional<Student> op=Optional.of(null);


        /**
         * 该种方式是构建一个null，在第一行不会报错，get时候才报错
         */
        Optional<Student> op1=Optional.empty();
        System.out.println(op1.get());

        /**
         * 传递进来能构建就构建对象，否则就构建null
         * 报错也是在get的时候
         * 其实就是of和empty的综合
         */
        Optional<Student> op2=Optional.ofNullable(null);
        System.out.println(op2.get());

        //代表有值才get，等价于非空判断
        if (op2.isPresent()) {
            System.out.println(op2.get());
        }

        //如果op有值则获取，否则调用orElse的构造并返回该对象
        Student student = op.orElse(new Student());
        //这个功能类似，只是参数是函数式接口，则可以内部写很复杂的逻辑，甚至根据条件返回不同的结果
        Student student1 =op.orElseGet(()->new Student());
        Student student2 =op.orElseGet(Student::new);


        Optional<String> str=  op.map(e->e.getName());
        System.out.println(str.get());//此时获取的就是name而不是全部对象属性


        //和map基本相同，只是返回的必须是Optional,说白了，进一步避免空指针异常
        Optional<String> str2=op.flatMap(e->Optional.of(e.getName()));
        System.out.println(str2.get());

    }

接口中的默认方法

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

public interface MyNumber<T> {
     T getValue(T t);
     //默认方法
     default String getName() {
          return "hahah";
     }
}

接口中的默认方法

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

• 选择父类中的方法。如果一个父类提供了具体的实现，那么 接口中具有相同名称和参数的默认方法会被忽略。

• 接口冲突。如果一个父接口提供一个默认方法，而另一个接 口也提供了一个具有相同名称和参数列表的方法（不管方法 是否是默认方法），那么必须覆盖该方法来解决冲突

  
  
  图三.png

其实就是自己指定调用哪个方法

接口中的静态方法

public interface TestNumber {
    default String getName() {
        return "heheh";
    }

    //静态方法
    static void show() {
        
    }
}

重复注解与类型注解

Java 8对注解处理提供了两点改进：可重复的注解及可用于类 型的注解。在之前是不支持的.

图四.png

新时间日期 API

使用 LocalDate、LocalTime、LocalDateTime

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

Instant 时间戳

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

Duration 和 Period

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

日期的操纵

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

LocalDate localDate=LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.SUNDAY));

解析与格式化

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

• 预定义的标准格式
• 语言环境相关的格式
• 自定义的格式

时区的处理

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

ZonedDate、ZonedTime、ZonedDateTime

其中每个时区都对应着 ID，地区ID都为 “{区域}/{城市}”的格式

例如 ：Asia/Shanghai 等

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

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

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

与传统日期处理的转换