您当前的位置: 首页 > 

小志的博客

暂无认证

  • 0浏览

    0关注

    1217博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

jdk1.8新特性——lambda表达式基础语法

小志的博客 发布时间:2021-08-24 22:06:39 ,浏览量:0

目录
    • 一、Lambda 表达式的基础语法
    • 二、使用Lambda 表达式的注意事项
    • 三、函数式接口的理解
    • 四、Lambda 表达式的基础语法示例
      • 1、基础语法一:无参数,无返回值
      • 2、基础语法二:有一个参数,并且无返回值
      • 3、基础语法三:有一个参数,并且无返回值(若只有一个参数,小括号可以省略不写)
      • 4、基础语法四:有两个以上的参数,有返回值,并且 Lambda 体中有多条语句
      • 5、基础语法五:若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写
      • 6、基础语法六: Lambda 表达式的参数列表的数据类型可以省略不写
    • 五、Lambda 表达式的基础练习
    • 六、Lambda 表达式的总结

一、Lambda 表达式的基础语法
  • Java8中引入了一个新的操作符 “->”, 该操作符称为箭头操作符或 Lambda 操作符。
  • 箭头操作符将 Lambda 表达式拆分成两部分:
  • 左侧:Lambda 表达式的参数列表。
  • 右侧:Lambda 表达式中所需执行的功能, 即 Lambda 体。
二、使用Lambda 表达式的注意事项
  • Lambda 表达式需要“函数式接口”的支持。
三、函数式接口的理解

1、理解

  • 接口中只有一个抽象方法的接口,称为 函数式接口。
  • 可以使用注解 @FunctionalInterface 修饰,可以检查是否是函数式接口。

2、例如:Runnable接口就是一个函数式接口

在这里插入图片描述 3、例如:Consumer接口就是一个函数式接口

在这里插入图片描述 4、例如:Comparator接口就是一个函数式接口

在这里插入图片描述

四、Lambda 表达式的基础语法示例 1、基础语法一:无参数,无返回值
  • 示例代码如下:

    package com.xz.springboot_java8.day2;
    /**
     * @description: Lambda 表达式的基础语法一:无参数,无返回值
     * @author: xz
     * @create: 2021-08-24 20:04
     */
    public class Test1 {
        public static void main(String[] args) {
            generalMethod();
            System.out.println("==============");
            lambdaMethod();
        }
    
        //匿名内部类方式
        public static void generalMethod(){
            Runnable r=new Runnable() {
                @Override
                public void run() {
                    System.out.println("Hello World!");
                }
            };
            r.run();
        }
        //lambda表达式方式(无参数,无返回值格式)
        public static void lambdaMethod(){
            Runnable r=()-> System.out.println("Hello Lambda!");
            r.run();
        }
    }
    
    
  • 输出结果如下: 在这里插入图片描述

2、基础语法二:有一个参数,并且无返回值
  • 示例代码如下:

    package com.xz.springboot_java8.day2;
    import java.util.function.Consumer;
    /**
     * @description: Lambda 表达式的基础语法二:有一个参数,并且无返回值
     * @author: xz
     * @create: 2021-08-24 20:15
     */
    public class Test2 {
        public static void main(String[] args) {
            generalMethod();
            System.out.println("--------");
            lambdaMethod();
        }
    
        //匿名内部类方式(有一个参数,并且无返回值)
        public static void generalMethod(){
            Consumer consumer= new Consumer() {
                @Override
                public void accept(String str) {
                    System.out.println(str);
                }
            };
            consumer.accept("Hello World!");
        }
    
        //lambda表达式方式(有一个参数,并且无返回值)
        public static void lambdaMethod(){
            Consumer con = (x) -> System.out.println(x);
            con.accept("Hello Lambda!");
        }
    }
    
  • 输出结果如下: 在这里插入图片描述

3、基础语法三:有一个参数,并且无返回值(若只有一个参数,小括号可以省略不写)
  • 示例代码如下:

    package com.xz.springboot_java8.day2;
    import java.util.function.Consumer;
    /**
     * @description: Lambda 表达式的基础语法三:
     *               有一个参数,并且无返回值(若只有一个参数,小括号可以省略不写)
     * @author: xz
     * @create: 2021-08-24 20:30
     */
    public class Test3 {
        public static void main(String[] args) {
            generalMethod();
            System.out.println("================");
            lambdaMethod();
        }
    
        //匿名内部类方式(有一个参数,并且无返回值)
        public static void generalMethod(){
            Consumer consumer= new Consumer() {
                @Override
                public void accept(String str) {
                    System.out.println(str);
                }
            };
            consumer.accept("Hello World!");
        }
    
        //lambda表达式方式(有一个参数,并且无返回值)
        //若只有一个参数,小括号可以省略不写
        public static void lambdaMethod(){
            Consumer con = x -> System.out.println(x);
            con.accept("Hello Lambda!");
        }
    }
    
  • 输出结果如下: 在这里插入图片描述

4、基础语法四:有两个以上的参数,有返回值,并且 Lambda 体中有多条语句
  • 示例代码如下:
    package com.xz.springboot_java8.day2;
    import java.util.Comparator;
    /**
     * @description: Lambda 表达式的基础语法四:
     *                      有两个以上的参数,有返回值,并且 Lambda 体中有多条语句
     * @author: xz
     * @create: 2021-08-24 20:45
     */
    public class Test4 {
        public static void main(String[] args) {
            generalMethod();
            System.out.println("=========================");
            lambdaMethod();
        }
    
        //匿名内部类方式(有两个以上的参数,有返回值,并且有多条语句)
        public static void generalMethod(){
            Comparator comparator= new Comparator() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    System.out.println("Hello World!");
                    System.out.println(Integer.compare(o1, o2));
                    return Integer.compare(o1,o2);
                }
            };
            comparator.compare(10,20);
        }
    
        //lambda表达式方式(有两个以上的参数,有返回值,并且有多条语句)
        public static void lambdaMethod(){
            Comparator com = (x, y) -> {
     			System.out.println("Hello Lambda!");
                System.out.println(Integer.compare(x, y));
     			return Integer.compare(x, y);
     		};
           com.compare(10,20);
        }
    }
    
  • 输出结果如下: 在这里插入图片描述
5、基础语法五:若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写
  • 示例代码如下:
    package com.xz.springboot_java8.day2;
    import java.util.Comparator;
    /**
     * @description: Lambda 表达式的基础语法五:
     *                   若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写
     * @author: xz
     * @create: 2021-08-24 20:58
     */
    public class Test5 {
        public static void main(String[] args) {
            int a1=generalMethod();
            System.out.println(a1);
    
            System.out.println("=========================");
    
            int a2=lambdaMethod();
            System.out.println(a2);
        }
    
        //匿名内部类方式(有两个以上的参数,有返回值并且只有一条语句)
        public static int generalMethod(){
            Comparator comparator= new Comparator() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return Integer.compare(o1,o2);
                }
            };
            return comparator.compare(10,20);
        }
    
        //lambda表达式方式(有两个以上的参数,有返回值并且只有一条语句)
        //若 Lambda 体中只有一条语句, return 和 大括号都可以省略不写
        public static int lambdaMethod(){
            Comparator com = (x, y) -> Integer.compare(x, y);
            return com.compare(10,20);
        }
    }
    
  • 输出结果如下: 在这里插入图片描述
6、基础语法六: Lambda 表达式的参数列表的数据类型可以省略不写
  • 示例代码如下:

    package com.xz.springboot_java8.day2;
    import java.util.Comparator;
    /**
     * @description:  Lambda 表达式的基础语法六:
     *                  Lambda 表达式的参数列表的数据类型可以省略不写,
     *                  因为JVM编译器通过上下文推断出,数据类型,即“类型推断”
     *
     *                  示例:
     *                  (Integer x, Integer y) -> Integer.compare(x, y);
     *                  可以省略参数类型如下:
     *                  (x,y) -> Integer.compare(x, y);
     * @author: xz
     * @create: 2021-08-24 21:12
     */
    public class Test6 {
        public static void main(String[] args) {
            int a1=generalMethod();
            System.out.println(a1);
    
            System.out.println("=========================");
    
            int a2=lambdaMethod();
            System.out.println(a2);
        }
    
        //匿名内部类方式(有两个以上的参数,有返回值并且只有一条语句)
        public static int generalMethod(){
            Comparator comparator= new Comparator() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return Integer.compare(o1,o2);
                }
            };
            return comparator.compare(10,20);
        }
    
        //Lambda表达式的参数列表的数据类型可以省略不写
        public static int lambdaMethod(){
            //Comparator com = (Integer x,Integer y) -> Integer.compare(x,y);
            Comparator com = (x,y) -> Integer.compare(x, y);
            return com.compare(10,20);
        }
    
    }
    
  • 输出结果如下: 在这里插入图片描述

五、Lambda 表达式的基础练习

习题1:调用Collections.sort()方法,通过定制排序比较两个Employee(先按年龄比,年龄相同按薪资比),使用Lambda作为参数传递。

1、创建一个Employee 类。代码如下:

public class Employee {
    private int id;//id
    private String name;//名称
    private int age;//年龄
    private Double salary; //薪水

    public Employee() { }

    public Employee(int id, String name, int age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    //getter、setter及toString方法此处省略
    ......
}

2、需求及测试代码如下:

public class Test1 {
    public static void main(String[] args) {
        //初始化员工数据并转成list
        List emps = Arrays.asList(
                new Employee(1, "张三", 25, 3333.33),
                new Employee(2, "李四", 38, 5555.55),
                new Employee(3, "王五", 18, 2222.22),
                new Employee(4, "赵六", 45, 8888.88),
                new Employee(3, "xz", 18, 1111.11)
        );
        getEmployeeInfo(emps);
    }

    public static void getEmployeeInfo(List emps){
        Collections.sort(emps,(o1,o2)->{
            if(o1.getAge() ==o2.getAge()){//年龄相同按薪资比
                return o1.getSalary().compareTo(o2.getSalary());
            }else{//按年龄比
                return  Integer.compare(o1.getAge(),o2.getAge());
            }
        });
        //遍历
        for (Employee emp : emps) {
            System.out.println(emp);
        }
    }
}

3、运行main函数,输出结果如下: 在这里插入图片描述

习题2: 声明函数式接口,接口中声明抽象方法,public String getvalue(String str); 声明类Test2,类中编写方法使用接口作为参数,将一个字符串转成大写,并作为方法的返回值。 再将一个字符串的第2个和第4个索引位置进行截取子串。

1、声明名称为MyInterface的函数式接口,代码如下:

package com.xz.springboot_java8.day3.interfaces;
/**
 * @description: 声明函数式接口
 */
@FunctionalInterface
public interface MyInterface {
    String getvalue(String str);
}

2、需求及测试代码如下:

package com.xz.springboot_java8.day3;
import com.xz.springboot_java8.day3.interfaces.MyInterface;

public class Test2 {
    public static void main(String[] args) {
        getResult();
    }
    /**
     * 获取结果方法
     */
    public static void getResult(){
        //将一个字符串转成大写
        String str1= strHandler("sdkljakdjlksa",(x) -> x.toUpperCase() );
        System.out.println(str1);

        //将字符串的第2个和第4个索引位置进行截取子串。
        String str2=strHandler("sdkljakdjlksa",(x)->x.substring(2,5));
        System.out.println(str2);
    }
    /**
     * 声明类Test2,类中编写方法使用接口作为参数,并作为方法的返回值。
     * @return
     */
    public static String strHandler(String str, MyInterface myInterface){
        return myInterface.getvalue(str);
    }
}

3、运行main函数,输出结果如下: 在这里插入图片描述

习题3: 声明一个带两个泛型的函数式接口,泛型类型为, T为参数,R为返回值 接口中声明对应的抽象方法 在Test3类中声明方法,使用接口作为参数,计算两个long型参数的和 再计算两个long型参数的乘积。

1、声明名称为MyInterface2的函数式接口,泛型类型为,代码如下:

package com.xz.springboot_java8.day3.interfaces;
/**
 * 声明函数式接口
 */
@FunctionalInterface
public interface MyInterface2 {
    public R getValue(T t1, T t2);
}

2、需求及测试代码如下:

public class Test3 {
    public static void main(String[] args) {
        getResult();
    }
    /**
     * 获取结果方法
     */
    public static void getResult(){
        long sumValue= getCompute(25l,30l,(x,y)->x+y);
        System.out.println("两数之和="+sumValue);
        long rideValue= getCompute(25l,30l,(x,y)->x*y);
        System.out.println("两数之积="+rideValue);
    }
    /**
     * 在Test3类中声明方法,使用接口作为参数,计算两个long型参数的和
     * @return
     */
    public static Long getCompute(Long l1,Long l2, MyInterface2 myInterface2){
        return myInterface2.getValue(l1,l2);
    }
}

3、运行main函数,输出结果如下: 在这里插入图片描述

六、Lambda 表达式的总结
  • 由以上示例可知,每次使用lambda表达式都需要创建函数式接口。而实际中java已经创建好了函数式接口,直接使用即可。
关注
打赏
1661269038
查看更多评论
立即登录/注册

微信扫码登录

0.1249s