Tutoriel de démarrage de Java Lambda

LambdaIntroduction

Lambda, en tant qu'élément de base de la programmation fonctionnelle, a longtemps été largement utilisé dans d'autres langages de programmation (tels que Scala), mais il s'est davantage développé dans le champ Java Lentement, Lambda n'était plus pris en charge jusqu'à Java 8.

Ignorez les définitions mathématiques et faisons directement connaissance avec Lambda. Les expressions Lambda sont essentiellement des méthodes anonymes et leur implémentation sous-jacente se fait via l'instruction Invokedynamic pour générer des classes anonymes. Il fournit une syntaxe et un style d'écriture plus simples, vous permettant de remplacer les interfaces fonctionnelles par des expressions. De l'avis de certaines personnes, Lambda peut rendre votre code plus concis, et vous n'avez pas du tout besoin de l'utiliser. Cette vue est bien sûr correcte, mais l'important est que lambda apporte des fermetures. Java. Grâce à la prise en charge des collections par Lamdba, les performances de parcours des collections via Lambda sont considérablement améliorées dans des conditions de processeur multicœur. De plus, nous pouvons traiter les collections de manière fluide - ce qui est très attrayant.

Syntaxe Lambda

La syntaxe de Lambda est extrêmement simple, similaire à la structure suivante :

(parameters) -> expression

ou

(parameters) -> { statements; }

L'expression Lambda consiste de trois partiesGrouper en :

1. paramaters : Semblable à la liste de paramètres formels dans une méthode, les paramètres ici sont des paramètres dans le fonctionnel interface. Les types de paramètres ici peuvent être explicitement déclarés ou non et implicitement déduits par la JVM. De plus, les parenthèses peuvent être omises lorsqu’il n’existe qu’un seul type déduit.

2. -> : peut être compris comme signifiant "être utilisé pour"

3. Corps de la méthode : Il peut s'agir d'une expression ou d'un bloc de code, et c'est l'implémentation de la méthode dans l'interface fonctionnelle. Un bloc de code peut renvoyer une valeur ou rien. Le bloc de code ici est équivalent au corps de la méthode. S'il s'agit d'une expression, elle peut également renvoyer une valeur ou rien.

Nous illustrons à travers les exemples suivants :

//示例1：不需要接受参数，直接返回10
()->10

//示例2：接受两个int类型的参数，并返回这两个参数相加的和
(int x,int y)->x+y;

//示例2：接受x,y两个参数，该参数的类型由JVM根据上下文推断出来，并返回两个参数的和
(x,y)->x+y;

//示例3：接受一个字符串，并将该字符串打印到控制到，不反回结果
(String name)->System.out.println(name);

//示例4：接受一个推断类型的参数name，并将该字符串打印到控制台
name->System.out.println(name);

//示例5：接受两个String类型参数，并分别输出，不反回
(String name,String sex)->{System.out.println(name);System.out.println(sex)}

//示例6：接受一个参数x，并返回该该参数的两倍
x->2*x

Où Lambda est-il utilisé ?

Dans [Interface fonctionnelle][1] Nous savons que le type cible d'une expression Lambda est une interface fonctionnelle - chaque Lambda peut être mis en correspondance avec un type donné via une interface fonctionnelle spécifique. Par conséquent, une expression lambda peut être utilisée n'importe où qui correspond à son type cible. L'expression lambda doit avoir les mêmes types de paramètres que la description de la fonction abstraite de l'interface fonctionnelle. Son type de retour doit également être compatible avec le type de retour de la fonction abstraite. et ça doit l'être. Les exceptions qui peuvent être levées sont également limitées à la portée de la description de la fonction.

Ensuite, regardons un exemple d'interface fonctionnelle personnalisée :

  @FunctionalInterface
  interface Converter<F, T>{

      T convert(F from);

}

Utilisez d'abord l'interface de manière traditionnelle :

  Converter<String ,Integer> converter=new Converter<String, Integer>() {
            @Override
            public Integer convert(String from) {
                return Integer.valueOf(from);
            }
        };

       Integer result = converter.convert("200");
        System.out.println(result);

Évidemment, il n'y a pas problème avec cela. Ensuite, l'étape suivante est lorsque Lambda entre en scène. Utilisez Lambda pour implémenter l'interface Converter :

Converter<String ,Integer> converter=(param) -> Integer.valueOf(param);
        Integer result = converter.convert("101");
        System.out.println(result);

Grâce à l'exemple ci-dessus, je pense que vous avez déjà une compréhension simple de l'utilisation de Lambda. . Ci-dessous, nous utilisons un Runnable couramment utilisé pour la démonstration :

Dans le passé, nous pouvions écrire ce type de code :

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello lambda");
            }
        }).start();

Dans certains cas, un grand nombre de classes anonymes le feraient. rendre le code semble désorganisé. Vous pouvez désormais utiliser Lambda pour le rendre concis :

new Thread(() -> System.out.println("hello lambda")).start();

Référence de méthode

La référence de méthode est une manière simplifiée d'écrire une expression Lambda. La méthode référencée est en fait l'implémentation du corps de méthode de l'expression Lambda. Sa structure syntaxique est la suivante :

ObjectRef::methodName

Le côté gauche peut être le nom de la classe ou le nom de l'instance, le milieu est le symbole de référence de la méthode " ::", et le côté droit est le nom de la méthode correspondante. Les références de méthodes sont divisées en trois catégories :

1. Références de méthodes statiques

Dans certains cas, nous pouvons écrire du code comme celui-ci :

public class ReferenceTest {
    public static void main(String[] args) {
        Converter<String ,Integer> converter=new Converter<String, Integer>() {
            @Override
            public Integer convert(String from) {
                return ReferenceTest.String2Int(from);
            }
        };
        converter.convert("120");

    }

    @FunctionalInterface
    interface Converter<F,T>{
        T convert(F from);
    }

    static int String2Int(String from) {
        return Integer.valueOf(from);
    }
}

À l'heure actuelle, utiliser static les références rendront le code plus concis :

 Converter<String, Integer> converter = ReferenceTest::String2Int;
 converter.convert("120");

2. Référence de la méthode d'instance

Nous pouvons également écrire du code comme celui-ci :

public class ReferenceTest {
    public static void main(String[] args) {

        Converter<String, Integer> converter = new Converter<String, Integer>() {
            @Override
            public Integer convert(String from) {
                return new Helper().String2Int(from);
            }
        };
        converter.convert("120");
    }

    @FunctionalInterface
    interface Converter<F, T> {
        T convert(F from);
    }

    static class Helper {
        public int String2Int(String from) {
            return Integer.valueOf(from);
        }
    }
}

Ce sera également plus concis pour utiliser les références de méthode d'instance :

  Helper helper = new Helper();
  Converter<String, Integer> converter = helper::String2Int;
  converter.convert("120");

3. Méthode constructeur Référence

Nous allons maintenant démontrer la référence de la méthode constructeur. Nous définissons d'abord une classe parent Animal :

    class Animal{
        private String name;
        private int age;

        public Animal(String name, int age) {
            this.name = name;
            this.age = age;
        }

       public void behavior(){

        }
    }

Ensuite, nous définissons deux sous-classes d'Animal : Dog, Bird

public class Bird extends Animal {

    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public void behavior() {
        System.out.println("fly");
    }
}

class Dog extends Animal {

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void behavior() {
        System.out.println("run");
    }
}

Ensuite, nous définissons l'interface d'usine :

    interface Factory<T extends Animal> {
        T create(String name, int age);
    }

Ensuite, nous utilisons toujours la méthode traditionnelle pour créer les objets de la classe Dog et de la classe Bird :

        Factory factory=new Factory() {
            @Override
            public Animal create(String name, int age) {
                return new Dog(name,age);
            }
        };
        factory.create("alias", 3);
        factory=new Factory() {
            @Override
            public Animal create(String name, int age) {
                return new Bird(name,age);
            }
        };
        factory.create("smook", 2);

J'ai écrit dix mots juste pour créer deux objets. Pour le code multi-numéros, essayons d'utiliser le constructeur référence :

  Factory<Animal> dogFactory =Dog::new;
  Animal dog = dogFactory.create("alias", 4);

  Factory<Bird> birdFactory = Bird::new;
  Bird bird = birdFactory.create("smook", 3);

De cette façon, le code aura l'air propre et soigné. Lors de la construction d'un objet via Dog::new, la signature de la fonction Factory.create sélectionne le constructeur correspondant.

Domaine Lambda et restrictions d'accès

Le domaine est la portée. Les paramètres de la liste des paramètres dans l'expression Lambda sont valides dans la portée (domaine) de l'expression Lambda. Au sein de l'action Lambda expression, vous pouvez accéder à des variables externes : variables locales, variables de classe et variables statiques, mais les opérations sont limitées à des degrés divers.

访问局部变量

在Lambda表达式外部的局部变量会被JVM隐式的编译成final类型，因此只能访问外而不能修改。

public class ReferenceTest {
    public static void main(String[] args) {

        int n = 3;
        Calculate calculate = param -> {
            //n=10; 编译错误
            return n + param;
        };
        calculate.calculate(10);
    }

    @FunctionalInterface
    interface Calculate {
        int calculate(int value);
    }

}

访问静态变量和成员变量

在Lambda表达式内部，对静态变量和成员变量可读可写。

public class ReferenceTest {
    public int count = 1;
    public static int num = 2;

    public void test() {
        Calculate calculate = param -> {
            num = 10;//修改静态变量
            count = 3;//修改成员变量
            return n + param;
        };
        calculate.calculate(10);
    }

    public static void main(String[] args) {

    }

    @FunctionalInterface
    interface Calculate {
        int calculate(int value);
    }

}

Lambda不能访问函数接口的默认方法

java8增强了接口，其中包括接口可添加default关键词定义的默认方法，这里我们需要注意，Lambda表达式内部不支持访问默认方法。

Lambda实践

在[函数式接口][2]一节中，我们提到java.util.function包中内置许多函数式接口，现在将对常用的函数式接口做说明。

Predicate接口

输入一个参数，并返回一个Boolean值，其中内置许多用于逻辑判断的默认方法:

    @Test
    public void predicateTest() {
        Predicate<String> predicate = (s) -> s.length() > 0;
        boolean test = predicate.test("test");
        System.out.println("字符串长度大于0:" + test);

        test = predicate.test("");
        System.out.println("字符串长度大于0:" + test);

        test = predicate.negate().test("");
        System.out.println("字符串长度小于0:" + test);

        Predicate<Object> pre = Objects::nonNull;
        Object ob = null;
        test = pre.test(ob);
        System.out.println("对象不为空:" + test);
        ob = new Object();
        test = pre.test(ob);
        System.out.println("对象不为空:" + test);
    }

Function接口

接收一个参数，返回单一的结果，默认的方法（andThen）可将多个函数串在一起，形成复合Funtion（有输入，有输出）结果，

    @Test
    public  void functionTest() {
        Function<String, Integer> toInteger = Integer::valueOf;
        //toInteger的执行结果作为第二个backToString的输入
        Function<String, String> backToString = toInteger.andThen(String::valueOf);
        String result = backToString.apply("1234");
        System.out.println(result);

        Function<Integer, Integer> add = (i) -> {
            System.out.println("frist input:" + i);
            return i * 2;
        };
        Function<Integer, Integer> zero = add.andThen((i) -> {
            System.out.println("second input:" + i);
            return i * 0;
        });

        Integer res = zero.apply(8);
        System.out.println(res);
    }

Supplier接口

返回一个给定类型的结果，与Function不同的是，Supplier不需要接受参数(供应者，有输出无输入)

    @Test
    public void supplierTest() {
        Supplier<String> supplier = () -> "special type value";
        String s = supplier.get();
        System.out.println(s);
    }

Consumer接口

代表了在单一的输入参数上需要进行的操作。和Function不同的是，Consumer没有返回值(消费者，有输入，无输出)

    @Test
    public void consumerTest() {
        Consumer<Integer> add5 = (p) -> {
            System.out.println("old value:" + p);
            p = p + 5;
            System.out.println("new value:" + p);
        };
        add5.accept(10);
    }

以上四个接口的用法代表了java.util.function包中四种类型，理解这四个函数式接口之后，其他的接口也就容易理解了，现在我们来做一下简单的总结：

Predicate用来逻辑判断，Function用在有输入有输出的地方，Supplier用在无输入，有输出的地方，而Consumer用在有输入，无输出的地方。你大可通过其名称的含义来获知其使用场景。

Stream

Lambda为java8带了闭包，这一特性在集合操作中尤为重要：java8中支持对集合对象的stream进行函数式操作，此外，stream api也被集成进了collection api，允许对集合对象进行批量操作。

下面我们来认识Stream。

Stream表示数据流，它没有数据结构，本身也不存储元素，其操作也不会改变源Stream，而是生成新Stream.作为一种操作数据的接口，它提供了过滤、排序、映射、规约等多种操作方法，这些方法按照返回类型被分为两类：凡是返回Stream类型的方法，称之为中间方法（中间操作），其余的都是完结方法（完结操作）。完结方法返回一个某种类型的值，而中间方法则返回新的Stream。中间方法的调用通常是链式的，该过程会形成一个管道，当完结方法被调用时会导致立即从管道中消费值，这里我们要记住：Stream的操作尽可能以“延迟”的方式运行，也就是我们常说的“懒操作”，这样有助于减少资源占用，提高性能。对于所有的中间操作（除sorted外）都是运行在延迟模式下。

Stream不但提供了强大的数据操作能力，更重要的是Stream既支持串行也支持并行，并行使得Stream在多核处理器上有着更好的性能。

Stream的使用过程有着固定的模式：

1. 创建Stream

2. 通过中间操作，对原始Stream进行“变化”并生成新的Stream

3. 使用完结操作，生成最终结果
   也就是

创建——>变化——>完结

Stream的创建

对于集合来说，可以通过调用集合的stream()或者parallelStream()来创建，另外这两个方法也在Collection接口中实现了。对于数组来说，可以通过Stream的静态方法of(T … values)来创建，另外，Arrays也提供了有关stream的支持。

除了以上基于集合或者数组来创建Stream,也可以通过Steam.empty()创建空的Stream,或者利用Stream的generate（）来创建无穷的Stream。

下面我们以串行Stream为例，分别说明Stream几种常用的中间方法和完结方法。首先创建一个List集合：

List<String> lists=new ArrayList<String >();
        lists.add("a1");
        lists.add("a2");
        lists.add("b1");
        lists.add("b2");
        lists.add("b3");
        lists.add("o1");

中间方法

过滤器（Filter）

结合Predicate接口，Filter对流对象中的所有元素进行过滤,该操作是一个中间操作，这意味着你可以在操作返回结果的基础上进行其他操作。

    public static void streamFilterTest() {
        lists.stream().filter((s -> s.startsWith("a"))).forEach(System.out::println);

        //等价于以上操作
        Predicate<String> predicate = (s) -> s.startsWith("a");
        lists.stream().filter(predicate).forEach(System.out::println);

        //连续过滤
        Predicate<String> predicate1 = (s -> s.endsWith("1"));
        lists.stream().filter(predicate).filter(predicate1).forEach(System.out::println);
    }

排序（Sorted）

结合Comparator接口，该操作返回一个排序过后的流的视图，原始流的顺序不会改变。通过Comparator来指定排序规则，默认是按照自然顺序排序。

     public static void streamSortedTest() {
        System.out.println("默认Comparator");
        lists.stream().sorted().filter((s -> s.startsWith("a"))).forEach(System.out::println);

        System.out.println("自定义Comparator");
        lists.stream().sorted((p1, p2) -> p2.compareTo(p1)).filter((s -> s.startsWith("a"))).forEach(System.out::println);

    }

映射（Map）

结合Function接口，该操作能将流对象中的每个元素映射为另一种元素，实现元素类型的转换。

    public static void streamMapTest() {
        lists.stream().map(String::toUpperCase).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);

        System.out.println("自定义映射规则");
        Function<String, String> function = (p) -> {
            return p + ".txt";
        };
        lists.stream().map(String::toUpperCase).map(function).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);

    }

在上面简单介绍了三种常用的操作，这三种操作极大简化了集合的处理。接下来，介绍几种完结方法：

完结方法

“变换”过程之后，需要获取结果，即完成操作。下面我们来看相关的操作：

匹配（Match）

用来判断某个predicate是否和流对象相匹配，最终返回Boolean类型结果，例如：

    public static void streamMatchTest() {
        //流对象中只要有一个元素匹配就返回true
        boolean anyStartWithA = lists.stream().anyMatch((s -> s.startsWith("a")));
        System.out.println(anyStartWithA);
        //流对象中每个元素都匹配就返回true
        boolean allStartWithA
                = lists.stream().allMatch((s -> s.startsWith("a")));
        System.out.println(allStartWithA);
    }

收集（Collect）

在对经过变换之后，我们将变换的Stream的元素收集，比如将这些元素存至集合中，此时便可以使用Stream提供的collect方法，例如：

    public static void streamCollectTest() {
        List<String> list = lists.stream().filter((p) -> p.startsWith("a")).sorted().collect(Collectors.toList());
        System.out.println(list);

    }

计数（Count）

类似sql的count，用来统计流中元素的总数，例如：

    public static void streamCountTest() {
        long count = lists.stream().filter((s -> s.startsWith("a"))).count();
        System.out.println(count);
    }

规约（Reduce）

reduce方法允许我们用自己的方式去计算元素或者将一个Stream中的元素以某种规律关联，例如：

    public static void streamReduceTest() {
        Optional<String> optional = lists.stream().sorted().reduce((s1, s2) -> {
            System.out.println(s1 + "|" + s2);
            return s1 + "|" + s2;
        });
    }

执行结果如下：

a1|a2
a1|a2|b1
a1|a2|b1|b2
a1|a2|b1|b2|b3
a1|a2|b1|b2|b3|o1

并行Stream VS 串行Stream

到目前我们已经将常用的中间操作和完结操作介绍完了。当然所有的的示例都是基于串行Stream。接下来介绍重点戏——并行Stream（parallel Stream）。并行Stream基于Fork-join并行分解框架实现，将大数据集合切分为多个小数据结合交给不同的线程去处理，这样在多核处理情况下，性能会得到很大的提高。这和MapReduce的设计理念一致：大任务化小，小任务再分配到不同的机器执行。只不过这里的小任务是交给不同的处理器。

通过parallelStream（）创建并行Stream。为了验证并行Stream是否真的能提高性能，我们执行以下测试代码：

首先创建一个较大的集合：

   List<String> bigLists = new ArrayList<>();
        for (int i = 0; i < 10000000; i++) {
            UUID uuid = UUID.randomUUID();
            bigLists.add(uuid.toString());
        }

测试串行流下排序所用的时间：

    private static void notParallelStreamSortedTest(List<String> bigLists) {
        long startTime = System.nanoTime();
        long count = bigLists.stream().sorted().count();
        long endTime = System.nanoTime();
        long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
        System.out.println(System.out.printf("串行排序: %d ms", millis));

    }

测试并行流下排序所用的时间：

    private static void parallelStreamSortedTest(List<String> bigLists) {
        long startTime = System.nanoTime();
        long count = bigLists.parallelStream().sorted().count();
        long endTime = System.nanoTime();
        long millis = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
        System.out.println(System.out.printf("并行排序: %d ms", millis));

    }

结果如下：

串行排序: 13336 ms
并行排序: 6755 ms

看到这里，我们确实发现性能提高了约么50%，你也可能会想以后都用parallel Stream不久行了么？实则不然，如果你现在还是单核处理器，而数据量又不算很大的情况下，串行流仍然是这种不错的选择。你也会发现在某些情况，串行流的性能反而更好，至于具体的使用，需要你根据实际场景先测试后再决定。

懒操作

上面我们谈到Stream尽可能以延迟的方式运行，这里通过创建一个无穷大的Stream来说明：

首先通过Stream的generate方法来一个自然数序列，然后通过map变换Stream：

 //递增序列
  class NatureSeq implements Supplier<Long> {
        long value = 0;

        @Override
        public Long get() {
            value++;
            return value;
        }
    }

  public  void streamCreateTest() {
        Stream<Long> stream = Stream.generate(new NatureSeq());
        System.out.println("元素个数："+stream.map((param) -> {
            return param;
        }).limit(1000).count());

    }

执行结果为：

元素个数：1000

我们发现开始时对这个无穷大的Stream做任何中间操作（如：filter,map等，但sorted不行）都是可以的，也就是对Stream进行中间操作并生存一个新的Stream的过程并非立刻生效的（不然此例中的map操作会永远的运行下去，被阻塞住），当遇到完结方法时stream才开始计算。通过limit()方法，把这个无穷的Stream转为有穷的Stream。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!