【Java学习】Lambda表达式
目录
一、函数式匿名
1.环境确定
2.Lambda部分实现
二、函数式书写
Lambda表达式：
三、函数式接口
1.Consumer行为接口
1.1Lambda匿名实现(核心)
1.2创建使用全过程
1.2.1创建匿名子类实例
1.2.1.1环境确定
1.2.1.2匿名实现
1.2.2向上转型
1.2.3Lambda方法重写
2.BiConsumer行为接口
2.1Lambda匿名实现(核心)
2.2创建使用全过程
3.Comparator比较接口
3.1Lambda匿名实现(核心)
3.2创建使用全过程
3.2.1创建匿名子类实例
3.2.1.1环境确定
3.2.1.2匿名实现
3.2.2向上转型
3.2.3Lambda方法重写
一、函数式匿名
1.环境确定
创建匿名子类 快速扩展实例化 使用时，如果 创建环境 能确定 要匿名的是哪个接口、该接口的泛型参信息，并且 该接口只有一个抽象方法 能确定要实现的是它
2.Lambda部分实现
那么该匿名类 可函数表达式地 实现该抽象方法，即可用Lambda表达式 实现接口的 该抽象方法部分的 扩展实现，达到代码的简化效果
二、函数式书写
Lambda表达式：
(形参) —> {方法体}
- 形参类型可以全部一起省略
- 形参只有一个参数，形参的括号可以省略
- 方法体只有一条语句，方法体的括号可以省略，并且如果该语句是return语句，括号省略完 return也得省略
三、函数式接口
集合中有许多 只设计一个抽象方法 为便利服务于 Lambda表达式使用的 函数式接口：
1.Consumer行为接口
Collection接口以下的集合中 提供有forEach(Consumer <? super T> action) 方法，方法形参类型Consumer 就是一个 里面只有一个 定义行为操作的 抽象方法 viod accept(T t) 的函数式接口
1.1Lambda匿名实现(核心)
collection.forEach(Lambada表达式+其它需要扩展部分->Consumer接口匿名子类实例)
1.2创建使用全过程
1.2.1创建匿名子类实例
1.2.1.1环境确定
在Collection以下的实现类 调用forEach方法时，已经确定了 要对着匿名实现的接口是 Consumer、此类里面的 元素类型是T、此Consumer接口里面 只有一个accept抽象方法
1.2.1.2匿名实现
就用Lambda表达式 简洁地用函数表达式 实现 必须要实现的 该接口的 accpet抽象方法部分 (再加上其它自己需要扩展部分) 来创建并实例化 此匿名子类
1.2.2向上转型
将实例 传入forEach的形参 Consumeraction接口类型的变量action中 向上转型地接收
1.2.3Lambda方法重写
forEach方法里面 会遍历每个元素地 用该向上转型的接口变量action 调用执行它的accept 即重写转到执行 匿名子类的accept 即Lambda的函数表达式执行
//Consumer函数式接口：
@FunctionalInterface
interface Consumer<T> {void accept(T t);//接口里面 只有一个 定义行为操作的 抽象方法
}//Collection接口下的 forEach方法，Collection接口下的实现类 都有forEach方法可使用：
interface Collection<T> {default void forEach(Consumer<? super T> action) {//使用此方法 需要创建Consumer函数式接口的 匿名子类实例Objects.requireNonNull(action);for (T t : this) {action.accept(t);}}
}//Collection接口下的实现类 调用forEach方法 需要传入Consumer接口的 匿名子类实例：
public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("hello");list.add("world");list.forEach(new Consumer<String>() {//常规方法 创建Consumer接口的 匿名子类实例 传入@Overridepublic void accept(String s) {System.out.println(s);}});list.forEach(s -> System.out.println(s));//Lambda表达式 创建Consumer接口的 匿名子类实例 传入
}2.BiConsumer行为接口
Map接口以下的集合中 提供有forEach(BiConsumer <? super K, ? super V> action)方法，方法形参类型 BiConsumer就是一个 里面只有一个 定义行为操作的 抽象方法void accept(T t, U u) 的函数式接口
2.1Lambda匿名实现(核心)
map.forEach(Lambda表达式 + 其它需要扩展部分->BigConsumer接口匿名子类实例)
2.2创建使用全过程
在Map以下的实现类 调用forEach方法时，用Lambda表达式 创建匿名子类实例 向上转型传给 BigConsumer接口类型action，action里调用accept 即重写执行匿名子类的accept 即Lambda的函数表达式 实现的内容
//BiConsumer函数式接口：
@FunctionalInterface
interface BiConsumer<K, V> {void accept(K k, V v);//接口里面 只有一个 定义行为操作的 抽象方法
}//Map接口下的 forEach方法，Map接口下的实现类 都有Foreach方法可使用：
interface Map<K,V> {default void forEach(BiConsumer<? super K, ? super V> action) {//使用此方法 需要创建BiConsumer函数式接口的 匿名子类实例Objects.requireNonNull(action);for (Map.Entry<K, V> entry : entrySet()) {K k;V v;try {k = entry.getKey();v = entry.getValue();} catch(IllegalStateException ise) {throw new ConcurrentModificationException(ise);}action.accept(k, v);}}
}//Map接口下的实现类 调用forEach方法 需要传入 BigConsumer接口的 匿名子类实例：
public static void main(String[] args) {java.util.Map<String,Integer> map = new HashMap<>();map.put("hello",1);map.put("world",2);map.forEach(new BiConsumer<String, Integer>() {//常规方法创建 BigConsumer接口的 匿名子类实例 传入@Overridepublic void accept(String s, Integer integer) {System.out.println("key:"+ s + "val:" + integer );}});map.forEach((s,integer) -> System.out.println("key:"+ s + "val:" + integer ));//Lambda表达式创建 BigConsumer接口的 匿名子类实例 传入
}3.Comparator比较接口
List接口以下的集合中 提供有sort(Comparator <? super E> c)方法，Comparator就是一个 里面只有一个 定义大小比较方式的 抽象方法int compare(T o1, T o2)的 函数式接口
3.1Lambda匿名实现(核心)
list.sort(Lambda表达式+其它需要扩展部分->Comparator接口匿名子类实例)
3.2创建使用全过程
3.2.1创建匿名子类实例
3.2.1.1环境确定
在List以下的实现类 调用sort方法时，已经确定了 要对着匿名实现的接口是 Comparator、此类里面的 元素类型是T、此Comparator接口里面 只有一个compare抽象方法
3.2.1.2匿名实现
就用Lambda表达式 简洁地用函数表达式 实现 必要实现的 该接口的 compare抽象方法部分（再加上其它自己需要扩展部分）来创建并实例化 此匿名子类
3.2.2向上转型
将实例 传入sort的形参 Comparator接口类型的变量c中 向上转型地接收
3.2.3Lambda方法重写
sort方法里面 会调用c的compare 即重写转到执行 匿名子类的compare 即Lambda函数表达式 执行出 比较方式 从而进行比较与排序
//Comparator函数式接口：
interface comparator<T> {int compare(T o1, T o2);//接口里面 只有一个 定义大小比较方式的 抽象方法
}//List接口下的 sort方法，List接口下的实现类 都有sort方法可使用：
interface List {default void sort(Comparator<? super E> c) {//使用此方法 需要创建Comparator函数式接口的 匿名子类实例Object[] a = this.toArray();Arrays.sort(a, (Comparator) c);ListIterator<E> i = this.listIterator();for (Object e : a) {i.next();i.set((E) e);}}
}//List接口下的实现类 调用sort方法 需要传入 Comparator接口的 匿名子类实例：
public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("hello");list.add("world");list.sort(new Comparator<String>() {//常规方法创建 Comparator接口的 匿名子类实例 传入@Overridepublic int compare(String o1, String o2) {return o1.compareTo(o2);}});list.sort((o1, o2) -> o1.compareTo(o2));//Lambda表达式创建 Comparator接口的 匿名子类实例 传入
}