java8新特性

最新推荐文章于 2025-03-03 19:46:48 发布

原创最新推荐文章于 2025-03-03 19:46:48 发布 · 309 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

java8新特性

一、lambda✔

表达式特点（允许函数作为一个方法的参数）

1）参数可以不声明参数类型

2）参数的圆括号，只有一个参数时，可以不写圆括号

3）只有一条语句，可以不写大括号

4）只有一个表达式，编译器会默认，将表达式作为返回值返回

5）如果有大括号，必须使用return关键字，进行返回

6）允许函数作为参数，进行传值

lambda变量作用域

1）lambda只能引用，外部用final修饰的变量。不能在lambda内部修改定义在域外的局部变量

2）lambda的表达式，参数不能和局部变量名称相同

二、方法引用✔

语法 ::

引用构造方法，例如 Instance::new 可以调用构造方法

引用今天静态方法，例如 Class::staticMthoed

引用特定对象的方法,例如

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TwS9V2V7-1639378763964)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20211208195116291.png)]

三、函数式接口✔

有且只有一个抽象方法，但是可以有多个非抽象方法的接口，成为函数式接口

java7之前需要写匿名内部类，但是java8的函数式接口，可以不用写匿名内部类，可以调用接口的方法

一个栗子🏷

public class FunctionalInterfaceDemo {
    public static void main(String[] args) {
        GreetingService greetingService=message -> System.out.println("message = " + message);
        List<Integer> list= Arrays.asList(1,2,3,4,5,6,7);
        System.out.println("输出所有参数");
        //java8函数式接口 传递参数（不用写匿名函数，但是只适用于函数式的接口：有且只有一个抽象方法、但可以有多个非抽象方法的接口）
        eval(list,n->{
            return true;
        });

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

        //java7的写法，需要写匿名函数
        eval(list, new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return true;
            }
        });

        System.out.println("输出所有偶数");
        //函数式接口，输出所有偶数
        eval(list,n->n%2==0);

        System.out.println("输出所有大于3的数字");
        eval(list,n->n>3);
    }

    public static void eval(List<Integer> list, Predicate<Integer> predicate){
        for (Integer n : list) {
            if (predicate.test(n)){
                System.out.println(n+" ");
            }
        }
    }

四、默认方法✔

默认方法：在接口的方法前添加关键字default，实现接口的方法不用去重写默认方法，一个接口可以有多个默认方法

🌮 java7接口

好处：面向抽象而不是具体的编程

坏处：以前的接口，如果要修改接口的方法，那么就要修改所有的实现类

问题描述：如果一个类实现了多个接口，切接口的默认方法同名，怎么办

解决方法：

1）自己重写重名的方法

2）使用super调用方法（接口名称.super.方法名称)

五、Stream API✔

Java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

通过stream得到流、parallel得到平行流

1）filter 过滤出符合条件设置（空字符串、空字符串个数等等）的数据源元素

public void filter(){
        List<String> list=new ArrayList<>();
        list.add("xc");
        list.add("xc");
        list.add("xc");
        list.add("xc");
        //去除重复的元素
        list=list.stream().distinct().collect(Collectors.toList());
        list.forEach(System.out::println);
        list.clear();

        list.add("xiaocheng");
        list.add("xiange");
        list.add("");
        list.add("qunjie");
        //过滤掉空的元素
        System.out.println("过滤掉数据源中空的元素");
        list=list.stream().filter(s -> !s.isEmpty()).collect(Collectors.toList());
        list.forEach(System.out::println);
    }

2）sorted排序（升序）

public void sort(){
    Random random = new Random();
    //得到大小区间为(1,100)的50位随机数，并排序
    random.ints(1,100).limit(50).map(i->new Integer(i)).sorted().distinct().forEach(System.out::println);
}

3）distinct去除重复的元素

list=list.stream().distinct().collect(Collectors.toList());

4）map映射数据源的每一个元素，可以对每个元素进项操作

  /**
     * stream中提供了map方法，用于映射每个数据源的元素
     * 得到数据源中每个元素的平方
     */
    @Test
    public void map(){
        List<Integer> list=Arrays.asList(1,2,3,4,5,6);
        list=  list.stream().map(i->i*i).collect(Collectors.toList());
        list.forEach(System.out::println);
    }

5）limit用来限制stream流的个数

 /**
     * limit用来限制stream流的个数
     */
    @Test
    public void limit(){
        List<String> list=Arrays.asList("pvcc","dashborad","","","cvqic");
        System.out.printf("limit用来限制stream输出流的个数");
        list.stream().limit(1).forEach(System.out::println);
    }

6）summaryStatistics统计（数据源中最大、最小、平均数、求和等等）

    /**
     * 统计（数据源中最大、最小、平均数、求和）
     */
    @Test
    public void tongJi(){
        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        IntSummaryStatistics summary = numbers.stream().mapToInt(x -> x).summaryStatistics();
        System.out.println("列表中最大的数" + summary.getMax());
        System.out.println("列表中最小的数" + summary.getMin());
        System.out.println("列表中平均数" + summary.getAverage());
        System.out.println("数据源求和" + summary.getSum());
        System.out.println("数据源个数"+summary.getCount());
    }

7）Collections

/**
*将List集合元素以",“作为拼接符，转换为String字符串
*/
public void collectors(){
    List list=Arrays.asList("xc","xg","wls","ss","km");
    String collect = list.stream().collect(Collectors.joining(",")).toString();
    System.out.printf( collect);
}

七、Date Time API✔

以前的java时间类线程不安全、设计很差（与sql里面的时间类名一样、可读性查、处理时区麻烦）

java8：Local（本地）简化了时间日期的处理、没有时区的问题

Zoned（时区）通过制定时区处理日期的时间

@Test
public void localDateAndLocalTime() {
    //获取当前的日期时间
    LocalDateTime now = LocalDateTime.now();
    System.out.println("获取当前的日期时间" + now);
    System.out.println("获取当前日期" + now.toLocalDate());
    System.out.println("获取当前日期年份" + now.getYear());
    System.out.println("获取当前日期月份" + now.getMonthValue());
    System.out.println("获取当前日期月份的第几天" + now.getDayOfMonth());
    System.out.println("秒" + now.getMinute());
    System.out.println("============");
    LocalDateTime time = now.withDayOfMonth(10).withYear(2012);
    System.out.println("得到" + now + "时间的月份,与2012年12月中的第10天拼接：最后的时间是" + time);
    LocalDate of = LocalDate.of(2021, Month.APRIL, 12);
    System.out.println(of);
    LocalTime of1 = LocalTime.of(23, 36);
    System.out.println("现在是北京时间" + of1 + "我还在敲代码，哈哈哈哈");
    //字符串解析
    LocalTime parse = LocalTime.parse("20:34:12");
    System.out.println("字符串解析" + parse);
}

八、Optional类✔

@Test
public void optionalMethod(){
    Integer valueA=null;
    Integer valueB=new Integer(5);
    //Optional.ofNullable-允许传递null作为参数
    Optional<Integer> optionalA=Optional.ofNullable(valueA);
    //System.out.println(optional.get());

    //Optional.of -如果传递的参数是null，抛出NPE异常
    Optional<Integer> optionalB=Optional.ofNullable(valueB);
    //求和
    System.out.println(sum(optionalA, optionalB));
}

@Test
public Integer sum(Optional<Integer> optionalA,Optional<Integer> optionalB){
    //Optional.isPresent-判断值是否存在
    System.out.println("判断optionalA是否存在"+optionalA.isPresent());
    System.out.println("判断optionaB是否存在"+optionalB.isPresent());

    //Optional.orElse -如果值存在，返回它，否则返回默认值,使用get()方法，要求值必须存在，否则会抛出NoSuchElementException异常
    return optionalA.orElse(new Integer(0)) + optionalB.get();
}