JAVA8新特性

于 2024-04-08 14:49:37 发布
阅读量456 收藏 7
点赞数 14
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60907575/article/details/137461593
版权

JAVA8新特性

1、函数式编程

主要关注对数据进行了什么操作

1.1 优点

代码简洁
容易理解
易于“并发编程”

2、lamada表达式

(参数列表)->{代码}

未使用

  new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(123123123);
            }
        }).start();

使用Lamada表达式

 new Thread(() ->{
                System.out.println(1111);
        }).start();

3 基本语法

一、语法特性1

Java8引入了一个新的操作符号“->”，该操作符称为箭头操作符或者Lamada操作符

左侧：Lamada 表达式的参数列表
右侧：Lamada 表达式中所需执行的功能即 Lamada体

**语法格式1:**无参，无返回值
() -> System.out.println(123123);

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

        Runnable r2 = () -> System.out.println(123123);
        r2.run();

  public void test(){
       int num  = 0; // 默认是被final修饰的，num++报错
       Runnable r1 = new Runnable() {
           @Override
           public void run() {
               System.out.println(123123213 + (num++));  
               //Variable 'num' is accessed from within inner class, 
               // needs to be final or effectively final
           }
       };
       r1.run();
   }

语法格式2： 有参，无返回值
(x) -> System.out.println(x);

 @Test
   public void test2(){
       Consumer<String> consumer = (x) -> System.out.println(x);
       consumer.accept("我的工作什么时候才能找到!");
   }

语法格式3：若只有一个参数，参数的小括号可以省略不写
x) -> System.out.println(x);

语法格式4：有两个以上参数，有返回值，并且Lamada体中有多条语句
Comparator comparator = (x,y) ->{
System.out.println(“函数式接口”);
return Integer.compare(x,y);
};

  @Test
    public void test3(){
        Comparator<Integer> comparator = (x,y) ->{
            System.out.println("函数式接口");
            return x.compareTo(y);
        };
        System.out.println(comparator.compare(2, 1));
    }

语法格式5：若Lambda 体中只有一条语句，return 和 大括号都可以省略不写，
Comparator comparator = (x,y) -> Integer.compare(x,y);

语法格式6：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即"类型推断";
在这里插入图片描述

上联：左右遇一括号省
下联：左侧推断类型省
横批：能省则省

二、Lambda 表达式需要“函数式接口”的支持

函数式接口: 接口中只有一个抽象方法的接口
可以使用注解@FunctionalInterface 修饰，可以检查是否是函数式接口

package com.wang;

@FunctionalInterface
public interface MyFun {
    Integer getInteger(Integer num);
}


    @Test
    public void test5(){
       Integer integer = getNum(100,(x)-> x * x);
        System.out.println(integer);  // 10000

        Integer integer1 = getNum(100,(y)-> y + 500);
        System.out.println(integer1); // 600
    }

    public Integer getNum(Integer num,MyFun myFun){
       return myFun.getInteger(num);
    }

练习题：

在这里插入图片描述
题1：

    @Test
    public void test6(){

        List<Student> students = Arrays.asList(
                new Student("zs",18),
                new Student("ls",10),
                new Student("ww",28),
                new Student("zl",6)
        );

        Collections.sort(students,(x,y) -> {
            if (x.getAge() == y.getAge()){
                return x.getName().compareTo(y.getName());
            }else{
                return -Integer.compare(x.getAge(),y.getAge());
            }
        });

        for (Student student : students) {
            System.out.println(student);
        }
    }

题2：

String string = getTestInfo("\t\t\t我大尚硅谷威武！！       ", (str) -> str.trim());
        System.out.println(string); // 我大尚硅谷威武！！

        String str12 = getTestInfo("asdasd",str -> str.toUpperCase());
        System.out.println(str12); //  ASDASD

        String str23 = getTestInfo("我大尚硅谷威武",str -> str.substring(2,5));
        System.out.println(str23); // 尚硅谷

Java几大核心接口

在这里插入图片描述
在这里插入图片描述
1、消费型接口

  @Test
    public void test1(){
        testConsumer(10,(x) -> System.out.println("我喜欢,每次花呗" + x));
    }

    public void testConsumer(Integer num, Consumer consumer){
         consumer.accept(num);
    }

2、供给型接口

  // todo Math.random() 方法生成一个介于 0.0 和 1.0 之间的随机数
      List<Integer> list =   getList(10,() -> (int)(Math.random() * 10));
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    public List<Integer> getList(Integer num, Supplier<Integer> supplier){
        List<Integer> integerList = new ArrayList<>();
        for (int i = 1; i < num ; i++) {
            integerList.add( i + supplier.get());
        }
        return integerList;
    }

3.函数型接口

 /**
     * Function 函数型接口
     */
    @Test
    public void test3(){
        String string = getString("我的尚硅谷威武", (str) -> str.substring(2, 5));
        System.out.println(string);
    }

    public String getString(String str, Function<String,String> function){
        return function.apply(str);
    }

4.断言型接口 boolean

    @Test
    public void test4(){
        List<String> list = Arrays.asList("Hello","atguigu","asd","ok","yrfc");
        List<String> filterStr = filterStr(list, (str) -> str.length() > 3);
        System.out.println(filterStr);
    }

    // 过滤符合条件的字符串
    public List<String> filterStr(List<String> strings, Predicate<String> predicate){
        List<String> stringList = new ArrayList<>();
        for (String s : strings) {
            if (predicate.test(s)){
                stringList.add(s);
            }
        }
        return stringList;
    }

在这里插入图片描述

方法引用和构造器引用

方法引用

在这里插入图片描述

1、对象::实例方法名
在这里插入图片描述

 @Test
    public void  test2(){
        Student student = new Student("zx",123);
        Supplier<Integer> studentConsumer = student::getAge;
        System.out.println(studentConsumer.get());
    }

    @Test
    public void test1(){
        PrintStream printStream = System.out;
        Consumer<Integer> consumer = printStream::print;
        consumer.accept(12);

        Consumer<String> stringConsumer = System.out::print;
        stringConsumer.accept("aaa");
    }

注意：Lambda体中的参数列表和返回值类型，要与函数式接口中抽象方法的参数列表和返回值类型保持一致。

在这里插入图片描述

// 类名::静态方法名

    @Test
    public void test3(){
        /**
         *  public static int compare(int x, int y) {
         *         return (x < y) ? -1 : ((x == y) ? 0 : 1);
         *     }
         */
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
        Comparator<Integer> com1 = Integer::compareTo;
        System.out.println(com1.compare(1, 2));
    }

构造器引用 和 数组引用

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

StreamAPI

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

筛选和切片

在这里插入图片描述

内部迭代和外部迭代

在这里插入图片描述

   @Test
    public void test01(){
        List<Student> students = Arrays.asList(
                new Student("zs", 18),
                new Student("ls", 10),
                new Student("ww", 28),
                new Student("zl", 6)
        );

        Stream<Student> stream = students.stream()
                .filter(e -> {
                    System.out.println("看看！！！！！！！！！！！");
                    return e.getAge() > 10;
                });
        stream.forEach(System.out::println);
    }

结果：

看看！！！！！！！！！！！
Student(name=zs, age=18)
看看！！！！！！！！！！！
看看！！！！！！！！！！！
Student(name=ww, age=28)
看看！！！！！！！！！！！
短路 limit

在这里插入图片描述

  @Test
    public void test2(){
        List<Student> students = Arrays.asList(
                new Student("zs", 18),
                new Student("ls", 10),
                new Student("ww", 28),
                new Student("zl", 6)
        );

        students.stream()
                .filter(e -> e.getAge() >= 10)
                .limit(2)
                .forEach(System.out::println);
    }
skip 跳过

在这里插入图片描述

map和flantMap

在这里插入图片描述

 List<Student> students = Arrays.asList(
                new Student("zs", 18),
                new Student("ls", 10),
                new Student("ww", 28),
                new Student("zl", 6)
        );

       students.stream()
               .map((m) -> m.getName())
               .forEach(System.out::println);

zs
ls
ww
zl

flantMap

  @Test
    public void test3(){
        List<String> list = Arrays.asList("aa","df","asdc","grtg");
        list.stream()
                .flatMap(s -> characterList(s))
                .forEach(System.out::println);
    }

    public static Stream<Character> characterList(String str){
        List<Character> list = new ArrayList<>();
        char[] charArray = str.toCharArray();
        for (char c : charArray) {
            list.add(c);
        }
        return list.stream();
    }

排序操作 sorted

在这里插入图片描述

终止操作

在这里插入图片描述
anyMatch

List<Student> students = Arrays.asList(
                new Student("zs", 18,Student.State.BUSY),
                new Student("ls", 10,Student.State.FREE),
                new Student("ww", 28,Student.State.VOCATION),
                new Student("zl", 6,Student.State.FREE)
        );

        boolean b = students.stream()
                .anyMatch((s) -> s.getStatus().equals(Student.State.VOCATION));
        System.out.println(b); //true

在这里插入图片描述

在这里插入图片描述

map 和 reduce

在这里插入图片描述

 List<Student> students = Arrays.asList(
                new Student("zs", 18,Student.State.BUSY),
                new Student("ls", 10,Student.State.FREE),
                new Student("ww", 28,Student.State.VOCATION),
                new Student("zl", 6,Student.State.FREE)
        );
        Optional<Integer> optionalInteger = students.stream()
                .map(Student::getAge)
                .reduce(Integer::sum);
        System.out.println(optionalInteger.get());

  List<Integer> integers = Arrays.asList(12, 34, 5, 6, 7, 86);
        Integer reduce = integers.stream().reduce(0, (x, y) -> x + y);
        System.out.println(reduce); //150

collect

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

   List<Student> students = Arrays.asList(
                new Student("zs", 18,Student.State.BUSY),
                new Student("ls", 10,Student.State.FREE),
                new Student("ww", 28,Student.State.VOCATION),
                new Student("zl", 6,Student.State.FREE),
                new Student("zl", 6,Student.State.FREE)

        );

        List<String> collect = students.stream()
                .map(Student::getName)
                .collect(Collectors.toList());
        collect.forEach(System.out::println);

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

        Set<String> stringSet = students.stream()
                .map(Student::getName)
                .collect(Collectors.toSet());
        stringSet.forEach(System.out::println);

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

        LinkedHashSet<String> linkedHashSet = students.stream()
                .map(Student::getName)
                .collect(Collectors.toCollection(LinkedHashSet::new));
        System.out.println(linkedHashSet);

在这里插入图片描述

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

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

在这里插入图片描述

  @Test
    public void test4(){
        List<Student> students = Arrays.asList(
                new Student("zs", 18,Student.State.BUSY),
                new Student("ls", 10,Student.State.FREE),
                new Student("ww", 28,Student.State.VOCATION),
                new Student("zl", 6,Student.State.FREE),
                new Student("zl", 6,Student.State.FREE)

        );

        // 使用分隔符连接
        String str = students.stream()
                .map(Student::getName)
                .collect(Collectors.joining(","));
        System.out.println(str);

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

        // 计算元素的个数
        Long count = students.stream()
                .map(Student::getAge)
                .collect(Collectors.counting());
        System.out.println(count);
        System.out.println("===============");

        // 计算年龄总和
        Integer integer = students.stream()
                .map(Student::getAge)
                .collect(Collectors.summingInt(Integer::intValue));
        System.out.println(integer);
        System.out.println("==========================");
        Integer countAge = students.stream()
                .collect(Collectors.summingInt(Student::getAge));
        System.out.println(countAge);
        System.out.println("====================");

        // 分组
        Map<Student.State, List<Student>> stateListMap = students.stream()
                .collect(Collectors.groupingBy(Student::getStatus));
        // 第一种遍历
        for (Map.Entry<Student.State, List<Student>> listEntry : stateListMap.entrySet()){
            Student.State key = listEntry.getKey();
            List<Student> value = listEntry.getValue();
            System.out.println("status: - -- " + key);
            for (Student student : value) {
                System.out.println(student);
            }
        }

        // 第二种
        stateListMap.forEach(((state, students1) -> System.out.println("state:\t" + state +"-----> student:\t" + students1)));


    }

并行流

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

  @Test
    public void test5(){
        long reduce = LongStream.rangeClosed(0, 1000000L).parallel().reduce(0, Long::sum);
        System.out.println(reduce);
    }

Optional 类

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

接口中default 关键字 和 静态方法

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

m0_60907575
关注
  • 14
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java8新特性
lanleihhh的博客
11-07 1901
Stream允许我们以声明式的方式处理数据集合,可以将Stream看作是遍历数据集合的高级迭代器。Stream 与Lambda表达式结合使用，将使编码效率大大提高，可读性增强。Stream与IO中的是不同的概念操作案例：使用stream将集合中的手机按照序号num从小到大排序：Stream流的操作顺序Stream语法Lambda表达式是一个匿名函数，可以将Lambda表达式理解为一段可以传递的代码（将代码段数据一样传递）。使用Lambda表达式可以写出更简洁，更灵活的代码。
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
JAVA8新特性(吐血整理)
热门推荐
yitian_66的博客
07-12 11万+
一、Java 8 Lambda 表达式... 31.1 语法... 31.2 Lambda 表达式实例... 3Java8Tester.java 文件... 31.3 变量作用域... 5Java8Tester.java 文件... 5Java8Tester.java 文件... 5二、Java 8 方法引用... 72.1方法引用... 72.2方法引用实例... 8Java8Tester.j...
Java8的新特性是什么？
weixin_42601608的博客
02-13 1290
Java 8在语言层面和API层面都有很多新特性，其中一些重要的特性如下： Lambda表达式：Java 8引入了Lambda表达式，这是一种函数式编程的特性，可以让代码更加简洁和灵活。 Stream API：Java 8引入了Stream API，它是一种数据处理的新方式，支持链式操作和并行计算。 接口的默认方法和静态方法：Java 8支持在接口中定义默认方法和静态方法，这样可以在不修改已...
Java8常用新特性详解
youthlql的博客
11-23 1829
只包含一个抽象方法的接口，称为函数式接口。你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常(即非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明）。我们可以在一个接口上使用注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。在java.util.function包下定义了Java8的丰富的函数式接口/***自定义函数式接口Stream到底是什么呢？Stream。...
Java 8 的新特性和改进总览
CTO=开发管理+架构+技术专栏
04-29 1083
这篇文章是对Java 8中即将到来的改进做一个面向开发者的综合性的总结，JDK的这一特性将会在2013年9月份发布。 在写这篇文章的时候，Java 8的开发工作仍然在紧张有序的进行中，语言特新和API仍然有可能改变，我会尽我最大的努力保持这份文档跟得到Java 8的改动。 Java 8的预览版，也就是 “Project Lambda”，现在可以从java.net下载到。 我使用了I
简单使用lambda表达式
qq_44716544的博客
07-24 810
什么是lambda表达式？ Lambda 是一个 匿名函数，我们可以把 Lambda 表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。 使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升 Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或 箭 头操作符。 它将 Lambda 分为两个部分：左侧：指定了 Lambda 表达式需要的参 参
java8新特性
11-08
本视频为java8新特性，百度云链接和密码，永久有效，失效联系我
java8 新特性
02-28
介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程 特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理、 高效Java 8 编程和...
JAVA8新特性讲解
12-15
Java 8是Java语言发展的一个重要里程碑，引入了许多创新特性，极大地提升了开发效率和代码质量。以下是关于Java 8新特性的详细讲解： ...通过观看“Java8 新特性视频教程”，你可以深入理解并熟练运用这些特性。
Java8新特性共76页
11-18
Java8新特性共76页
java8新特性-最新
12-18
在Java 8中，最重要的两个新特性无疑是Lambda表达式和Stream API。这两个特性都与函数式编程思想密切相关，让Java开发者能够更加灵活地处理数据。 ### Lambda表达式 Lambda表达式是Java 8中最显著的新特性之一，它...
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性
09-02
全网详解(波哥)Java8新特性(Lambda、Stream、LocalDate等)新特性 自学java的同行们应该都要学习java8的新特性，譬如：（Lambda、Stream、LocalDate等）！本人在学习java的时候看的是波哥的视频，确实讲的不错，很...
史上最全Java8新特性详解
小学生波波
09-22 2007
史上最全Java8新特性详解
java 8 新特性
最新发布
07-27
Java 8引入了许多令人兴奋的新特性，以下是其中一些： 1. Lambda表达式：Lambda表达式允许以更简洁的方式编写匿名函数，并且可以更方便地使用函数式编程风格。 2. 函数式接口：Java 8引入了函数式接口的概念，这是只包含一个抽象方法的接口。函数式接口可以与Lambda表达式一起使用，从而实现函数式编程。 3. Stream API：Stream API提供了一种新的处理集合数据的方式，使得我们可以更轻松地进行过滤、映射、排序等操作。 4. 默认方法：默认方法允许在接口中添加具有默认实现的方法。这样一来，当接口的实现类没有实现该方法时，就会使用默认方法。 5. 方法引用：方法引用提供了一种更简洁的方式来调用已经存在的方法。 6. Optional类：Optional类是一个容器对象，可以包含或不包含非空值。它可以避免空指针异常，并且可以简化对null值的处理。 7. 新的日期和时间API：Java 8引入了全新的日期和时间API，提供了更好的日期和时间处理方式，并且解决了旧API中的一些问题。 这些是Java 8引入的一些主要新特性，它们使得Java编程更加现代化和灵活。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值