JDK8新特性

2021-10-23 16:29:59 阅读：143 来源： 互联网

标签：void 接口 Person JDK8 特性方法 public lambda

总结:

1.写list的高效for循环时.可以list.for 有自动提示
2.写 Collections.sort(list,(Person o1,Person o2)->{
return o1.getAge() - o2.getAge();
}); 时,鼠标在o2.getAge()后面.return 自动显示
3.数组也可以遍历数组.for
4.

一 Lambda表达式

创建一个空的maven项目
在这里插入图片描述

1.需求分析:

创建一个新的线程,指定线程要执行的任务

package cn.tedu.jdk.lambda;

public class Demo01Lambda {
    public static void main(String[] args) {
        //开启一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程中执行的代码:"+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程中的代码:"+Thread.currentThread().getName());
    }
}

代码分析:
1.Thread类需要一个Runnable接口作为参数.其中的run方法用来指定线程任务内容的核心
2.为了指定run方法,不得需要Runnable接口的实现类
3.为了省去定义一个Runnable实现类.,不得不使用匿名内部类
4.必须覆盖抽象run方法,方法名,方法参数,返回值类型,不得不重写一遍,而且不能出错
5.实际上,我们只关注方法体中的代码

2.Lambda表达式初体验

Lambda表达式是一个匿名函数,可以理解为是一段可以传递的代码,

new Thread(()->{ System.out.println("新线程Lambda表达式..."+Thread.currentThread().getName()); })
			.start();

lambda表达式的优点:简化了匿名内部类的使用,语法更加简单
匿名内部类语法冗余,发现lambda表达式是简化匿名内部类的使用

3.Lambda语法规则

lambda省去了面向对象的条条框框,lambda语法规则有3部分组成

(参数类型 参数名称): 参数列表
{代码体}: 方法体
-> 箭头  分割参数列表和方法体

lambda练习1

无参无返回值的lambda
定义一个接口,

package cn.tedu.jdk.lambda.service;

public interface UserService {
    void show(); //无参无返回值
}

然后创建主方法使用

package cn.tedu.jdk.lambda;

import cn.tedu.jdk.lambda.service.UserService;

public class Demo03Lambda {
    /**
     * (String[] args)->{}
     * @param args
     */
    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show 方法执行了...");
            }
        });
        System.out.println("-----------------");
        goShow(()->{
            System.out.println("lambda show方法 执行了...");
        });
    }
    public static void goShow(UserService userService){
        userService.show();
    }
}

输出:

show 方法执行了...
-----------------
lambda show方法 执行了...

lambda练习2

完成一个有参有返回值的lambda案例
创建一个Person对象

package cn.tedu.jdk.lambda.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private Integer height;
}

然后我们在main方法中,.List集合中保存多个person对象,然后对这些对象做根据age排序操作

package cn.tedu.jdk.lambda;

import cn.tedu.jdk.lambda.domain.Person;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo04Lambda {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person("周杰伦", 33, 175));
        list.add(new Person("刘德华", 50, 185));
        list.add(new Person("许攸", 46, 165));
        list.add(new Person("曹操", 30, 169));

//        Collections.sort(list, new Comparator<Person>() {
//            public int compare(Person o1, Person o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });
//        for (Person person : list) {
//            System.out.println(person);
//        }

        System.out.println("------------------");
        Collections.sort(list,(Person o1,Person o2)->{
            return o1.getAge() - o2.getAge();
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }

}

我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类,且执行的方法有参数和返回值,我们可以改写为lambda表达式
输出结果

------------------
Person(name=曹操, age=30, height=169)
Person(name=周杰伦, age=33, height=175)
Person(name=许攸, age=46, height=165)
Person(name=刘德华, age=50, height=185)

4.@FunctionalInterface注解

使用lambda时,这个接口只能保证有一个抽象方法

package cn.tedu.jdk.lambda.service;

/**
 * @FunctionalInterface
 * 这是一个标志注解,被该注解修饰的接口,只能声明一个抽象方法
 */
@FunctionalInterface
public interface UserService {
    void show();
}

5.Lambda表达式的原理

在这里插入图片描述
lambda中的代码是在这个方法里面执行的

利用JDK自带工具javap 对字节码进行反汇编操作
javap -c -p XXX.class文件
-c 表示对代码进行反汇编
-p 显示所有的类和成员

在这个反编译的源码中我们看到了一个静态方法 lambda$main$0()

小结:

匿名内部类在反编译时.会产生一个class文件
lambda表达式在程序运行时会形成一个类
1.在类中会新增一个static方法,该方法体就是lambda表达式的代码
2.还会形成一个匿名内部类,实现接口,重写抽象方法
3.在接口中重写方法,调用新生成的方法

6.Lambda表达式省略写法

在lambda表达式标准写法基础上,可以省略的语法规则为:
1.小括号内的参数类型可以省略
2.如果小括号内有且仅有一个参数,则小括号可以省略
3.如果大括号内有且仅有一条语句,则可以同时省略大括号,return关键字及语句分号

package cn.tedu.jdk.lambda;

import cn.tedu.jdk.lambda.service.OrderService;
import cn.tedu.jdk.lambda.service.StudentService;

public class Demo05Lambda {
    public static void main(String[] args) {
        goStudent((String name, Integer age) -> {
            return name + age + "6666...";
        });
        //省略写法
        goStudent((name,age)->name + age + "6666...");
        System.out.println("--------------");

        goOrder((String name) -> {
            System.out.println("---->"+name);
            return 666;
        });
        //省略写法
        goOrder(name ->666);
    }

    public static void goStudent(StudentService studentService) {
        studentService.show("张三", 22);
    }

    public static void goOrder(OrderService orderService) {
        orderService.show("李四");
    }


}

7.Lambda表达式使用前提

lambda使用时有几个条件特别注意:
1.方法的参数或局部变量的类型必须为接口才能使用lambda
2.接口中有且仅有一个抽象方法 @FunctionalInterface

8.lambda和匿名内部类的对比

1.所需类型不同:
匿名内部类的类可以类,抽象类.接口,
lambda表达式需要的类型必须为接口
2.抽象方法的数量不一样
匿名内部类所需的接口中的抽象方法数量是随意的
lambda表达式所需的接口中只能有一个抽象方法
3.实现原理不一样
匿名内部类是在编译后生成的class
lambda表达式是在程序运行时动态生成class

二接口中新增的方法

JDK8中针对接口有做新增,在JDK8之前

interface 接口名{
	静态常量;
	抽象方法;
}

在JDK8后,对接口做了增强,接口中可以有默认方法和静态方法

interface 接口名{
	静态常量;
	抽象方法;
	默认方法;
	静态方法;
}

默认方法

为什么要增加默认方法?

在JDK8以前,接口中只能有抽象方法和静态常量.会存在以下问题:
如果接口中新增抽象方法,那么实现类都必须抽象这个抽象方法.非常不利于接口的扩展

package cn.tedu.jdk.inter;

public interface Demo01Interface {
    public static void main(String[] args) {
        A b=new B();
        A c=new C();
    }
}
interface A{
    void test1();
    //接口中新增抽象方法,所有实现类都需要重写这个方法,不利于接口的扩展
    void test2();

}
class B implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}
class C implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

接口中默认方法的格式?

接口中默认方法的语法格式

interface 接口名{
	修饰符 default 返回值类型 方法名(){方法体;}
}

package cn.tedu.jdk.inter;

public interface Demo01Interface {
    public static void main(String[] args) {
        A b=new B();
         b.test3();
        A c=new C();
    }
}
interface A{
    void test1();
    //接口中新增抽象方法,所有实现类都需要重写这个方法,不利于接口的扩展
    void test2();

    /**
     * 接口中定义的默认方法
     * @return
     */
    public default String test3(){
        System.out.println("接口中的默认方法执行了...");
        return "hello";
    }
}
class B implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }

    @Override
    public String test3() {
        System.out.println("B 实现类重写了默认方法");
        return A.super.test3();
    }
}
class C implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

接口中默认方法的使用

接口中默认方法的使用有2种方式
1.实现类直接调用接口中的默认方法
2.实现类重写接口的默认方法

静态方法

JDK8中为接口新增了静态方法,作用也是为了接口的扩展
语法规则:

interface 接口名{
	修饰符 static 返回值类型 方法名(){
		方法体;
	}
}

代码:

package cn.tedu.jdk.inter;

public interface Demo01Interface {
    public static void main(String[] args) {
        A b = new B();
        b.test3();
        A c = new C();
        A.test4();
    }
}

interface A {
    void test1();

    //接口中新增抽象方法,所有实现类都需要重写这个方法,不利于接口的扩展
    void test2();

    /**
     * 接口中定义的默认方法
     *
     * @return
     */
    public default String test3() {
        System.out.println("接口中的默认方法执行了...");
        return "hello";
    }

    /**
     * 接口中的静态方法
     * @return
     */
    public static String test4() {
        System.out.println("接口中的静态方法...");
        return "hello";
    }
}

class B implements A {
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }


//    @Override
//    public String test3() {
//        System.out.println("B 实现类重写了默认方法");
//        return A.super.test3();
//    }
}

class C implements A {
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}

静态方法的使用

接口中的静态方法是不能被重写的,调用的话,只能通过接口类型来实现, 接口名.方法名

如果扩展的内容支持重写用默认方法,否则用static
在这里插入图片描述

default和static的区别

默认方法通过实例调用,静态方法通过接口名调用
默认方法可以被继承,实现类可以直接调用接口默认方法,也可以重写接口默认方法
静态方法不能被继承,实现类不能重写接口中的静态方法,只能通过接口名调用

三函数式接口

函数式接口的由来?

使用lambda表达式的前提是需要有函数式接口. 而使用lambda表达式不关心接口名,抽象方法名,
只关心抽象抽象方法的参数列表和返回值类型

package cn.tedu.jdk.fun;

public class Demo01Fun {

    public static void main(String[] args) {
        fun1(arr -> {
            int sum=0;
            for (int i : arr) {
                sum+=i;
            }
            return sum;
        });
    }

    public static void fun1(Operator operator) {
        int arr[]={1,2,3,4};
        int sum=operator.getSum(arr);
        System.out.println("sum="+sum);
    }
}

/**
 * 函数式接口
 */
@FunctionalInterface
interface Operator{
    int getSum(int[] arr);
}

在JDK8后函数式接口.,package java.util.function;包下,
Supplier接口, 无参有返回值方法 T get();
Consumer接口.有参无返回值的方法 void accept(T t);

标签：void,接口,Person,JDK8,特性,方法,public,lambda
来源： https://blog.csdn.net/qq_44773677/article/details/120914432

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9