JavaSE知识点总结

• Lambda表达式
• 函数式(Functional)接口
• 方法引用与构造器引用
• • 方法引用
  • 构造器引用
  • 数组引用
• 强大的Stream API
• • 创建 Stream方式一：通过集合
  • 创建 Stream方式二：通过数组
  • 创建 Stream方式三：通过Stream的of()
  • 创建 Stream方式四：创建无限流
  • Stream的中间操作
  • Stream 的终止操作
• Optional类

Lambda表达式

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

// 匿名内部类
Runnable runnable = new Runnable(){
	@Override
	public void run(){
	}
}

// Lambda表达式
Runnable r1 = () -> System.out.println("Lambda");

Lambda表达式

Lambda表达式是Java8语言中引入的一种新的语法元素和操作符。这个操作符为“->”，该操作符被称为Lambda操作符或箭头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的参数列表
右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能

类型推断

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

函数式(Functional)接口

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

• Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即java不但可以支持OOP还可以支持OOF（面向函数编程）
• 在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。
• 简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。
• 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写

/*
* 函数式接口举例
*/
@FunctionalInterface
public interface Runnable{
	public abstract void run();
}

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

• 其他函数式接口

方法引用与构造器引用

方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用
• 方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖
• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致
• 格式：使用操作符 “::” 将类(或对象)与方法名分隔开来
• 如下三种主要使用情况：
      对象::实例方法名
      类::静态方法名
      类::实例方法名

Comsumer<String> con = (x) -> System.out.println(x);
// 等同于
Comsumer<String> con = System.out::println;

Comsumer<Integer> con = (x,y) -> Integer.compare(x,y);
// 等同于
Comsumer<Integer> com = Integer::compare;

BiPredicate<String String> bp = (x,y) -> x.equals(y);
// 等同于
BiPredicate<String,String> bp = String::equals;

// 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName

构造器引用

• 格式： ClassName::new
• 与函数式接口相结合，自动与函数式接口中方法兼容
• 可以把构造器引用赋值给定义的方法，要求构造器参数列表要与接口中抽象方法的参数列表一致！且方法的返回值即为构造器对应类的对象

Function<Integer,MyClass> fun = (n) -> new MyClass(n);
// 等同于
Function<Integer,MyClass> fun = MyClass::new;

数组引用

• 格式： type[] :: new

Function<Integer,Integer[]> fun = (n) -> new Integer[n];
// 等同于
Function<Integer,Integer[]> fun = Integer[]::new;

强大的Stream API

• Stream 和 Collection 集合的区别：Collection 是一种静态的内存数据结构，而 Stream 是有关计算的。前者是主要面向内存，存储在内存中，后者主要是面向 CPU，通过 CPU 实现计算
• 集合讲的是数据，Stream讲的是计算
• 注意
      Stream 自己不会存储元素
      Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
      Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行

Stream的操作三个步骤

1- 创建 Stream
    一个数据源（如：集合、数组），获取一个流
2- 中间操作
    一个中间操作链，对数据源的数据进行处理
3- 终止操作(终端操作)
    一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

创建 Stream方式一：通过集合

• Java8 中的 Collection 接口被扩展，提供了两个获取流的方法
• default Stream stream() : 返回一个顺序流
• default Stream parallelStream() : 返回一个并行流

创建 Stream方式二：通过数组

• Java8 中的Arrays 的静态方法 stream() 可以获取数组流
• static <T> Stream<T> stream(T[] array): 返回一个流

创建 Stream方式三：通过Stream的of()

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

创建 Stream方式四：创建无限流

• 使用静态方法 Stream.iterate() 和 Stream.generate(), 创建无限流
• public static Stream iterate(final T seed, final UnaryOperator f) 迭代
• public static Stream generate(Supplier s) 生成

public void test4() {
// 迭代
// public static<T> Stream<T> iterate(final T seed, final
// UnaryOperator<T> f)
Stream<Integer> stream = Stream.iterate(0, x -> x + 2); 
stream.limit(10).forEach(System.out::println);
// 生成
// public static<T> Stream<T> generate(Supplier<T> s) 
Stream<Double> stream1 = Stream.generate(Math::random); 
stream1.limit(10).forEach(System.out::println);
}

Stream的中间操作

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

Stream 的终止操作

• 终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如：List、Integer，甚至是 void
• 流进行了终止操作后，不能再次使用

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

• 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率
• Java8中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换

Optional类

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

• Optional类的Javadoc描述如下：这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象

• Optional提供很多有用的方法，这样我们就不用显式进行空值检测

• 创建Optional类对象的方法：
      Optional.of(T t) : 创建一个 Optional 实例，t必须非空；
      Optional.empty() : 创建一个空的 Optional 实例
      Optional.ofNullable(T t)：t可以为null

• 判断Optional容器中是否包含对象：
      boolean isPresent() : 判断是否包含对象
      void ifPresent(Consumer<? super T> consumer) ：如果有值，就执行Consumer接口的实现代码，并且该值会作为参数传给它

• 获取Optional容器的对象：
      T get(): 如果调用对象包含值，返回该值，否则抛异常
      T orElse(T other) ：如果有值则将其返回，否则返回指定的other对象。
      T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier接口实现提供的对象。
      T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier接口实现提供的异常

@Test
public void test1() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend()); // 如果女朋友存在就打印女朋友的信息
opt.ifPresent(System.out::println);
}
@Test
public void test2() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend()); // 如果有女朋友就返回他的女朋友，否则只能欣赏“嫦娥”了
Girl girl = opt.orElse(new Girl("嫦娥"));
System.out.println("他的女朋友是：" + girl.getName());
}
@Test
public void test3(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888)); //判断opt中员工对象是否满足条件，如果满足就保留，否则返回空
Optional<Employee> emp = opt.filter(e -> e.getSalary()>10000); System.out.println(emp);
}
@Test
public void test4(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888)); //如果opt中员工对象不为空，就涨薪10%
Optional<Employee> emp = opt.map(e -> 
{e.setSalary(e.getSalary()%1.1);return e;});
System.out.println(emp);
}