Java 8 新特性

最新推荐文章于 2021-06-21 23:58:51 发布
最新推荐文章于 2021-06-21 23:58:51 发布
阅读量95 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41920595/article/details/115986123
版权

1、函数式接口
函数式接口主要指只包含一个抽象方法的接口，Java8提供@FunctionalInterface注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错，并且增加了java.util.function包，该包包含了常用的函数式接口。
2、匿名内部类和Lambda表达式实现函数式接口
lambda表达式：参数列表、箭头符号->和方法体组成，而方法体中可以是表达式，也可以是语句块。
语法格式：(参数列表) -> { 方法体; } - 其中()、参数类型、{} 以及return关键字 可以省略

import java.util.Comparator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class FunctionalInterfaceTest {
    public static void main(String[] args) {
        // 1.匿名内部类的语法格式： 父类/接口类型  引用变量名 = new 父类/接口类型(){ 方法的重写 };
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是既没有参数又没有返回值的方法！");
            }
        };
        runnable.run(); // 我是既没有参数又没有返回值的方法！

        // 使用lambda表达式实现函数式接口对象的创建: (参数列表)->{方法体;}
        //Runnable runnable1 = () -> { System.out.println("我是既没有参数又没有返回值的方法！"); };
        Runnable runnable1 = () -> System.out.println("我是既没有参数又没有返回值的方法！");
        runnable1.run();

        System.out.println("----------------------------------------------------------------------");
        Consumer consumer = new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o + "有参但没有返回值的方法就是我！");
            }
        };
        consumer.accept("友情提示："); // 友情提示：有参但没有返回值的方法就是我！

        //Consumer consumer1 = (Object o) -> {System.out.println(o + "有参但没有返回值的方法就是我！");};
        //Consumer consumer1 = (o) -> System.out.println(o + "有参但没有返回值的方法就是我！");
        // 省略了()、参数类型、{}， 自动类型推断
        Consumer consumer1 = o -> System.out.println(o + "有参但没有返回值的方法就是我！");
        consumer1.accept("友情提示：");

        System.out.println("----------------------------------------------------------------------");
        Supplier supplier = new Supplier() {
            @Override
            public Object get() {
                return "无参有返回值！";
            }
        };
        System.out.println(supplier.get()); // 无参有返回值

        //Supplier supplier1 = () -> {return "无参有返回值！";};
        Supplier supplier1 = () -> "无参有返回值！";
        System.out.println(supplier1.get());

        System.out.println("----------------------------------------------------------------------");
        Function function = new Function() {
            @Override
            public Object apply(Object o) {
                return o;
            }
        };
        System.out.println(function.apply("有参有返回值的方法")); // 有参有返回值的方法

        // return 和 {} 都可以省略
        Function function1 = o -> o;
        System.out.println(function1.apply("有参有返回值的方法"));

        System.out.println("----------------------------------------------------------------------");
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
        System.out.println(comparator.compare(10, 20)); // 0

        Comparator comparator1 = (o1, o2) -> 0;
        System.out.println(comparator1.compare(10, 20));

        System.out.println("----------------------------------------------------------------------");
        Predicate predicate = new Predicate() {
            @Override
            public boolean test(Object o) {
                return false;
            }
        };
        System.out.println(predicate.test("hello")); // false

        Predicate predicate1 = o -> false;
        System.out.println(predicate1.test("hello"));
    }
}

3、方法引用实现函数式接口
person类：

public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public void show() {
        System.out.println("没事出来秀一下哦");
    }

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

    @Override
    public int compareTo(Person o) {
        //return getName().compareTo(o.getName());
        return getAge() - o.getAge();
    }
}

测试类：

import java.util.Arrays;
import java.util.Comparator;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class MethodReferenceTest {

    public static void main(String[] args) {

        // 1.使用匿名内部类的方式通过函数式接口Runnable中的方法实现对Person类中show方法的调用
        Person person = new Person("zhangfei", 30);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                person.show();
            }
        };
        runnable.run(); // 没事出来秀一下哦

        System.out.println("-------------------------------------------------------------");
        // 2.使用lambda表达式的方式实现Person类中show方法的调用
        Runnable runnable1 = () -> person.show();
        runnable1.run(); // 没事出来秀一下哦

        System.out.println("-------------------------------------------------------------");
        // 3.使用方法引用的方式实现Person类中show方法的调用
        Runnable runnable2 = person::show;
        runnable2.run();

        System.out.println("-------------------------------------------------------------");
        // 4.使用匿名内部类的方式通过函数式接口Consumer中的方法来实现Person类中setName方法的调用
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                person.setName(s);
            }
        };
        consumer.accept("guanyu");
        System.out.println("person = " + person); // guanyu 30

        System.out.println("-------------------------------------------------------------");
        // 5.使用lambda表达式的方式实现Person类中setName方法的调用
        Consumer<String> consumer1 = s -> person.setName(s);
        consumer1.accept("liubei");
        System.out.println("person = " + person); // liubei 30

        System.out.println("-------------------------------------------------------------");
        // 6.使用方法引用的方式实现Person类中setName方法的调用
        Consumer<String> consumer2 = person::setName;
        consumer2.accept("zhangfei");
        System.out.println("person = " + person); // zhangfei 30

        System.out.println("-------------------------------------------------------------");
        // 7.使用匿名内部类的方式通过函数式接口Supplier中的方法来实现Person类中getName方法的调用
        Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                return person.getName();
            }
        };
        System.out.println(supplier.get()); // zhangfei

        Supplier<String> supplier1 = () -> person.getName();
        System.out.println(supplier1.get()); // zhangfei

        Supplier<String> supplier2 = person::getName;
        System.out.println(supplier2.get()); // zhangfei

        System.out.println("-------------------------------------------------------------");
        // 8.使用匿名内部类的方式通过函数式接口Function中的方法实现Integer类中parseInt方法的调用
        Function<String, Integer> function = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        };
        System.out.println(function.apply("12345")); // 12345

        Function<String, Integer> function1 = s -> Integer.parseInt(s);
        System.out.println(function1.apply("12345")); // 12345

        Function<String, Integer> function2 = Integer::parseInt;
        System.out.println(function2.apply("12345")); // 12345

        System.out.println("-------------------------------------------------------------");
        // 9.使用匿名内部类的方式通过函数式接口Comparator中的方法实现Integer类中compare方法的调用
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(comparator.compare(10, 20));  // -1

        Comparator<Integer> comparator1 = (o1, o2) -> Integer.compare(o1, o2);
        System.out.println(comparator1.compare(10, 20)); // -1

        Comparator<Integer> comparator2 = Integer::compare;
        System.out.println(comparator2.compare(10, 20)); // -1

        System.out.println("-------------------------------------------------------------");
        // 10.使用匿名内部类的方式通过类名来调用非静态方法
        // 其中一个参数对象作为调用对象来调用方法时，可以使用上述方式   更抽象
        Comparator<Integer> comparator3 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(comparator3.compare(10, 20)); // -1

        Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comparator4.compare(10, 20)); // -1

        Comparator<Integer> comparator5 = Integer::compareTo;
        System.out.println(comparator5.compare(10, 20)); // -1

        System.out.println("-------------------------------------------------------------");
        // 11.使用匿名内部类的方式通过Supplier函数式接口创建Person类型的对象并返回
        Supplier<Person> supplier3 = new Supplier<Person>() {
            @Override
            public Person get() {
                return new Person();
            }
        };
        System.out.println(supplier3.get()); // null 0

        Supplier<Person> supplier4 = () -> new Person();
        System.out.println(supplier4.get()); // null 0

        Supplier<Person> supplier5 = Person::new;
        System.out.println(supplier5.get()); // null 0

        System.out.println("-------------------------------------------------------------");
        // 12.使用匿名内部类的方式通过BiFunction函数式接口采用有参方式创建Person类型的对象并返回
        BiFunction<String, Integer, Person> biFunction = new BiFunction<String, Integer, Person>() {
            @Override
            public Person apply(String s, Integer integer) {
                return new Person(s, integer);
            }
        };
        System.out.println(biFunction.apply("zhangfei", 30)); // zhangfei 30

        BiFunction<String, Integer, Person> biFunction1 = (s, integer) -> new Person(s, integer);
        System.out.println(biFunction1.apply("zhangfei", 30)); // zhangfei 30

        BiFunction<String, Integer, Person> biFunction2 = Person::new;
        System.out.println(biFunction2.apply("zhangfei", 30)); // zhangfei 30

        System.out.println("-------------------------------------------------------------");
        // 12.使用匿名内部类的方式通过Function函数式接口创建指定数量的Person类型的对象数组并返回
        Function<Integer, Person[]> function3 = new Function<Integer, Person[]>() {
            @Override
            public Person[] apply(Integer integer) {
                return new Person[integer];
            }
        };
        Person[] pArr = function3.apply(3);
        System.out.println(Arrays.toString(pArr));

        Function<Integer, Person[]> function4 = integer -> new Person[integer];
        System.out.println(Arrays.toString(function4.apply(4)));

        Function<Integer, Person[]> function5 = Person[]::new;
        System.out.println(Arrays.toString(function5.apply(5)));
    }
}

4、Stream接口
5、Optional类

LikCM
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
Java8新特性 - 04 - 方法引用05 - 方式四 【类名::new】
northcastle的博客
02-25 1917
1.类名::new 1.将Lambda表达式 替换为 【类名::new】 的写法。 2.确保 【类的构造方法】 的 参数与返回值 和 Lambda表达式的一致！ * 分析 ： 匿名内部类的方式 ： 正常重写接口中的方法即可，可以使用lambda表达式进行代码优化； * lambda表达式的方法 ： 【无参构造】【有参构造】 * 类名::new 的方式 ：【无参构造】【有参构造】 * * 使用 提供者Supplier接口进行一个 调用无参构
JAVA8 新特性 问题汇总
qq_36249132的博客
11-12 172
记录JAVA8中遇到得问题 1.stream has already been operated upon or closed 一个 Stream 只可以使用一次 问题代码 这里我有一个集合的流在循环外创建，循环内重复使用流出错! 这里修改为每次需要的时候创建，解决问题 ...
java8新特性学习总结
weixin_45453240的博客
06-18 319
一、Lambda表达式 Lambda 表达式在Java语言中引入了一个新的语法元素和操作符,将函数当成参数传递给某个方法或者把代码本身当作数据处理 语法格式:用逗号分隔的参数列表,->符号,和语句块组成 二、函数式接口 三、方法引用与构造器引用 四、Stream API 五、接口中的默认方法与静态方法 六、新时间日期API 七、其他新特性 ...
java基础面试01
杜盟恩的博客
05-11 273
1、overload（重载） 与 overwrite（重写） 重载：表示一个类中 可以有多个名称相同的方法，但彼此的参数不同（参数个数或参数类型），与方法的作用域和返回类型无关； 重写：表示子类中的方法可以与父类的某个方法的 名称和参数完全相同；当通过子类创建的对象调用这个方法时，将调用子类中的定义方法，相当于将父类的此方法覆盖，这也是多态的一种表现； 2、throw 与 throws throw：手动抛出异常，一般出现在函数体中； throws：声明方法可能抛出的异常，一般出现在 方法头部； 3、
使用java8新特性 Stream遇到的问题
qq_33236991的博客
10-14 918
空指针异常： 最简单的方法又是最不效率的：在使用list.stream之前判断list是否为null 同样也是要校验，但不是硬编码到业务中，在getXXX方法中校验，若为null返回ArrayList public class UserVo extends User implements Serializable { private List<Role> roleList; public List<Role> getRoleList() {
java8新特性
11-08
本视频为java8新特性，百度云链接和密码，永久有效，失效联系我
Java8新特性
06-15
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常常见。 即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是...
java8 新特性
02-28
介绍了Java 8 这个里程碑版本的新特性，包括Lambdas、流和函数式编程。有了函数式的编程 特性，可以让代码更简洁，同时也能自动化地利用多核硬件。全书分四个部分：基础知识、函数式数据处理、 高效Java 8 编程和...
JDK8新特性（表示原版本有部分错误，我就手打修改了）
04-15
网上写的代码，有部分错误！经过测试，结果是不正确的，就提交了份正确版本，和一些自己的理解！
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新特性Stream之list转map及问题解决
热门推荐
博客园
10-11 23万+
List集合转Map，用到的是Stream中Collectors的toMap方法：Collectors.toMap 具体用法实例如下： //声明一个List集合 List&amp;lt;Person&amp;gt; list = new ArrayList(); list.add(new Person(&quot;1001&quot;, &quot;小A&quot;)); list.add(new Person
java8新特性Stream踩坑
qq_31830173的博客
06-21 253
error：java.lang.IllegalStateException: stream has already been operated upon or closed； 出现环境： @Test public void consumer_test(){ Consumer<String> consumer = new Consumer<>() { @Override public void acc
JDK8新特性一览
虫草
04-20 3万+
官方新特性说明地址 Jdk8新特性.png 下面对几个常用的特性做下重点说明。 一、Lambda表达式 1.1 函数式编程 百科介绍：http://baike.baidu.com/link?url=LL9X3-SoS4XJGgdzrXvURuKEGm6ad5zY1NLDxDygjTaSRnEZ0Bp3wqX0QgkB7fjPwMSQS1tLfq
Java 8新特性终极指南
★訡夜侑颩
03-05 1419
1.介绍毫无疑问，Java 8发行版是自Java 5（发行于2004，已经过了相当一段时间了）以来最具革命性的版本。Java 8 为Java语言、编译器、类库、开发工具与JVM（Java虚拟机）带来了大量新特性。在这篇教程中，我们将一一探索这些变化，并用真实的例子说明它们适用的场景。这篇教程由以下几部分组成，它们分别涉及到Java平台某一特定方面的内容： Java语言 编译器 类库 工具
深入解析Java8新特性
" Beginning Java 8 Language Features 是一本关于了解Java 8新特性的书籍，涵盖了从注解、内部类到流等广泛的主题，旨在帮助读者深入理解Java 8的重要更新。" Java 8作为Java语言的一个重大版本更新，引入了许多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值