Java의 람다 표현식을 사용한 빠른 시작

Lambda 소개

Lambda 표현식은 Java SE 8의 중요한 새로운 기능입니다. 람다 표현식을 사용하면 기능 인터페이스를 표현식으로 바꿀 수 있습니다. 람다 식은 메서드와 마찬가지로 일반 매개 변수 목록과 이러한 매개 변수를 사용하는 본문(식 또는 코드 블록일 수 있는 본문)을 제공합니다.

Lambda 표현식도 컬렉션 라이브러리를 향상시킵니다. Java SE 8에는 컬렉션 데이터에 대한 일괄 작업을 위해 java.util.function 패키지와 java.util.stream 패키지라는 두 가지 패키지가 추가되었습니다. 스트림은 반복자와 비슷하지만 추가 기능이 많이 있습니다. 전반적으로 람다 표현식과 스트림은 제네릭과 주석이 추가된 이후 Java 언어에 대한 가장 큰 변화입니다.

Lambda 표현식은 기본적으로 익명 메서드이며 해당 기본 메서드는 Invokedynamic 명령을 통해 익명 클래스를 생성하여 구현됩니다. 이는 더 간단한 구문과 작성 스타일을 제공하므로 기능적 인터페이스를 표현식으로 대체할 수 있습니다. 어떤 사람들은 Lambda가 코드를 더 간결하게 만들 수 있고 전혀 피할 수 있다고 생각합니다. 물론 이러한 관점은 괜찮지만 중요한 것은 Lambda가 Java를 폐쇄한다는 것입니다. Lamdba의 컬렉션 지원 덕분에 멀티 코어 프로세서 조건에서 Lambda를 통한 컬렉션 순회 성능이 크게 향상되었습니다. 또한 데이터 흐름 방식으로 컬렉션을 처리할 수 있다는 점은 매우 매력적입니다.

Lambda 구문

Lambda의 구문은 매우 간단하며 다음 구조와 유사합니다.

(parameters) -> expression

또는

(parameters) -> { statements; }

람다 표현식은 세 부분으로 구성됩니다.

1. 매개변수: 메소드의 형식 매개변수 목록과 유사하게 여기의 매개변수는 기능적 인터페이스의 매개변수입니다. 여기서 매개변수 유형은 명시적으로 선언되거나 선언되지 않고 JVM에 의해 암시적으로 추론될 수 있습니다. 또한, 추론된 유형이 하나만 있는 경우에는 괄호를 생략할 수 있습니다.

2. ->: "사용하다"라는 의미로 이해 가능

3. 메소드 본문: 표현식 또는 코드 블록일 수 있으며, 또는 함수 인터페이스의 메소드 구현입니다. 코드 블록은 값을 반환하거나 아무것도 반환하지 않을 수 있습니다. 여기서 코드 블록은 메서드의 메서드 본문과 동일합니다. 표현식인 경우 값을 반환하거나 아무것도 반환하지 않을 수도 있습니다.

다음 예를 사용하여 설명합니다.

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

Lambda는 어디에 사용됩니까?][1] 우리는 다음을 알고 있습니다. Lambda 표현식의 대상 유형은 기능적 인터페이스입니다. 각 Lambda는 특정 기능적 인터페이스를 통해 특정 유형과 일치할 수 있습니다. 따라서 람다 표현식은 대상 유형과 일치하는 모든 위치에서 사용할 수 있습니다. 람다 표현식은 기능적 인터페이스의 추상 함수 설명과 동일한 매개변수 유형을 가져야 하며, 해당 반환 유형도 추상 함수의 반환 유형과 호환되어야 합니다. 발생할 수 있는 예외도 함수의 설명 범위로 제한됩니다.

다음으로 사용자 정의 기능 인터페이스의 예를 살펴보겠습니다.

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

먼저 기존 방식으로 인터페이스를 사용합니다.

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

분명히 문제가 없으므로 다음 단계는 Lambda를 사용하여 Converter 인터페이스를 구현하는 것입니다.

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

위의 예를 보면 아래에서는 일반적으로 사용되는 Runnable을 사용하여 설명합니다.

과거에는 다음과 같은 코드를 작성했을 수도 있습니다.

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

어떤 경우에는 익명 클래스가 너무 많아 코드가 복잡해 보일 수 있습니다. 이제 Lambda를 사용하여 간결하게 만들 수 있습니다.

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

메서드 참조

메서드 참조는 Lambda 표현식을 작성하는 단순화된 방법입니다. 참조된 메서드는 실제로 Lambda 표현식의 메서드 본문을 구현한 것입니다. 구문 구조는 다음과 같습니다.

ObjectRef::methodName

왼쪽은 클래스 이름 또는 인스턴스 이름일 수 있으며 가운데는 메소드 참조 기호 "::", 오른쪽은 해당 메소드 이름입니다.

메서드 참조는 세 가지 범주로 나뉩니다.

1. 정적 메서드 참조

어떤 경우에는 다음과 같은 코드를 작성할 수 있습니다. 🎜>

이때 정적 참조를 사용하면 코드가 더 간결해집니다.

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

2. 인스턴스 메소드

을 인용하면 다음과 같은 코드를 작성할 수도 있습니다.

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

생성자 메서드 참조

이제 생성자 메서드 참조를 보여드리겠습니다. 먼저 상위 클래스 Animal을 정의합니다:

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

다음으로 Animal의 두 하위 클래스인 Dog, Bird

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

<를 정의합니다. 🎜>그런 다음 팩토리 인터페이스를 정의합니다.

class Animal{
  private String name;
  private int age;
 
  public Animal(String name, int age) {
    this.name = name;
    this.age = age;
  }
 
  public void behavior(){
 
  }
}

다음으로 전통적인 방법을 사용하여 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");
  }
}

두 개의 객체를 생성하기 위해 10개 이상의 코드를 작성했습니다. 이제 생성자 참조를 사용해 보겠습니다.

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

이렇게 하면 코드가 깨끗하고 깔끔하게 보일 것입니다. Dog::new를 통해 객체를 생성할 때 Factory.create 함수의 시그니처는 해당 생성자를 선택합니다.

Lambda의 도메인 및 접근 제한

域即作用域，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中文网！