Jdk1.8新特性看这篇就够了

最新推荐文章于 2025-04-18 10:36:53 发布
最新推荐文章于 2025-04-18 10:36:53 发布
阅读量232 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40553042/article/details/109142486
版权

前言

Jdk1.8提出了很多新特性，比如增加新的语言(Lambda表达式)、Stream API，Optional类。jdk8增加的新特性，使得程序效率会更快，提升程序员的编程体验。

Lambda表达式

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码。使得写出更简洁、灵活的代码。
举例:(o1,o2)->Integer.compare(o1,o2)，其中->：Lambda操作符或箭头操作符；->左边：Lambda形参列表(接口中抽象方法的形参列表);->右边：Lambda体(重写接口抽象方法的方法体)。使用情况介绍，主要分为6种语法格式:

  • 语法格式一:无参，无返回值
    @Test
    public  void  test(){

        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable ...");
            }
        };
        runnable.run();

        System.out.println("*************Lambda************");
        Runnable runnable1=()->{
            System.out.println("Runnable ...");
        };
        runnable1.run();
    }
  • 语法格式二:有一个参数，无返回值
 @Test
    public void  test2(){
        Consumer<String>consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("helo.xf");

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

        //由于泛型指明<String>,这里s不用指明类型，编译器会自动进行类型推断
        Consumer<String>consumer1=(s)->{
            System.out.println(s);
        };
        consumer1.accept("hello,xf");
    }
  • 语法格式三:需要有一个参数，参数的小括号可以省略
 @Test
    public void  test3(){
        Consumer<String>consumer=new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("helo.xf");

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

        //参数s不用带小括号
        Consumer<String>consumer1=s->{
            System.out.println(s);
        };
        consumer1.accept("hello,xf");
    }
  • 语法格式四：两个或两个以上参数，方法体有多条执行语句，并有返回值
    @Test
    public void test4(){
        Comparator<Integer>comparator=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("o1:"+o1);
                System.out.println("o2:"+o2);
                return o1.compareTo(o2);
            }
        };
        int compare = comparator.compare(12, 20);

        System.out.println(compare);

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

        Comparator<Integer>comparator1=(o1,o2)->{
            System.out.println("o1:"+o1);
            System.out.println("o2:"+o2);
            return o1.compareTo(o2);
        };

        int compare1 = comparator1.compare(20, 34);
        System.out.println(compare1);
    }
  • 语法格式五：Lambda体只有一条语句，return与大括号若有，都可以省略
@Test
    public void  test5(){

        Comparator<Integer>comparator=new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        int compare = comparator.compare(12, 20);

        System.out.println(compare);

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

        Comparator<Integer>comparator1=(o1,o2)-> o1.compareTo(o2);

        int compare1 = comparator1.compare(20, 34);
        System.out.println(compare1);

    }

Lambda总结得到：->左边:Lambda形参列表类型可以省略(类型推断)，若形参只有一个，这对()也可以省略；->右边:Lambda体使用一对{}包住，若体内只有一条语句(也包括return语句)，这对{}和return关键字都可以省略，并且{}省略了return关键字也必须省略。其实Lambda本质也是一个借口的实例，看=号右边就能明白了。

函数式接口

FunctionalInterface：若一个接口中只声明一个抽象方法，则此接口称为函数式借口，可以在接口上加上@FunctionalInterface注解，验证该接口为函数式接口。例如：


/**
 * 函数式接口
 *
 */
@FunctionalInterface
public interface Animal {
    String eat(String food);

}

//Lambda表达式实现函数式接口

        Animal catAnimal=(s)->{
            System.out.println(s);
            return  s;
        };
        String s = catAnimal.eat("fish");  //fish

而且函数式接口的实现可以用Lambda表达式

四大函数式接口

在java.util.function包下，为我们提供了常用的四大函数式接口:Predicate<T>、Supplier<T>、Function<T, R>、Consumer<T>、

  • Predicate<T>:
    断定型接口，参数类型为T，根据传入的参数是否满足某些约束并返回boolean值，包含方法: boolean test(T t)
  Predicate<Integer>predicate=(t->{
           if (t>10) {
               return true;
           }else {
               return false;
           }
       });
        boolean test = predicate.test(1);  //false
  • Supplier<T>:
    供给型接口，不接受任何参数，根据泛型T，返回T类型的对象，包含 T get()方法
  Supplier<Student>supplier=(()->{
           return  new Student(1,"xf",24);
   });
   Student student = supplier.get();
  • Consumer<T>:
    消费型接口，参数类型为T，对传入的参数进行操作，无返回值，包含void accept(T t)方法
    Consumer<String>consumer=((s)->{
            System.out.println("s:"+s);
        });

        consumer.accept("xfnihao");  //xfnihao
  • Function<T, R>:
    函数型接口，对参数类型为T的对象操作后返回R类型结果，包含 R apply(T t)方法
   Function<String, Boolean>function=((s)->{
         
            if (s.equals("xf")){
                return true;
            }else {
                return false;
            }
        });

        Boolean result = function.apply("nihao");  //false

Stream API

Jdk8重大改变一个是Lambda表达式，另一个就是Stream API。Stream API实现函数式编程，使得程序代码更简洁、高效。常用用于对集合数据的计算，包括排序、查找、过滤等。
Stream的操作三个步骤:
1.创建Stream
一个数据源(如:集合、数组)，获取一个流
2.中间操作
对数据源的数据进行处理
3.终止操作(终端操作)
一旦执行终止操作，就执行中间操作，并产生结果。

  • 代码演示

    /**
     * 1.创建流
     */
    @Test
    public void test1() {

        //顺序流
        List<Student> listData = Student.getStudents();

        Stream<Student> studentStream = listData.stream();

        //并行流
        Stream<Student> parallelStream = listData.parallelStream();


        int[] array = new int[]{1, 2, 3, 4, 5};
        //数据
        IntStream stream = Arrays.stream(array);
    }

 @Test
    /**
     * 2.中间操作->筛选与切片:类似操作SQL，通过where或聚合函数来进行条件查询
     */
    public void test2() {
        //顺序流
        List<Student> listData = Student.getStudents();

        //过滤 filter
        Stream<Student> stream = listData.stream();

        stream.filter((s)->s.getId()>1).forEach(System.out::println);

        //限流 limit
        Stream<Student> stream1 = listData.stream();

        stream1.limit(3).forEach(System.out::println);


        //跳过 skip
        Stream<Student> stream2 = listData.stream();
        stream2.skip(3).forEach(student -> System.out.println(student));


        //去重 distinct,要重写hashCode和equals方法

        Stream<Student> stream3 = listData.stream();
        stream3.distinct().forEach(student -> System.out.println(student));



    }


    /**
     * 中间操作->映射:map(function f)接收一个函数作为参数，将元素转为其他形式或提取元素
     */
    @Test
    public void test3() {

        List<Student> list = Student.getStudents();

        //将学生姓名转为大写
        list.stream().map(student -> student.getName().toUpperCase()).forEach(s -> System.out.println(s));


    }

    /**
     * 中间操作->排序
     */
    @Test
    public void test4(){

        //自然排序: Stream<T> sorted();

        List<Integer> list = Arrays.asList(0, 12, -90, 23, 100, 56, 2);
        list.stream().sorted().forEach(i -> System.out.println(i) );



        //定制排序: Stream<T> sorted(Comparator<? super T> comparator);按学号从大到小排序
        List<Student> listData = Student.getStudents();
        listData.stream().sorted((s1,s2)->{
            return -s1.getId().compareTo(s2.getId());
        }).forEach(item-> System.out.println(item));
    }

 /**
     * 3.终止操作->匹配与查找
     */

    @Test
    public void  test5(){
        List<Integer> list = Arrays.asList(0, 12, -90, 23, 100, 56, 2);
        //findFirst:返回第一个元素
        Integer i = list.stream().sorted().findFirst().get();
        System.out.println(i);


        //findAny：返回任意元素
        Optional<Integer> any = list.parallelStream().findAny();
        System.out.println(any);

        //count:返回元素个数
        long count = list.stream().count();
        System.out.println(count);


        //max:返回最大的元素
        Optional<Integer> max = list.stream().max((s1, s2) -> {
            return s1.compareTo(s2);
        });
        System.out.println(max);
    }

    /**
     *
     * 终止操作->规约:reduce,将流中的元素反复结合起来，得到新值并返回
     */
    @Test
    public void test6(){

        List<Integer> list = Arrays.asList(0, 12, -90, 23, 100, 56, 2);

        //reduce(T identity, BinaryOperator<T> accumulator);
        //求数组总和
        Integer sum = list.stream().reduce(0, (a, b) -> {
            return Integer.sum(a, b);
        });
        System.out.println(sum);
    }

    /**
     * 终止操作->收集:collect(Collectors ...)将处理后的流转为其他集合形式(Set/Map/List)
     */
    @Test
    public  void  test7(){

        List<Student> students = Student.getStudents();
        //返回有序List
        List<Student> list = students.stream().filter(
                student -> student.getId() > 1)
                .collect(Collectors.toList());

        //无序Set
        Set<Student> set = students.stream().filter
                (student -> student.getId() > 1).collect(Collectors.toSet());

    }

练习

/**
 * @author xfnihao
 * 根据Stream流条件查询
 */
public class StreamDemo {
    public static void main(String[] args) {

        Student s1=new Student(1,"a",12);
        Student s2=new Student(2,"b",8);
        Student s3=new Student(3,"c",18);
        Student s4=new Student(4,"d",24);
        Student s5=new Student(5,"e",20);
        Student s6=new Student(6,"f",20);

        //id为偶数&age>18&名字大写&倒排序获取一个
        //select name from tb where id %2==0 and age>18   func(name)  order by  ..
        List<Student>list=Arrays.asList(s1,s2,s3,s4,s5,s6);
        list.stream().filter((s -> {
            return s.getId() % 2 == 0;
        })).filter((s -> {
            return s.getAge() > 18;
        })).map((student -> {
            return student.getName().toUpperCase();
        })).sorted((o1, o2) -> {
            return -o1.compareTo(o2);
        }).limit(1).forEach(System.out::println);
    }
}

这样，我们就学会并使用Stream API，简化了代码，使得编程更高效。要想更熟练这套API，需要大量的实践。

总结

Jdk8中的常用新特性主要是Lambda表达式和Stream API，目前只需掌握这两个就够了。简化代码的编写和提升集合操作的效率。

C/C++区别
小白的逆袭
07-18 531
本文主要参考了C++标准委员会出品的 Mix-c-and-cpp 和 Learning C++ if you already know C 两个链接对应的一些问答内容，加上我个人的理解完成。本文先会说明C++和C的发展历史和它们之间关系，然后从编程范式上提纲挈领地总结一下表达下我个人的感受，之后从几个区别点来具体说明它们的不同。有不准确或疏漏的地方还请大家指正，谢谢。 然后，关于C++语言标准参...
VsCode安装和配置c/c++环境（超完整，小白专用）
热门推荐
黄化的多多
07-21 59万+
1. vsCode配置C/C++环境 1. vsCode下载和安装 1. 下载Microsoft vsCode [vsCode在这里插入图片描述官网下载: https://code.visualstudio.com/ 2. 安装vsCode 3. 下载中文插件 我这边已经下载过，刚卸载但是没有重启编译器，所以界面显示了中文 2. MinGW编译器下载和配置 1. 下载MinGW 在线安装——下载MinGW-W64-install.exe（速度慢） 下载压缩包——×86_64-posix-
C与C++的区别
wqvbjhc的专栏
04-24 3万+
在很大程度上,标准C++是标准C的超集.实际上,所有C程序也是C++程序,然而,两者之间有少量区别.下面简要介绍一下最重要的区别.    在C++中,民,局部变量可以在一个程序块内在任何地方声明,在C中,局部变量必须在程序块的开始部分,即在所有"操作"语句之前声明,请注意,C99标准中取消了这种限制.    在C中,按如下方式声明的函数没有对函数参数进行任何说明;    int func();  
【C/C++】C转C++学习笔记
最新发布
ayaishere_的博客
04-18 634
帮助有C基础的朋友简单了解C++中的关键组件，快速上手C++！
c/c++区别
Victor_psl的博客
03-17 292
一、面向过程语言和面向对象语言 我们都知道C语言是面向过程语言，而C++是面向对象语言，说C和C++的区别，也就是在比较面向过程和面向对象的区别。C与C++的最大区别：在于它们的用于解决问题的思想方法不一样。之所以说C++比C更先进，是因为“ 设计这个概念已经被融入到C++之中 ”，而就语言本身而言，在C中更多的是算法的概念。那么是不是C就不重要了，错！算法是程序设计的基础，好的设计如果没有好的算...
c/c++帮助文档中文
04-03
C/C++是两种广泛使用的编程语言，特别是在系统编程、嵌入式开发以及高性能计算领域。这份"c/c++帮助文档中文"提供了丰富的中文资源，帮助开发者深入理解和掌握这两种语言。 C语言是最早由Dennis Ritchie在贝尔实验...
二维码（QRcode）生成算法 C语言/C++源码
02-11
#二维码（QRcode）生成算法 C语言/C++ 源码 1. 根据输入字符串识别编码模式； 2. 根据输入字符串长度选择合适的QRcode版本； 3. 将编码转换为二进制位流表示为数据码字； 4. 使用多项式生成纠错码； 5. 将数据码和...
Dev-cpp5.4.0及API帮助文档 2018年蓝桥杯C语言/c++
03-07
这个版本在2018年的蓝桥杯编程竞赛中被广泛使用，帮助参赛者进行C语言和C++程序的编写。 【C++API.chm】：这是一个关于C++标准库的API帮助文档，以CHM（Compiled HTML Help）格式呈现。CHM是微软的HTML帮助文件格式...
华为c++编码规范&c/c++安全编码规范
04-24
华为c++编码规范和安全编码规范最新3.1版本 华为c++编码规范和安全编码规范最新3.1版本 华为c++编码规范和安全编码规范最新3.1版本 华为c++编码规范和安全编码规范最新3.1版本 华为c++编码规范和安全编码规范最新3.1...
《基础知识——C和C++的主要区别》
安徒生木槿
07-15 509
C和C++的主要区别 设计思想上： C++是面向对象的语言，而C是面向过程的结构化编程语言 语法上： C++具有封装、继承和多态三种特性 C++相比C，增加多许多类型安全的功能，比如强制类型转换、 C++支持范式编程，比如模板类、函数模板等 知乎复制： 你问区别，那一定有区别，语言在设计走向上总是朝着更加优化和简便的方向去开发的，这是最原始的动机，也是根本区别，只不过相应的...
【c++】从以下八个方面浅谈c/c++的区别
IT_Mitchell的博客
07-23 1499
C和C++的简单区别，C是一门面向过程的语言，抽象化的通用程序设计语言，重点在于数据结构和算法的实现，广泛用于底层开发，而C++是一种面向对象的计算机程序设计语言，它支持过程化程序设计，数据抽象，面向对象程序设计，泛型设计等多种程序设计风格。C++可以说是c的继承，它进一步完善并扩充了C，但是切记C++是C的继承，C++不能完全代替C。本文将从以下八个方面浅谈关于C/C++的区别。...
C与C++区别
xiaoxiaojinglinger的博客
06-14 6749
一、返回值 C中：如果函数未指定返回值类型，则默认为int  c++中：如果一个函数没有返回值，返回值类型必须指定为void 二、参数列表 C中：如果函数没有指定参数列表，则默认可以接受任意多个参数 C++中：有严格的类型检测，没有参数列表的函数默认为void，不接受任意参数 三、缺省参数（即给参数一个默认值） C:不支持 C++:支持（如果没有指定实参则使用缺省值，有则使用指定实参） ...
C/C++的区别？（总结）
weixin_43748094的博客
08-08 217
首先在大体上，C 是面向过程的语言，而 C++是面向对象的语言，因此 C++语言中有类和对象以及继承多态这样的 OOP 语言必备的内容，此外 C++支持模板，运算符重载，异常处理机制，以及一个非常强的 C++标准模板库 STL，另外一个 Boost 库现在也归属 C++标准库，提供了很多强大的功能。C++支持类对象，类和类之间的代理，组合，继承，多态等等面向对象的设计，有很多的设计模式可以直接使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值