Java에서 Lambda 표현식을 사용하는 방법은 무엇입니까?

람다 표현식 소개

• 람다 표현식의 본질은 컴파일러가 추론하는 "구문 설탕"일 뿐이며 이를 일반 코드로 변환하고 래핑하는 데 도움이 되므로 더 적은 코드를 사용하여 원하는 결과를 얻을 수 있습니다. 동일한 기능.

• Lambda 표현식은 Java SE 8의 중요한 새로운 기능입니다.

Lambda 및 익명 내부 클래스

Lamda 표현식은 SAM(SingleAbstractMethod, 추상 메소드를 포함하는 인터페이스) 환경에 적용되는 단순화된 정의 형식을 나타냅니다.

익명 내부 클래스에 비해 Lambda의 장점

간단함(자세한 내용은 아래 "기능적 인터페이스" 참조)

익명 내부 클래스에 비해 Lamda의 단점

• Lamda의 해당 인터페이스에는 메서드가 하나만 있을 수 있습니다.

• 익명 내부 클래스에 해당하는 인터페이스는 여러 메서드를 가질 수 있습니다

인터페이스 요구 사항

1. Lambda에서는 인터페이스에서 구현해야 하는 메서드가 하나만 있을 수 있다고 규정합니다(예: abstract 방법).

인터페이스에는 하나의 추상 메서드(하나만 있을 수 있음), 여러 개의 기본 메서드, 여러 개의 정적 메서드가 동시에 존재할 수 있습니다.

// jdk 8에는 또 다른 새로운 기능이 있습니다: 기본값. 기본적으로 수정된 메소드는 기본 구현을 가지게 되며 반드시 구현해야 하는 메소드가 아니므로 람다 표현식 사용에 영향을 미치지 않습니다.

2.@FunctionalInterface: 기능적 인터페이스를 수정하는 데 사용됩니다.

@FunctionalInterface는 쓸 수도 있고 안 쓸 수도 있습니다. 이 주석은 주로 컴파일 수준 오류 검사에 사용됩니다. 인터페이스가 기능적 인터페이스 정의를 따르지 않으면 컴파일러는 오류를 보고합니다.

올바른 예, 오류가 보고되지 않음:

@FunctionalInterface
public interface HelloWorldService {
    void sayHello(String msg);
}

잘못된 예, 오류가 보고됨:

인터페이스에는 기능 인터페이스의 정의를 위반하는 두 개의 추상 메서드가 포함되어 있어 재정의되지 않은 여러 추상 메서드가 인터페이스에서 발견되었습니다.

참고: @FunctionalInterface를 추가하거나 추가하지 않는 것은 인터페이스가 기능적 인터페이스인지 여부에 영향을 미치지 않습니다. 이 주석은 단지 인터페이스에 하나의 추상 메서드만 포함되어 있는지 확인하도록 컴파일러에 상기시킵니다.

변수 및 범위

• Lambda 표현식은 최종으로 표시된 외부 지역 변수만 참조할 수 있습니다. 즉, 범위 외부에 정의된 지역 변수는 람다 내부에서 수정할 수 없습니다. 그렇지 않으면 컴파일 오류가 보고됩니다

• 람다 식의 지역 변수는 최종 선언할 필요는 없지만 후속 작업에서 수정해서는 안 됩니다. 코드(즉, 암시적 최종 의미 체계가 있음)

• 람다 식에서는 지역 변수와 이름이 같은 매개변수나 지역 변수를 선언할 수 없습니다.

Format

람다 표현식의 중요한 기능

• 선택적 유형 선언: 매개변수 유형을 선언할 필요가 없으며 컴파일러는 매개변수 값을 균일하게 식별할 수 있습니다.

• 선택적 매개변수 괄호: 매개변수에 대해 괄호를 정의할 필요는 없지만 여러 매개변수에서 괄호를 정의해야 합니다.

• 선택적 중괄호: 본문에 명령문이 포함되어 있으면 중괄호를 사용할 필요가 없습니다. 예: () -> Sysout.out.println("Test");

• 선택적 반환 키워드: 본문에 표현식 반환 값이 하나만 있는 경우 컴파일러는 자동으로 값을 반환하며 중괄호를 지정해야 합니다. 분명히 표현식이 숫자 값을 반환했습니다.

람다 표현식의 간단한 예

1. 매개변수가 필요하지 않으며 반환 값은 5

() -> 5

2 매개변수(숫자 유형)를 받고 해당 값의 2배를 반환합니다.

x -> 2 * x

3. 2개의 매개변수(숫자)를 받아들이고 그 차이를 반환합니다.

(x, y) -> x –

4 2개의 정수를 받아 그 합계를 반환합니다. (int x, int y) -> s) -> System.out.print(s)

Syntax format

Format:

(매개변수) -> ) ->{ 문; } code>

왼쪽: 람다 표현식의 매개변수 목록

오른쪽: 람다 표현식에서 실행될 함수(람다 본문)

구문 형식 1: 아니요 매개변수, 반환값 없음(parameters) -> statement   或(parameters) ->{ statements; }

左侧：Lambda 表达式的参数列表

右侧：Lambda 表达式中所需要执行的功能 （Lambda体）

语法格式一：无参数，无返回值

() -> Sysout.out.println("Test");

语法格式二：有一个参数，并且无返回值

(X)-> Sysout.out.println(x);

语法格式三：如果有一个参数括号可以不写

X-> Sysout.out.println(x);

语法格式四：有两个以上的参数，有返回值，并且Lambda体中有多条语句，语法体中需要用{}

    Comparator<Integer> comparator = (o1, o2) -> {
        System.out.println("Test");
        return Integer.compare(o1, o2);
    };

语法格式五：Lambda体中只用一条语句，return和{}可以省略不写

Comparator comparator = (o1, o2)->Integer.compare(o1, o2);

🎜 () -> Sysout.out.println("Test");🎜🎜🎜구문 형식 2: 매개변수는 하나이고 반환값은 없습니다🎜🎜🎜(X)-> Sysout.out .println(x);🎜🎜🎜문법 형식 3: 매개변수 대괄호가 있으면 작성할 필요가 없습니다🎜🎜🎜X -> Sysout.out.println(x);🎜🎜 🎜문법 형식 4: 두 개 이상의 매개변수, 반환 값이 있고 Lambda 본문에 여러 개의 문이 필요합니다. 문법 본문🎜🎜

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run();
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class: ");
            }
        };
 
        Interface params1 = () -> System.out.println("Lambda: ");
 
        params.run();
        params1.run();
    }
}

🎜🎜문법 형식 5: 람다 본문에는 하나의 문만 사용되며, 반환 및 {}는 생략 가능🎜🎜🎜비교기 비교기 = (o1, o2)->Integer.compare(o1 , o2);🎜

语法格式六：表达式的参数列表的数据类型可以省略不写，JVM编译器通过上下文推断出数据类型

(x ,y ) ->Integer.compare(x ,y)

实例

无参数无返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run();
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class: ");
            }
        };
 
        Interface params1 = () -> System.out.println("Lambda: ");
 
        params.run();
        params1.run();
    }
}

执行结果

Anonymous Internal Class: 
Lambda: 

有参数无返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run(String s);
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
            }
        };
 
        Interface params1 = (s) -> System.out.println("Lambda: " + s);
 
        params.run("hello");
        params1.run("hi");
    }
}

执行结果

Anonymous Internal Class: hello
Lambda: hi 

有参数有返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    String run(String s);
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public String run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
                return "abc";
            }
        };
 
        Interface params1 = (s) -> {
            System.out.println("Lambda: " + s);
            return "def";
        };
 
        System.out.println(params.run("hello"));
        System.out.println(params1.run("hi"));
    }
}

执行结果

Anonymous Internal Class: hello
abc
Lambda: hi
def 

lambda作为参数

传递一个函数

package org.example.a;
 
interface IRun {
    String welcome(String string);
}
 
class Util {
    public static long executionTime1(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时，防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
 
    public long executionTime2(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时，防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
 
    public static String hello(String string){
        String tmp;
        tmp = "hello: " + string;
        return tmp;
    }
 
    public String hi(String string){
        String tmp;
        tmp = "hi: " + string;
        return tmp;
    }
}
 
public class Demo {
    public static void main(String[] args) {
        long time1 = Util.executionTime1(Util::hello, "Tony");
        long time2 = new Util().executionTime2(new Util()::hi, "Pepper");
        System.out.println("time1: " + time1 + "ms");
        System.out.println("time2: " + time2 + "ms");
    }
}

执行结果

hello: Tony
hi: Pepper
time1: 11ms
time2: 11ms

直接传递lambda函数 

package org.example.a;
 
interface IRun {
    String welcome(String string);
}
 
class Util {
    public static long executionTime(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时，防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
}
 
public class Demo {
    public static void main(String[] args) {
        long time = Util.executionTime((string -> {
                    String tmp;
                    tmp = "hello: " + string;
                    return tmp;
                })
                , "Tony");
        System.out.println("time: " + time + "ms");
    }
}

执行结果

hello: Tony
time: 11ms

遍历集合

package org.example.a;
 
import java.util.ArrayList;
import java.util.List;
 
public class Demo{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
 
        //以前的循环方式
        for (String string : list) {
            System.out.println(string);
        }
 
        //使用lambda表达式输出list中的每个值
        list.forEach(c->{
            System.out.println(c);
        });
 
        // 在 Java 8 中使用双冒号操作符(double colon operator）。也属于lamda表达式
        list.forEach(System.out::println);
    }
}

执行结果

aaa
bbb
aaa
bbb
aaa
bbb

创建线程

package org.example.a;
 
public class Demo{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class !");
            }
        }).start();
 
        new Thread(() -> System.out.println("Lambda !")).start();
    }
}

执行结果

Anonymous Internal Class !
Lambda !

排序

package org.example.a;
 
import java.util.Arrays;
import java.util.Comparator;
 
public class Demo{
    public static void main(String[] args) {
        String[] players = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka"};
        
        Arrays.sort(players, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return (o1.compareTo(o2));
            }
        });
 
//        Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
//        Arrays.sort(players, sortByName);
        
//        Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));
        
        for(String string:players){
            System.out.println(string);
        }
    }
}

执行结果（换成注释掉的两种任意一种都是一样的）

Novak Djokovic
Rafael Nadal
Stanislas Wawrinka

위 내용은 Java에서 Lambda 표현식을 사용하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!