Neue Funktionen von Java 8: Lambda-Ausdrücke

Zusammenfassung: Der Lambda-Ausdruck ist eine von mehreren wichtigen neuen Funktionen, die uns Java8 bietet. Das Ausleihen des Lambda-Ausdrucks kann unser Java-Programmdesign prägnanter machen. Dieser Artikel ist die erste der neuen Funktionen von Java 8 und behandelt Verhaltensparametrisierung, Lambda-Ausdrücke und Methodenreferenzen.

Der Lambda-Ausdruck ist eine von mehreren wichtigen neuen Funktionen, die uns Java8 bietet. Das Ausleihen des Lambda-Ausdrucks kann das Design unseres Java-Programms prägnanter machen. Kürzlich haben neue Projekte Version 1.6 aufgegeben und werden vollständig auf Basis von Java8 entwickelt. Dieser Artikel ist der erste Artikel über die neuen Funktionen von Java8 und behandelt Verhaltensparametrisierung, Lambda-Ausdrücke und Methodenreferenzen.

1. Verhaltensparametrisierung

Verhaltensparametrisierung bedeutet einfach, dass der Hauptteil der Funktion nur allgemeinen Code der Vorlagenklasse enthält und sich einige mit der Geschäftsszenario-Logik ändern Durch die Verwendung von Verhaltensparametrisierung kann das Programm vielseitiger werden, um häufige Änderungen bewältigen zu können.

Stellen Sie sich ein Geschäftsszenario vor. Wir müssen zunächst eine Apfelentität definieren:

/**
 * 苹果实体
 *
 * @author zhenchao.wang 2016-09-17 12:49
 * @version 1.0.0
 */
public class Apple {
    /** 编号 */
    private long id;
    /** 颜色 */
    private Color color;
    /** 重量 */
    private float weight;
    /** 产地 */
    private String origin;
    public Apple() {
    }
    public Apple(long id, Color color, float weight, String origin) {
        this.id = id;
        this.color = color;
        this.weight = weight;
        this.origin = origin;
    }
    // 省略getter和setter
}

Die anfänglichen Bedürfnisse des Benutzers könnten „Wir“ sein Ich hoffe einfach, dass wir durch das Programm grüne Äpfel herausfiltern können, damit wir es durch das Programm schnell erreichen können:

/**
 * 筛选绿苹果
 *
 * @param apples
 * @return
 */
public static List<Apple> filterGreenApples(List<Apple> apples) {
    List<Apple> filterApples = new ArrayList<>();
    for (final Apple apple : apples) {
        if (Color.GREEN.equals(apple.getColor())) {
            filterApples.add(apple);
        }
    }
    return filterApples;
}

Wenn der Benutzer nach einer Weile neue Bedürfnisse vorbringt, Wir Ich hoffe, durch das Programm rote Äpfel herausfiltern zu können, deshalb haben wir die Funktion zum Herausfiltern roter Äpfel hinzugefügt:

/**
 * 筛选红苹果
 *
 * @param apples
 * @return
 */
public static List<Apple> filterRedApples(List<Apple> apples) {
    List<Apple> filterApples = new ArrayList<>();
    for (final Apple apple : apples) {
        if (Color.RED.equals(apple.getColor())) {
            filterApples.add(apple);
        }
    }
    return filterApples;
}

Eine bessere Implementierung besteht darin, die Farbe als Parameter zu übergeben in die Funktion ein, damit wir in Zukunft auf verschiedene Farbfilterungswünsche von Benutzern reagieren können:

/**
 * 自定义筛选颜色
 *
 * @param apples
 * @param color
 * @return
 */
public static List<Apple> filterApplesByColor(List<Apple> apples, Color color) {
    List<Apple> filterApples = new ArrayList<>();
    for (final Apple apple : apples) {
        if (color.equals(apple.getColor())) {
            filterApples.add(apple);
        }
    }
    return filterApples;
}

Nachdem Sie auf diese Weise entworfen haben, müssen Sie sich keine Gedanken mehr über Änderungen in der machen Die Anforderungen des Benutzers an die Farbfilterung wurden jedoch leider eines Tages nach einer Anforderung gefragt, um Äpfel auswählen zu können, deren Gewicht einen bestimmten Standard erreicht. In der vorherigen Lektion haben wir auch den Gewichtsstandard als Parameter an die Screening-Funktion übergeben wir haben:

/**
 * 筛选指定颜色，且重要符合要求
 *
 * @param apples
 * @param color
 * @param weight
 * @return
 */
public static List<Apple> filterApplesByColorAndWeight(List<Apple> apples, Color color, float weight) {
    List<Apple> filterApples = new ArrayList<>();
    for (final Apple apple : apples) {
        if (color.equals(apple.getColor()) && apple.getWeight() >= weight) {
            filterApples.add(apple);
        }
    }
    return filterApples;
}

Ist das wirklich eine gute Möglichkeit, Parameter zu übergeben? Wenn es immer mehr Filterbedingungen gibt und der Kombinationsmodus immer komplexer wird, müssen wir dann alle Situationen berücksichtigen und für jede Situation entsprechende Strategien haben, und diese Funktionen unterscheiden sich nur in einem Teil der Filterbedingungen Mit demselben Vorlagencode (durch die Sammlung) können wir zu diesem Zeitpunkt das Verhalten parametrisieren , sodass die Funktion nur den Vorlagencode behält, die Filterbedingungen extrahiert und sie als Parameter vor Java8 übergibt. Wir haben dies durch die Definition einer Filterschnittstelle implementiert:

/**
 * 苹果过滤接口
 *
 * @author zhenchao.wang 2016-09-17 14:21
 * @version 1.0.0
 */
@FunctionalInterface
public interface AppleFilter {
    /**
     * 筛选条件抽象
     *
     * @param apple
     * @return
     */
    boolean accept(Apple apple);
}
/**
 * 将筛选条件封装成接口
 *
 * @param apples
 * @param filter
 * @return
 */
public static List<Apple> filterApplesByAppleFilter(List<Apple> apples, AppleFilter filter) {
    List<Apple> filterApples = new ArrayList<>();
    for (final Apple apple : apples) {
        if (filter.accept(apple)) {
            filterApples.add(apple);
        }
    }
    return filterApples;
}

Nachdem wir das obige Verhalten abstrahiert haben, können wir die Filterbedingungen an der spezifischen Aufrufstelle festlegen und die Bedingungen als Parameter verwenden, an die sie übergeben werden die Methode:

public static void main(String[] args) {
    List<Apple> apples = new ArrayList<>();
    // 筛选苹果
    List<Apple> filterApples = filterApplesByAppleFilter(apples, new AppleFilter() {
        @Override
        public boolean accept(Apple apple) {
            // 筛选重量大于100g的红苹果
            return Color.RED.equals(apple.getColor()) && apple.getWeight() > 100;
        }
    });
}

Die obige Verhaltensparametrisierungsmethode wird mithilfe anonymer Klassen implementiert. Dieses Design wird auch häufig in JDK verwendet, z. B.

java.util.Comparator

,

java.util.concurrent.Callable

usw. Wenn wir diese Art von Schnittstelle verwenden, können wir anonyme Klassen verwenden, um die spezifische Ausführungslogik der Funktion an der spezifischen Aufrufstelle anzugeben, aber aus dem oben Gesagten Der Codeblock ist zwar sehr geekig, aber in Java8 nicht prägnant genug. Wir können ihn durch Lambda vereinfachen:

// 筛选苹果
List<Apple> filterApples = filterApplesByAppleFilter(apples,
        (Apple apple) -> Color.RED.equals(apple.getColor()) && apple.getWeight() >= 100);

Der Code wird durch Lambda-Ausdrücke stark vereinfacht Lernen Sie den Lambda-Ausdruck von Java~

2. Definition des Lambda-Ausdrucks

Wir können den Lambda-Ausdruck als eine Art präzise und realisierbare übergebene anonyme Funktion definieren, Erstens müssen wir klarstellen, dass der Lambda-Ausdruck im Wesentlichen eine Funktion ist, obwohl er nicht zu einer bestimmten Klasse gehört, aber zweitens über eine Parameterliste, einen Funktionskörper, einen Rückgabetyp und die Möglichkeit verfügt, Ausnahmen auszulösen. Es ist anonym und Lambda-Ausdrücke haben keine spezifischen Funktionsnamen. Lambda-Ausdrücke können wie Parameter übergeben werden, was das Schreiben von Code erheblich vereinfacht. Das Format ist wie folgt definiert:

Format 1: Parameterliste-> Ausdruck
Format 2: Parameterliste-> Daher müssen wir in einem einzelnen Ausdruck das Schlüsselwort „return“ nicht explizit schreiben. Wenn der Ausdruck jedoch eine Sammlung von Anweisungen ist, müssen Sie „return“ explizit hinzufügen und geschweifte Klammern verwenden

{ }

Mehrere Ausdrücke umgeben . Hier sind ein paar Beispiele:

//返回给定字符串的长度，隐含return语句
(String s) -> s.length() 
// 始终返回42的无参方法
() -> 42 
// 包含多行表达式，则用花括号括起来
(int x, int y) -> {
    int z = x * y;
    return x + z;
}

3. Verlassen Sie sich auf funktionale Schnittstellen, um Lambda-Ausdrücke zu verwenden.

Lambda-Ausdruck Die Verwendung von Ausdrücken erfordert die Hilfe von funktionalen Schnittstellen , was bedeutet, dass wir nur dort, wo funktionale Schnittstellen vorkommen, diese mit Lambda-Ausdrücken vereinfachen können.

Benutzerdefinierte funktionale Schnittstelle

Eine funktionale Schnittstelle ist als eine Schnittstelle mit nur

einer abstrakten Methode definiert. Die Verbesserung der Schnittstellendefinition in Java 8 ist die Einführung von Standardmethoden, die es uns ermöglichen, Standardimplementierungen für Methoden in der Schnittstelle bereitzustellen. Unabhängig davon, wie viele Standardmethoden es gibt, solange es nur eine abstrakte Methode gibt , dann handelt es sich um eine funktionale Schnittstelle wie folgt (Zitat des AppleFilters oben):

/**
 * 苹果过滤接口
 *
 * @author zhenchao.wang 2016-09-17 14:21
 * @version 1.0.0
 */
@FunctionalInterface
public interface AppleFilter {
    /**
     * 筛选条件抽象
     *
     * @param apple
     * @return
     */
    boolean accept(Apple apple);
}

AppleFilter

enthält nur eine abstrakte Methode

accept(Apple apple)

, Da es sich bei der Definition um eine Funktionsschnittstelle handelt, haben wir dieser Schnittstelle bei der Definition

hinzugefügt

@FunctionalInterface

注解，用于标记该接口是函数式接口，不过这个接口是可选的，当添加了该接口之后，编译器就限制了该接口只允许有一个抽象方法，否则报错，所以推荐为函数式接口添加该注解。

jdk自带的函数式接口

jdk为lambda表达式已经内置了丰富的函数式接口，如下表所示(仅列出部分)：

函数式接口	函数描述符	原始类型特化
Predicate8742468051c85b06f0a0af9e3e506b5c	T -> boolean	IntPredicate, LongPredicate, DoublePredicate
Consumer8742468051c85b06f0a0af9e3e506b5c	T -> void	IntConsumer, LongConsumer, DoubleConsumer
Funcation469df1b70b2914a3841e0404ec3e3d5d	T -> R	IntFuncation0f1763a9dfcc95d54eac98034f0cdcdd, IntToDoubleFunction, IntToLongFunction0f1763a9dfcc95d54eac98034f0cdcdd, LongFuncation…
Supplier8742468051c85b06f0a0af9e3e506b5c	() -> T	BooleanSupplier, IntSupplier, LongSupplier, DoubleSupplier
UnaryOperator8742468051c85b06f0a0af9e3e506b5c	T -> T	IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator
BinaryOperator8742468051c85b06f0a0af9e3e506b5c	(T, T) -> T	IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator
BiPredicateedf640cc243cef8451ed278a13e0f190	(L, R) -> boolean
BiConsumerabbd655bd3f9f929be0207abcc18a2ef	(T, U) -> void
BiFunction96b8c9ba1c8b330d622a8468a6113c2e	(T, U) -> R

下面分别就

Predicate<T>

、

Consumer<T>

、

Function<T, R>

的使用示例说明。

Predicate8742468051c85b06f0a0af9e3e506b5c

@FunctionalInterface
public interface Predicate<T> {
    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

Predicate的功能类似于上面的

AppleFilter

，利用我们在外部设定的条件对于传入的参数进行校验，并返回验证结果

boolean

，下面利用

Predicate

对List集合的元素进行过滤：

/**
 * 按照指定的条件对集合元素进行过滤
 *
 * @param list
 * @param predicate
 * @param 
 * @return
 */
public  List filter(List list, Predicate<T> predicate) {
    List newList = new ArrayList();
    for (final T t : list) {
        if (predicate.test(t)) {
            newList.add(t);
        }
    }
    return newList;
}

利用上面的函数式接口过滤字符串集合中的空字符串：

demo.filter(list, (String str) -> null != str && !str.isEmpty());
Consumer<T>
@FunctionalInterface
public interface Consumer<T> {
    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

Consumer提供了一个accept抽象函数，该函数接收参数，但不返回值，下面利用

Consumer

遍历集合：

/**
 * 遍历集合，执行自定义行为
 *
 * @param list
 * @param consumer
 * @param 
 */
public  void filter(List list, Consumer<T> consumer) {
    for (final T t : list) {
        consumer.accept(t);
    }
}

利用上面的函数式接口，遍历字符串集合，并打印非空字符串：

demo.filter(list, (String str) -> {
        if (StringUtils.isNotBlank(str)) {
            System.out.println(str);
        }
    });

Function469df1b70b2914a3841e0404ec3e3d5d

@FunctionalInterface
public interface Function<T, R> {
    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

Funcation执行转换操作，输入是类型T的数据，返回R类型的数据，下面利用

Function

对集合进行转换：

/**
 * 遍历集合，执行自定义转换操作
 *
 * @param list
 * @param function
 * @param 
 * @param 
 * @return
 */
public  List filter(List list, Function<T, R> function) {
    List newList = new ArrayList();
    for (final T t : list) {
        newList.add(function.apply(t));
    }
    return newList;
}

下面利用上面的函数式接口，将一个封装字符串（整型数字的字符串表示）的接口，转换成整型集合：

demo.filter(list, (String str) -> Integer.parseInt(str));
上面这些函数式接口还提供了一些逻辑操作的默认实现，留到后面介绍java8接口的默认方法时再讲吧~

使用过程中需要注意的一些事情

类型推断

在编码过程中，有时候可能会疑惑我们的调用代码会去具体匹配哪个函数式接口，实际上编译器会根据参数、返回类型、异常类型（如果存在）等做正确的判定。

在具体调用时，在一些时候可以省略参数的类型，从而进一步简化代码：

/

/ 筛选苹果
List<Apple> filterApples = filterApplesByAppleFilter(apples,
        (Apple apple) -> Color.RED.equals(apple.getColor()) && apple.getWeight() >= 100);
// 某些情况下我们甚至可以省略参数类型，编译器会根据上下文正确判断
List<Apple> filterApples = filterApplesByAppleFilter(apples,
        apple -> Color.RED.equals(apple.getColor()) && apple.getWeight() >= 100);

局部变量

上面所有例子我们的lambda表达式都是使用其主体参数，我们也可以在lambda中使用局部变量，如下：

int weight = 100;
List<Apple> filterApples = filterApplesByAppleFilter(apples,
        apple -> Color.RED.equals(apple.getColor()) && apple.getWeight() >= weight);

该例子中我们在lambda中使用了局部变量weight，不过在lambda中使用局部变量必须要求该变量 显式声明为final或事实上的final ，这主要是因为局部变量存储在栈上，lambda表达式则在另一个线程中运行，当该线程视图访问该局部变量的时候，该变量存在被更改或回收的可能性，所以用final修饰之后就不会存在线程安全的问题。

四. 方法引用

采用方法引用可以更近一步的简化代码，有时候这种简化让代码看上去更加的直观，先看一个例子：

/* ... 省略apples的初始化操作 */
// 采用lambda表达式
apples.sort((Apple a, Apple b) -> Float.compare(a.getWeight(), b.getWeight()));
// 采用方法引用
apples.sort(Comparator.comparing(Apple::getWeight));

方法引用通过

::

将方法隶属和方法自身连接起来，主要分为三类：

静态方法

(args) -> ClassName.staticMethod(args)

转换成

ClassName::staticMethod

参数的实例方法

(args) -> args.instanceMethod()

转换成

ClassName::instanceMethod  // ClassName是args的类型

外部的实例方法

(args) -> ext.instanceMethod(args)

转换成

ext::instanceMethod(args)

 以上就是Java8 新特性之 Lambda 表达式 的内容，更多相关内容请关注PHP中文网（www.php.cn）！