Java 프로그래밍에서 람다 표현식 사용에 대한 팁

람다 표현식을 사용하는 이유
몇 가지 예를 살펴보겠습니다.

첫 번째 예는 독립 스레드에서 작업을 수행하는 것입니다. 일반적으로 다음과 같이 구현합니다.

class Worker implements Runnable {
  public void run() {
    for (int i = 0; i < 100; i++)
      doWork();
  }
  ...
}
 
Worker w = new Worker();
new Thread(w).start();

두 번째 예는 문자열 비교 방법을 사용자 정의하는 것입니다(문자열 길이를 통해). 일반적으로 다음을 수행합니다.

class LengthComparator implements Comparator<String> {
  public int compare(String first, String second) {
    return Integer.compare(first.length(), second.length());
  }
}
Arrays.sort(strings, new LengthComparator());

아니요, 세 가지 예입니다. JavaFX에서는 버튼에 콜백을 추가합니다.

button.setOnAction(new EventHandler<ActionEvent>() {
  public void handle(ActionEvent event) {
    System.out.println("Thanks for clicking!");
  }
});

이러한 예에는 한 가지 공통점이 있습니다. 즉, 먼저 코드 블록을 정의하고 이를 객체나 메소드에 전달하고, 그런 다음 실행되었습니다. Lambda 테이블
표현식 이전에는 Java가 객체 지향이기 때문에 Java가 코드 블록을 직접 전달할 수 없으므로 코드 블록을 객체로 캡슐화하기 위해 객체를 전달해야
합니다.

람다 표현식의 구문
위 두 번째 예의 LengthComparator는 람다 표현식으로 표현됩니다.

(String first, String second) -> Integer.compare(first.length(),
  second.length());

-> 그 뒤에 식 문 본문이 옵니다.

식 문 본문이 한 줄 이상인 경우 일반 함수와 마찬가지로 {}에 문 본문을 작성합니다.

(String first, String second) -> {
  if (first.length() > second.length()) {
    return 1;
  } else if (first.length() == second.length()) {
    return 0;
  } else {
    return -1;
  }
};

매개변수가 없는 경우에도 ()를 가져와야 합니다. 예를 들어 위의 첫 번째 예는 다음과 같이 표현할 수 있습니다.

() -> {
  for (int i = 0; i < 1000; i ++) {
    doWork();
  }
}

매개변수 유형을 자동으로 지정할 수 있는 경우 컨텍스트에서 추론된 경우 생략 가능:

Comparator<String> comp
  = (first, second) // Same as (String first, String second)
  -> Integer.compare(first.length(), second.length());

매개변수가 하나만 있고 유형을 자동으로 추론할 수 있는 경우 괄호()도 생략할 수 있습니다:

// Instead of (event) -> or (ActionEvent event) ->
eventHandler<ActionEvent> listener =
  event -> System.out.println("Thanks for clicking!");

lambda 표현식의 반환 값 유형은 자동으로 유추되므로 람다 표현식에서 이를 지정할 필요가 없습니다. 일부 조건부 분기에는
반환 값이 있고 다른 분기에는

반환 값이 있습니다. 다음과 같은 반환 값은 허용되지 않습니다.

(x) -> {
  if (x >= 0) {
    return 1;
  }
}

또한 식 람다와 명령문 람다의 차이점은 식 람다에서는 반환을 작성하는 데
가 필요하지 않다는 점입니다. 키워드. Java 런타임은 표현식의 결과를 반환 값으로 반환합니다. while 문 람다

가 {}로 작성한 표현식이며, return 키워드를 사용해야 합니다. 예:

// expression lambda
Comparator<String> comp1 =
  (first, second) -> Integer.compare(first.length(), second.length());
 
// statement lambda
Comparator<String> comp2 = (first, second) ->
  { return Integer.compare(first.length(), second.length());};

함수형 인터페이스
인터페이스에 추상 메서드(추상 메서드)가 하나만 있는 경우
Runnable, Comparator 등 함수형 인터페이스라고 합니다.

Functional Interface 객체가 필요할 때마다 람다 식을 사용할 수 있습니다.

Arrays.sort(words,
  (first, second) -> Integer.compare(first.length(), second.length()));

여기에서 sort()의 두 번째 매개변수에는 Comparator 객체가 필요합니다. Comparator는
입니다. 기능적 인터페이스이므로 객체의 Compare() 메서드

가 호출되면 람다 표현식의 명령문 본문이 실행됩니다. 람다 표현식이 예외를 발생시키는 경우 기능 인터페이스의 해당 추상 메소드는 예외를

발생시켜야 합니다. 그렇지 않으면 예외는 람다 표현식에서 명시적으로 캡처되어야 합니다:

Runnable r = () -> {
  System.out.println("------");
  try {
    Thread.sleep(10);
  } catch (InterruptedException e) {
    // catch exception
  }
};
 
Callable<String> c = () -> {
  System.out.println("--------");
  Thread.sleep(10);
  return "";
};

메서드 참조

람다 식의 매개 변수가 메서드에 매개 변수로 전달되고 해당 실행 효과가 동일한 경우 람다 식
은 다음 두 가지 방법으로 메서드 참조를 사용하여 표현할 수 있습니다.

(x) -> System.out.println(x)
System.out::println

여기서 System.out::println은 Method Reference라고 합니다.

메서드 참조에는 주로 세 가지 형식이 있습니다.

object::instanceMethod

Class::staticMethod

Class::instanceMethod

처음 두 메서드의 경우 해당 람다 식의 매개 변수는 메서드의 매개 변수와 일치합니다. 예:

System.out::println
(x) -> System.out.println(x)
 
Math::pow
(x, y) -> Math.pow(x, y)

세 번째 메서드의 경우 해당 람다 식은 다음과 같습니다. 명령문 본문에서 첫 번째 매개변수는 객체로 사용되고 메서드가 호출되며 다른 매개변수

는 메서드의 매개변수로 사용됩니다. 예:

String::compareToIgnoreCase
(s1, s2) -> s1.compareToIgnoreCase(s2)
1.5 Constructor Reference

생성자 참조 Method Reference와 비슷하지만 특별한 메소드입니다. new는 호출되는 생성자가 컨텍스트에 따라 결정됩니다. 예를 들어

List<String> labels = ...;
Stream<Button> stream = labels.stream().map(Button::new);

Button::new는 (x와 동일합니다. ) -> Button(x), 따라서 호출되는 생성자는 다음과 같습니다. Button(x);

단일 개체를 만드는 것 외에도 다음 두 가지 방법은 동일합니다.

int[]::new
(x) -> new int[x]

변수 범위

lambd 표현식은 다음과 같이 현재 범위에서 사용 가능한 변수를 캡처합니다.

public void repeatMessage(String text, int count) {
  Runnable r = () -> {
    for (int i = 0; i < count; i ++) {
      System.out.println(text);
      Thread.yield();
    }
  };
  new Thread(r).start();
}

그러나 이러한 변수는 불변이어야 하는데, 왜 그렇습니까? 다음 예를 살펴보세요.

int matches = 0;
for (Path p : files)
  new Thread(() -> { if (p has some property) matches++; }).start();
  // Illegal to mutate matches

변경 가능한 변수는 람다 식에서 스레드로부터 안전하지 않기 때문에 이는 내부 클래스의 요구 사항과 일치합니다.

외부적으로만 참조할 수 있습니다.

람다 식의 범위는 중첩된 코드 블록의 범위와 동일하므로 람다 식의 매개변수 이름이나 변수 이름은

지역 변수 충돌과 동일할 수 없습니다. 예:

Path first = Paths.get("/usr/bin");
Comparator<String> comp = (first, second) -> Integer.compare(first.length(),
   second.length()); // Error: Variable first already defined

이 변수가 람다 식에서 참조되는 경우 다음과 같이 람다 식을 만든 메서드의 this 변수입니다.

public class Application() {
  public void doWork() {
    Runnable runner = () -> {
      ...;
      System.out.println(this.toString());
      ...
    };
  }
}

여기서 this.toString()은 Runnable

객체가 아닌 Application 객체의 toString()을 호출합니다.

기본 메서드

인터페이스에는 추상 메서드만 있을 수 있습니다. 기존 인터페이스에 새 메서드가 추가되는 경우 인터페이스의 모든 구현 클래스는 이 메서드를 구현해야 합니다.
기본 메서드 개념은 Java 8에서 도입되었습니다. 인터페이스에 새 기본 메서드를 추가해도 기존 인터페이스 규칙은 삭제되지 않습니다. 인터페이스의 구현 클래스는 기본 메서드를 재정의하거나 직접 상속하도록 선택할 수 있습니다.
아아아아

Java是允许多继承的，如果一个类的父类中定义的方法和接口中定义的default方法完全相同，或者
一个类的两个接口中定义了完全相同的方法， 则如何处理这种冲突呢？处理规则如下：

如果是父类和接口的方法冲突：以父类中的方法为准，接口中的方法被忽略；
如果两个接口中的default方法冲突，则需要重写该方法解决冲突；

Static Method
Java 8之前，接口中只能定义static变量，Java 8开始，接口中可以添加static方法，比如
Comparator接口新增了一系列comparingXXX的static方法，比如：

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T>
  keyExtractor) {
  Objects.requireNonNull(keyExtractor);
  return (Comparator<T> & Serializable)
   (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1),
       keyExtractor.applyAsInt(c2));
}

使用这个static方法，以下两种方式也是等价的：

1、

Arrays.sort(cities, (first, second) -> Integer.compare(first.length(),
  second.length()));

2、

Arrays.sort(cities, Comparator.comparingInt(String::length));

所以，以后我们在设计自己的接口时，不需要再定义单独的工具类（如Collections/Collection)，
在接口中使用static方法就行了。

匿名内部类

在 Java 世界中，匿名内部类 可以实现在应用程序中可能只执行一次的操作。例如，在 Android 应用程序中，一个按钮的点击事件处理。你不需要为了处理一个点击事件单独编写一个独立的类，可以用匿名内部类完成该操作：

Button button = (Button) findViewById(R.id.button1);
button.setOnClickListener(new OnClickListener() {
  
  @Override
  public void onClick(View view) {
    Toast.makeText(MainActivity.this, "Button Clicked", Toast.LENGTH_SHORT).show();
  }
  
});

Lambda 示例

1.Runnable Lambda

来看几个示例， 下面是一个 Runnable 的示例：

public void runnableTest() {
    System.out.println("=== RunnableTest ===");
    // 一个匿名的 Runnable
    Runnable r1 = new Runnable() {
      @Override
      public void run() {
        System.out.println("Hello world one!");
      }
    };
    // Lambda Runnable
    Runnable r2 = () -> System.out.println("Hello world two!");
    // 执行两个 run 函数
    r1.run();
    r2.run();
  }

public void runnableTest() {
  System.out.println("=== RunnableTest ===");
  // 一个匿名的 Runnable
  Runnable r1 = new Runnable() {
    @Override
    public void run() {
      System.out.println("Hello world one!");
    }
  };
 
  // Lambda Runnable
  Runnable r2 = () -> System.out.println("Hello world two!");
 
  // 执行两个 run 函数
  r1.run();
  r2.run();
}

   

这两个实现方式都没有参数也没有返回值。Runnable lambda 表达式使用代码块的方式把五行代码简化为一个语句。
2.Comparator Lambda

在 Java 中，Comparator 接口用来排序集合。在下面的示例中一个 ArrayList 中包含了一些 Person 对象， 并依据 Person 对象的 surName 来排序。下面是 Person 类中包含的 fields:

public class Person {
  private String givenName;
  private String surName;
  private int age;
  private Gender gender;
  private String eMail;
  private String phone;
  private String address;
}

public class Person {
  private String givenName;
  private String surName;
  private int age;
  private Gender gender;
  private String eMail;
  private String phone;
  private String address;
}

下面是分别用匿名内部类和 Lambda 表达式实现 Comparator 接口的方式：

 
public class ComparatorTest {
  public static void main(String[] args) {
    List<Person> personList = Person.createShortList();
    // 使用内部类实现排序
    Collections.sort(personList, new Comparator<Person>() {
      public int compare(Person p1, Person p2) {
        return p1.getSurName().compareTo(p2.getSurName());
      }
    });
    System.out.println("=== Sorted Asc SurName ===");
    for (Person p : personList) {
      p.printName();
    }
    // 使用 Lambda 表达式实现
    // 升序排列
    System.out.println("=== Sorted Asc SurName ===");
    Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));
    for (Person p : personList) {
      p.printName();
    }
    // 降序排列
    System.out.println("=== Sorted Desc SurName ===");
    Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
    for (Person p : personList) {
      p.printName();
    }
  }
}

public class ComparatorTest {
  public static void main(String[] args) {
    List<Person> personList = Person.createShortList();
  
    // 使用内部类实现排序
    Collections.sort(personList, new Comparator<Person>() {
      public int compare(Person p1, Person p2) {
        return p1.getSurName().compareTo(p2.getSurName());
      }
    });
  
    System.out.println("=== Sorted Asc SurName ===");
    for (Person p : personList) {
      p.printName();
    }
  
    // 使用 Lambda 表达式实现
  
    // 升序排列
    System.out.println("=== Sorted Asc SurName ===");
    Collections.sort(personList, (Person p1, Person p2) -> p1.getSurName().compareTo(p2.getSurName()));
    for (Person p : personList) {
      p.printName();
    }
  
    // 降序排列
    System.out.println("=== Sorted Desc SurName ===");
    Collections.sort(personList, (p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));
    for (Person p : personList) {
      p.printName();
    }
  }
}

   

可以看到 匿名内部类可以通过 Lambda 表达式实现。注意 第一个 Lambda 表达式定义了参数的类型为 Person；而第二个 Lambda 表达式省略了该类型定义。Lambda 表达式支持类型推倒，如果通过上下文可以推倒出所需要的类型，则可以省略类型定义。这里由于 我们把 Lambda 表达式用在一个使用泛型定义的 Comparator 地方，编译器可以推倒出这两个参数类型为 Person 。

更多Java编程中使用lambda表达式的奇技淫巧相关文章请关注PHP中文网！