Tutorial zum Einstieg in Java Lambda-javaLernprogramm-php.cn

LambdaEinführung

Lambda wird als grundlegender Bestandteil der funktionalen Programmierung seit langem häufig in anderen Programmiersprachen (wie Scala) verwendet, hat sich jedoch weiter weiterentwickelt Langsam wurde Lambda bis Java 8 nicht unterstützt.

Ignorieren Sie die mathematischen Definitionen und lernen Sie Lambda direkt kennen. Lambda-Ausdrücke sind im Wesentlichen anonyme Methoden, und ihre zugrunde liegende Implementierung erfolgt über die invokedynamic-Anweisung zum Generieren anonymer Klassen. Es bietet eine einfachere Syntax und einen einfacheren Schreibstil, sodass Sie funktionale Schnittstellen durch Ausdrücke ersetzen können. Nach Meinung einiger Leute kann Lambda Ihren Code prägnanter machen, und Sie müssen ihn überhaupt nicht verwenden. Diese Ansicht ist natürlich in Ordnung, aber das Wichtigste ist, dass Lambda Abschlüsse mit sich bringt Java. Dank der Unterstützung von Sammlungen durch Lamdba wird die Leistung der Sammlungsdurchquerung durch Lambda unter Multi-Core-Prozessorbedingungen erheblich verbessert. Darüber hinaus können wir Sammlungen im Datenfluss verarbeiten – was sehr attraktiv ist.

Lambda-Syntax

Die Syntax von Lambda ist äußerst einfach und ähnelt der folgenden Struktur:

(parameters) -> expression

Nach dem Login kopieren

oder

(parameters) -> { statements; }

Nach dem Login kopieren

Lambda-Ausdruck besteht aus drei TeilenGruppe in:

Parameter: Ähnlich wie die formale Parameterliste in einer Methode sind die Parameter hier Parameter in der Funktion Schnittstelle. Die Parametertypen hier können explizit deklariert oder nicht deklariert und von der JVM implizit abgeleitet werden. Darüber hinaus können die Klammern weggelassen werden, wenn nur ein abgeleiteter Typ vorhanden ist.
->: kann als „verwendet für“ verstanden werden
Methodenkörper: Es kann ein Ausdruck oder ein Codeblock sein und ist die Implementierung der Methode in der Funktionsschnittstelle. Ein Codeblock kann einen Wert oder nichts zurückgeben. Der Codeblock entspricht hier dem Methodenkörper der Methode. Wenn es sich um einen Ausdruck handelt, kann er auch einen Wert oder nichts zurückgeben.

Wir veranschaulichen dies anhand der folgenden Beispiele:

//示例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

Nach dem Login kopieren

Wo wird Lambda verwendet?

In [Funktionsschnittstelle][1] Das wissen wir Der Zieltyp eines Lambda-Ausdrucks ist eine funktionale Schnittstelle – jedes Lambda kann über eine bestimmte funktionale Schnittstelle einem bestimmten Typ zugeordnet werden. Daher kann ein Lambda-Ausdruck überall dort verwendet werden, wo er mit seinem Zieltyp übereinstimmt. Der Lambda-Ausdruck muss dieselben Parametertypen haben wie die abstrakte Funktionsbeschreibung der funktionalen Schnittstelle. Sein Rückgabetyp muss auch mit dem Rückgabetyp der abstrakten Funktion kompatibel sein. und es muss sein Die Ausnahmen, die ausgelöst werden können, sind auch auf den Beschreibungsbereich der Funktion beschränkt.

Als nächstes schauen wir uns ein Beispiel einer benutzerdefinierten Funktionsschnittstelle an:

  @FunctionalInterface
  interface Converter<F, T>{

      T convert(F from);

}

Nach dem Login kopieren

Verwenden Sie die Schnittstelle zunächst auf herkömmliche Weise:

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

Nach dem Login kopieren

Offensichtlich gibt es keine Problem damit. Dann kommt der nächste Schritt, wenn Lambda auf die Bühne kommt:

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

Nach dem Login kopieren

Durch das obige Beispiel haben Sie meiner Meinung nach bereits ein einfaches Verständnis für die Verwendung von Lambda . Unten verwenden wir ein häufig verwendetes Runnable zur Demonstration:

In der Vergangenheit haben wir möglicherweise diese Art von Code geschrieben:

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

Nach dem Login kopieren

In einigen Fällen war dies bei einer großen Anzahl anonymer Klassen der Fall Machen Sie den Code unorganisiert. Jetzt können Sie Lambda verwenden, um es prägnant zu gestalten:

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

Nach dem Login kopieren

Methodenreferenz

Methodenreferenz ist eine vereinfachte Art, Lambda-Ausdrücke zu schreiben. Die referenzierte Methode ist eigentlich die Implementierung des Methodenkörpers des Lambda-Ausdrucks. Ihre Syntaxstruktur ist:

ObjectRef::methodName

Nach dem Login kopieren

Die linke Seite kann der Klassenname oder der Instanzname sein, die Mitte ist das Methodenreferenzsymbol. ::“, und die rechte Seite ist Der entsprechende Methodenname. Methodenreferenzen sind in drei Kategorien unterteilt:

1. Statische Methodenreferenzen

In einigen Fällen schreiben wir möglicherweise Code wie diesen:

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

Nach dem Login kopieren

Zu diesem Zeitpunkt verwenden wir statische Methoden Referenzen machen den Code prägnanter:

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

Nach dem Login kopieren

2. Instanzmethodenreferenz

Wir können auch Code wie diesen schreiben:

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

Nach dem Login kopieren

Es wird auch mehr sein Kurzbeschreibung der Verwendung von Instanzmethodenreferenzen:

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

Nach dem Login kopieren

3. Konstruktormethode Referenz

Jetzt demonstrieren wir die Referenz der Konstruktormethode. Zuerst definieren wir eine übergeordnete Klasse Animal:

    class Animal{
        private String name;
        private int age;

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

       public void behavior(){

        }
    }

Nach dem Login kopieren

Als nächstes definieren wir zwei Unterklassen von 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");
    }
}

Nach dem Login kopieren

Dann definieren wir die Factory-Schnittstelle:

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

Nach dem Login kopieren

Als nächstes verwenden wir immer noch die traditionelle Methode, um die

Objekte der Dog-Klasse und der Bird-Klasse zu erstellen:

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

Nach dem Login kopieren

Ich habe zehn Wörter geschrieben, nur um zwei Objekte zu erstellen. Für mehrstelligen Code versuchen wir es mit der Referenz

Konstruktor :

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

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

Nach dem Login kopieren

Auf diese Weise sieht der Code sauber und ordentlich aus. Beim Erstellen eines Objekts über Dog::new wählt die Signatur der Factory.create-Funktion den entsprechenden Konstruktor aus.

Lambdas Domäne und Zugriffsbeschränkungen

Die Domäne ist der Bereich. Die Parameter in der Parameterliste im Lambda-Ausdruck sind innerhalb des Bereichs (Domäne) des Lambda-Ausdrucks gültig. Innerhalb des Aktions-Lambda-Ausdrucks können Sie auf externe

-Variablen zugreifen: lokale Variablen, Klassenvariablen und statische Variablen, die Operationen sind jedoch in unterschiedlichem Maße eingeschränkt.

访问局部变量

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

}

Nach dem Login kopieren

访问静态变量和成员变量

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

}

Nach dem Login kopieren

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

Nach dem Login kopieren

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

Nach dem Login kopieren

Supplier接口

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

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

Nach dem Login kopieren

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

Nach dem Login kopieren

以上四个接口的用法代表了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的使用过程有着固定的模式：

创建Stream
通过中间操作，对原始Stream进行“变化”并生成新的Stream
使用完结操作，生成最终结果
也就是

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

Nach dem Login kopieren

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

Nach dem Login kopieren

中间方法

过滤器（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);
    }

Nach dem Login kopieren

排序（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);

    }

Nach dem Login kopieren

映射（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);

    }

Nach dem Login kopieren

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

完结方法

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

匹配（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);
    }

Nach dem Login kopieren

收集（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);

    }

Nach dem Login kopieren

计数（Count）

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

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

Nach dem Login kopieren

规约（Reduce）

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

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

Nach dem Login kopieren

执行结果如下：

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

Nach dem Login kopieren

并行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());
        }

Nach dem Login kopieren

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

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

    }

Nach dem Login kopieren

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

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

    }

Nach dem Login kopieren

结果如下：

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

Nach dem Login kopieren

看到这里，我们确实发现性能提高了约么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());

    }

Nach dem Login kopieren

执行结果为：

元素个数：1000

Nach dem Login kopieren

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

Das obige ist der detaillierte Inhalt vonTutorial zum Einstieg in Java Lambda. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!