Nouvelles fonctionnalités de Java 8 : expressions Lambda-javaDidacticiel-php.cn

Résumé : L'expression lambda est l'une des nombreuses nouvelles fonctionnalités importantes apportées par Java8. L'emprunt d'une expression lambda peut rendre la conception de notre programme Java plus concise. Cet article est la première des nouvelles fonctionnalités de Java 8 et explorera le paramétrage du comportement, les expressions lambda et les références de méthodes.

L'expression lambda est l'une des nombreuses nouvelles fonctionnalités importantes apportées par java8. L'emprunt d'une expression lambda peut rendre la conception de notre programme Java plus concise. Récemment, de nouveaux projets ont abandonné la version 1.6 et sont entièrement développés sur la base de Java8. Cet article est le premier article sur les nouvelles fonctionnalités de Java8 et discutera du paramétrage du comportement, des expressions lambda et des références de méthodes.

1. Paramétrage du comportement

Le paramétrage du comportement signifie simplement que le corps principal de la fonction ne contient que le code général de la classe modèle, et certains changeront avec l'entreprise. scénario. La logique est transmise à la fonction sous forme de paramètres. L'utilisation du paramétrage comportemental peut rendre le programme plus polyvalent pour faire face aux changements fréquents.

Considérons un scénario commercial. Supposons que nous devions filtrer les pommes via un programme. Nous définissons d'abord une entité Apple :

/**
 * 苹果实体
 *
 * @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
}

Copier après la connexion

Les besoins initiaux de l'utilisateur peuvent être Nous. espérons simplement que nous pourrons filtrer les pommes vertes grâce au programme, afin que nous puissions y parvenir rapidement grâce au programme :

/**
 * 筛选绿苹果
 *
 * @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;
}

Copier après la connexion

Si au bout d'un moment l'utilisateur met en avant de nouveaux besoins, nous j'espère pouvoir filtrer les pommes rouges via le programme, nous avons donc ajouté la fonction de filtrage des pommes rouges :

/**
 * 筛选红苹果
 *
 * @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;
}

Copier après la connexion

Une meilleure implémentation consiste à passer la couleur en paramètre dans la fonction, afin que nous puissions répondre aux diverses demandes de filtrage de couleurs des utilisateurs à l'avenir :

/**
 * 自定义筛选颜色
 *
 * @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;
}

Copier après la connexion

Après avoir conçu de cette façon, vous n'avez plus à vous soucier des changements dans le les besoins de filtrage des couleurs de l'utilisateur, mais malheureusement, un jour, l'utilisateur a demandé une exigence pour pouvoir sélectionner les pommes dont le poids atteint une certaine norme. Avec la leçon précédente, nous avons également transmis la norme de poids comme paramètre à la fonction de filtrage, donc. nous avons obtenu :

/**
 * 筛选指定颜色，且重要符合要求
 *
 * @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;
}

Copier après la connexion

Est-ce vraiment un bon moyen de transmettre des paramètres ? S'il y a de plus en plus de conditions de filtrage et que le mode de combinaison devient de plus en plus complexe, devons-nous considérer toutes les situations et avoir des stratégies correspondantes pour chaque situation et ces fonctions ne sont différentes que dans une partie des conditions de filtrage, le reste l'est ? le même code de modèle (traversant la collection), à ce moment nous pouvons paramétrer le comportement , de sorte que la fonction ne conserve que le code du modèle, extrait les conditions de filtrage et les transmet en tant que paramètres. Avant java8, nous avons implémenté cela en définissant une interface de filtre :

/**
 * 苹果过滤接口
 *
 * @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;
}

Copier après la connexion

Après avoir résumé le comportement ci-dessus, nous pouvons définir les conditions de filtrage au lieu d'appel spécifique et utiliser les conditions lorsque les paramètres sont transmis la méthode :

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;
        }
    });
}

Copier après la connexion

La méthode de paramétrage du comportement ci-dessus est implémentée à l'aide de classes anonymes. Cette conception est également souvent utilisée dans jdk, comme

java.util.Comparator

Copier après la connexion

<. 🎜>,

java.util.concurrent.Callable

Copier après la connexion

, etc., lors de l'utilisation de ce type d'interface, nous pouvons utiliser des classes anonymes pour spécifier la logique d'exécution spécifique de la fonction au lieu d'appel spécifique, mais d'après ce qui précède à en juger par le bloc de code, bien qu'il soit très geek, il n'est pas assez concis. En Java8, on peut le simplifier grâce à lambda :

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

Copier après la connexion

Le code est grandement simplifié grâce aux expressions lambda. apprendre l'expression lambda de Java ~

2. Définition de l'expression lambda

Nous pouvons définir l'expression lambda comme une sorte de

fonction anonyme passée concise et réalisable , tout d'abord, nous devons préciser que l'expression lambda est essentiellement une fonction, même si elle n'appartient pas à une classe spécifique, elle a une liste de paramètres, un corps de fonction, un type de retour et la possibilité de lever des exceptions. Il est anonyme et les expressions lambda n'ont pas de noms de fonction spécifiques ; les expressions lambda peuvent être transmises comme des paramètres, simplifiant ainsi grandement l'écriture de code. Le format est défini comme suit :
Format 1 : Liste de paramètres-> Expression
Format 2 : Liste de paramètres-> , donc dans une seule expression, nous n'avons pas besoin d'écrire explicitement le mot-clé return, mais lorsque l'expression est une collection d'instructions, vous devez ajouter explicitement return et utiliser des accolades

Entourer plusieurs expressions . Voici quelques exemples :

{ }

Copier après la connexion

3. S'appuyer sur des interfaces fonctionnelles pour utiliser des expressions lambda

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

Copier après la connexion

expression lambda L'utilisation d'expressions nécessite l'aide d'interfaces fonctionnelles. , ce qui signifie que ce n'est que là où les interfaces fonctionnelles apparaissent que nous pouvons les simplifier avec des expressions lambda.

Interface fonctionnelle personnalisée

Une interface fonctionnelle est définie comme une interface avec une seule

une méthode abstraite

. L'amélioration de la définition de l'interface dans Java 8 est l'introduction de méthodes par défaut, ce qui nous permet de fournir des implémentations par défaut pour les méthodes dans l'interface. Cependant, quel que soit le nombre de méthodes par défaut, tant qu'il existe une et une seule méthode abstraite. , alors c'est une interface fonctionnelle comme suit (citant le AppleFilter ci-dessus) :

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

Copier après la connexion

ne contient qu'une seule méthode abstraite

AppleFilter

Copier après la connexion

, qui peut être considérée comme une interface de fonction par définition, nous avons ajouté

accept(Apple apple)

Copier après la connexion

à cette interface lors de sa définition

@FunctionalInterface

Copier après la connexion

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

jdk自带的函数式接口

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


函数式接口	函数描述符	原始类型特化
Predicate<T>	T -> boolean	IntPredicate, LongPredicate, DoublePredicate
Consumer<T>	T -> void	IntConsumer, LongConsumer, DoubleConsumer
Funcation	T -> R	IntFuncation, IntToDoubleFunction, IntToLongFunction, LongFuncation…
Supplier	() -> T	BooleanSupplier, IntSupplier, LongSupplier, DoubleSupplier
UnaryOperator	T -> T	IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator
BinaryOperator	(T, T) -> T	IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator
BiPredicate	(L, R) -> boolean
BiConsumer	(T, U) -> void
BiFunction	(T, U) -> R

下面分别就

Predicate<T>

Copier après la connexion

、

Consumer<T>

Copier après la connexion

、

Function<T, R>

Copier après la connexion

的使用示例说明。

Predicate<T>

@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);
}

Copier après la connexion

Predicate的功能类似于上面的

AppleFilter

Copier après la connexion

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

boolean

Copier après la connexion

，下面利用

Predicate

Copier après la connexion

对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;
}

Copier après la connexion

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

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);
}

Copier après la connexion

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

Consumer

Copier après la connexion

遍历集合：

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

Copier après la connexion

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

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

Copier après la connexion

Function<T, R>

@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);
}

Copier après la connexion

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

Function

Copier après la connexion

对集合进行转换：

/**
 * 遍历集合，执行自定义转换操作
 *
 * @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;
}

Copier après la connexion

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

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);

Copier après la connexion

局部变量

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

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

Copier après la connexion

该例子中我们在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));

Copier après la connexion

方法引用通过

::

Copier après la connexion

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

静态方法

(args) -> ClassName.staticMethod(args)

Copier après la connexion

转换成

ClassName::staticMethod

Copier après la connexion

参数的实例方法

(args) -> args.instanceMethod()

Copier après la connexion

转换成

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

Copier après la connexion

外部的实例方法

(args) -> ext.instanceMethod(args)

Copier après la connexion

转换成

ext::instanceMethod(args)

Copier après la connexion

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