JDK8新特新

最新推荐文章于 2022-07-20 23:52:54 发布
最新推荐文章于 2022-07-20 23:52:54 发布
阅读量199 收藏
点赞数 1
分类专栏： java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38009686/article/details/121764512
版权

interface

public interface JDK8Interface {

    void thisMethod();

    default void defaultMethod(){
        System.out.println("jdk8接口默认方法");
    }
    static void  staticMethod(){
        System.out.println("jdk8接口静态方法");
    }
}

public class JDK8InterfcaeImpl implements JDK8Interface {
    @Override
    public void thisMethod() {
        System.out.println("实现接口");
    }

    public static void main(String[] args) {
        JDK8InterfcaeImpl jdk8Interfcae = new JDK8InterfcaeImpl();
        jdk8Interfcae.thisMethod();
        jdk8Interfcae.defaultMethod();
        JDK8Interface.staticMethod();
    }
}

函数接口

1.一个接口只允许一个抽象方法
2.在函数接口中允许定义Object类 中的方法
3.在函数接口中 允许定义默认和静态方法
4.添加@FunctionalInterface 标识该接口未函数接口


@FunctionalInterface
public interface JDK8Interface {

    void thisMethod();

    default void defaultMethod(){
        System.out.println("jdk8接口默认方法");
    }
    static void  staticMethod(){
        System.out.println("jdk8接口静态方法");
    }

    /**
     * 重新Object中的toString方法
     * @return
     */
    String toString();
}

Lambda表达式

lambda前提是依赖于函数接口
语法 ()->{}

无参数

public interface JDK8InterfaceLambda {
    void noParamLambdaMethod();
}

public class TextJDK8InterfaceLambda {
    public static void main(String[] args) {
        ((JDK8InterfaceLambda)()->{
            System.out.println("lambda表达式依赖于函数接口");
        }).noParamLambdaMethod();
    }
}

有参数

public interface JDK8InterfaceLambda {
    void noParamLambdaMethod(String var1,String var2);
}

public class TextJDK8InterfaceLambda {
    public static void main(String[] args) {
        //第一种写法
        ((JDK8InterfaceLambda)(var1,var2)->{
            System.out.println(var1);
            System.out.println(var2);
        }).noParamLambdaMethod("参数一","参数二");
        //第二种写法
        JDK8InterfaceLambda jdk8InterfaceLambda = (var3,var4)->{
            System.out.println(var3);
            System.out.println(var4);
        };
        jdk8InterfaceLambda.noParamLambdaMethod("参数三","参数四");
    }
}

Stream流相关操作

public class TestStream {

    public static void main(String[] args) {
        List<UserEntity> list = new ArrayList<>();
        UserEntity user = new UserEntity("张三",20);
        UserEntity user1 = new UserEntity("隶属",21);
        UserEntity user2 = new UserEntity("鬼道",18);
        UserEntity user3 = new UserEntity("斯莱穆",30);
        UserEntity user4 = new UserEntity("斯莱穆",30);
        list.add(user);list.add(user1);list.add(user2);list.add(user3);list.add(user4);

        /**
         * 创建stream流有两种方式  1.串行流 stream() 2.并行流parallelStream()
         *  stream() 单线程的  并行流parallelStream() 是多线程的
         */
        //1.串行流
        Stream<UserEntity> stream = list.stream();

        //2.并行流
        Stream<UserEntity> userEntityStream = list.parallelStream();
        /**
         * 将stream流转化为set集合  如果想要set去重得重写 equals()方法
         */
        Set<UserEntity> setUserEntity = stream.collect(Collectors.toSet());
        System.out.println("set集合遍历");
        setUserEntity.forEach(userEntity -> {
            System.out.println(userEntity);
        });

        /**
         * 将stream流转化为map集合
         */
        System.out.println("map集合遍历");
        Stream<UserEntity> mapStream = list.stream();
        //有重复key时下面这种方式报错  Duplicate key UserEntity{name='斯莱穆', age=30}
        //Map<String, UserEntity> maps = mapStream.collect(Collectors.toMap(userEntity -> userEntity.getName(), userEntity -> userEntity));
        //处理重复key
        Map<String, UserEntity> maps = mapStream.collect(Collectors.toMap(userEntity -> userEntity.getName(), userEntity -> userEntity,(k1, k2) -> k1));
        maps.forEach((k,v)->{
            System.out.println(k+"-->"+v);
        });
        /**
         * stream流求和
         */
        //返回其元素为指定值的顺序流
        System.out.println("对指定值进行求和");
        Stream<Integer> integerStream = Stream.of(10, 50, 60, 70);
       // integerStream.forEach(integer -> System.out.println(integer));  //注：一个stream 只能使用一次
        // 求和
        Optional<Integer> reduce = integerStream.reduce((a, a2) -> a + a2);
        System.out.println("求和结果"+reduce.get());

        System.out.println("对list中的age进行求和");
        Stream<UserEntity> reduceStream = list.stream();
        Optional<UserEntity> sum = reduceStream.reduce((a, a1) -> {
            //对user的age求和
            UserEntity userEntity = new UserEntity();
            Integer age = a.getAge() + a1.getAge();
            userEntity.setAge(age);
            userEntity.setName("sum");
            return userEntity;
        });
        System.out.println("求和结果"+sum.get());

        /**
         * 求list集合中 年龄最大和 最小的元素
         */
        System.out.println("求取集合中最大值");
        Stream<UserEntity> maxstream = list.stream();
        Optional<UserEntity> max = maxstream.max((a, b) -> {
          return a.getAge()-b.getAge();
        });  // 这一段lambda表达式 后面会做替换需要了解如何使用请继续往下看
        System.out.println("最大值"+max.get());
        System.out.println("求取集合中最小值");
        Stream<UserEntity> minStream = list.stream();
        Optional<UserEntity> min = minStream.min((a, b) -> {
            return a.getAge() - b.getAge();
        });
        System.out.println("最小值"+min.get());

        /**
         * match 条件匹配
         */
        Stream<UserEntity> anyMatchStream = list.stream();
        System.out.println("anyMatch条件匹配开始");
        boolean anyMatch = anyMatchStream.anyMatch(t -> {
            return t.getAge() == 20;
        });  //anyMatch 表示只要其中一条能够被配上 就返回true
        System.out.println("条件匹配："+anyMatch);

        System.out.println("allMatch条件匹配开始");
        Stream<UserEntity> allMatchStream = list.stream();
        boolean allMatch = allMatchStream.allMatch(t->t.getAge()==20);//allMatch 表示全部匹配成功 才返回true
        System.out.println("条件匹配："+allMatch);

        System.out.println("noneMatch条件匹配开始");
        Stream<UserEntity> noneMatchStream = list.stream();
        boolean noneMatch = noneMatchStream.noneMatch(t -> t.getAge() == 20);//noneMatch 表示全部都匹配不上才返回true
        System.out.println("条件匹配："+noneMatch);

        /**
         * stream流过滤器
         */
        System.out.println("########stream流过滤器");
        Stream<UserEntity> streamFilter = list.stream();
        Stream<UserEntity> userEntityStreamFilter = streamFilter.filter(t -> t.getAge()>26);
        userEntityStreamFilter.forEach(userEntity -> System.out.println("年龄大于26："+userEntity));

        /**
         * stream 对数据分页
         */
        System.out.println("#########stream对数据分页 limit从头开始");
        Stream<UserEntity> limitStream = list.stream();
        Stream<UserEntity> limitStreamUserEntitys = limitStream.limit(4);
        limitStreamUserEntitys.forEach(userEntity -> {
            System.out.println("####################"+userEntity);
        });

        Stream<UserEntity> skipStream = list.stream();
        System.out.println("#########stream对数据分页 skip 跳过");
        Stream<UserEntity> skip = skipStream.skip(1).limit(4);
        skip.forEach(s->System.out.println("####################"+s));

        /**
         * stream流排序
         */
        System.out.println("根据年龄由小到大排序：");
        Stream<UserEntity> sortedStream = list.stream();
        Stream<UserEntity> sorted = sortedStream.sorted((a, a2) -> a.getAge() - a2.getAge());
        sorted.forEach(s-> System.out.println(s));
        System.out.println("根据年龄由大到小排序：");
        Stream<UserEntity> sortedStream2 = list.stream();
        Stream<UserEntity> sorted1 = sortedStream2.sorted((a, a1) -> a1.getAge() - a.getAge());
        sorted1.forEach(s-> System.out.println(s));

    }
}

函数引用

静态方法引用

语法：类名::（静态方法）方法名称

//函数接口
@FunctionalInterface
public interface FunctionInterface {
    void getInteface(int a);
}
public class FunctionReference {
    public static void main(String[] args) {

        FunctionInterface functionInterface= FunctionReference::cc;  //个人理解：相当于 把下面的cc 静态方法 当作了 FunctionInterface 接口getInteface()的实现
        functionInterface.getInteface(1);
    }

    private static void cc(int a) {
        System.out.println(a);
    }

}
实例方法引用

语法：先new对象 对象实例::实例方法名称


//函数接口
@FunctionalInterface
public interface FunctionInterface {
    void getInteface(int a);
}
public class FunctionReference {
    public static void main(String[] args) {
        FunctionReference reference = new FunctionReference();
        FunctionInterface functionInterface= reference::cc;
        functionInterface.getInteface(1);
    }

    private void cc(int a) {
        System.out.println(a);
    }

}
构造方法引用

语法：类名::new4

@FunctionalInterface
public interface FunctionInterface {
    
    FunctionReference getInteface();
}

public class FunctionReference {

    FunctionReference(){}

    public static void main(String[] args) {

        FunctionInterface functionReference = FunctionReference::new;
    }


}
对象方法引用
@FunctionalInterface
public interface FunctionInterface {

    void getInteface(FunctionReference functionReference);
}

public class FunctionReference {

    FunctionReference(){}

    public void getClassReference(){
        System.out.println("对象方法引用");
    }

    public static void main(String[] args) {
        FunctionReference functionReference = new FunctionReference();
        FunctionInterface functionInterface = FunctionReference::getClassReference;
        functionInterface.getInteface(functionReference);
    }


}

Optional

ofNullable() 允许传递一个空值，返回Optional
of() 不允许传递空值，返回Optional
这里设置空串的话是可以取到空串的

         String userName = null;
        //Optional<String> s = Optional.of(userName);  //会报错，不允许传空值
        Optional<String> s1 = Optional.ofNullable(userName);
      //  System.out.println(s.get());
      //  System.out.println(s1.get());  //在没有设值的时候会报错

isPresent() 如果为null 返回false 如果不为null 返回ture；

  boolean present = s1.isPresent();

如果为空设置默认值

 String cc = s1.ofNullable(userName).orElse("cc");

Optional过滤

    public static void main(String[] args) {
        String userName = "cc";
        Optional<String> s1 = Optional.ofNullable(userName).filter(t-> t.equals("cc"));
        System.out.println(s1);
        boolean present = s1.isPresent();
        System.out.println(present);

        String userName1 = "pp";
        Optional<String> s2 = Optional.ofNullable(userName1).filter(t -> "cc".equals(t));
        System.out.println(s2);
        boolean present2 = s2.isPresent();
        System.out.println(present2);
        Optional.ofNullable(userName1).ifPresent(t->{
            System.out.println(t);
        });
    }
小白人生
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK8新特性
曹某人的博客
08-25 249
简述 Java 8由Oracle从2014年3月18日发布，此版本是自Java 5（发布于2004年）之后的一个重量级版本，也是java发展史上的一个里程碑式的版本。这个版本在JVM、编译器、库、Java语法特性等方面都做了很大改进，同时在语言的表达力、简洁性等个方面也有了很大的提高。目前几乎所有的JAVA框架也都已升级到支持JDK8，打开框架源码想了解其设计，假如不理解JDK8的这些特性看起来就会非常吃力。所以我们设计了这个专题，我们将在这个专题中讲解JDK8中的部分关键特性，并用实际案例讲解这些特性应
Java中TypeReference用法
想找我?: 【编程张无忌的个人空间-哔哩哔哩】 https://b23.tv/0yjNTt2
03-27 1725
Java中TypeReference用法
Java中TypeReference用法说明
技术老鸟
07-20 1626
Java中TypeReference用法说明
java为什么使用TypeReference
weixin_34138521的博客
10-17 637
用途 在使用fastJson时,对于泛型的反序列化很多场景下都会使用到TypeReference，例如： void testTypeReference() { List&lt;Integer&gt; list = new ArrayList&lt;&gt;(); list.add(1); list.add(9); li...
深入理解JDK中的Reference原理和源码实现
ting2909的博客
02-07 307
Reference的简介和分类# 在JDK1.2之前，Java中的引用的定义是十分传统的：如果reference类型的数据中存储的数值代表的是另一块内存的起始地址，就称这块内存代表着一个引用。在这种定义之下，一个对象只有被引用和没有被引用两种状态。 实际上，我们更希望存在这样的一类对象：当内存空间还足够的时候，这些对象能够保留在内存空间中；如果当内存空间在进行了垃圾收集之后还是非常紧张，则可以抛弃...
Java8新特性实测源码下载
05-08
1. Lambda 表达式 2. 函数式接口 3. 方法引用与构造器引用 4. Stream API 5. 接口中的默认方法与静态方法 ...7. 其他新特性 博文说明： https://blog.csdn.net/Hello_World_QWP/article/details/80245129
JDK1.8 API
11-03
本文档将Java8的新特新逐一添加，比如如何使用默认接口方法，lambda表达式，方法引用以及多重Annotation，之后你将会学到最新的API上的改进，比如流，函数式接口，Map以及全新的日期API。祝你Java技术更上一层楼！
jdk-8u291-windows-x64.zip
04-25
Java Development Kit（JDK）是Java编程语言的软件开发工具包，它包含了编译、调试、文档生成等工具，使得开发者能够创建、测试和部署Java...在使用过程中，理解并熟练运用JDK 8的新特性能极大提升开发效率和代码质量。
java 压缩、解压缩 tar.gz
qq_38009686的博客
01-25 5494
java 压缩解压缩 tar.gz
docker安装maven
qq_38009686的博客
09-15 5374
拉取镜像 docker pull sonatype/nexus3 将容器/var/nexus-data挂载到主机/root/nexus-data目录启动 docker run -d -p 8081:8081 --name nexus -v /root/nexus-data:/var/nexus-data --restart=always sonatype/nexus3 查看启动日志 docker attach 容器id 关闭防火墙 service iptables stop 访问端口号 8081 ...
java中clone的使用场景
qq_38009686的博客
10-10 2072
Persion.java类 。 测试类 测试结果 这里为什么list中的每一个persion对象中年龄是20呢，简单点来看，list里面存的每一个对象都是同一个persion，及每一个对象指向的是同一个地址，所以在list中的对象全部都是最后一个persion故而全部年龄都是20，进而想到了new一个对象 测试结果是行不通的 原因在于将persion赋值给persion1 同样的道理 最后...
什么是序列化，怎么序列化，为什么序列化，反序列化会遇到什么问题
qq_38009686的博客
04-09 1916
什么是序列化 Java对象序列化是指将Java对象转化为·字节序列的过程而反序列化则是将字节序列转化为Java对象的过程 为什么需要序列化 我们知道不同线程/进程进行远程通信时可以相互发送各种数据，包括文本图片音视频等，Java对象不能直接传输，所以需要转化为二进制序列传输，所以需要序列化 怎么序列化 实现Serializable接口实现这个接口就会添加一个serialVersionUID 的版本...
解析xml转对象（适用于根节点和一级节点）
qq_38009686的博客
12-29 1588
import org.dom4j.*; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.List; /** * ClassName: XmlUtils * Date: 2021/1.
new对象如何使用 @mapper或者 @service
qq_38009686的博客
11-16 1570
需求 定时任务中注册task 这里如果直接使用 @Autowired DynamicPrintTask task; 这个task的话 因为设置的是单例的 所以 不管你加多少 task 他永远只会以最后一个task 来执行所有的任务 所以这里需要用 new的形式来创建 task 但是这个task 里面 用到了 很多 mapper 如果直接 用 new 的话 这些mapper 则会报 null 所以我们需要通过 ApplicationContext 来获取上下文 解决方案 public class S
mq简单实现
qq_38009686的博客
08-16 958
mq简单实现（为网络简单版） public class MqServer { public static void main(String[] args) throws InterruptedException { //定义消息队列容器 LinkedBlockingDeque<String> blockingDeque = new LinkedBlockingDeque<>(); //创建生产者线程 Thread
字符串30.0 转integer
qq_38009686的博客
11-28 829
lo.get(3).toString() 为获取的支出穿 30.0 int level = 0 ; if (!StringUtils.isEmpty(lo.get(3).toString())){ level=new Double(Double.parseDouble(lo.get(3).toString())).intValue(); }
Docker安装中文可视化shipyard
qq_38009686的博客
01-08 596
docker pull rethinkdb docker pull microbox/etcd docker pull shipyard/docker-proxy docker pull swarm docker pull dockerclub/shipyard 将原先脚本修改为中文脚本 wget https://raw.githubusercontent.com/shipyard/shipyar...
Lambda表达式与JDK8新特性详解
本资源主要讨论了JDK 8的新特性，特别是Lambda表达式、函数式编程思想以及Stream流的相关内容。首先，介绍了OpenJDK和Oracle JDK的关系，指出OpenJDK是Sun公司在2006年Java平台开源后的产物，由Java社区支持，而...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值