Java의 람다 표현식에 대해 인기가 있습니다. 예제와 작업이 포함되어 있습니다. 1 부

이 글은 누구를 위한 글인가요?

• 이미 Java Core를 잘 알고 있다고 생각하지만 Java의 람다 표현식에 대해서는 전혀 모르는 사람들을 위한 것입니다. 아니면 이미 람다에 대해 들어봤지만 자세한 내용은 없을 수도 있습니다.
• 람다 표현식을 어느 정도 이해하고 있지만 여전히 이를 사용하는 것이 두렵고 익숙하지 않은 사람들을 위한 것입니다.

이러한 범주 중 하나에 속하지 않는다면 이 기사가 지루하고 부정확하며 일반적으로 "멋지지 않다"고 생각할 수도 있습니다. 이 경우에는 그냥 넘어가시거나, 해당 주제에 대해 잘 알고 계시다면 댓글에서 기사를 개선하거나 보완할 수 있는 방법을 제안해 주세요. 이 자료는 학문적 가치를 주장하지 않으며 참신함은 말할 것도 없습니다. 오히려 그 반대로, 복잡한 것(일부에게는)을 가능한 한 간단하게 설명하려고 노력할 것입니다. 스트림 API에 대해 설명해달라는 요청에 영감을 받아 글을 쓰게 되었습니다. 나는 그것에 대해 생각했고 람다 표현을 이해하지 않으면 "스트림"에 대한 나의 예 중 일부를 이해할 수 없을 것이라고 결정했습니다. 그럼 람다부터 시작해 보겠습니다. 이 기사를 이해하려면 어떤 지식이 필요합니까?

1. 객체지향 프로그래밍(이하 OOP)에 대한 이해, 즉:
• 클래스와 객체가 무엇인지, 이들 사이의 차이점이 무엇인지에 대한 지식
• 인터페이스가 무엇인지, 클래스와 어떻게 다른지, 인터페이스(인터페이스와 클래스) 사이의 연결은 무엇인지에 대한 지식
• 메소드가 무엇인지, 어떻게 호출하는지, 추상 메소드(또는 구현이 없는 메소드)가 무엇인지, 메소드의 매개변수/인수가 무엇인지, 거기에 전달하는 방법에 대한 지식
• 액세스 수정자, 정적 메서드/변수, 최종 메서드/변수;
• 상속(클래스, 인터페이스, 인터페이스의 다중 상속).
2. Java Core에 대한 지식: 제네릭, 컬렉션(목록), 스레드.

자, 시작해 보겠습니다.

약간의 역사

람다 표현식은 함수형 프로그래밍과 수학에서 Java로 왔습니다. 20 세기 중반 미국의 특정 Alonzo Church는 수학과 모든 종류의 추상화를 매우 좋아하는 Princeton University에서 일했습니다. 람다 미적분학을 생각해낸 사람은 알론조 처치(Alonzo Church)였습니다. 람다 미적분학은 처음에는 프로그래밍과는 아무런 관련이 없는 추상적인 아이디어 집합이었습니다. 동시에 앨런 튜링(Alan Turing)과 존 폰 노이만(John von Neumann)과 같은 수학자들도 같은 프린스턴 대학교에서 근무했습니다. 모든 것이 하나로 합쳐졌습니다. Church는 람다 미적분학 시스템을 생각해 냈고 Turing은 현재 "Turing machine"으로 알려진 추상 컴퓨팅 기계를 개발했습니다. 폰 노이만은 현대 컴퓨터의 기초를 형성한 컴퓨터 아키텍처 다이어그램을 제안했습니다(현재는 "폰 노이만 아키텍처"라고 함). 당시 Alonzo Church의 아이디어는 동료의 작업만큼 명성을 얻지 못했습니다 ( "순수"수학 분야 제외). 그러나 조금 후에 특정 John McCarthy (또한 이야기 ​​당시 프린스턴 대학을 졸업했으며 매사추세츠 공과 대학의 직원)가 Church의 아이디어에 관심을 갖게되었습니다. 이를 바탕으로 1958년에 그는 최초의 함수형 프로그래밍 언어인 Lisp를 만들었습니다. 그리고 58년 후, 함수형 프로그래밍의 아이디어가 8번째로 자바에 유출되었습니다. 70년도 채 지나지 않았습니다... 사실 수학적 아이디어를 실제로 적용하는 데에는 이것이 가장 긴 시간이 아닙니다.

본질

람다 표현식은 그러한 함수입니다. 이것을 Java의 일반 메소드로 생각할 수 있지만 유일한 차이점은 다른 메소드에 인수로 전달될 수 있다는 것입니다. 네, 숫자, 문자열, 고양이를 메소드에 전달할 뿐만 아니라 다른 메소드에도 전달하는 것이 가능해졌습니다! 언제 이것이 필요할 수 있습니까? 예를 들어 콜백을 전달하려는 경우입니다. 우리가 전달하는 다른 메서드를 호출할 수 있으려면 호출하는 메서드가 필요합니다. 즉, 어떤 경우에는 하나의 콜백을 전송하고 다른 경우에는 다른 콜백을 전송할 수 있는 기회를 갖게 됩니다. 그리고 콜백을 받아들이는 메서드가 이를 호출합니다. 간단한 예는 정렬입니다. 다음과 같은 까다로운 정렬을 작성한다고 가정해 보겠습니다.

public void mySuperSort() {
    // ... do something here
    if(compare(obj1, obj2) > 0)
    // ... and here we do something
}

여기서 if우리는 메서드를 호출하고 compare()비교하는 두 개체를 전달하고 이 개체 중 어느 것이 "더 큰지" 알아내려고 합니다. "더 작은" 것 앞에 "더 많은" 것을 놓을 것입니다. 오름차순뿐만 아니라 내림차순으로도 정렬할 수 있는 보편적인 방법을 작성하고 있기 때문에 "more"를 따옴표로 묶었습니다. (이 경우 "more"는 본질적으로 더 작은 개체가 되고 그 반대의 경우도 마찬가지입니다.) . 정확히 정렬 방법에 대한 규칙을 설정하려면 어떻게든 이를 mySuperSort(). 이 경우, 메소드가 호출되는 동안 어떻게든 메소드를 "제어"할 수 있습니다. 물론 오름차순과 내림차순으로 정렬하는 mySuperSortAsc()두 가지 별도의 방법을 작성할 수 있습니다. mySuperSortDesc()또는 메서드 내부에 일부 매개변수를 전달합니다(예: booleanif true, 오름차순 정렬, if false내림차순 정렬). 하지만 간단한 구조가 아니라 예를 들어 문자열 배열 목록을 정렬하려면 어떻게 해야 할까요? 우리 메소드는 mySuperSort()이러한 문자열 배열을 정렬하는 방법을 어떻게 알 수 있습니까? 사이즈에 맞춰? 총 단어 길이로? 아마도 배열의 첫 번째 행에 따라 알파벳순으로 될까요? 그러나 어떤 경우에는 배열의 크기에 따라 배열 목록을 정렬해야 하고, 다른 경우에는 배열에 있는 단어의 전체 길이에 따라 정렬해야 한다면 어떻게 될까요? 비교기에 대해 이미 들어보셨을 것입니다. 그러한 경우에는 정렬 방법에 비교기 개체를 전달하면 정렬 규칙을 설명하기만 하면 됩니다. 표준 방법은 과 sort()동일한 원리로 구현되므로 mySuperSort()예제에서는 표준 방법을 사용하겠습니다 sort().

String[] array1 = {"Mother", "soap", "frame"};
String[] array2 = {"I", "Very", "I love", "java"};
String[] array3 = {"world", "work", "May"};

List<String[]> arrays = new ArrayList<>();
arrays.add(array1);
arrays.add(array2);
arrays.add(array3);

Comparator<String[]> sortByLength = new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1.length - o2.length;
    }
};

Comparator<String[]> sortByWordsLength = new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        int length1 = 0;
        int length2 = 0;
        for (String s : o1) {
            length1 += s.length();
        }
        for (String s : o2) {
            length2 += s.length();
        }
        return length1 - length2;
    }
};

arrays.sort(sortByLength);

결과:

1. 엄마가 액자를 씻어서
2. 평화 노동은
3. 나는 자바를 정말 좋아한다.

여기서 배열은 각 배열의 단어 수에 따라 정렬됩니다. 단어 수가 적은 배열은 "더 작은" 것으로 간주됩니다. 그렇기 때문에 처음에 나옵니다. 단어가 더 많은 단어는 "더 많은" 것으로 간주되어 마지막에 끝납니다. sort()메소드에 다른 비교기를 전달 하면 (sortByWordsLength)결과 는 달라집니다.

1. 평화 노동은
2. 엄마가 액자를 씻어서
3. 나는 자바를 정말 좋아한다.

이제 배열은 해당 배열 단어의 총 문자 수를 기준으로 정렬됩니다. 첫 번째 경우에는 10개의 문자가 있고, 두 번째에는 12개, 세 번째에는 15개의 문자가 있습니다. 하나의 비교기만 사용하는 경우 별도의 변수를 만들 수 없으며 간단히 익명 클래스의 개체를 바로 생성할 수 있습니다. 메소드를 호출한 시간입니다 sort(). 그렇게:

String[] array1 = {"Mother", "soap", "frame"};
String[] array2 = {"I", "Very", "I love", "java"};
String[] array3 = {"world", "work", "May"};

List<String[]> arrays = new ArrayList<>();
arrays.add(array1);
arrays.add(array2);
arrays.add(array3);

arrays.sort(new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1.length - o2.length;
    }
});

결과는 첫 번째 경우와 동일합니다. 작업 1 . 배열의 단어 수에 따라 오름차순이 아닌 내림차순으로 배열을 정렬하도록 이 예제를 다시 작성하세요. 우리는 이미 이 모든 것을 알고 있습니다. 우리는 객체를 메소드에 전달하는 방법을 알고 있으며, 현재 필요한 것에 따라 이 객체 또는 저 객체를 메소드에 전달할 수 있으며, 그러한 객체를 전달하는 메소드 내부에서 구현을 작성한 메소드가 호출됩니다. . 질문이 생깁니다. 람다 표현이 그것과 어떤 관련이 있습니까? 람다는 정확히 하나의 메서드를 포함하는 객체라고 가정합니다. 메소드 객체와 같습니다. 객체에 래핑된 메서드입니다. 약간 특이한 구문을 가지고 있습니다(그러나 이에 대해서는 나중에 자세히 설명합니다). 이 항목을 다시 살펴보겠습니다.

arrays.sort(new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1.length - o2.length;
    }
});

여기서는 목록을 가져와 arrays해당 메소드를 호출합니다 sort(). 여기서는 하나의 단일 메소드가 있는 비교기 객체를 전달합니다 compare()(이 객체에 유일한 메소드이기 때문에 이름이 무엇인지는 중요하지 않습니다. 놓치지 않을 것입니다). 이 메서드는 다음에 작업할 두 개의 매개변수를 사용합니다. IntelliJ IDEA 에서 작업하는 경우 이 코드를 통해 크게 단축되는 방법을 본 적이 있을 것입니다.

arrays.sort((o1, o2) -> o1.length - o2.length);

이렇게 여섯 줄이 하나의 짧은 줄로 바뀌었습니다. 6줄을 짧게 1줄로 다시 작성했습니다. 뭔가가 사라졌지만 중요한 것은 아무것도 사라지지 않았음을 보장하며 이 코드는 익명 클래스와 정확히 동일하게 작동합니다. 작업 2 . 람다를 사용하여 문제 1에 대한 솔루션을 다시 작성하는 방법을 알아보세요. 최후의 수단으로 IntelliJ IDEA 에 익명 클래스를 람다로 전환하도록 요청하세요.

인터페이스에 대해 이야기해보자

기본적으로 인터페이스는 추상 메서드 목록일 뿐입니다. 클래스를 생성하고 그것이 일종의 인터페이스를 구현할 것이라고 말할 때, 인터페이스에 나열된 메소드의 구현을 클래스에 작성해야 합니다(또는 최후의 수단으로 작성하지 않고 클래스를 추상화해야 합니다). ). 다양한 메서드(예: List동일한 Comparator 또는 Runnable)가 있는 인터페이스가 있고, 메서드가 하나만 있는 인터페이스가 있습니다. 단일 메소드가 전혀 없는 인터페이스(소위 마커 인터페이스, 예를 들어 직렬화 가능)가 있습니다. 메서드가 하나만 있는 인터페이스를 기능적 인터페이스 라고도 합니다 . Java 8에서는 특별한 @FunctionalInterface 주석 으로 표시됩니다 . 람다 식에 사용하기에 적합한 단일 메서드와의 인터페이스입니다. 위에서 말했듯이 람다 표현식은 객체에 래핑된 메서드입니다. 그리고 그러한 객체를 어딘가에 전달할 때 실제로는 이 단일 메서드를 전달합니다. 이 메서드를 무엇이라고 부르는지는 우리에게 중요하지 않습니다. 우리에게 중요한 것은 이 메서드가 사용하는 매개 변수와 실제로 메서드 코드 자체입니다. 람다 표현식은 본질적으로 그렇습니다. 기능적 인터페이스 구현. 하나의 메서드가 있는 인터페이스가 있다는 것은 람다를 사용하여 이러한 익명 클래스를 다시 작성할 수 있음을 의미합니다. 인터페이스에 하나 이상의 메서드가 있는 경우 람다 식이 적합하지 않으며 익명 클래스 또는 일반 클래스를 사용합니다. 이제 람다를 자세히 알아볼 시간입니다. :)

통사론

일반적인 구문은 다음과 같습니다.

(параметры) -> {тело метода}

즉, 괄호 안에는 메소드 매개변수인 "화살표"(연속된 두 문자: 빼기 및 큼)가 있으며, 그 뒤에 메소드의 본문은 항상 그렇듯이 중괄호 안에 있습니다. 매개변수는 메소드를 설명할 때 인터페이스에 지정된 매개변수에 해당합니다. 변수의 유형이 컴파일러에 의해 명확하게 정의될 수 있는 경우(우리의 경우 문자열 배열로 정확하게 유형이 지정되므로 문자열 배열로 작업하고 있다는 것이 확실합니다 List) 변수의 유형은 String[]필요하지 않습니다. 쓰여진다. 예를 들어 Oracle 튜토리얼 에서 자세한 내용을 읽을 수 있습니다 . 이것을 "타겟 타이핑" 이라고 합니다 . 변수에 이름을 지정할 수 있지만 반드시 인터페이스에 지정된 이름일 필요는 없습니다. 매개변수가 없으면 괄호만 사용합니다. 매개변수가 하나만 있는 경우 괄호 없이 변수 이름만 입력합니다. 이제 람다 표현식 자체의 본문에 대해 매개변수를 정리했습니다. 중괄호 안에 일반 메서드처럼 코드를 작성합니다. 전체 코드가 한 줄로만 구성된 경우 (ifs 및 루프와 마찬가지로) 중괄호를 전혀 작성할 필요가 없습니다. 람다가 무언가를 반환하지만 본문이 한 줄로 구성되어 있으면 return작성할 필요가 전혀 없습니다. 하지만 중괄호가 있는 경우 일반적인 방법과 마찬가지로 명시적으로 return.

예

예시 1.

() -> {}

가장 간단한 옵션입니다. 그리고 가장 의미 없는 것입니다. :) 아무것도 하지 않기 때문입니다. 예시 2.

() -> ""

또한 흥미로운 옵션입니다. 아무것도 받아들이지 않고 빈 문자열을 반환합니다( return불필요하므로 생략됨). 동일하지만 다음과 같습니다 return.

() -> {
    return "";
}

예 3. 람다를 사용한 Hello World

() -> System.out.println("Hello world!")

아무것도 받지 않고 아무것도 반환하지 않습니다( 메소드의 반환 유형이 단순히 화면에 비문을 표시하기 때문에 return호출 앞에 넣을 수 없습니다. 인터페이스 구현에 이상적입니다 . 동일한 예가 더 완전합니다. System.out.println()println() — void)Runnable

public class Main {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("Hello world!")).start();
    }
}

또는 다음과 같습니다:

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> System.out.println("Hello world!"));
        t.start();
    }
}

또는 람다 표현식을 유형의 객체로 저장한 Runnable다음 생성자에 전달할 수도 있습니다 thread’а.

public class Main {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("Hello world!");
        Thread t = new Thread(runnable);
        t.start();
    }
}

람다 표현식을 변수에 저장하는 순간을 자세히 살펴보겠습니다. 인터페이스는 Runnable객체에 메소드가 있어야 한다고 알려줍니다 public void run(). 인터페이스에 따르면 run 메소드는 어떤 것도 매개변수로 허용하지 않습니다. 그리고 아무것도 반환하지 않습니다 (void). 따라서 이런 방식으로 작성하면 아무것도 받아들이거나 반환하지 않는 일부 메서드를 사용하여 객체가 생성됩니다. run()이는 인터페이스의 메소드와 매우 일치합니다 Runnable. 이것이 바로 우리가 이 람다 표현식을 와 같은 변수에 넣을 수 있었던 이유입니다 Runnable. 실시예 4

() -> 42

다시 말하지만, 아무것도 허용하지 않고 숫자 42를 반환합니다. 이 인터페이스는 Callable다음과 같은 하나의 메서드만 정의하므로 이 람다 식은 유형의 변수에 배치될 수 있습니다.

V call(),

반환 값의 유형은 어디에 V있습니까(이 경우 int). 따라서 다음과 같은 람다 표현식을 저장할 수 있습니다.

Callable<Integer> c = () -> 42;

예 5. 여러 줄의 람다

() -> {
    String[] helloWorld = {"Hello", "world!"};
    System.out.println(helloWorld[0]);
    System.out.println(helloWorld[1]);
}

다시 말하지만, 이는 매개변수와 반환 유형이 없는 람다 표현식입니다 void( 가 없기 때문입니다 return). 실시예 6

x -> x

여기서는 변수에 무언가를 가져 х와서 반환합니다. 매개변수가 하나만 허용되는 경우 매개변수 주위에 괄호를 작성할 필요가 없습니다. 동일하지만 대괄호를 사용합니다.

(x) -> x

다음은 명시적인 옵션이 있는 옵션입니다 return.

x -> {
    return x;
}

또는 다음과 같이 괄호와 다음을 사용합니다 return.

(x) -> {
    return x;
}

또는 유형을 명시적으로 표시하고 그에 따라 괄호를 사용하여 다음을 수행합니다.

(int x) -> x

실시예 7

x -> ++x

우리는 이를 수락 х하고 반환하지만 그 1이상입니다. 다음과 같이 다시 작성할 수도 있습니다.

x -> x + 1

두 경우 모두 매개변수, 메소드 본문 및 단어 주위에 괄호를 표시하지 않습니다 return. 이는 필요하지 않기 때문입니다. 대괄호와 return이 포함된 옵션은 예제 6에 설명되어 있습니다. 예제 8

(x, y) -> x % y

우리는 일부를 받아들이고 х, у나눗셈의 나머지 부분을 x로 반환합니다 y. 여기에는 매개변수 주위에 괄호가 이미 필요합니다. 매개변수가 하나만 있는 경우에만 선택사항입니다. 유형을 명시적으로 표시하면 다음과 같습니다.

(double x, int y) -> x % y

실시예 9

(Cat cat, String name, int age) -> {
    cat.setName(name);
    cat.setAge(age);
}

이름과 정수 나이가 포함된 문자열인 Cat 개체를 허용합니다. 메서드 자체에서는 전달된 이름과 나이를 Cat에 설정합니다. 변수는 cat참조 유형이므로 람다 식 외부의 Cat 개체가 변경됩니다(내부로 전달된 이름과 나이를 받게 됩니다). 유사한 람다를 사용하는 약간 더 복잡한 버전:

public class Main {
    public static void main(String[] args) {
        // create a cat and print to the screen to make sure it's "blank"
        Cat myCat = new Cat();
        System.out.println(myCat);

        // create lambda
        Settable<Cat> s = (obj, name, age) -> {
            obj.setName(name);
            obj.setAge(age);
        };

        // call the method, to which we pass the cat and the lambda
        changeEntity(myCat, s);
        // display on the screen and see that the state of the cat has changed (has a name and age)
        System.out.println(myCat);
    }

    private static <T extends WithNameAndAge>  void changeEntity(T entity, Settable<T> s) {
        s.set(entity, "Murzik", 3);
    }
}

interface WithNameAndAge {
    void setName(String name);
    void setAge(int age);
}

interface Settable<C extends WithNameAndAge> {
    void set(C entity, String name, int age);
}

class Cat implements WithNameAndAge {
    private String name;
    private int age;

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

결과: Cat{name='null', age=0} Cat{name='Murzik', age=3} 보시다시피 처음에는 Cat 개체의 상태가 하나였지만 람다 식을 사용한 후에는 상태가 변경되었습니다. . 람다 표현식은 제네릭과 잘 작동합니다. Dog예를 들어 을 구현하는 클래스를 생성해야 하는 경우 WithNameAndAge메서드에서 main()람다 식 자체를 전혀 변경하지 않고도 Dog를 사용하여 동일한 작업을 수행할 수 있습니다. 작업 3 . 숫자를 받아서 부울 값을 반환하는 메서드를 사용하여 기능적 인터페이스를 작성하세요. true전달된 숫자가 나머지 없이 13으로 나누어지는 경우 반환하는 람다 식 형식으로 이러한 인터페이스의 구현을 작성합니다 . 작업 4 . 두 개의 문자열을 가져와 동일한 문자열을 반환하는 메서드를 사용하여 기능적 인터페이스를 작성하세요. 가장 긴 문자열을 반환하는 람다 형식으로 이러한 인터페이스의 구현을 작성합니다. 작업 5 . 세 개의 분수( a, b, ) 를 받아들이고 c동일한 분수를 반환하는 메서드를 사용하여 기능적 인터페이스를 작성하세요. 판별식을 반환하는 람다 식 형식으로 이러한 인터페이스의 구현을 작성합니다. 잊어버린 사람은 D = b^2 - 4ac 입니다 . 작업 6 . 작업 5의 기능적 인터페이스를 사용하여 작업 결과를 반환하는 람다 식을 작성합니다 a * b^c. Java의 람다 표현식에 대해 인기가 있습니다. 예제와 작업이 포함되어 있습니다. 2 부.