java8新特性

最新推荐文章于 2022-12-19 19:34:25 发布
最新推荐文章于 2022-12-19 19:34:25 发布
阅读量78 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jeremyl/article/details/112679788
版权
  • 函数式接口
  • Lambda表达式
  • 方法引用/构造器引用
  • Stream API
  • 接口的增强
  • Optional类
  • 新的时间和日期API

1. Lambda表达式

举例一：

@Test
    public void test1(){
        Runnable r1=new Runnable() {
            @Override
            public void run() {
                System.out.println("hi");
            }
        };

        r1.run();

        System.out.println("*********************************");

        Runnable r2=()-> System.out.println("hello");

        r2.run();
    }

举例二：

@Test
    public void test2(){

        Comparator<Integer> com1=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        int compare1 = com1.compare(12, 21);
        System.out.println(compare1);

        System.out.println("*****************************");
        //Lambda表达式的写法
        Comparator<Integer> com2=(i1,i2)->Integer.compare(i1,i2);

        int compare2 = com2.compare(32, 21);
        System.out.println(compare2);

        System.out.println("*****************************");
        //方法引用的写法
        Comparator<Integer>com3=Integer::compare;

        int compare3=com3.compare(32,21);
        System.out.println(compare3);

    }

1.1 基本语法

  1. 举例：(o1,o2)->Integer.compare(o1,o2);
  2. 格式：
    ->: Lambda操作符 或 箭头操作符
    ->左边: lambda形参列表（其实就是接口中的抽象方法的形参列表）
    ->右边: lambda体（其实就是重写的抽象方法的方法体）

1.2 如何使用：6种情况

在这里插入图片描述
在这里插入图片描述

总结六种情况：

  •  ->左边: lambda形参列表的参数类型可以省略（类型推断）；如果lambda形参列表只有一个参数，其一对()也可以省略

  •  ->右边: lambda体应该使用一对{}包裹；如果lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字

2. 函数式接口

2.1 四个基本函数式接口

在这里插入图片描述

3. 方法引用

  1. 可以看做是lambda的深层次表达

  2. 使用格式：
    类(或对象) :: 方法名

  3. 具体分为如下的三种情况：

  • 情况1 对象 :: 非静态方法
  • 情况2 类 :: 静态方法
  • 情况3 类 :: 非静态方法
  1. 要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）
public class MethodRefTest {

	// 情况一：对象 :: 实例方法
	//Consumer中的void accept(T t)
	//PrintStream中的void println(T t)
	@Test
	public void test1() {
		Consumer<String> con1 = str -> System.out.println(str);
		con1.accept("北京");

		System.out.println("*******************");
		PrintStream ps = System.out;
		Consumer<String> con2 = ps::println;
		con2.accept("beijing");
	}
	
	//Supplier中的T get()
	//Employee中的String getName()
	@Test
	public void test2() {
		Employee emp = new Employee(1001,"Tom",23,5600);

		Supplier<String> sup1 = () -> emp.getName();
		System.out.println(sup1.get());

		System.out.println("*******************");
		Supplier<String> sup2 = emp::getName;
		System.out.println(sup2.get());

	}

	// 情况二：类 :: 静态方法
	//Comparator中的int compare(T t1,T t2)
	//Integer中的int compare(T t1,T t2)
	@Test
	public void test3() {
		Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
		System.out.println(com1.compare(12,21));

		System.out.println("*******************");

		Comparator<Integer> com2 = Integer::compare;
		System.out.println(com2.compare(12,3));

	}
	
	//Function中的R apply(T t)
	//Math中的Long round(Double d)
	@Test
	public void test4() {
		Function<Double,Long> func = new Function<Double, Long>() {
			@Override
			public Long apply(Double d) {
				return Math.round(d);
			}
		};

		System.out.println("*******************");

		Function<Double,Long> func1 = d -> Math.round(d);
		System.out.println(func1.apply(12.3));

		System.out.println("*******************");

		Function<Double,Long> func2 = Math::round;
		System.out.println(func2.apply(12.6));
	}

	// 情况三：类 :: 实例方法  (有难度)
	// Comparator中的int compare(T t1,T t2)
	// String中的int t1.compareTo(t2)
	@Test
	public void test5() {
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		System.out.println(com1.compare("abc","abd"));

		System.out.println("*******************");

		Comparator<String> com2 = String :: compareTo;
		System.out.println(com2.compare("abd","abm"));
	}

	//BiPredicate中的boolean test(T t1, T t2);
	//String中的boolean t1.equals(t2)
	@Test
	public void test6() {
		BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
		System.out.println(pre1.test("abc","abc"));

		System.out.println("*******************");
		BiPredicate<String,String> pre2 = String :: equals;
		System.out.println(pre2.test("abc","abd"));
	}
	
	// Function中的R apply(T t)
	// Employee中的String getName();
	@Test
	public void test7() {
		Employee employee = new Employee(1001, "Jerry", 23, 6000);


		Function<Employee,String> func1 = e -> e.getName();
		System.out.println(func1.apply(employee));

		System.out.println("*******************");


		Function<Employee,String> func2 = Employee::getName;
		System.out.println(func2.apply(employee));
	}
}

4. 构造器引用和数组引用

4.1 构造器引用

类名：：new
  1. 要求：和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。 抽象方法的返回值类型即为构造器所属的类的类型。
	//构造器引用
    //Supplier中的T get()
    //Employee的空参构造器：Employee()
    @Test
    public void test1(){

        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("*******************");

        Supplier<Employee>  sup1 = () -> new Employee();
        System.out.println(sup1.get());

        System.out.println("*******************");

        Supplier<Employee>  sup2 = Employee :: new;
        System.out.println(sup2.get());
    }

	//Function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

        System.out.println("*******************");

        Function<Integer,Employee> func2 = Employee :: new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);

    }

	//BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        System.out.println(func1.apply(1001,"Tom"));

        System.out.println("*******************");

        BiFunction<Integer,String,Employee> func2 = Employee :: new;
        System.out.println(func2.apply(1002,"Tom"));

    }

4.2 数组引用

数组类型[]::new

  //Function中的R apply(T t)
    @Test
    public void test4(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

        System.out.println("*******************");

        Function<Integer,String[]> func2 = String[] :: new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

    }

5. Stream API

  1. Stream关注的是对数据的运算，与CPU打交道
    集合关注的是数据的存储，与内存打交道
    使用这套API可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于SQL对数据库中表的操作

  • （1）Stream 自己不会存储元素
  • （2）Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream
  • （3）Stream 操作是延迟执行的。意味着他们会等到需要结果的时候才执行

  1. 使用流程：Stream实例化->一系列中间操作（过滤，映射…)->终止操作

  2. 使用流程的注意点：
    （1）一个中间操作链，对数据源的数据进行处理
    （2）一旦执行终止操作，就执行中间操作链，并产生结果，之后不会再被使用。

  3. 创建

//创建Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> employees= EmployeeData.getEmployees();

        //default Stream<E> stream(): 返回一个顺序流
        Stream<Employee> stream = employees.stream();

        //default Stream<E> parallelStream: 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();

    }

    //创建Stream方式二：通过数组
    @Test
    public void test2(){
        int []arr=new int[]{1,2,3,4};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1=new Employee(1001,"tom");
        Employee e2=new Employee(1002,"tim");
        Employee[] arr1=new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);
    }

    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    }

    //创建Stream方式四：创建无限流
    @Test
    public void test4(){
        //迭代
        //public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);

        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }
  1. 中间操作
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
//    1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list =EmployeeData.getEmployees();
        //filter(Predicate p) --接收lambda，从流中排除某些元素
        Stream<Employee> stream = list.stream();
        //查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary()>7000).forEach(System.out::println);

        System.out.println();

//        limit(n)   --截断流，使其元素不超过给定数量
        list.stream().limit(3).forEach(System.out::println);

//        skip(n)    --跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空流。和limit互补
        list.stream().skip(3).forEach(System.out::println);
//        distinct() --筛选，通过流所生成元素的hashCode()和equals()去除重复元素
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));

        list.stream().distinct().forEach(System.out::println);
    }

    //2-映射
    @Test
    public void test2(){
        //map(Function f) --接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str->str.toUpperCase()).forEach(System.out::println);

        //练习1：获取员工姓名长度大于3的员工的姓名
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> nameStream = employees.stream().map(Employee::getName);
        nameStream.filter(s->s.length()>3).forEach(System.out::println);

        //练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s->{
            s.forEach(System.out::println);
        });
        //flatMap(Function f) --接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);
    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){
        ArrayList<Character> list=new ArrayList<>();
        for (Character c:str.toCharArray()){
            list.add(c);
        }
        return list.stream();
    }

    @Test
    public void test3(){
        ArrayList list1=new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        ArrayList list2=new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);

//        list1.add(list2)
        list1.addAll(list2);
        System.out.println(list1);

    }
    //3-排序
    @Test
    public void test4(){
        //sorted() -- 自然排序
        List<Integer> list = Arrays.asList(12, 43, 21, 44, 54);
        list.stream().sorted().forEach(System.out::println);


        //sorted(Comparator com) -- 定制排序
        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1,e2)->{
            int ageValue = Integer.compare(e1.getAge(), e2.getAge());
            if (ageValue!=0){
                return ageValue;
            }else{
                return Double.compare(e1.getSalary(),e2.getSalary());
            }
        }).forEach(System.out::println);

    }
  1. 终止操作
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    Collector需要使用Collectors提供实例
    在这里插入图片描述
    //1-匹配与查找
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

        //allMatch(Predicate p) --检查是否匹配所有元素。
        //练习：是否所有员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

        //anyMatch(Predicate p) --检查是否至少匹配一个元素
        //是否存在员工工资大于10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

        //noneMatch(Predicate p) --检查是否有没有匹配的元素
        //是否存在员工姓雷
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);

        //findFirst --返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee);

        //findAny --返回当前流中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);


    }

    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();

        //count --返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);

        //max(Comparator c) --返回流中的最大值
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> max = salaryStream.max(Double::compare);
        System.out.println(max);

        //min(Comparator c) --返回流中的最小值
        Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min);

        //forEach(Consumer c) --内部迭代
        employees.stream().forEach(System.out::println);
    }

    //2-归约
    @Test
    public void test3(){
        //reduce(T identity, BinaryOperator) --可以将流中的元素反复结合起来，得到一个值，返回一个T
        //练习1：计算1-10的自然数的和
        List<Integer>list= Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);

        //reduce(BinaryOperator) --可以将流中元素反复结合起来，得到一个值，返回Optional
        //练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
//        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2)->d1+d2);
        System.out.println(sumMoney);
    }

    //3-收集
    @Test
    public void test4(){
        //collect(Collector c) --将流转换为其他形式。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法
        //练习1：查找工资大于6000的员工，结果返回一个List或Set
        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
        //也可以toSet, toCollection
        employeeList.forEach(System.out::println);
    }

6. Optional类

为了解决空指针问题

6.1 常用方法

    @Test
    public void test1(){
        Optional<Object> op1 = Optional.empty();
        if (!op1.isPresent()){//是否包含数据
            System.out.println("empty");
        }

        //如果Optional封装的数据为空，则get()报错
        //不为空，返回数据
        System.out.println(op1.get());

    }

    @Test
    public void test2(){
        String str = "hello";
        //of(T t): 封装t生成Optional对象，要求t非空
        Optional<String> op1 = Optional.of(str);
        //get()通常与of()搭配使用
        String str1=op1.get();
        System.out.println(str1);
    }

    @Test
    public void test3(){
        //ofNullable(T t): 封装数据t给Optional内部的value,t可以空
        Optional<String> op1 = Optional.ofNullable("beijing");
        //orElse(T t1): 如果optional内部value非空，返回value；
//                        如果为空，返回t1
        String str2 = op1.orElse("shanghai");

        System.out.println(str2);



    }
Jeremy202109
关注
专栏目录
JAVA8新特性
一个编码爱好者的博客
12-30 122
1，接口中默认方法和静态方法  1.1默认方法又称扩展方法，需要在方法前使用default关键字记性修饰 必须通过接口的实现类的实例进行访问，既：对象名.默认方法名() 1.2 静态方法又称为类方法，需要在方法前使用static 关键字进行修饰 静态方法既可以通过接口名进行访问，也可以通过接口时实现类的实例进行访问。建议使用:接口名.静态方法名() 2,Lambda表达式 2.1多参数...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 【Java8】Lambda表达式 和 Stream API 详解笔记 md文档
【Java8】Lambda表达式 和 Stream API 详解笔记
passerbyYSQ
11-26 1137
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 笔记 md 文档：xxx（稍后补上） Lambda表达式 概念 ​ Lambda是一个匿名函数，Lambda表达式可以理解为一段可以传递的代码（将代码像数据一样进行传递） 引入 /** * 匿名内部类 */ @Test public void test1() { Comparator<Integer> com = new Comparator<Integer>().
Java8新特性之Lambda表达式、函数式接口、Stream API（笔记）
lzfaq的博客
12-21 561
1、Lambda表达式 Lambda是java8的新特性，使用Lambda可以替代只有一个抽象方法的接口（函数接口）实现，类似于匿名内部类。 1.1 、Lambda的语法格式 （）-> {} (): 用来描述参数列表。 {}：用来描述方法体、执行语句，当只有一条执行语句或只有返回值的时候可以省略。 -> :Lambda运算符 1.2、Lambda基本语法实例 创建多个接口 public interface LambdaInterface { int test1(); }
java lambda表达式、stream流学习笔记
weixin_52472152的博客
12-02 156
java lambda表达式、stream流学习笔记
Java8中Lambda表达式使用和Stream API详解
08-26
主要给大家介绍了关于Java8中Lambda表达式使用和Stream API的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Java8具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Java8 新特性
06-17
Java8是Java历史上一个重要的里程碑版本，它引入了多项革命性的新特性，显著提升了开发效率和程序性能。本篇将详细解读Java8的关键新特性，包括Lambda表达式、函数式接口、Stream API、日期时间API的改进以及...
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性
09-02
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性 自学java的同行们应该都要学习java8的新特性，譬如：（Lambda、Stream、LocalDate等）！本人在学习java的时候看的是波哥的视频，确实讲的不错，很...
JDK8特性(Lambda表达式+StreamAPI简单示例代码)
04-02
JDK8特性(Lambda表达式+StreamAPI的简单使用示例代码)
Java8新特性
06-15
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常常见。 即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是...
Java8 Lambda 表达式官方文档
weixin_38833041的博客
07-07 565
匿名类的实现非常简单，例如只包含一个方法的接口，在这些情况下，您通常会尝试将函数作为参数传递给另一个方法，例如当有人单击按钮时应采取的操作。 Lambda 表达式使您能够做到这一点，将函数视为方法参数，或将代码视为数据。对于只有一个方法的类，即使是匿名类也显得有些多余和繁琐。 Lambda 表达式让您可以更紧凑地表达单方法类的实例。...
lambda学习笔记，常见函数式接口，Stream流处理相关操作
Rigel的博客
07-29 251
lambda学习笔记 Lambda的常见函数式接口 自定义的符合函数式接口加入@FunctionInterface注解为该类添加合法性校验 以下的函数式内建接口都是java.util.function包提供的API，都是通过lambda实现的传入某对象 进行一定的业务处理后(业务处理需要自己写)返回某种数据类型 或不返回。 调用 方法类 方法描述 test(T) Predicate 接受参数对象T，返回boolean类型结果 accep(T) Comsumer 接受参数对象T，不返回任
Java8新特性之Lambda表达式和Stream API
最新发布
qq_64580912的博客
12-19 1991
举例:格式:-> : Lambda操作符或箭头操作符->左边: Lambda形参列表(其实就是接口中的抽象方法的形参列表) ->右边: Lambda体(其实就是重写的抽象方法的方法体)本质:作为函数式接口的实例如果一个接口中只声明了一个抽象方法,则此接口就叫做函数式接口可以通过Lambda表达式来创建该接口的对象。
初识Lambda-含API及Demo
qq_40274514的博客
08-26 241
/* * 一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符 * 箭头操作符将 Lambda 表达式拆分成两部分： * * 左侧：Lambda 表达式的参数列表 * 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体 * * 语法格式一：无参数，无返回值 * (...
Java 8流和Lambda表达式–解析文件示例
最佳 Java 编程
05-26 381
最近，我想从输出日志中提取某些数据。 这是日志文件的一部分： 2015-01-06 11:33:03 b.s.d.task [INFO] Emitting: eVentToRequestsBolt __ack_ack [-6722594615019711369 -1335723027906100557] 2015-01-06 11:33:03 c.s.p.d.PackagesProvide...
java stream api和 lambda 表达式
朝立的博客
06-14 1086
学而不思则罔
Java 8新特性全解析
"Java 8新特性终极指南，详尽解析了Java 8的主要更新，包括Lambda表达式、Functional接口、接口的默认与静态方法、方法引用等语言新特性，以及Optional、Streams、新的Date/Time API、Nashorn JavaScript引擎等类库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值