java8新特性实操

最新推荐文章于 2024-06-07 08:25:31 发布
最新推荐文章于 2024-06-07 08:25:31 发布
阅读量354 收藏 10
点赞数 5
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shiboluobuding/article/details/138724052
版权

一、Interface

  1. default修饰的方法，是普通实例方法，可以用this调用，可以被子类继承、重写。
  2. static修饰的方法，使用上和一般类静态方法一样。但它不能被子类继承，只能用Interface调用。
public interface Interface1 {
    void f();
    default void f1(){
        System.out.println("这是Interface1中的f1()");
    };
    static void f2(){
        System.out.println("这是Interface1中static的f2()");
    }
}

public interface Interface2 {
    default void f1(){
        System.out.println("这是Interface1中的f1()");
    }
}

public class InterfaceImpl implements Interface1,Interface2{
    @Override
    public void f() {
        System.out.println("InterfaceImpl重写f()方法");
    }
    @Override
    public void f1() {
        Interface2.super.f1();
    }
    public static void main(String[] args) {
        InterfaceImpl anInterface = new InterfaceImpl();
        anInterface.f();//InterfaceImpl重写f()方法
        anInterface.f1();//这是Interface1中的f1()
        Interface1.f2();//这是Interface1中static的f2()
    }
}







二、Lambda 表达式

1.替代匿名内部类
		//1.Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是传统方法new Runnable()");
            }
        }).start();
        new Thread(()-> System.out.println("这是Lamabda方法new Runnable()")).start();
        //等价于
        Runnable runnable = () -> System.out.println();
        new Thread(runnable).start();


        //2.Compactor接口
        List<Integer> list = Arrays.asList(1, 2, 3, 8, 5);
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        Collections.sort(list,(o1,o2)->o1-o2);
        //等价于
        Comparator<Integer> comparator = (o1, o2) -> o1 - o2;
        Collections.sort(list,comparator);


        //3.Listener接口
        JButton jButton = new JButton();
        jButton.addItemListener(new ItemListener() {
            @Override
            public void itemStateChanged(ItemEvent e) {
                e.getItem();
            }
        });
        jButton.addItemListener(e->e.getItem());
2.自定义函数式接口
@FunctionalInterface
public interface LamabdaInterface {
    void f1(Integer i);
}
class LamabdaInterfaceDemo{
    static void f1(Integer num,LamabdaInterface lamabdaInterface){
        lamabdaInterface.f1(num);
    }
    public static void main(String[] args) {
        LamabdaInterfaceDemo.f1(2, num -> System.out.println("这是用来测试函数式接口"+num));
    }
}
3.集合迭代
		//传统foreach
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        for(Integer num : list){
            System.out.println(num);
        }
        //lamabda foreach
        list.forEach(item-> System.out.println(item));
        //or
        list.forEach(System.out::println);
        //map
        HashMap<String, String> map = new HashMap<>();
        map.put("k1","v1");
        map.put("k2","v2");
        map.forEach((k,v)-> System.out.println(v));
4.方法引用
public class Base {
    LamabdaInterface superf(){
        return null;
    }
}
class Son extends Base{
    public LamabdaInterface f(){
        return null;
    }
    public static LamabdaInterface staticf(){
        return null;
    }
    void deal(){
        //1.静态方法调用
        AbstractWrapper.DoSomething staticf = Son::staticf;
        //2.实例方法调用
        AbstractWrapper.DoSomething f = new Son()::f;
        //3.父类方法调用
        AbstractWrapper.DoSomething superf = super::superf;
        //4.构造函数调用
        AbstractWrapper.DoSomething aNew = Son::new;
    }
}







三、stream

       List<String> list = Arrays.asList("1","2","3");
        //1.符合条件的流
        Stream<String> stringStream = list.stream().filter(item -> item.equals("1") || item.equals("2"));
        stringStream.forEach(System.out::print);
        //2.流中元素的个数
        long count = list.stream().count();
        System.out.println(count);
        //3.foreach 遍历打印
        list.stream().forEach(System.out::print);
        //4.limit 获取指定元素个数的流
        Stream<String> limit = list.stream().limit(2);
        limit.forEach(System.out::print);
        //5.toArray 流转换成数组
        String[] strings = list.stream().toArray(String[]::new);
        Arrays.stream(strings).forEach(System.out::print);
        //6.map 对每个元素操作并返回新的流
        Stream<String> stringStream1 = list.stream().map(item -> item + "--");
        //7.sort 排序并打印
        stringStream1.sorted().forEach(System.out::print);

        //8.collect 将符合的元素放到容器中
        List<String> collect = list.stream().filter(item -> "1".equals(item) || "2".equals(item)).collect(Collectors.toList());
        collect.forEach(System.out::print);
        //9.List 转换成 String 逗号分割
        String collect1 = list.stream().collect(Collectors.joining(","));
        System.out.println(collect1);


        //10.对数组进行统计
        IntSummaryStatistics statistics = list.stream().mapToInt(item -> Integer.parseInt(item)).summaryStatistics();
        System.out.println("最大值:"+statistics.getMax());
        System.out.println("最小值:"+statistics.getMin());
        System.out.println("平均值:"+statistics.getAverage());
        System.out.println("总和:"+statistics.getSum());

        //11.合并流
        Stream<String> concat = Stream.concat(Arrays.asList("1", "2", "3").stream(), Arrays.asList("4", "5", "6").stream());
        concat.forEach(System.out::print);
        //12.一个流只能使用一次
        Stream<String> stream = list.stream();
        stream.limit(2);//不能再stream.foreach()
        list.stream().forEach(System.out::print);//可以这样处理

补充

public class StreamExercise {
    public static void main(String[] args) {
        //1.对map集合的操作
        HashMap<String, String> map = new HashMap<>();
        map.put("k1","1");
        map.put("k2","2");
        map.put("k3","3");
        //1.1 map 集合中key为 k1 或 k2 value总和 :
        int sum = map.entrySet().stream()
                .filter(entry -> "k1".equals(entry.getKey()) || "k2".equals(entry.getKey()))
                .mapToInt(entry -> Integer.parseInt(entry.getValue())).sum();
        System.out.println(sum);
        //1.2合并两个map key相同的进行相加
        HashMap<String, Integer> map2 = new HashMap<>();
        map2.put("k1",1);
        map2.put("k2",2);
        map2.put("k3",3);
        HashMap<String, Integer> map3 = new HashMap<>();
        map3.put("k1",1);
        map3.put("k2",2);
        map3.put("k3",3);
        map2.forEach((key,value)->map3.merge(key,value,Integer::sum));//map2合并到map3中 key相同的进行相加
        System.out.println(map3);


        //2.对list集合的操作
        List<Data> list = new ArrayList<>();
        list.add(new Data(LocalDate.now().plusDays(0)));
        list.add(new Data(LocalDate.now().plusDays(1)));
        list.add(new Data(LocalDate.now().plusDays(2)));
        //2.1根据时间对list集合元素进行升序排列
        List<Data> collect = list.stream().sorted(Comparator.comparing(Data::getLocalDate)).collect(Collectors.toList());
        collect.forEach(System.out::println);
        //2.2根据时间筛选数据
        List<Data> collect1 = list.stream().filter(item ->
                (item.getLocalDate().isAfter(LocalDate.MIN) && item.getLocalDate().isBefore(LocalDate.MAX)))
                .collect(Collectors.toList());
        collect1.forEach(System.out::println);
        //2.3对list根据某一属性进行过滤,创建新的对象组成新的集合
        List<Map<String, String>> collect2 = list.stream().filter(item -> item.getLocalDate().isAfter(LocalDate.MIN))
                .map(item -> {
                    Map<String, String> entity = new HashMap<>();
                    entity.put(item.toString(), item.getLocalDate().toString());
                    return entity;
                }).distinct().collect(Collectors.toList());
        System.out.println(collect2);
        //2.4对list集合使用分页查询
        List<Data> collect3 = list.stream().skip(1).limit(1).collect(Collectors.toList());
        System.out.println(collect3);
        //2.5对list集合中对象属性为字符串的数值进行排序
        ArrayList<Num> list1 = new ArrayList<>();
        list1.add(new Num("1"));
        list1.add(new Num("2"));
        list1.add(new Num("3"));
        List<Integer> collect5 = list1.stream().map(item -> Integer.parseInt(item.getNum())).sorted(Comparator.comparing(Integer::intValue)).collect(Collectors.toList());
        System.out.println(collect5);
        //2.6取多个list的交集
        List<Data> collect4 = list.stream().filter(list::contains).filter(list1::contains).collect(Collectors.toList());
        System.out.println(collect4);
        //2.7根据对象某一字段组成新的集合
        List<LocalDate> collect6 = list.stream().filter(item->item.getLocalDate()!=null).map(item -> item.getLocalDate()).distinct().collect(Collectors.toList());
        System.out.println(collect6);
        //2.8求list集合中某一属性的和
        int sum1 = list1.stream().mapToInt(item -> Integer.parseInt(item.getNum())).sum();
        //2.9按照list对象中某一属性进行分组
        Map<LocalDate, List<Data>> collect7 = list.stream().collect(Collectors.groupingBy(Data::getLocalDate));
        System.out.println(collect7);
    }
}
class Num{
    private String num;
    public Num(String num){
        this.num = num;
    }

    public String getNum() {
        return num;
    }
}
class Data{
    private LocalDate localDate;
    public Data(LocalDate localDate){
        this.localDate  = localDate;
    }
    public LocalDate getLocalDate() {
        return localDate;
    }
    @Override
    public String toString() {
        return "Data{" +
                "localDate=" + localDate +
                '}';
    }
}
阿正要努力
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java8 新特性
06-17
java8的新特性，包含lambda表达式，stream流以及Optional和日期
Java8新特性共76页
11-18
Java8新特性共76页
java8 新特性5 方法引用
健康平安的活着的专栏
11-05 475
: 该符号为引用运算符，而它所在的表达式被称为方法引用。
Stream-java8新特性
PrettyEagle的博客
06-21 2961
java8 stream的使用实操
【Java8新特性】5.BASE64
小确幸的博客
12-29 426
BASE64编码和解码
Java8新特性
m0_71212413的博客
11-15 167
新特性
Java8新特性： Lambda helloworld
doomwatcher的博客
12-11 386
这里是小冷的博客 优质技术好文见：专栏 个人公众号，分享一些技术上的文章，以及遇到的坑 当前系列：Java8 新特性 系列 源代码 git 仓库 代码 Git 仓库地址 Java8 新特性 Java 8 （又称为 jdk 8 ） 是java语言开发的一个主要版本，Java8是 oracle 公司 2014 4月发布的，可以看成自java5 以来最具革命性的版本，Java 8 为java 语言，编译器，类库，开发功能与JVM带来了大量的新特性 Java 8 新特性介绍 速度更快 代码更少（增加了.
JDK21新特性及演示代码示例
nanxiaotao的博客
03-15 1105
JDK21版本是 Java SE 平台版本 21 的参考实现，如 Java Community Process 中的 JSR 396 所指定。 JDK 21于2023年09月19日发布。
【JDK8新特性之日期时间API-案例实操】
Coder_ljw的博客
02-26 455
【JDK8新特性之日期时间API-案例实操】1. 设计不合理，没有一个统一衡量的标准，在java.util和java.sql的包各自中都有日期类。2. 非线程安全，所有的日期类都是可变的。3. 不提供时区支持。JDK 8中全新的日期时间API，是线程安全的。新的日期及时间API位于 java.time 包中，以下是关于日期时间关键类API。 - LocalDate ：表示日期，包含年月日，格式为 2019-10-16 - LocalTime ：表示时间，包含时分秒，格式为 16:38:54.158549
JAVA学习笔记(一)-JAVA概述与一点实操
CSDNXXCQ的博客
01-27 511
Java语言发展史 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。 0世纪90年代，硬件领域出现了单片
【JDK8新特性之Lambda表达式-案例实操】
Coder_ljw的博客
02-25 664
【JDK8新特性之Lambda表达式-案例实操】Lambda表达式有关的内容。如果你想在今后做决定时有更多的选择，那么此时此刻，现在，不要想过多不切实际的，付出更多的努力，你肯定没有问题的！Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意。Lambda表达式是一个匿名函数，使用Lambda表达式可以简化了匿名内部类的使用，语法更加简单。
java8新特性
12-26
主要是对java8新特性的一些讲解，在ppt中，有lambda表达式，有Stream等知识点
Java8新特性练习.zip
07-08
这个文件是关于Java8新特性的文件，里面包含了lambda表达式，代替了匿名内部类，它简化了代码，但不是匿名内部类的代码糖， 其中包含了lambda表达式的无参无返回和有参有返回的标准格式还有lambda表达式的标准写法。
java环境部署
JiuMeilove的博客
06-04 400
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
finereport 9.0 Tomcat 集群-来自帆软
最新发布
chenmingfa110的博客
06-07 595
APACHE_HOME ％为你的安装目录。对于每个新来的session，Apache按照节点配置中的lbfactor比重选择访问节点，如果某节点node1不能访问，则寻找下一可访问节点，并且将此node1就在该访问session的访问黑名单中，以后该session的访问直接不考虑node1，即使node1又可以访问了。注：由于这里三个tomcat全在一台机器上，所以需要修改三种类型的端口号，如果是在不同的机器上，则只需要修改AJP13的connector的port，其他端口号不需要修改。
java中Overload和Override的区别
codedadi的博客
06-04 583
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1435
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
java8新特性详解
03-28
Java 8引入了许多新特性，以下是其中一些重要的特性： 1. Lambda表达式：Lambda表达式是Java 8中最重要的特性之一。它允许我们以更简洁的方式编写匿名函数。Lambda表达式可以作为参数传递给方法，或者用于函数式...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值