Java8 Lambda表达式

精华

小牛编辑

271浏览

2023-03-14

1 Java8 Lambda表达式的介绍

Lambda表达式是Java8中包含的一项新的重要功能。它提供了一种简洁明了的方式来使用表达式表示一个方法接口。在Collection集合中非常有用。它有助于集合元素的迭代，过滤和从集合中提取数据。

Lambda表达式用于提供具有功能接口的接口的实现。它节省了大量代码。在使用Lambda表达式的情况下，我们无需再次定义用于提供实现的方法。我们只编写实现代码。

Java Lambda表达式被视为函数，因此编译器不会创建.class文件。

2 Java8 Lambda表达式的好处

提供执行功能的接口。
更少的编码。

3 Java8 Lambda表达式的语法

(参数列表) -> {主体}

Java Lambda表达式由三个组件组成。

参数列表：也可以为空或非空。
箭头：用于链接参数列表和表达式主体。
主体：它包含用于Lambda表达式的表达式和语句。

3.1 无参数语法

() -> {  
//主体
}

3.2 一个参数的语法

(p1) -> {  
//单个参数主体
}

3.3 多个参数的语法

(p1,p2) -> {  
//多个参数的主体
}

4 没有使用Java8 Lambda表达式之前

让我们看一下我们不实现Java Lambda表达式的情况。在这里，我们正在实现一个不使用lambda表达式的接口。

/**
 * 小牛知识库： https://www.xnip.cn
 */
interface Drawable{  
    public void draw();  
}  
public class LambdaExpressionExample {  
    public static void main(String[] args) {  
        int width=10;  
  
        //without lambda, Drawable implementation using anonymous class  
        Drawable d=new Drawable(){  
            public void draw(){System.out.println("Drawing "+width);}  
        };  
        d.draw();  
    }  
}

输出结果为：

Drawing 10

5 Java8 Lambda表达式的案例

现在，我们将借助Java Lambda表达式来实现上述示例。

/**
 * 小牛知识库： https://www.xnip.cn
 */
@FunctionalInterface  //It is optional  
interface Drawable{  
    public void draw();  
}  
  
public class LambdaExpressionExample2 {  
    public static void main(String[] args) {  
        int width=10;  
          
        //with lambda  
        Drawable d2=()->{  
            System.out.println("Drawing "+width);  
        };  
        d2.draw();  
    }  
}

输出结果为：

Drawing 10

6 Java8 Lambda表达式的案例：无参数

Lambda表达式可以具有零个或任意数量的参数。让我们看看示例：

/**
 * 小牛知识库： https://www.xnip.cn
 */
interface Sayable{  
    public String say();  
}  
public class LambdaExpressionExample3{  
public static void main(String[] args) {  
    Sayable s=()->{  
        return "I have nothing to say.";  
    };  
    System.out.println(s.say());  
}  
}

输出结果为：

I have nothing to say.

7 Java8 Lambda表达式的案例：单个参数

/**
 * 小牛知识库： https://www.xnip.cn
 */
interface Sayable{  
    public String say(String name);  
}  
  
public class LambdaExpressionExample4{  
    public static void main(String[] args) {  
      
        // Lambda expression with single parameter.  
        Sayable s1=(name)->{  
            return "Hello, "+name;  
        };  
        System.out.println(s1.say("Sonoo"));  
          
        // You can omit function parentheses    
        Sayable s2= name ->{  
            return "Hello, "+name;  
        };  
        System.out.println(s2.say("Sonoo"));  
    }  
}

输出结果为：

Hello, Sonoo
Hello, Sonoo

8 Java8 Lambda表达式的案例：多个参数

/**
 * 小牛知识库： https://www.xnip.cn
 */
interface Addable{  
    int add(int a,int b);  
}  
  
public class LambdaExpressionExample5{  
    public static void main(String[] args) {  
          
        // Multiple parameters in lambda expression  
        Addable ad1=(a,b)->(a+b);  
        System.out.println(ad1.add(10,20));  
          
        // Multiple parameters with data type in lambda expression  
        Addable ad2=(int a,int b)->(a+b);  
        System.out.println(ad2.add(100,200));  
    }  
}

输出结果为：

30
300

9 Java8 Lambda表达式的案例：return关键字

在Java Lambda表达式中，如果只有一条语句，则可以使用也可以不使用return关键字。当Lambda表达式包含多个语句时，必须使用return关键字。

/**
 * 小牛知识库： https://www.xnip.cn
 */
interface Addable{  
    int add(int a,int b);  
}  
  
public class LambdaExpressionExample6 {  
    public static void main(String[] args) {  
          
        // Lambda expression without return keyword.  
        Addable ad1=(a,b)->(a+b);  
        System.out.println(ad1.add(10,20));  
          
        // Lambda expression with return keyword.    
        Addable ad2=(int a,int b)->{  
                            return (a+b);   
                            };  
        System.out.println(ad2.add(100,200));  
    }  
}

输出结果为：

30
300

10 Java8 Lambda表达式的案例：ForEach循环

/**
 * 小牛知识库： https://www.xnip.cn
 */
import java.util.*;  
public class LambdaExpressionExample7{  
    public static void main(String[] args) {  
          
        List<String> list=new ArrayList<String>();  
        list.add("ankit");  
        list.add("mayank");  
        list.add("irfan");  
        list.add("jai");  
          
        list.forEach(  
            (n)->System.out.println(n)  
        );  
    }  
}

输出结果为：

ankit
mayank
irfan
jai

11 Java8 Lambda表达式的案例：多条语句

/**
 * 小牛知识库： https://www.xnip.cn
 */
@FunctionalInterface  
interface Sayable{  
    String say(String message);  
}  
  
public class LambdaExpressionExample8{  
    public static void main(String[] args) {  
      
        // You can pass multiple statements in lambda expression  
        Sayable person = (message)-> {  
            String str1 = "I would like to say, ";  
            String str2 = str1 + message;   
            return str2;  
        };  
            System.out.println(person.say("time is precious."));  
    }  
}

输出结果为：

I would like to say, time is precious.

12 Java8 Lambda表达式的案例：创建线程

您可以使用lambda表达式来运行线程。在下面的示例中，我们通过使用lambda表达式实现run方法。

/**
 * 小牛知识库： https://www.xnip.cn
 */
public class LambdaExpressionExample9{  
    public static void main(String[] args) {  
      
        //Thread Example without lambda  
        Runnable r1=new Runnable(){  
            public void run(){  
                System.out.println("Thread1 is running...");  
            }  
        };  
        Thread t1=new Thread(r1);  
        t1.start();  
        //Thread Example with lambda  
        Runnable r2=()->{  
                System.out.println("Thread2 is running...");  
        };  
        Thread t2=new Thread(r2);  
        t2.start();  
    }  
}

输出结果为：

Thread1 is running...
Thread2 is running...

13 Java8 Lambda表达式的案例：比较器

/**
 * 小牛知识库： https://www.xnip.cn
 */
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
class Product{  
    int id;  
    String name;  
    float price;  
    public Product(int id, String name, float price) {  
        super();  
        this.id = id;  
        this.name = name;  
        this.price = price;  
    }  
}  
public class LambdaExpressionExample10{  
    public static void main(String[] args) {  
        List<Product> list=new ArrayList<Product>();  
          
        //Adding Products  
        list.add(new Product(1,"HP Laptop",25000f));  
        list.add(new Product(3,"Keyboard",300f));  
        list.add(new Product(2,"Dell Mouse",150f));  
          
        System.out.println("Sorting on the basis of name...");  
  
        // implementing lambda expression  
        Collections.sort(list,(p1,p2)->{  
        return p1.name.compareTo(p2.name);  
        });  
        for(Product p:list){  
            System.out.println(p.id+" "+p.name+" "+p.price);  
        }  
  
    }  
}

输出结果为：

Sorting on the basis of name...
2 Dell Mouse 150.0
1 HP Laptop 25000.0
3 Keyboard 300.0

14 Java8 Lambda表达式的案例：过滤器收集数据

/**
 * 小牛知识库： https://www.xnip.cn
 */
import java.util.ArrayList;  
import java.util.List;  
import java.util.stream.Stream;   
class Product{  
    int id;  
    String name;  
    float price;  
    public Product(int id, String name, float price) {  
        super();  
        this.id = id;  
        this.name = name;  
        this.price = price;  
    }  
}  
public class LambdaExpressionExample11{  
    public static void main(String[] args) {  
        List<Product> list=new ArrayList<Product>();  
        list.add(new Product(1,"Samsung A5",17000f));  
        list.add(new Product(3,"Iphone 6S",65000f));  
        list.add(new Product(2,"Sony Xperia",25000f));  
        list.add(new Product(4,"Nokia Lumia",15000f));  
        list.add(new Product(5,"Redmi4 ",26000f));  
        list.add(new Product(6,"Lenevo Vibe",19000f));  
          
        // using lambda to filter data  
        Stream<Product> filtered_data = list.stream().filter(p -> p.price > 20000);  
          
        // using lambda to iterate through collection  
        filtered_data.forEach(  
                product -> System.out.println(product.name+": "+product.price)  
        );  
    }  
}

输出结果为：

Iphone 6S: 65000.0
Sony Xperia: 25000.0
Redmi4 : 26000.0

15 Java8 Lambda表达式的案例：事件监听器

/**
 * 小牛知识库： https://www.xnip.cn
 */
import javax.swing.JButton;  
import javax.swing.JFrame;  
import javax.swing.JTextField;  
public class LambdaEventListenerExample {  
    public static void main(String[] args) {  
        JTextField tf=new JTextField();  
        tf.setBounds(50, 50,150,20);  
        JButton b=new JButton("click");  
        b.setBounds(80,100,70,30);  
          
        // lambda expression implementing here.  
        b.addActionListener(e-> {tf.setText("hello swing");});  
          
        JFrame f=new JFrame();  
        f.add(tf);f.add(b);  
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        f.setLayout(null);  
        f.setSize(300, 200);  
        f.setVisible(true);  
  
    }  
  
}