【Java学习】Lambda表达式-EW帮帮网

//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接口的 匿名子类实例 传入
        @Override
        public 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接口的 匿名子类实例 传入
        @Override
        public 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接口的 匿名子类实例 传入
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);
        }
    });

    list.sort((o1, o2) -> o1.compareTo(o2));//Lambda表达式创建 Comparator接口的 匿名子类实例 传入
}

【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方法重写