Java1.8新特性

新特性



一、Lambda表达式


*
* Lambda表达式
*   是一种没有名字的函数,也可称为闭包,是Java8的新特性
*   本质上是一段匿名内部类,也可以是一段可传递的代码。也称箭头函数
*   特点:
*       允许把函数作为一个方法的参数(函数作为参数传递到方法中)
*       使用Lambda表达式可以让代码变得更加简洁
*   应用场景:
*       列表迭代、Map映射、Reduce聚合、想替代一个不想命名的函数或类,该函数或类往往并不复杂、
* 		想尽量缩短代码量的场景
*   具体语法:
*       1(parameters)->expression
*       2(parameters)->{
   statements;}
*   语法特点:
*       可选类型声明:不需要声明参数类型,编译器可以统一识别参数值
*       可选参数圆括号:一个参数无需定义圆括号,多个参数需要定义
*       可选大括号:如果主体只包含一个语句,就不需要大括号
*       可选的返回关键字:如果表达式只有一个返回值则编译器自动返回值,大括号需要指明表达式返
* 		回了一个数值
*   案例:
*       ()->5 不需要参数,返回值为5
*       x->2*x 接受一个参数(数字类型),返回其2倍值
*       (x,y)->x-y 接收两个参数,返回其差值
*       (int x, int y)->x+y 接收两个int类型整数,返回和
*       (String s)->System.out.print(s) 接收一个String对象,控制台打印
* 闭包:是能够读取其他函数内部变量的函数
*   在Java中,方法内部的局部变量只能在方法内使用,所以闭包可以理解为函数内部的函数
*   闭包本质是将函数内部和函数外部连接起来的桥梁
* */

public class Lambda_01 {
   

    public static void main(String[] args) {
   
        // 遍历
        String[] strings = {
   "one","two","three"};
        List<String> list = Arrays.asList(strings);

        // jdk1.7-老版
        for (String string : list) {
   
            System.out.println(string);
        }
        System.out.println("-------------");

        // jdk1.8。也叫箭头函数
        list.forEach(x->{
   
            System.out.println(x);
        });

        // 类似于下面写法。相当于自己创建了一个方法,然后遍历调用这个方法
        // 把集合中每个元素作为参数传递进入并打印
        for (String string : list) {
   
            test(string);
        }
    }

    public static void test(String string){
   
        System.out.println(string);
    }
}

/*
* 列表排序
* */
public class lambda_02 {
   

    public static void main(String[] args) {
   
        Integer[] arr = {
   4,6,1,2,7};
        List<Integer> list = Arrays.asList(arr);
        System.out.println(list);

        list.sort(new Comparator<Integer>() {
   
            @Override
            public int compare(Integer o1, Integer o2) {
   
                return o1-o2;
            }
        });
        System.out.println(list);

        Integer[] arr1 = {
   4,6,1,2,7};
        list = Arrays.asList(arr1);
        System.out.println(list);
        // 如果只有一条语句,并且是返回值语句,可以不写return和{}
        // 如果写上{}, 就必须写return和;
        // 如果有多条语句。必须写 {}、return、;
        list.sort((x,y)->y-x);
        System.out.println(list);
    }
}

二、函数式接口


*
* 函数式接口(FunctionalInterface)
*   本质是 一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口
*   核心是为了为Lambda表达式提供更好的支持,进一步达到函数式编程的目标。
*       通过函数式编程极大提高编程效率
*   可以被隐式转换为lambda表达式
* 特点:
*   函数式接口是只定义一个抽象方法的接口
*   可以包含一个或多个静态或默认方法
*   专用注解@FunctionalInterface 检查此接口是否是一个函数式接口,也可不添加该注解
*   如果有两个或以上 抽象方法,就不能当做函数式接口使用,也不能添加@FunctionalInterface注解
*   如果只有一个抽象方法,@FunctionalInterface注解可省略
*   简单地说是回调函数,方法的参数是一个方法,在方法中对传递的方法进行调用
* */

public class _01_FuncInterface {
   

    public static void main(String[] args) {
   
        // 1.8之前编码方式
        // 方式1:实现类写法
        Test test = new Test();
        call(test);
        // 方式2:匿名内部类写法
        call(new MyFunctionInter() {
   
            @Override
            public void printMessage() {
   
                System.out.println("匿名内部类写法");
            }
        });

        // 1.8新特性
        // 方式1:直接在call函数中传入箭头函数
        // 箭头函数等于是实现类中实现了这个抽象方法,不过不用写实现类。且比匿名内部类实现简单
        call( ()->{
   
            System.out.println("lambda写法");
        } );
        // 方式2:先创建函数对象,类似于实现类接口的内部类对象
        MyFunctionInter inter = ()->{
   
            System.out.println("保存为函数对象变量。再调用");
        };
        call(inter);

        // 调用实现方式2的这个方法
        inter.printMessage();
    }

    // 自定义静态方法,接收接口对象
    public static void call(MyFunctionInter func){
   
        func.printMessage();
    }
}

// 函数式接口,只能有一个抽象方法。但可以有默认方法
@FunctionalInterface
interface MyFunctionInter{
   
    void printMessage();
}

// 实现类
class Test implements MyFunctionInter{
   

    @Override
    public void printMessage() {
   
        System.out.println("实现类写法");
    }
}

/*
* 函数式接口-有参
* */
public class _02_FuncInterface {
   

    public static void main(String[] args) {
   

        // 1.8新特性
        // 方式1:直接在call函数中传入箭头函数
        // 箭头函数等于是实现类中实现了这个抽象方法,不过不用写实现类。且比匿名内部类实现简单
        call( (str)->{
   
            System.out.println(str);
        }, "参数1" );
        // 方式2:先创建函数对象,类似于实现类接口的内部类对象
        MyFunctionInter_02 inter = (str)->{
   
            System.out.println(str);
        };
        call(inter,"参数2");

        // 调用实现方式2的这个方法
        inter.<
  • 2
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值