jdk8的新特性

最新推荐文章于 2024-02-21 10:25:57 发布
最新推荐文章于 2024-02-21 10:25:57 发布
阅读量551 收藏 1
点赞数 1
文章标签： servlet java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aimeiyyds/article/details/125879390
版权

1. lambda表达式

概念：
        Lambda表达式：特殊的匿名内部类，语法更简洁。
        Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递。

语法：

<函数式接口> <变量名> = (参数1，参数2...) -> {

        //方法体

}；

注意：函数式接口：如果一个接口只有一个抽象方法，则该接口称之为函数式接口。
           （参数1，参数2）：抽象方法的参数，形参列表的数据类型会自动推断；如果形参列表为空，只需要保留()；如果形参只有1个，()可以省略，只需要参数的名称即可。
           -> : 分隔符，Lambda引入了新的操作符。
          {} ： 表示抽象方法的实现(方法体),如果执行语句只有一句，且无返回值，{}可以省略；若有返回值，则若想省去{}，则必须同时省略return，且执行语句也保证只有一句。

package demo01;

public class Test01 {
    public static void main(String[] args) {
        Runnable runnable = () ->{
            System.out.println("这是lambda表达式方式创建的任务方法对象");
        };
        Thread t1 = new Thread(runnable);
        t1.start();
    }
}

Lambda表达式的作用：简化匿名内部类的使用，语法更加简单。

2. 函数式接口

如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。
@FunctionalInterface  注解检测接口是否符合函数式接口。

常见的函数式接口
        由于Lambda使用时不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型。因此JDK提供了大量常用的函数式接口。java.util.function

2.1 Consumer<T>

        有参数，无返回值。

package demo03;

import java.util.function.Consumer;

public class Test03 {

    public static void main(String[] args) {
        fun(arr -> {
            int sum=0;
            for(int n:arr){
                sum+=n;
            }
            System.out.println("数组的和为:"+sum);
        });
    }

    public static void fun(Consumer<int[]> consumer){
         int[] arr={1,3,5,7,8,10};
         consumer.accept(arr);
    }

}

2.2 Supplier<T>供给型函数式接口

        T:表示返回结果的泛型    无参，有返回结果的函数式接口时。

package demo04;

import java.util.Random;
import java.util.function.Supplier;

public class Test04 {
    public static void main(String[] args) {
        fun(()->{
            return new Random().nextInt(10);
        });
    }
    public static void fun(Supplier<Integer> supplier){
        Integer integer = supplier.get();
        System.out.println("内容:"+integer);
    }
}

2.3 Function<T,R>   函数型函数式接口

        T：参数类型的泛型
        R：函数返回结果的泛型
        有参，有返回值时。

package demo05;

import java.util.function.Function;

public class Test05 {
    public static void main(String[] args) {
        fun((t)->{
            return t.toUpperCase();
        },"hello world");
    }
    public static void fun(Function<String,String> function,String msg){
        String s = function.apply(msg);
        System.out.println("字符串小写转大写后:"+s);
    }
}

 2.4 Predicated<T>

        T: 参数的泛型   返回一个boolean值
        当传入一个参数时，需要对该参数进行判断时，则需要这种函数。

package demo06;

import java.util.function.Predicate;

public class Test06 {
    public static void main(String[] args) {
        fun((t)->{
            return t.length()>2?true:false;
        },"小黄人");
    }
    public static void fun(Predicate<String> predicate,String name){
        boolean test = predicate.test(name);
        System.out.println("名字长度是否大于2:"+test);
    }
}

3. 方法引用

如果我们在Lambda中所指定的功能，已经有其他方法存在相同方案，没必要再写重复的逻辑，可以直接"引用"过去。

package demo07;

import java.util.function.Consumer;

public class Test07 {
    public static void main(String[] args) {
        fun(Test07::sum);
    }

    public static void fun(Consumer<int[]> consumer){
        int[] arr={1,2,3,4,5};
        consumer.accept(arr);
    }

    public static void sum(int[] arr){
        int sum=0;
        for(int n:arr){
            sum+=n;
        }
        System.out.println("数组的和为:"+sum);
    }
}

方法引用是Lambda表达式的一种简写形式，如果Lambda表达式方法体中只是调用一个特定的已经存在的方法，则可以使用方法引用。

常见形式：
        对象::实例方法
        类::静态方法
        类::实例方法
        类::new
请注意其中的双冒号 :: 写法，这被称为"方法引用",是一种新的语法。

方法引用的分类：

3.1 静态方法引用

对应的Lambda表达式：    (args)->类名.staticMethod(args)

package demo07;

import java.util.function.Consumer;

public class Test07 {
    public static void main(String[] args) {
//        fun((arr)->Test07.sum(arr));
        fun(Test07::sum);
    }

    public static void fun(Consumer<int[]> consumer){
        int[] arr={1,2,3,4,5};
        consumer.accept(arr);
    }

    public static void sum(int[] arr){
        int sum=0;
        for(int n:arr){
            sum+=n;
        }
        System.out.println("数组的和为:"+sum);
    }
}

3.2 实例方法引用

对应的Lambda表达式：    (args)->inst.instMethod(args)

package demo08;

import java.util.function.Supplier;

public class Test08 {
    public static void main(String[] args) {
        User user = new User("暧昧",18);
        //Supplier<String> supplier = ()->user.getName();
        Supplier<String> supplier = user::getName;
        System.out.println(supplier.get());
    }
}
class User{
    private String name;
    private Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.3 对象方法引用

对应的Lambda表达式：    (inst,args)->inst.instMethod(args)

package demo09;

import java.util.function.BiFunction;

public class Test09 {
    public static void main(String[] args) {
//        BiFunction<String,String,Boolean> biFunction = (x,y)->x.equals(y);
        BiFunction<String,String,Boolean> biFunction = String::equals;
        Boolean apply = biFunction.apply("hello", "world");
        System.out.println(apply);
    }
}

3.4 构造方法引用

对应的Lambda表达式：    (args)->new 类名(args)

package demo10;

import java.util.function.Function;

public class Test10 {
    public static void main(String[] args) {
//        Function<String,String> function = (x)->new String(x);
        Function<String,String> function = String::new;
        String hello = function.apply("hello");
        System.out.println(hello);
    }
}

4. Stream流

Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作.

4.1 Stream流的原理

Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

4.2 如何获取Stream流对象

package demo12;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Test12 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("暧昧");
        list.add("小黄人");
        list.add("大yelou");
        Stream<String> stream = list.stream();

        Integer[] arr = {1,5,8,10,15};
        Stream<Integer> stream1 = Arrays.stream(arr);

        Stream<String> stream2 = Stream.of("张三", "李四", "王五", "刘六");

        IntStream stream3 = IntStream.of(1, 2, 3, 5, 6);

        //上面都是串行流,这个是并行流。如果流中的数据量足够大,并行流可以加快速度。
        Stream<String> stringStream = list.parallelStream();
    }
}

4.3 Stream流中常见的api

中间操作api：一个操作的中间链，对数据源的数据进行操作。而这种操作的返回类型还是一个Stream对象。

终止操作api：一个终止操作，执行中间操作链，并产生结果，返回类型不在是Stream流对象。

package demo13;

import java.util.*;
import java.util.stream.Collectors;

public class Test13 {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("欧阳雪",18,"中国",'F'));
        personList.add(new Person("Tom",24,"美国",'M'));
        personList.add(new Person("Harley",22,"英国",'F'));
        personList.add(new Person("向天笑",20,"中国",'M'));
        personList.add(new Person("李康",22,"中国",'M'));
        personList.add(new Person("小梅",20,"中国",'F'));
        personList.add(new Person("何雪",21,"中国",'F'));
        personList.add(new Person("李康",22,"中国",'M'));

        //输出country为英国的元素
        //personList.stream().filter(item -> item.getCountry().equals("英国")).forEach(System.out::println);

        //输出sex为F的元素
        //personList.stream().filter(item->item.getSex()=='F').forEach(System.out::println);

        //只要name 和 age , 原来流中每个元素转换成另一种格式。
        // map--接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
//        personList.stream().map(item->{
//            Map<String,Object> map = new HashMap<>();
//            map.put("name",item.getName());
//            map.put("age",item.getAge());
//            return map;
//        }).forEach(System.out::println);

        //根据年龄排序
        //personList.stream().sorted((o1,o2)->o1.getAge()-o2.getAge()).forEach(System.out::println);

        //输出年龄最大的
        //Optional<Person> max = personList.stream().max((o1, o2) -> o1.getAge() - o2.getAge());
        //System.out.println(max.get());

        //输出年龄最小的
        //Optional<Person> min = personList.stream().min((o1, o2) -> o1.getAge() - o2.getAge());
        //System.out.println(min);

        //规约reduce
        //求集合中所有人的年龄和
        //Optional<Integer> reduce = personList.stream().map(item -> item.getAge()).reduce((a, b) -> a + b);
        //System.out.println(reduce.get());

        //求a有初始化值的规约
        //Integer reduce = personList.stream().map(item -> item.getAge()).reduce(20, (a, b) -> a + b);
        //System.out.println(reduce);

        //collect搜集  搜集年龄大于20且性别为F的
        //List<Person> collect = personList.stream().filter(item -> item.getAge() > 20).filter(item -> item.getSex() == 'F').collect(Collectors.toList());

        //findFirst() 方法根据命名可以大致知道是获取Optional流中的第一个元素。
        //findAny() 方法是获取Optional 流中任意一个，存在随机性，其实里面也是获取元素中的第一个。(适用于并行流)
        //Optional<Person> first = personList.stream().filter(item -> item.getSex() == 'F').findFirst();
        //System.out.println(first.get());

        //allMatch  查询所有元素都符合条件则返回true
        //boolean b = personList.stream().allMatch(item -> item.getAge() > 17);
        //System.out.println(b);

        //anyMatch  查询任一元素有一个符合条件则返回true
        //boolean b = personList.stream().anyMatch(item -> item.getAge() > 23);
        //System.out.println(b);

        //noneMatch 查询没有一个元素符合我们的条件则返回true
        //boolean b = personList.stream().noneMatch(item -> item.getAge() > 23);
        //System.out.println(b);
    }
}
class Person {
    private String name;
    private Integer age;
    private String country;
    private char sex;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                ", sex=" + sex +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Person() {
    }

    public Person(String name, Integer age, String country, char sex) {
        this.name = name;
        this.age = age;
        this.country = country;
        this.sex = sex;
    }
}

5. 新增了日期时间类

Date日期时间类的缺点：
        1.设计比较乱，Date日期在java.util和java.sql都有，而且它的时间格式转换类在java.text包下
        2.线程不安全。

新增的日期时间类:

LocalDate： 表示日期类。yyyy-MM-dd

LocalTime: 表示时间类。 HH:mm:ss

LocalDateTime: 表示日期时间类 yyyy-MM-dd t HH:mm:ss sss

DatetimeFormatter:日期时间格式转换类。

Instant: 时间戳类。

Duration: 用于计算两个日期类

public class Test {
    public static void main(String[] args) {
        //获取当前日期
        LocalDate now = LocalDate.now(); 
        //指定日期
        LocalDate date = LocalDate.of(2022, 8, 23);

        //当前时间
        LocalTime now1 = LocalTime.now();
        LocalTime of = LocalTime.of(17, 30, 20, 600);

        //获取当前日期时间
        LocalDateTime now2 = LocalDateTime.now();
        LocalDateTime now3 = LocalDateTime.of(2022,6,20,17,45,20);
        Duration between = Duration.between(now2, now3);
        System.out.println(between.toHours());


        DateTimeFormatter dateTimeFormatter=DateTimeFormatter.ofPattern("yyyy-MM-dd");
        //把字符串转换为日期格式
        LocalDate parse = LocalDate.parse("1999-12-12", dateTimeFormatter);
        //把日期格式转换为字符串
        String format = parse.format(dateTimeFormatter);
    }
}
Aimeiyyds
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jdk8新特性
11-22
jdk8新特性，百度云盘。jdk8新特性，百度云盘。jdk8新特性，百度云盘。
JDK8新特性：
m0_49102053的博客
05-01 1324
java基础--jDK8新特性
JDK8新特性看这一篇文章就够了
Andrew_Chenwq的博客
02-12 296
1234567891011我们在说方法引用前,先说一下Lambda表达式的组成或者左侧的括号: 函数式接口里面定义的抽象方法的形参列表箭头: Lambda表达式的操作符,看见这个箭头,就可以认为他是一个Lambda表达式右侧Lambda体: 函数式接口中,我们实现了函数式接口抽象方法的方法体对于右侧的Lambda体,可以是一个自定义的表达式(比如上面的a+b)
探索JDK8的新特性
最新发布
南 阳 的博客
02-21 1106
Java 8这个版本提供了很多实用的新特性,针对接口推出了接口默认方法，接口静态方法以及函数式接口，同时为了简化代码编写，推出了lambda表达式，为了增强对数据的操作，还定义了Stream操作等。这个版本目前是市场上一个应用最广泛，也是最重要的一个版本。JDK8中对接口规范进行了新的定义，允许在接口中定义默认方法（使用default关键字修饰），静态方法，同时还推出了函数式接口（使用@FunctionInterface注解描述）设计。
JDK8的新特性
huyulong0612的博客
07-21 5336
java8 的新特性
JDK8 新特性
学习技术的路上不断沉淀自己
02-18 4728
个人博客 个人博客: https://www.crystalblog.xyz/ 备用地址: https://wang-qz.gitee.io/crystal-blog/ 1. 简介 JDK8是官方发布的一个大版本, 提供了很多新特性功能给开发者使用, 包含语言、编译器、库、工具和JVM等方面的十多个新特性。 本文将介绍编码过程中常用的一些新特性. JDK8帮助文档 Lambda表达式 函数式接口 方法引用和构造器调用 Stream API 接口中的默认方法和静态方法 新的日期时间API Optiona
JDK8新特性介绍
偏偏爱吃梨的博客
10-23 1543
JDK8新特性介绍 JDK8新特性： ​ 1，Lambda表达式 ​ 2，新的日期API ​ 3，引入Optional ​ 4，使用Base64 ​ 5，接口的默认方法和静态方法 ​ 6，新增方法引用格式 ​ 7，新增Stream类 ​ 8，注解相关的改变 ​ 9，支持并行（parallel）数组 ​ 10，对并发类（Concurrency）的扩展。 1，Lambda表达式 Lambda 表...
28.java中Java8.0的新特性（附讲解和练习）
Royalic的博客
08-04 1306
Java 8新特性简介 速度更快 代码更少(增加了新的语法： Lambda 表达式) 强大的 Stream API 便于并行 最大化减少空指针异常： Optional Nashorn引擎，允许在JVM上运行JS应用 Lambda表达式 Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。 函数式(Functional)接口 函数式(Funct
JDK8新特性
扛麻袋的少年的博客
01-02 6359
1.Lambda表达式 JDK8以前，我们编写匿名内部类，看着很繁琐。 JDK8带来了Lambda表达式，编写代码更加简单，可以减少冗余代码。 参考：Lambda表达式 Lambda表达式原理分析 Lambda表达式----常用的内置函数式接口 ...
JDK8新特性详解
weixin_47072986的博客
12-26 1898
JDK8新特性详解
JDK8新特性（pdf版）
06-26
JDK8新特性（pdf版）
jdk7新特性jdk8新特性
01-13
# jdk7新特性 ## try-with-resources 是一种声明了`一种或多种资源的try语句`。资源是指在程序用完了之后必须要关闭的对象。try-with-resources语句保证了每个声明了的`资源在语句结束的时候都会被关闭`。任何实现...
jdk8的十大新特性
super_weilin的博客
08-06 8720
了解jdk8的新特性首先要了解jdk7的新特新都有哪些方面增强： 1.jdk语法上 1.1二进制变量的表示，支持将整数类型用二进制来表示，用Ob开头。 1.2Switch语句支持String类型 1.3Try-with-resource语句 注意：实现Java.lang.AutoCloseable接口的资源都...
JDK8的新特性总结
key_768的博客
11-14 3733
JDK8 新版任你发，我用Java8 身为使用最多的版本，我们还是需要好好了解JDK8的改动 JDK的常用新特性总结： Lambda 表达式：Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中） 函数式接口 方法引用和构造器调用：方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。 接口支持静态方法和默认方法 Stream API：新添加的Stream API
Java版本：JDK8的十大新特性介绍
热门推荐
ZytheMoon的博客
04-30 4万+
JDK8新特性： 1.Lambda表达式 2.新的日期API 3.引入Optional 4.使用Base64 5.接口的默认方法和静态方法 6.新增方法引用格式 7.新增Stream类 8.注解相关的改变 9.支持并行（parallel）数组 10.对并发类（Concurrency）的扩展。 ...
JDK8的新特性详解
Dmeo_meng的博客
07-08 181
1、Lambda表达式 1、概述 （1）Lambda表达式是内部类的一种简写形式，对为提升代码开发效率对函数式接口的一种抽象实现的方式。 （2）好处：避免了很多无用或者说不需要的代码； （3）Lambda表达式的专用符号**->通常称为箭头符号，或者是砖石操作符； （4）在->**的左边是表达式的参数，在符号的右边是表达式的逻辑代码 （5）Lambda的语法格式 （1）语法格式一：没有...
jdk8新特性有哪些
12-14
JDK 8，也就是 Java Development Kit 8，有许多新的特性。以下是其中一些主要的新特性： 1. **Lambda 表达式和函数式接口**：这是 JDK 8 中最重要的新特性之一。Lambda 表达式允许开发者以更简洁的方式编写代码，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值