Java 基础系列的笔记终于完成了🎉🎉🎉

目录

一、Lambda 表达式

1. Lamdba 表达式概述

2. 使用 Lambda 表达式前后对比

3. 怎样使用Lambda表达式

4. Lamdba表达式总结

二、函数式接口

1. 函数式接口概述

3. Java内置函数式接口

4. 使用总结

三、方法的引用

1. 方法引用概述

2. 使用情景

3. 使用格式

4. 使用情况

5. 使用要求

6. 使用建议

7. 使用举例

四、构造器和数组的引用

1. 使用格式

2. 使用要求

3. 使用举例

五、StreamAPI

1. Stream API概述

2. Stream 使用流程

3. 使用方法

六、Optional 类的使用

1. OPtional 类的概述

2. Optional 类提供的方法

3. 应用举例

七、对反射的支持增强

Java 8新特性汇总

Java 8的改进

• 速度更快

• 代码更少（增加了新的语法：Lambda表达式）

• 引入强大的 Stream APl

• 便于并行

• 最大化减少空指针异常：Optional

• Nashorn 引擎，允许在JVM上运行 JS 应用

• 并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。相比较串行的流，并行的流可以很大程度上提高程序的执行效率。

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

一、Lambda 表达式

1. Lamdba 表达式概述

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

2. 使用 Lambda 表达式前后对比

示例一：调用 Runable 接口

@Test
public void test1(){//未使用Lambda表达式的写法Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("hello Lambda!");}};r1.run();System.out.println("========================");//Lamdba表达式写法Runnable r2 = () -> System.out.println("hi Lambda!");r2.run();
}复制代码

示例二：使用Comparator接口

@Test
public void test2(){//未使用Lambda表达式的写法Comparator com1 = new Comparator() {@Overridepublic int compare(Integer o1, Integer o2) {return Integer.compare(o1,o2);}};int compare1 = com1.compare(12, 32);System.out.println(compare1);//-1System.out.println("===================");//Lambda表达式的写法Comparator com2 = (o1,o2) -> Integer.compare(o1,o2);int compare2 = com2.compare(54, 21);System.out.println(compare2);//1System.out.println("===================");//方法引用Comparator cpm3 = Integer::compareTo;int compare3 = cpm3.compare(12, 12);System.out.println(compare3);//0
}复制代码

3. 怎样使用Lambda表达式

3.1 Lamdba表达式基本语法

1.举例： (o1,o2) -> Integer.compare(o1,o2);

2.格式：

• -> ：lambda 操作符 或 箭头操作符
• -> 左边：lambda 形参列表 （其实就是接口中的抽象方法的形参列表）
• -> 右边：lambda 体（其实就是重写的抽象方法的方法体）

3.2 Lamdba表达式使用（包含六种情况）

3.2.1 语法格式一：无参，有返回值

Runnable r1 = () -> {System.out.println(“hello Lamdba!”)}
复制代码

3.2.2 语法格式二：Lamdba需要一个参数，但没有返回值

Consumer con = (String str) -> {System.out.println(str)}
复制代码

3.2.3 语法格式三：数据类型可省略，因为可由编译器推断得出，称为类型推断

Consumer con = (str) -> {System.out.println(str)}
复制代码

3.2.4 语法格式四：Lamdba若只需要一个参数时，小括号可以省略

Consumer con = str -> {System.out.println(str)}
复制代码

3.2.5 语法格式五：Lamdba需要两个以上的参数，多条执行语句，并且可以有返回值

Comparatorcom = (o1,o1) -> {Syste.out.println("Lamdba表达式使用");return Integer.compare(o1,o2);
}
复制代码

3.2.6 语法格式六：当Lamdba体只有一条语句时，return和大括号若有，都可以省略

Comparatorcom = (o1,o1) ->	Integer.compare(o1,o2);
复制代码

代码示例：

public class LamdbaTest2 {//语法格式一：无参，无返回值@Testpublic void test1() {//未使用Lambda表达式Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("Hello Lamdba");}};r1.run();System.out.println("====================");//使用Lambda表达式Runnable r2 = () -> {System.out.println("Hi Lamdba");};r2.run();}//语法格式二：Lambda 需要一个参数，但是没有返回值。@Testpublic void test2() {//未使用Lambda表达式Consumer con = new Consumer() {@Overridepublic void accept(String s) {System.out.println(s);}};con.accept("你好啊Lambda！");System.out.println("====================");//使用Lambda表达式Consumer con1 = (String s) -> {System.out.println(s);};con1.accept("我是Lambda");}//语法格式三：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”@Testpublic void test3() {//未使用Lambda表达式Consumer con = new Consumer() {@Overridepublic void accept(String s) {System.out.println(s);}};con.accept("你好啊Lambda！");System.out.println("====================");//使用Lambda表达式Consumer con1 = (s) -> {System.out.println(s);};con1.accept("我是Lambda");}@Testpublic void test(){ArrayList list = new ArrayList<>();//类型推断，用左边推断右边int[] arr = {1,2,3,4};//类型推断，用左边推断右边}//语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略@Testpublic void test4() {//未使用Lambda表达式Consumer con = new Consumer() {@Overridepublic void accept(String s) {System.out.println(s);}};con.accept("你好啊Lambda！");System.out.println("====================");//使用Lambda表达式Consumer con1 = s -> {System.out.println(s);};con1.accept("我是Lambda");}//语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值@Testpublic void test5() {//未使用Lambda表达式Comparator com1 = new Comparator() {@Overridepublic int compare(Integer o1, Integer o2) {System.out.println(o1);System.out.println(o2);return Integer.compare(o1, o2);}};System.out.println(com1.compare(23, 45));System.out.println("====================");//使用Lambda表达式Comparator com2 = (o1, o2) -> {System.out.println(o1);System.out.println(o2);return o1.compareTo(o2);};System.out.println(com2.compare(23, 12));}//语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略@Testpublic void test6() {//未使用Lambda表达式Comparator com1 = new Comparator() {@Overridepublic int compare(Integer o1, Integer o2) {return Integer.compare(o1, o2);}};System.out.println(com1.compare(23, 45));System.out.println("====================");//使用Lambda表达式Comparator com2 = (o1, o2) -> o1.compareTo(o2);System.out.println(com2.compare(23, 12));}@Testpublic void test7(){//未使用Lambda表达式Consumer con1 = new Consumer() {@Overridepublic void accept(String s) {System.out.println(s);}};con1.accept("hi!");System.out.println("====================");//使用Lambda表达式Consumer con2 = s -> System.out.println(s);con2.accept("hello");}}
复制代码

3.3 Lambda 表达式使用总结

• -> 左边：lambda 形参列表的参数类型可以省略(类型推断)；如果 lambda 形参列表只有一个参数，其一对 () 也可以省略
• -> 右边：lambda 体应该使用一对 {} 包裹；如果 lambda 体只有一条执行语句（可能是 return 语句），省略这一对 {} 和 return 关键字

4. Lamdba表达式总结

• Lambda 表达式的本质：作为函数式接口的实例
• 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。
• 因此以前用匿名实现类表示的现在都可以用 Lambda 表达式来写。

二、函数式接口

1. 函数式接口概述

• 只包含一个抽象方法的接口，称为函数式接口。

• 可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常（即：非运行时异常），那么该异常需要在目标接口的抽象方法上进行声明）。

• 可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

• Lambda 表达式的本质：作为函数式接口的实例

• 在 java.util.function 包下定义了Java 8的丰富的函数式接口

自定义函数式接口

@FunctionalInterface
public interface MyInterface {void method1();
}
复制代码

3. Java内置函数式接口

3.1 四大核心函数式接口

应用举例

public class LambdaTest3 {//    消费型接口 Consumer     void accept(T t)@Testpublic void test1() {//未使用Lambda表达式Learn("java", new Consumer() {@Overridepublic void accept(String s) {System.out.println("学习什么？ " + s);}});System.out.println("====================");//使用Lambda表达Learn("html", s -> System.out.println("学习什么？ " + s));}private void Learn(String s, Consumer stringConsumer) {stringConsumer.accept(s);}//    供给型接口 Supplier     T get()@Testpublic void test2() {//未使用LambdabiaodasSupplier sp = new Supplier() {@Overridepublic String get() {return new String("我能提供东西");}};System.out.println(sp.get());System.out.println("====================");//使用Lambda表达Supplier sp1 = () -> new String("我能通过lambda提供东西");System.out.println(sp1.get());}//函数型接口 Function   R apply(T t)@Testpublic void test3() {//使用Lambda表达式Employee employee = new Employee(1001, "Tom", 45, 10000);Function func1 =e->e.getName();System.out.println(func1.apply(employee));System.out.println("====================");//使用方法引用Functionfunc2 = Employee::getName;System.out.println(func2.apply(employee));}//断定型接口 Predicate    boolean test(T t)@Testpublic void test4() {//使用匿名内部类Function func = new Function() {@Overridepublic Long apply(Double aDouble) {return Math.round(aDouble);}};System.out.println(func.apply(10.5));System.out.println("====================");//使用Lambda表达式Function func1 = d -> Math.round(d);System.out.println(func1.apply(12.3));System.out.println("====================");//使用方法引用Functionfunc2 = Math::round;System.out.println(func2.apply(12.6));}
}
复制代码

3.2 其他函数式接口

4. 使用总结

4.1 何时使用lambda表达式？

当需要对一个函数式接口实例化的时候，可以使用 lambda 表达式。

4.2 何时使用给定的函数式接口？

如果我们开发中需要定义一个函数式接口，首先看看在已有的jdk提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了。

三、方法的引用

1. 方法引用概述

方法引用可以看做是 Lambda 表达式深层次的表达。换句话说，方法引用就是 Lambda 表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。

2. 使用情景

当要传递给 Lambda 体的操作，已经实现的方法了，可以使用方法引用！

3. 使用格式

类(或对象) :: 方法名

4. 使用情况

• 情况1 对象 :: 非静态方法

• 情况2 类 :: 静态方法

• 情况3 类 :: 非静态方法

5. 使用要求

• 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）
• 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName（针对于情况3）

6. 使用建议

如果给函数式接口提供实例，恰好满足方法引用的使用情境，就可以考虑使用方法引用给函数式接口提供实例。如果不熟悉方法引用，那么还可以使用 lambda 表达式。

7. 使用举例

public class MethodRefTest {// 情况一：对象 :: 实例方法//Consumer中的void accept(T t)//PrintStream中的void println(T t)@Testpublic void test1() {//使用Lambda表达Consumer con1 = str -> System.out.println(str);con1.accept("中国");System.out.println("====================");//使用方法引用PrintStream ps = System.out;Consumer con2 = ps::println;con2.accept("China");}//Supplier中的T get()//Employee中的String getName()@Testpublic void test2() {//使用Lambda表达Employee emp = new Employee(1001, "Bruce", 34, 600);Supplier sup1 = () -> emp.getName();System.out.println(sup1.get());System.out.println("====================");//使用方法引用Supplier sup2 = emp::getName;System.out.println(sup2.get());}// 情况二：类 :: 静态方法//Comparator中的int compare(T t1,T t2)//Integer中的int compare(T t1,T t2)@Testpublic void test3() {//使用Lambda表达Comparator com1 = (t1, t2) -> Integer.compare(t1, t2);System.out.println(com1.compare(32, 45));System.out.println("====================");//使用方法引用Comparator com2 = Integer::compareTo;System.out.println(com2.compare(43, 34));}//Function中的R apply(T t)//Math中的Long round(Double d)@Testpublic void test4() {//使用匿名内部类Function func = new Function() {@Overridepublic Long apply(Double aDouble) {return Math.round(aDouble);}};System.out.println(func.apply(10.5));System.out.println("====================");//使用Lambda表达式Function func1 = d -> Math.round(d);System.out.println(func1.apply(12.3));System.out.println("====================");//使用方法引用Function func2 = Math::round;System.out.println(func2.apply(12.6));}// 情况三：类 :: 实例方法// Comparator中的int comapre(T t1,T t2)// String中的int t1.compareTo(t2)@Testpublic void test5() {//使用Lambda表达式Comparator com1 = (s1, s2) -> s1.compareTo(s2);System.out.println(com1.compare("abd", "aba"));System.out.println("====================");//使用方法引用Comparator com2 = String::compareTo;System.out.println(com2.compare("abd", "abc"));}//BiPredicate中的boolean test(T t1, T t2);//String中的boolean t1.equals(t2)@Testpublic void test6() {//使用Lambda表达式BiPredicate pre1 = (s1, s2) -> s1.equals(s2);System.out.println(pre1.test("abc", "abc"));System.out.println("====================");//使用方法引用BiPredicate pre2 = String::equals;System.out.println(pre2.test("abc", "abd"));}// Function中的R apply(T t)// Employee中的String getName();@Testpublic void test7() {//使用Lambda表达式Employee employee = new Employee(1001, "Tom", 45, 10000);Function func1 =e->e.getName();System.out.println(func1.apply(employee));System.out.println("====================");//使用方法引用Functionfunc2 = Employee::getName;System.out.println(func2.apply(employee));}
}
复制代码

四、构造器和数组的引用

1. 使用格式

方法引用：类名 ::new

数组引用：数组类型 [] :: new

2. 使用要求

2.1 构造器引用

和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型

2.2 数组引用

可以把数组看做是一个特殊的类，则写法与构造器引用一致。

3. 使用举例

3.1 构造器引用

//构造器引用
//Supplier中的T get()
@Test
public void test1() {//使用匿名内部类Supplier sup = new Supplier() {@Overridepublic Employee get() {return new Employee();}};System.out.println(sup.get());//使用Lambda表达式System.out.println("====================");Supplier sup1 = () -> new Employee(1001, "Tom", 43, 13333);System.out.println(sup1.get());//使用方法引用Supplier sup2 = Employee::new;System.out.println(sup2.get());}//Function中的R apply(T t)
@Test
public void test2() {//使用Lambda表达式Function func1 = id -> new Employee(id);Employee employee = func1.apply(1001);System.out.println(employee);System.out.println("====================");//使用方法引用Function func2 = Employee::new;Employee employee1 = func2.apply(1002);System.out.println(employee1);}//BiFunction中的R apply(T t,U u)
@Test
public void test3() {//使用Lambda表达式BiFunction func1 = (id, name) -> new Employee(id, name);System.out.println(func1.apply(1001, "Tom"));System.out.println("====================");//使用方法引用BiFunction func2 = Employee::new;System.out.println(func2.apply(1002, "Jarry"));
}
复制代码

3.2 数组引用

//数组引用
//Function中的R apply(T t)
@Test
public void test4() {Function func1 = length -> new String[length];String[] arr1 = func1.apply(5);System.out.println(Arrays.toString(arr1));System.out.println("====================");//使用方法引用Functionfunc2=String[]::new;String[] arr2 = func2.apply(10);System.out.println(Arrays.toString(arr2));
}
复制代码

五、StreamAPI

1. Stream API概述

• Stream 关注的是对数据的运算，与 CPU 打交道;集合关注的是数据的存储，与内存打交道;
• Java 8 提供了一套 api ，使用这套 api 可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于 sql 对数据库中表的相关操作。
• Stream 是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据， Stream讲的是计算！”

使用注意点:

① Stream 自己不会存储元素。

② Stream 不会改变源对象。相反，他们会返回一个持有结果的新 Stream。

③ Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

2. Stream 使用流程

① Stream 的实例化

② 一系列的中间操作（过滤、映射、...)

③ 终止操作

使用流程中的注意点：

• 一个中间操作链，对数据源的数据进行处理
• 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

3. 使用方法

3.1 步骤一 创建 Stream

3.1.1 创建方式一：通过集合

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

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

3.1.2 创建方式二：通过数组

Java 8中的 Arrays 的静态方法 stream() 可以获取数组流

• 调用 Arrays 类的 static\ Stream\ stream(T[] array): 返回一个流
• 重载形式，能够处理对应基本类型的数组：
  • public static IntStream stream（int[] array）
  • public static LongStream stream（long[] array）
  • public static DoubleStream stream（double[] array）

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

可以调用Stream类静态方法of()，通过显示值创建一个流。可以用于接收任意数量的参数

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

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

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

代码示例：

public class StreamAPITest1 {//创建 Stream方式一：通过集合@Testpublic void test1() {List employees = EmployeeData.getEmployees();//efault Stream stream() : 返回一个顺序流Stream stream = employees.stream();//default Stream parallelStream() : 返回一个并行流Stream employeeStream = employees.parallelStream();}//创建 Stream方式二：通过数组@Testpublic void test2() {int[] arrs = {1, 2, 3, 6, 2};//调用Arrays类的static  Stream stream(T[] array): 返回一个流IntStream stream = Arrays.stream(arrs);Employee e1 = new Employee(1001, "Tom");Employee e2 = new Employee(1002, "Jerry");Employee[] employees = {e1, e2};Stream stream1 = Arrays.stream(employees);}//创建 Stream方式三：通过Stream的of()@Testpublic void test3() {Stream integerStream = Stream.of(12, 34, 45, 65, 76);}//创建 Stream方式四：创建无限流@Testpublic void test4() {//迭代//public static Stream iterate(final T seed, final UnaryOperator f)//遍历前10个偶数Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);//生成//public static Stream generate(Supplier s)Stream.generate(Math::random).limit(10).forEach(System.out::println);}
}复制代码

3.2 步骤二 中间操作

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

3.2.1 筛选与切片

代码示例:

//1-筛选与切片,注意执行终止操作后，Stream流就被关闭了，使用时需要再次创建Stream流
@Test
public void test1(){List employees = EmployeeData.getEmployees();//filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。Stream employeeStream = employees.stream();//练习：查询员工表中薪资大于7000的员工信息employeeStream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);//limit(n)——截断流，使其元素不超过给定数量。employeeStream.limit(3).forEach(System.out::println);System.out.println();//skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补employeeStream.skip(3).forEach(System.out::println);//distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素employees.add(new Employee(1010,"刘庆东",56,8000));employees.add(new Employee(1010,"刘庆东",56,8000));employees.add(new Employee(1010,"刘庆东",56,8000));employees.add(new Employee(1010,"刘庆东",56,8000));employeeStream.distinct().forEach(System.out::println);
}复制代码

3.2.2 映射

代码示例:

//2-映射
@Test
public void test2(){List list = Arrays.asList("aa", "bb", "cc", "dd");//map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);//练习1：获取员工姓名长度大于3的员工的姓名。List employees = EmployeeData.getEmployees();Stream nameStream = employees.stream().map(Employee::getName);nameStream.filter(name -> name.length() >3).forEach(System.out::println);System.out.println();//练习2：使用map()中间操作实现flatMap()中间操作方法Stream> streamStream = list.stream().map(StreamAPITest2::fromStringToStream);streamStream.forEach(s ->{s.forEach(System.out::println);});System.out.println();//flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。Stream characterStream = list.stream().flatMap(StreamAPITest2::fromStringToStream);characterStream.forEach(System.out::println);}
//将字符串中的多个字符构成的集合转换为对应的Stream的实例
public static StreamfromStringToStream(String str){ArrayList list = new ArrayList<>();for (Character c :str.toCharArray()) {list.add(c);}return list.stream();
}
//map()和flatMap()方法类似于List中的add()和addAll()方法
@Test
public void test(){ArrayList