java jdk1.8新特性粗略总结

最新推荐文章于 2023-07-30 21:07:49 发布
最新推荐文章于 2023-07-30 21:07:49 发布
阅读量200 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/resistancealex/article/details/119771724
版权

JDK1.8中的特性：

  1. 接口方法
  2. lambda表达式
  3. 方法引用
  4. Stream API

接口增强

JDK1.8中引入了一种新的机制：接口可以支持在声明方法的同时，提供实现。
主要通过两种方式可以完成这种操作：

  1. 默认方法
  2. 静态方法

实现接口的类，可以继承这些方法并直接使用，就不再需要强制在实现类中的去实现（重写）接口中的方法了。这种机制可以使我们更平滑地进行接口的优化和演进。

方法调用的判断规则：

  1. 类中声明的方法优先级最高。
    类或父类中，声明的方法要高于任何默认方法的优先级
  2. 如果无法依据第一条进行判断，那么子接口的优先级更高
    例如，如果 B 接口继承了 A接口 ，那么 B 就比 A 更加具体，优先级更高
    所以，在上述例子中，B是子接口，优先级别更高，调用test方法后输出：defaut method test in B.
  3. 最后，如果还是无法判断，那么继承了多个接口的类，必须通过实现（重写）方法来确定方法的
    调用
class A{
    public void test(){
    	System.out.println("Default Method test in A");
    }
}

interface B {
    default void test(){
   	 	System.out.println("default method test in B");
    }
}

class C extends A implements B{
    public static void main(String[] args){
        C c = new C();
        c.test();
   	}
}

//运行结果：default method test in A
//因为A是类，B是接口，A里面的test方法优先级更高

interface A{
    default void test(){
    	System.out.println("Default Method test in A");
    }
}

interface B {
    default void test(){
    	System.out.println("default method test in B")
    }
}

//如下代码编译会报错。
/*class C implements A,B{
    public static void main(String[] args){
        C c = new C();
        c.test();
    }
}*/

//如果C需要同时实现A和B接口，那么必须显示覆盖
class C implements A,B{
    public void test(){
    //如果在C中需要显示访问A/B的默认方法，可以使用接口名.super.方法名();
        A.super.test();
        B.super.test();
    //或者自己编写test方法的实现
    }
}

静态方法

public interface StaticMethod{
    public static void test(){
    	System.out.println("我是StaticMethod接口中的静态方法！");
    }
}

class A implements StaticMethod{}
    class Test{
    public static void main(String args[]){
        //运行成功
        StaticMethod.test();
        //编译报错：
        //Static method may be invoked on containing interface class only
        //A.test();
    }
}

注意，接口中的静态方法，只能使用当前接口的名字来调用

Lambda表达式

行为参数化 在java代码中，我们如果需要运算，那么大部分我们的过程是确定的，但是实际参与运算的数却不确定。

在实际项目中，用户需求的变动，是很正常的一件事情，所以在上述的案例中，我们不断的增加方法，来解决用户新的需求，但是在整个过程中，我们复制了大量的相同的代码。

这几个方法之间相同的地方，例如：
方法的修饰符
方法的返回类型
方法的参数列表
方法中对数据的遍历
这几个方法之间不同的地方，例如：
方法的名字
方法中遍历数据后的核心操作

需要注意的是，方法的名字其实是无关紧要的，它只是在调用时，用到的一个标示符，最关键的是，对这个对数据的核心操作，也就是代码中核心的行为操作。 这时候，我们可以将这个核心的行为操作，进行抽象，变成一个参数

interface Action{
	int action(int result,int i);
}

public static int calculate(int a,int b, Action cal){
    int result = a;
    for(int i = a+1;i<=b;i++){
    	result = cal.action(result,i);
    }
    return result;
}

class Test{
    public static void main(String[] args){
        int result = 0;
        /*
        //忽略掉之前匿名内部类形式中，不重要的部分
        Action add = (int result,int i) -> {
        return result + i;
        };
        */
        //简化写法
        Action add = (result,i) -> result + i;
        result = calculate(3,5,add);
        //去掉中间变量add
        //相当于，第三个参数，我们传了一个核心的计算行为
        //这个核心的计算行为，就是对Action接口中action方法的实现
        //result = calculate(3,5,(result,next) -> result + next);
        //[3,5]之间，累加的结果
        System.out.println(result);
    }
}

常用接口
JDK1.8中，已经定了一些会常用到的函数式接口，这些函数式接口都定义在 java.lang.function 包中，

例如 Predicate 、 Consumer 、 Function 、 Supplier 、 UnaryOperator 和BinaryOperator 等。

注意，如果需要，也可以自己定义类似的函数式接口，并不是必须要使用这些定义好的接口。

Predicate
java.util.function.Predicate 接口定义了一个名叫 test 的抽象方法，它接受泛型T 对象，
并返回一个 boolean 类型的结果

例如：定义一个方法，用来过滤数组中所有符合要求的数据，选出大于50的数据

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        Integer[] arr = {12,3,43,123,34,6,56,7};
        arr = t.filter(arr,e->e>50);
        System.out.println(Arrays.toString(arr));
    }
    
    public Integer[] filter(Integer[] arr, Predicate<Integer> p){
        List<Integer> list = new ArrayList<>();
        for(Integer i: arr){
            //判断当前数据是否符合要求
            if(p.test(i)){
                list.add(i);
            }
        }
        //把集合转为Integer类型数组
        return list.toArray(new Integer[list.size()]);
    }
}
//运行结果：	[123, 56]

Predicate 接口中，还定义了一些默认方法和静态方法：
and()
or()
negate()
在使用该接口来做判断的时候，经常需要几个条件同时成立，或者其中一个条件成立，或者求反。
在这种情况下，除了可以在代码中选择使用&&，||，！之外，也可以分别使用这三个方法来代替。

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        Integer[] arr = {12,3,43,123,34,6,56,7};
        //条件1，数据大于10
        Predicate<Integer> p1 = e -> e>10;
        //条件2，数据小于50
        Predicate<Integer> p2 = e -> e<50;
        //俩个条件同时成立
        Predicate<Integer> p = p1.and(p2);
        arr = t.filter(arr,p);
        System.out.println(Arrays.toString(arr));
    }
    
    public Integer[] filter(Integer[] arr, Predicate<Integer> p){
        List<Integer> list = new ArrayList<>();
        for(Integer i: arr){
            //判断当前数据是否符合要求
            if(p.test(i)){
                list.add(i);
            }
        }
        //把集合转为Integer类型数组
        return list.toArray(new Integer[list.size()]);
    }
}
//运行结果：[12, 43, 34]

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        Integer[] arr = {12,3,43,123,34,6,56,7};
        //条件1，数据小于10
        Predicate<Integer> p1 = e -> e<10;
        //条件2，数据大于50
        Predicate<Integer> p2 = e -> e>50;
        //俩个条件成立一个即可
        Predicate<Integer> p = p1.or(p2);
        arr = t.filter(arr,p);
        System.out.println(Arrays.toString(arr));
    }
    
    public Integer[] filter(Integer[] arr, Predicate<Integer> p){
        List<Integer> list = new ArrayList<>();
        for(Integer i: arr){
            if(p.test(i)){
                //判断当前数据是否符合要求
                list.add(i);
            }
        }
        //把集合转为Integer类型数组
        return list.toArray(new Integer[list.size()]);
    }
}
//运行结果：	[3, 123, 6, 56, 7]

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        Integer[] arr = {12,3,43,123,34,6,56,7};
        //条件1，数据大于10
        Predicate<Integer> p1 = e -> e>10;
        //获取条件1相反的数据
        Predicate<Integer> p = p1.negate();
        arr = t.filter(arr,p);
        System.out.println(Arrays.toString(arr));
    }
    
    public Integer[] filter(Integer[] arr, Predicate<Integer> p){
        List<Integer> list = new ArrayList<>();
        for(Integer i: arr){
            //判断当前数据是否符合要求
            if(p.test(i)){
            	list.add(i);
            }
        }
        //把集合转为Integer类型数组
        return list.toArray(new Integer[list.size()]);
    }
}
//运行结果：[3, 6, 7]

//JDK1.8中，给 Collection 集合增加了默认方法： removeIf
//此方法就使用了 Predicate 作为自己的参数，来移除符合条件的数据，实现如下：
public class Test {
    public static void main(String[] args) {
        Collection<String> col = new ArrayList<String>();
        col.add("abc");
        col.add("hello");
        col.add("world");
        col.removeIf((str)->str.contains("o"));
        System.out.println(col);
    }
}
//运行结果：[abc]

Consumer

java.util.function.Consumer 接口：

定义一个方法，用来对学生对象进行操作

public class Test {
    public static void main(String[] args) {
        Test t = new Test();
        Student stu = new Student("tom");
        //操作1，给stu对象的name属性值加前缀
        Consumer<Student> consumer1 = (s) -> s.name = "briup_"+s.name;
        //操作2，给stu对象的name属性值加后缀
        Consumer<Student> consumer2 = (s) -> s.name =
        s.name+"_"+System.currentTimeMillis();
        //操作3，给stu对象的name属性值，先加前缀，再加后缀
        Consumer<Student> consumer3 = consumer1.andThen(consumer2);
        //如果传入consumer1，表示只加前缀
        //如果传入consumer2，表示只加后缀
        //如果传入consumer3，表示先加前缀，再加后缀
        t.operStu(stu,consumer3);
        System.out.println(stu.name);
    }
    
    public void operStu(Student stu, Consumer<Student> consumer){
    	consumer.accept(stu);
    }
}

class Student{
    String name;
    public Student(String name) {
    	this.name = name;
    }
}
//运行结果：briup_tom_1598282322884

JDK1.8中，给Collection集合增加了默认方法： forEach 用来遍历集合

public class Test {
    public static void main(String[] args) {
        Collection<String> col = new ArrayList<String>();
        col.add("abc");
        col.add("hello");
        col.add("world");
        //去掉中间变量，直接把Lambda表达式当前参数传入到forEach方法中
        col.forEach((t)->System.out.println(t));
    }
}
//运行结果：
abc
hello
world

Function
java.util.function.Function<T, R> 接口，

public class Test {
    public static void main(String[] args) {
        String str = "a-b-c-a-b-c";
        //传入字符串，返回数组，操作为把字符串按照 "-" 进行分割为字符串数组
        // "a-b-c-a-b-c" 转换为 {"a","b","c","a","b","c"}
        Function<String,String[]> f1 = s -> s.split("-");
        //传入字符串数组，返回Set<String>集合，目的是去除数组中重复的数据，存放把结果存放到Set集合中
        //{"a","b","c","a","b","c"} 转换为集合 [a, b, c]
        Function<String[], Set<String>> f2 = arr -> {
            Set<String> set = new HashSet<>();
            for(String string : arr){
                set.add(string);
            }
            return set;
        };
        //刚好，f1函数的结果，作为f2函数的参数，f1和f2组合成f3函数
        //f3函数表示传入字符串，最后返回Set<String>集合
        //其实内部是先将字符串交给f1函数转换数组，在将数组交给f2函数转换Set集合
        //通过上面列出的andThen源码也可以看出是这个效果
        Function<String,Set<String>> f3 = f1.andThen(f2);
        Set<String> set = f3.apply(str);
        System.out.println(set);
    }
}
//运行结果：
[a, b, c]

理解了andThen方法，那么compose方法也就理解：f1.andThen(f2)，f1.compose(f2)
俩个方法的区别是，把f2操作放在f1操作之前还是之后的问题

方法引用

使用Lambda表达式，可以表示一个函数，这个函数由 “参数列表、函数主体、返回类型” 这三部分组 成，同时这个函数还是一个函数式接口中，唯一的抽象方法的实现

方法引用三大类：方法/构造器：类名::new/数组：类型[]::new

方法：
静态：类名::方法名/实例

实例：类名::非静态方法名

构造方法引用:类名::new

使用对象引用方法:对象::方法名

数组构造:数组类型::new

Optional

在Java8之前，一个函数可能因为代码逻辑问题，最终返回一个null，这时候程序中很可能出现空指针异常。而在Java8中，不推荐返回 null ，而是返回 Optional

Optional 中常用的方法： of ofNullable isPresent ifPresent get orElse orElseGet map flatMap filter

Stream

java.util.stream.Stream 接口，表示能应用在一组元素上，一次执行的操作序列，也就是可以对一组数据进行连续的多次操作。

Stream在使用的时候，需要指定一个数据源，比如 java.util.Collection 的子类， List 或者 Set都可以，但是 Map 类型的集合不支持。
Stream是对集合功能的增强，它提供了各种非常便利、高效的聚合操作，可以大批量数据操作，同时再结合Lambda表达式，就可以极大的提高编程效率。

Stream的API提供了串行和并行两种模式进行操作数据。
Stream操作分为中间操作或者最终操作两种：

中间操作，返回Stream本身，这样就可以将多个操作依次串起来
例如， map、flatMap、filter、distinct、sorted、peek、limit、skip、parallel、
sequential、unordered

最终操作，返回一特定类型的计算结果
例如， forEach、forEachOrdered、toArray、reduce、collect、min、max、count、
anyMatch、allMatch、noneMatch、findFirst、findAny、iterator

基本类型
对于基本数值类型，有专门的三种Stream类型：
IntStream
LongStream
DoubleStream
虽然也可以用Stream类型，并指定泛型：
Stream<\Integer>
Stream<\Long>
Stream<\Double>
但是，在数据量较大的时候，自动拆箱/装箱会比较消耗性能，所以提供了上面三种专门针对基本类型的
Stream

Stream转其他
使用Stream的API对数据操作后，还可以把结果转换为其他类型

一个Stream在代码中，只能使用一次，再次使用就会报错

Stream操作主要分为中间操作或者最终操作：
最终操作，就是把Stream处理完了，已经有结果了，之后就不能再使用这个Stream了
中间操作，对Stream进行一个中间操作后，还可以对其进行下一步的继续操作

../Aleister
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JDK1.8的新特性
qq_61679345的博客
04-23 659
JDK1.8新特性（Lambda）
jdk1.8新特性总结及使用示例
11-16
jdk1.8新特性总结及使用示例中介绍了Java 8中的Lambda表达式。Lambda表达式是一种匿名函数，可以将一段代码赋给一个变量。这种特性在Java 8中被引入，允许开发者将一块代码赋给一个变量，从而使得代码变得更加简洁。...
JDK1.8中遍历List集合的几种方式
PrimeYun的博客
05-24 2万+
本文大纲： 一、List集合循坏方式：for循坏、forEach循坏、迭代器Iterator以及Lambda表达式。 二、Iterator迭代器和ListIterator迭代器的比较 本文以ArrayList为例。 一、for循坏 public class ForList { public static void main(String[] args) { List<Integer...
JDK8新特性的学习总结
冷血之心的博客
02-24 2846
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/87903464冷血之心的博客） 目录 背景： 正文： Lambda表达式 定义  语法 示例 总结： 默认方法 总结： Stream API 什么是 Stream？ 生成流 总结： 总结： 背景：        JDK8发布于2...
JDK1.8新特性详解
weixin_44251099的博客
05-27 3543
函数式接口是一种只包含一个抽象方法的接口。函数式接口通常作为函数式编程和Lambda表达式的基础。Java 8为常见的函数式编程场景提供了专门的函数式接口，比如，和等。：断言型接口，输入一个参数T，返回一个布尔值，用于执行一些判断逻辑。：函数型接口，输入一个参数T，返回一个结果R，用于执行一些转换逻辑。：消费型接口，输入一个参数T，表示消费掉这个参数，执行一些操作但没有返回值。：供给型接口，返回一个数据T，用于执行一些数据生成操作。Filter：过滤，用于过滤出满足条件的元素。Map。
java1.8新特性
qq_31842721的博客
02-13 119
1.lambda表达式   lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码     例子1: package classes;   import java.util.TreeSet;   public class JAVA8 {   public static void main(String[] args) {   //省去了函数实现体的编写麻烦...
JDK1.8新特性
qq_42315935的博客
12-17 1130
只包含一个抽象方法的接口，在接口上添加注解声明的为函数式接口，函数式接口可以隐式的转换为lambda表达式/***/**}Stream（流）是一个来自数据源的元素队列并支持聚合操作，帮助我们对更好地对数据进行集合操作。Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
jdk1.8新特性.doc
04-01
本文主要介绍了JDK1.8版本中的一些新特性，仅供参考。 jdk1.8新特性知识点： 1、Lambda表达式 2、函数式接口 3、方法引用和构造器调用 4、Stream API 5、接口中的默认方法和静态方法 6、新时间日期API
jdk1.8新特性
03-13
JDK1.8新特性简介剖析，仅做参考，希望大家相互学习 作为Comparator 和Runnable早期的证明，在JDK中已经定义的接口恰巧作为函数接口而与lambdas表达式兼容。同样方式可以在你自己的代码中定义任何函数接口或第三方...
java JDK 1.8 文档
04-28
javaJDK 1.8文档
java jdk1.8 中文版
05-09
以上只是Java JDK 1.8部分核心特性，实际使用中还有许多其他改进和增强，如模块化系统（Project Jigsaw），尽管该特性在Java 8中并未完全实现，但在后续版本中得到了加强。通过深入学习和掌握这些知识点，开发者能够...
JDK8十大新特性详解
02-23
JDK8十大新特性详解，仅做参考，希望大家相互学习
Java 中的双冒号“::”
热门推荐
ChineseSoftware的博客
02-17 3万+
一、双冒号“::”就是 Java 中的方法引用(Method references) 方法引用的格式是类名::方法名。一般是用作 Lambda表达式。 形如 ClassName::methodName 或者 objectName::methodName 的表达式，叫做方法引用(Method Reference)。看看编译器是如何根据 “晦涩难懂” 的 Method Reference 来推断开发者的意图的。例如： 1.表达式： person -> person.getName(); 可以替换成： Pe
JDK8新特性
有多勉为其难的博客
09-05 2413
Stream是JDK8中引入，Stream是一个来自数据源的元素序列并支持聚合操作。可以让你以一种声明的方式处理数据，Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。一个stream是由三部分组成的。数据源，零个或一个或多个中间操作，一个或零个终止操作。
JAVA从入门到精通------基础篇------java8新特性
weixin_56777219的博客
02-11 1550
JAVA从入门到精通------基础篇
jdk8新特性
最新发布
jiapu_的博客
07-30 2831
Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：左侧：指定了 Lambda 表达式需要的参数列表 右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。只包含一个抽象方法的接口，称为函数式接口。你可以通过 Lambda 表达式来创建该接口的对象。
JDK8 新特性
学习技术的路上不断沉淀自己
02-18 5186
个人博客 个人博客: https://www.crystalblog.xyz/ 备用地址: https://wang-qz.gitee.io/crystal-blog/ 1. 简介 JDK8是官方发布的一个大版本, 提供了很多新特性功能给开发者使用, 包含语言、编译器、库、工具和JVM等方面的十多个新特性。 本文将介绍编码过程中常用的一些新特性. JDK8帮助文档 Lambda表达式 函数式接口 方法引用和构造器调用 Stream API 接口中的默认方法和静态方法 新的日期时间API Optiona
[Stream]--Java1.8新特性,抽象流Stream:中间操作
weixin_70506521的博客
02-13 143
Java1.8新特性,抽象流Stream:中间操作

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值