Java基础-JDK8新特性

最新推荐文章于 2024-09-04 15:29:36 发布
最新推荐文章于 2024-09-04 15:29:36 发布
阅读量112 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Feirana/article/details/115375976
版权

函数式接口

有且只有一个抽象方法的接口,称为函数式接口;
在JDK8中新增了 @FunctionalInterface注解, 可以用其检测接口是否是一个函数式接口;
在JDK8中 java.util.function包下定义了丰富的函数式接口, 内置四大核心函数式接口:

函数式接口参数类型返回类型用途
Consumer<T>消费型Tvoid对类型为T的对象应用操作,包含方法 void accept(T t)
Supplier<T>供给型T返回类型为T的对象,包含方法 T get()
Function<T,R>函数型TR对类型为T的对象应用操作,并返回R类型的结果对象, 包含方法 R apply(T t)
Predicate<T>断定型TBoolean确定类型为T的对象是否满足某约束,并放回Boolean值,包含方法 boolean test(T t)
// 自定义函数式接口
@FunctionalInterface
interface MyFunctionInterface<K, V, R> {
	// 有且只有一个抽象方法
    R check(K t, V e);

    static Boolean check2() {
        return null;
    }

    default String check3() {
        return null;
    }
}
@Test
public void functionTest(){
	// 使用匿名实现类方式实例化这些函数式接口
    Consumer<String> c = new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    };
    c.accept("我是消费型函数式接口");

    Supplier<String> s = new Supplier<String>() {
        @Override
        public String get() {
            return "供给型函数式接口匿名实现类";
        }
    };
    System.out.println(s.get());

    Function<String, Character[]> f = new Function<String, Character[]>() {
        @Override
        public Character[] apply(String s) {
            char[] chars = s.toCharArray();;
            Character[] cs = new Character[chars.length];
            for (int i = 0; i<= chars.length-1; i++) {
                cs[i] = chars[i];
            }
            return cs;
        }
    };

    Character[] characters = f.apply("我是函数型函数式接口");
    for (Character cr: characters) {
        System.out.println(cr);
    }

    Predicate<String> p = new Predicate<String>() {
        @Override
        public boolean test(String s) {
            Integer i = s.compareTo("");
            return Boolean.parseBoolean(i.toString());
        }
    };

    System.out.println(p.test("你是SB"));
}

Lambda表达式

Lambda表达式的本质: 是函数式接口的实例, 使用匿名实现类来实例化接口的方式可以使用Lambda表达式来简化编写过程;
Lambda表达式的公式: (函数式接口抽象方法的形参列表…) -> {函数式接口被重写的抽象方法的方法体}

  1. -> 左边: lambda形参列表; 本质是接口中的抽象方法的形参列表, 形参列表的参数类型可以省略(类型推断), 如果形参列表有且只有一个参数, 那么一对()可以省略;
  2. -> : lambda操作符;
  3. -> 右边: lambda体; 本质是函数式接口中被重写的抽象方法的方法体, lambda体应使用一对{}包裹, 如果lambda体只有一句执行语句(可能是return语句),那么{} 和 return关键字都可以省略;
@Test
public void lambdaTest(){
	// 只有一个形参则->左边省略(), 方法体只有一句执行语句则-> 右边省略{}
    Consumer<String> c = s -> System.out.println(s);
    c.accept("我是消费型函数式接口");
	
	// 没有形参列表 则 -> 左边是(), 方法体只有一个返回语句 则 -> 右边省略{}和return关键字
    Supplier<String> s = () -> "供给型函数式接口匿名实现类";
    System.out.println(s.get());
	
	// 只有一个形参则->左边省略() 方法体有多条执行语句 则->右边为完整的{方法体...return ....;}
    Function<String, Character[]> f = str -> {
        char[] chars = str.toCharArray();;
        Character[] cs = new Character[chars.length];
        for (int i = 0; i<= chars.length-1; i++) {
            cs[i] = chars[i];
        }
        return cs;
    };
    Character[] characters = f.apply("我是函数型函数式接口");
    for (Character cr: characters) {
        System.out.println(cr);
    }
	// 没有形参列表 则 -> 左边是(), 方法体只有一个返回语句 则 -> 右边省略{}和return关键字
    Predicate<String> p = str -> Boolean.parseBoolean(((Integer)str.compareTo("")).toString());
    System.out.println(p.test("你是SB"));
	
	// 形参列表有多个形参则->左边是(xxx), 方法体只有一个返回语句 则 -> 右边省略{}和return关键字
    Comparator<String> comparator = (s1, s2) -> s1.compareTo(s2);
    System.out.println(comparator.compare("H", "C"));

	// 形参列表有多个形参则->左边是(xxx),方法体有多条执行语句 则->右边为完整的{方法体...return ....;}
	// MyFunctionInterface<K,V,R> mfi = (K, V)->{ ... return R};
	MyFunctionInterface<String, String[], List<String>> mfi = (check, arr) -> {
		List<String> list = new ArrayList<>();
        if (arr != null && arr.length > 0) {
	        for (String str: arr) {
	            if (str.contains(check)) {
	                list.add(str);
	            }
	        }
        }
        return  list;
    };
    List<String> list = mfi.check("京", new String[]{"北京","东京","西京","南京","天津"});
    System.out.println(list);
}

方法引用与构造器引用

方法引用

方法引用的本质: Lambda表达式的进一步简写, 所以也是函数式接口的实例;
方法引用的公式: 1. 对象::非静态方法; 2. 类::静态方法; 3. 类::非静态方法
使用条件:

  1. 当存在一个类且这个类的存在一个方法的形参列表以及返回值类型与函数式接口的抽象方法的形参列表以及返回值类型完全相同, 则此类的这个方法可以在函数式接口实例化时使用方法引用的形式被引用;(格式1.2可使用的条件)
  2. 当存在一个类且此类作为函数式接口的抽象方法的形参列表的第一个参数类型, 同时此类存在一个方法,此方法的形参列表与函数式接口的抽象方法的剩余形参列表相同, 此方法的返回类型与函数式接口的抽象方法返回类型相同,则此类的这个方法可以在函数式接口实例化时使用方法引用的形式被引用;(格式3使用的条件)

个人理解: 其实可以看做某个类的方法在满足上述条件时, 此类的方法可以看做为函数式接口的抽象方法的重写, 所以使用方法引用实例化函数式接口后,函数式接口调用抽象方法时,实际调用的就是被引用的方法;

@Test
public void functionQuoteTest(){
    // 类::静态方法 System.out 输出流的 println(String s)方法 与 Consumer 的accept(T t) 方法的参数列表和返回类型一致
    Consumer<String> c = System.out::println;
    c.accept("哈哈");

    // 类::非静态方法 String类本身与Comparator的compare(T o1, T o2)第一个参数类型相同, 
    // String的compareTo(String anotherStr)方法的形参与Comparator的compare(T o1, T o2)后续的新参相同, 且返回值相同
    Comparator<String> comparator = String::compareTo;
    System.out.println(comparator.compare("abc", "abd"));
}
构造器引用

Stream API

Stream 是数据渠道, 用于操作数据源(集合,数组等)所生成的元素序列; 集合本质是数据,Stream本质是计算;
Stream 操作的三个步骤: 1.创建: 从数据源中获取; 2.中间操作: 一个中间操作链,对数据源的数据进行计算处理; 3. 终止操作: 也叫终端操作,一点执行终止操作, 就执行中间操作链, 并产生新的结果.不会对原来的数据产生影响; Stream执行终止操作后不可以继续使用;

class BasketBallPlayer {
    private String name;
    private Integer age;
    private BigDecimal salary;
    public BasketBallPlayer(String name, Integer age, BigDecimal salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public BasketBallPlayer(BigDecimal salary) {
        this.salary = salary;
    }
    public BasketBallPlayer(String name) {
        this.name = name;
    }
    public BasketBallPlayer() {
    }
    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 BigDecimal getSalary() {
        return salary;
    }
    public void setSalary(BigDecimal salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "BasketBallPlayer{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        BasketBallPlayer that = (BasketBallPlayer) o;
        return Objects.equals(name, that.name) &&
                Objects.equals(age, that.age) &&
                Objects.equals(salary, that.salary);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
}
Stream实例化方式
public static List<BasketBallPlayer> getBasketBallPlayers(){
    List<BasketBallPlayer> list = new ArrayList<>();
    list.add(new BasketBallPlayer("Kobe Bryant",40,new BigDecimal("40000000")));
    list.add(new BasketBallPlayer("LeBron James",36,new BigDecimal("30000000")));
    list.add(new BasketBallPlayer("Michael Jordan",50,new BigDecimal("60000000")));
    list.add(new BasketBallPlayer("Stephen Curry",33,new BigDecimal("10000000")));
    list.add(new BasketBallPlayer("Kevin Durant",29,new BigDecimal("25000000")));
    list.add(new BasketBallPlayer("Dwyane Wade",41,new BigDecimal("15000000")));
    list.add(new BasketBallPlayer("Dwyane Wade",41,new BigDecimal("15000000")));
    return list;
}
@Test
public void streamTest(){
    // 实例化
    // 通过集合获取
    List<BasketBallPlayer> basketBallPlayers = getBasketBallPlayers();
    Stream<BasketBallPlayer> basketBallPlayerStream = basketBallPlayers.stream();
    // 通过Arrays获取
    String[] strings = {"AA", "BB", "CC", "DD"};
    Stream<String> stringStream = Arrays.stream(strings);
    // Stream.of(T t...)获取
    Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5);
    // Stream.iterate(final T seed, final UnaryOperator<T> f)获取
    Stream<Integer> iterate = Stream.iterate(0, t -> t + 2).limit(10);
}
中间操作
@Test
public void streamTest(){
	List<BasketBallPlayer> basketBallPlayers = getBasketBallPlayers();
	// 中间操作
    System.out.println("filter********************");
    // Stream<T> filter(Predicate<? super T> predicate);
    // 传入Predicate判定型函数式接口, 用于过滤流中不符合条件的元素
    Stream<BasketBallPlayer> filter = basketBallPlayers.stream().filter(e -> e.getAge() > 30); // 获取年龄大于三十的球员
    filter.forEach(System.out::println); // 执行终止操作
    
    System.out.println("limit********************");
    // limit(long maxSize); 截断流中前几个元素, 只保留0-maxSize元素
    Stream<BasketBallPlayer> limit = basketBallPlayers.stream().limit(3);
    limit.forEach(System.out::println); // 执行终止操作
    
    System.out.println("skip********************");
    // skip(long n); 截断流中后几个元素 只保留 n至流的最后一个元素, 如果n大于流的元素格式,则返回空的流
    Stream<BasketBallPlayer> skip = basketBallPlayers.stream().skip(3);
    skip.forEach(System.out::println); // 执行终止操作
    
    System.out.println("distinct********************");
    // distinct() 去重 通过元素的equals()和hashCode()方法比较
    Stream<BasketBallPlayer> distinct = basketBallPlayers.stream().distinct();
    distinct.forEach(System.out::println); // 执行终止操作

	// 映射
    System.out.println("map********************");
    // map(Function<? super T, ? extends R> mapper)
    Stream<String> map = basketBallPlayers.stream().map(BasketBallPlayer::getName);
    map.forEach(System.out::println);
    // flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
//      basketBallPlayers.stream().flatMap()

    // 排序
    System.out.println("sorted********************");
    // sorted() 调用空参接口需要T实现Comparator接口才行
    // sorted(Comparator<? super T> comparator)
    Stream<BasketBallPlayer> sorted = basketBallPlayers.stream().sorted((b1, b2) -> b1.getSalary().compareTo(b2.getSalary()));
    sorted.forEach(System.out::println);
}

@Test
public void streamTest(){
	// 终止操作
	// 匹配 查找
    System.out.println("allMatch********************");
    // boolean allMatch(Predicate<? super T> predicate); 传入断定型函数式接口实例,表示是否所有数据都满足条件
    boolean allMatch = basketBallPlayers.stream().allMatch(e -> e.getAge() > 30);
    System.out.println(allMatch);
    System.out.println("anyMatch********************");
    // boolean anyMatch(Predicate<? super T> predicate); 传入断定型函数式接口实例,表示是否存在某个数据满足条件
    boolean anyMatch = basketBallPlayers.stream().anyMatch(e -> e.getAge() > 30);
    System.out.println(anyMatch);
    System.out.println("noneMatch********************");
    // boolean noneMatch(Predicate<? super T> predicate); 传入断定型函数式接口实例,表示是否所有数据都不满足条件
    boolean noneMatch = basketBallPlayers.stream().noneMatch(e -> e.getAge() > 60);
    System.out.println(noneMatch);
    System.out.println("findFirst********************");
    // Optional<T> findFirst(); 返回流中的第一个元素 使用Optional包装
    Optional<BasketBallPlayer> first = basketBallPlayers.stream().findFirst();
    System.out.println(first);

    System.out.println("findAny********************");
    // 随机返回一个
    Optional<BasketBallPlayer> any = basketBallPlayers.stream().findAny();
    System.out.println(any);

    System.out.println("count********************");
    // 查找个数
    long count = basketBallPlayers.stream().count();
    System.out.println(count);

    System.out.println("max********************");
    // Optional<T> max(Comparator<? super T> comparator); 最大值
    Optional<BasketBallPlayer> max = basketBallPlayers.stream().max((e1, e2) -> e1.getAge().compareTo(e2.getAge()));
    System.out.println(max);

    System.out.println("min********************");
    // 最小值
    Optional<BasketBallPlayer> min = basketBallPlayers.stream().min((e1, e2) -> e1.getAge().compareTo(e2.getAge()));
    System.out.println(min);
    System.out.println("forEach********************");
    // 遍历
    basketBallPlayers.stream().forEach(System.out::println);
    // 归约
    System.out.println("reduce********************");
    // 将流中元素反复结合, 得到一个值 返回Optional<T>
    Optional<BigDecimal> reduce = basketBallPlayers.stream().map(BasketBallPlayer::getSalary).reduce(BigDecimal::add);
    System.out.println(reduce);
    // 将流中元素反复结合, 得到一个值 返回T
    BigDecimal reduce1 = basketBallPlayers.stream().map(BasketBallPlayer::getSalary).reduce(new BigDecimal("0"), BigDecimal::add);
    System.out.println(reduce1);
    // 收集
    List<BasketBallPlayer> collect = basketBallPlayers.stream().sorted((e1, e2) -> e1.getSalary().compareTo(e2.getSalary())).collect(Collectors.toList());
}

Optional

java.util.Optional 是一个容器类, 他可以保存类型T的值, 代表这个值存在, 或者仅仅保存NULL, 标志这个值不存在. 远啦用NULL表示一个至不存在, 现在用Optional可以更好的表达这个概念,并且可以避免空指针异常;

Feirana
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础】JDK8新特性最佳实践
互联网小阿祥
10-31 2071
JAVA8的新特性总结，全是实用的API！
Java基础：JDK8新特性(1)
2401_84408217的博客
04-18 872
外链图片转存中…(img-sa9tuGne-1713438208857)][外链图片转存中…(img-pW48VjJK-1713438208858)][外链图片转存中…(img-g0pB2bgt-1713438208858)]
jdk目录详解及其使用方法
hanghangde的博客
01-29 7959
jdk目录详解 jdk目录详解 JDK(Java Development Kit，Java开发包，Java开发工具)是一个写Java的applet和应用程序的程序开发环境。它由一个处于操作系统层之上的运行环境还有开发者 编译，调试和运行用Java语言写的applet和应用程序所需的工具组成。        JDK(Java Development Kit)是Sun Microsyst
Java基础：JDK8新特性
2401_84814221的博客
05-11 999
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
【JDK8】Java8新特性
linchaoquande的专栏
11-22 216
一、Lambda 表达式 1、概念： Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为“->” ，该操作符被称为Lambda 操作符或剪头操作符。它将Lambda 分为两个部分： 左侧：指定了Lambda 表达式需要的所有参数 右侧：指定了Lambda 体，即Lambda 表达式要执行的功能。 2、语法：...
java-jdk1.8-jdk-8u201-linux-x64.zip
11-15
这个压缩包文件"java-jdk1.8-jdk-8u201-linux-x64.zip"包含了JDK 8u201的安装程序，特别是针对64位Linux系统的版本。JDK是Java语言开发的基础，它提供了编译、调试和运行Java应用程序所需的所有工具。 首先，让我们...
java-jdk1.8-jdk-8u192-linux-x64.zip
11-15
这个压缩包“java-jdk1.8-jdk-8u192-linux-x64.zip”包含了用于在64位Linux系统上运行和开发Java应用程序所需的组件。JDK全称为Java Development Kit，它是Java编程语言的核心组成部分，提供了编译、调试、运行Java...
java-jdk1.8-jdk-8u181-windows-x64.zip
11-15
这个压缩包"java-jdk1.8-jdk-8u181-windows-x64.zip"内包含两个文件：一个是主安装程序“jdk-8u181-windows-x64.exe”，用于在Windows 64位系统上安装JDK 1.8的更新181版本；另一个是“使用说明.txt”，通常会提供...
java-jdk1.8-jdk-8u181-linux-x64.zip
11-15
这个压缩包文件“java-jdk1.8-jdk-8u181-linux-x64.zip”包含了适用于64位Linux系统的JDK 1.8更新181版本。JDK（Java Development Kit）是开发者编写、调试和运行Java应用程序所必需的一套工具，包括Java编译器、...
java-jdk1.8-jdk-8u192-windows-x64.zip
11-15
标题中的"java-jdk1.8-jdk-8u192-windows-x64.zip"表明这是一个压缩包，内含64位的Java JDK 1.8u192版本，适用于Windows操作系统。这种格式的文件通常用于方便下载和传输大文件，用户需要先将其解压缩才能进行后续...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 3228
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
okhttp，retrofit,rxjava 是如何配合工作的 作用分别是什么
最新发布
追梦的鱼儿
09-04 274
OkHttp、Retrofit 和 RxJava 是 Android 开发中常用的三种库，它们各自有不同的作用，并且可以很好地配合工作来实现网络请求和响应的处理。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1227
浅析synchronized锁升级的原理与实现
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 779
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7292
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
深度解读并发安全集合的原理及源码
DougLiang的博客
09-01 1323
本节主要介绍J.U.C包中的几种并发安全集合：ConcurrentHashMap,ConcurrentLinkedQueue,和ConcurrentLinkedDeque。所谓并发安全集合，相对于普通集合来说，能够保证在多线程环境下向集合中添加数据时的线程安全性。主要讲ConcurrentHashMap在实现线程安全性方面对性能和安全性的合理平衡。
JavaWeb（基于SpringBoot开发）全总结（1）
2302_81420820的博客
09-02 982
再到spring boot中去设置，当我们遇到报错不要紧，我们直接再复制我们在DG上面写的sql语句，到idea那个数据库那里再运行一次，2.由于使用不同开发工具开发出来的略有不同，导致不能够互通，所以国际规定，使用maven创建的项目为统一标准结构，也就是下图所示的结构。还有我们写的案例里面的mapper层写的sql语句的新增，删除，等等操作，都是基于mybatis来实现的。例如：传入的是路径参数，json格式的参数等等，根据不同的参数我们使用不同的注解。
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现
央顺科技官方博客
08-31 1373
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 1696
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
Java JDK1.5-1.7新特性详解
"JDK1.5-1.7的新特性包括自动装箱与拆箱、枚举类型、泛型、可变参数、foreach循环、静态导入、注解、增强...这些新特性不仅提高了代码的简洁性和可读性，还增强了程序的安全性和性能，是Java程序员必须掌握的基础知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值