java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java Lambda表达式

Java中Lambda表达式的使用详细教程

作者:IT利刃出鞘

这篇文章将通过示例为大家详细展示Java中Lambda表达式的用法,同时也会介绍Lambda的相关知识,感兴趣的小伙伴可以跟随小编一起学习一下

简介

说明

本文用示例展示Lambda表达式的用法。同时也会介绍Lambda的相关知识。

Lambda表达式介绍

Lambda与匿名内部类

Lamda表达式指的是应用在SAM(SingleAbstractMethod,含有一个抽象方法的接口)环境下的一种简化定义形式。

Lambda比匿名内部类的优点

简洁(详见下边“函数式接口”)

Lamda相对于匿名内部类的缺点

对接口的要求

1.Lambda 规定接口中只能有一个需要被实现的方法(即抽象方法)。

在一个接口中,后边几个可同时存在:一个抽象方法(只能有一个)、多个default方法、多个static方法。

// jdk 8 中有另一个新特性:default, 被 default 修饰的方法会有默认实现,不是必须被实现的方法,所以不影响 Lambda 表达式的使用。

2.@FunctionalInterface:用来修饰函数式接口。

@FunctionalInterface写不写都可以。此注解主要用于编译级错误检查:当接口不符合函数式接口定义的时候,编译器会报错。

正确例子,没有报错:

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

错误例子,报错:

接口中包含了两个抽象方法,违反了函数式接口的定义,提示在接口中找到多个非重写的抽象方法。 

注意: 加不加 @FunctionalInterface对于接口是不是函数式接口没有影响,该注解只是提醒编译器去检查该接口是否仅包含一个抽象方法。

变量和作用域

格式

lambda表达式的重要特征

Lambda 表达式的简单例子 

1. 不需要参数,返回值为 5  

() -> 5  

2. 接收一个参数(数字类型),返回其2倍的值  

x -> 2 * x  

3. 接受2个参数(数字),并返回他们的差值  

(x, y) -> x – y  

4. 接收2个int型整数,返回他们的和  

(int x, int y) -> x + y  

5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  

(String s) -> System.out.print(s)

语法格式

格式:

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

语法格式六:表达式的参数列表的数据类型可以省略不写,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表达式的使用详细教程的详细内容,更多关于Java Lambda表达式的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:
阅读全文