Schnellstart mit Lambda-Ausdrücken in Java

Einführung in Lambda

Lambda-Ausdrücke sind eine wichtige neue Funktion in Java SE 8. Mit Lambda-Ausdrücken können Sie funktionale Schnittstellen durch Ausdrücke ersetzen. Ein Lambda-Ausdruck ist wie eine Methode. Er stellt eine normale Parameterliste und einen Körper (Körper, der ein Ausdruck oder ein Codeblock sein kann) bereit, der diese Parameter verwendet.

Lambda-Ausdrücke erweitern auch die Sammlungsbibliothek. Java SE 8 fügt zwei Pakete für Batch-Vorgänge für Sammlungsdaten hinzu: das Paket java.util.function und das Paket java.util.stream. Ein Stream ist wie ein Iterator, verfügt jedoch über viele zusätzliche Funktionen. Insgesamt sind Lambda-Ausdrücke und -Streams die größten Änderungen an der Java-Sprache seit der Hinzufügung von Generika und Anmerkungen.

Der Lambda-Ausdruck ist im Wesentlichen eine anonyme Methode, und die zugrunde liegende Methode wird durch Generieren einer anonymen Klasse über die invokedynamic-Anweisung implementiert. 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 kann überhaupt vermieden werden. Diese Ansicht ist natürlich in Ordnung, aber das Wichtigste ist, dass Lambda Java zum Abschluss bringt. 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

oder

(parameters) -> { statements; }

Der Lambda-Ausdruck besteht aus drei Teilen:

1. Parameter: Ähnlich wie die formale Parameterliste in einer Methode sind die Parameter hier Parameter in der Funktionsschnittstelle. 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.

2. ->: Kann als „zu verwenden für“ verstanden werden

3. Methodenkörper: Es kann ein Ausdruck oder ein Codeblock sein. oder eine Funktion Die Implementierung der Methoden in der Schnittstelle. 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 verwenden die folgenden Beispiele zur Veranschaulichung:

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

Wo wird Lambda in [Funktionsschnittstelle] verwendet? ] wissen wir, dass der Zieltyp eines Lambda-Ausdrucks eine funktionale Schnittstelle ist – 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 funktionalen Schnittstelle an:

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

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

Natürlich gibt es kein Problem, dann kommt der nächste Schritt, wenn Lambda auf die Bühne kommt. Verwenden Sie Lambda, um die Converter-Schnittstelle zu implementieren:

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

By the Ich denke, Sie haben zum Beispiel bereits ein einfaches Verständnis für die Verwendung von Lambda. Im Folgenden verwenden wir ein häufig verwendetes Runnable als 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();

In manchen Fällen kann eine große Anzahl anonymer Klassen dazu führen, dass der Code unübersichtlich aussieht. Jetzt können Sie Lambda verwenden, um es prägnant zu gestalten:

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

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

Die linke Seite kann der Klassenname oder der Instanzname sein Die Mitte ist das Methodenreferenzsymbol. „:“, 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);
  }
}

Wenn Sie zu diesem Zeitpunkt statische Referenzen verwenden, wird der Code prägnanter:

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

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

In ähnlicher Weise erscheint die Verwendung einer Instanzmethodenreferenz prägnanter:

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

3. Konstruktormethodenreferenz

Jetzt demonstrieren wir die Konstruktormethodenreferenz. 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(){
 
  }
}

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

Dann definieren wir die Fabrikschnittstelle:

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

Als nächstes verwenden wir immer noch die traditionelle Methode, um Objekte von Dog zu erstellen Klasse und Bird-Klasse:

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

Ich habe mehr als zehn Codes geschrieben, nur um zwei Objekte zu erstellen. Versuchen Sie es mit:

Factory<Animal> dogFactory =Dog::new;
Animal dog = dogFactory.create("alias", 4);
 
Factory<Bird> birdFactory = Bird::new;
Bird bird = birdFactory.create("smook", 3);

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

域即作用域，Lambda表达式中的参数列表中的参数在该Lambda表达式范围内（域）有效。在作用Lambda表达式内，可以访问外部的变量：局部变量、类变量和静态变量，但操作受限程度不一。

访问局部变量

在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。

总结

以上就是Java Lambda快速入门详解的全部内容，看完本文后大家是不是对Java Lambda有了更深的了解，希望本文对大家学习Java Lambda能有所帮助。

更多快速入门Java中的Lambda表达式相关文章请关注PHP中文网！