欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JDK8新特性

程序员文章站 2022-06-05 13:17:53
...

Lambda

Lambda表达式的结构

  • 一个 Lambda 表达式可以有零个或多个参数
  • 参数的类型既可以明确声明,也可以根据上下文来推断。例如:(int a)与(a)效果相同
  • 所有参数需包含在圆括号内,参数之间用逗号相隔。例如:(a, b) 或 (int a, int b) 或 (String a, int b,
    float c)
  • 空圆括号代表参数集为空。例如:() -> 42
  • 当只有一个参数,且其类型可推导时,圆括号()可省略。例如:a -> return a*a
  • Lambda 表达式的主体可包含零条或多条语句
  • 如果 Lambda 表达式的主体只有一条语句,花括号{}可省略。匿名函数的返回类型与该主体表达式一致
  • 如果 Lambda
    表达式的主体包含一条以上语句,则表达式必须包含在花括号{}中(形成代码块)。匿名函数的返回类型与代码块的返回类型一致,若没有返回则为空

语法

Interface var = (x,y) -> {}该接口只能有一个需要被实现的方法,小括号中参数取决于Interface 的接口方法的参数,没有参数则为空,{}中为方法的实现内容,如果内容只有一行代码,{}可以省略。实际上就是匿名函数

Runnable run = new Runnable(){
    @Override
    publicvoidrun(){
        System.out.println("常规写法");
    }
};
Runnable run1 = () -> {System.out.println("lambda");};//{}中只有一条语句时,{}可以省略
//匿名函数的访问权限可以省略(跟接收变量的作用域保持一致,返回值和参数类型都可以编译器自动判断。)

只有一个抽象方法需要被实现的接口,称为“函数式接口”,为了避免后续被人在该接口中添加方法,导致规则被破坏,可以在该接口上加一个声明@FunctionalInterface,这样该接口就无法添加新的接口函数了

Stream

  • 不是数据结构:它没有内部存储,它只是用操作管道从 source(数据结构、数组、generator function、IO channel)抓取数据。它也绝不修改自己所封装的底层数据结构的数据。例如 Stream 的 filter操作会产生一个不包含被过滤元素的新 Stream,而不是从 source 删除那些元素。
  • 不支持索引访问:但是很容易生成数组或者 List 。
  • 惰性化:很多 Stream 操作是向后延迟的,一直到它弄清楚了最后需要多少数据才会开始。Intermediate 操作永远是惰性化的。
  • 并行能力。当一个 Stream 是并行化的,就不需要再写多线程代码,所有对它的操作会自动并行进行的。
  • 可以是无限的:集合有固定大小,Stream 则不必。limit(n) 和 findFirst() 这类的 short-circuiting操作可以对无限的 Stream 进行运算并很快完成。
  • 注意事项:所有 Stream 的操作必须以 lambda 表达式为参数。## 并行迭代器

首先通过普通的方式进行过滤:

List<String> list = Arrays.asList("张三", "李四", "王五", "xuwujing");
 System.out.println("过滤之前:" + list);
 List<String> result = new ArrayList<>();
 for (String str : list) {
  if (!"李四".equals(str)) {
   result.add(str);
  }
 }
 System.out.println("过滤之后:" + result);

使用Steam方式进行过滤:

List<String> result2 = list.stream().filter(str -> !"李四".equals(str)).collect(Collectors.toList());
System.out.println("stream 过滤之后:" + result2);

1.构造Stream流的方式

 Stream stream = Stream.of("a", "b", "c");
 String[] strArray = new String[] { "a", "b", "c" };
 stream = Stream.of(strArray);
 stream = Arrays.stream(strArray);
 List<String> list = Arrays.asList(strArray);
 stream = list.stream();

2.Stream流的之间的转换
注意:一个Stream流只可以使用一次,这段代码为了简洁而重复使用了数次,因此会抛出 stream has already been operated upon or closed 异常。

try {
  Stream<String> stream2 = Stream.of("a", "b", "c");
  // 转换成 Array
  String[] strArray1 = stream2.toArray(String[]::new);

  // 转换成 Collection
  List<String> list1 = stream2.collect(Collectors.toList());
  List<String> list2 = stream2.collect(Collectors.toCollection(ArrayList::new));
  Set set1 = stream2.collect(Collectors.toSet());
  Stack stack1 = stream2.collect(Collectors.toCollection(Stack::new));

  // 转换成 String
  String str = stream.collect(Collectors.joining()).toString();
 } catch (Exception e) {
  e.printStackTrace();
 }

3.Stream流的map使用
map方法用于映射每个元素到对应的结果,一对一。
示例一:转换大写

 List<String> list3 = Arrays.asList("zhangSan", "liSi", "wangWu");
 System.out.println("转换之前的数据:" + list3);
 List<String> list4 = list3.stream().map(String::toUpperCase).collect(Collectors.toList());
 System.out.println("转换之后的数据:" + list4);
 // 转换之后的数据:[ZHANGSAN, LISI,WANGWU]

示例二:转换数据类型

 List<String> list31 = Arrays.asList("1", "2", "3");
 System.out.println("转换之前的数据:" + list31);
 List<Integer> list41 = list31.stream().map(Integer::valueOf).collect(Collectors.toList());
 System.out.println("转换之后的数据:" + list41);
 // [1, 2, 3]

4.Stream流的filter使用
filter方法用于通过设置的条件过滤出元素。
示例一:通过与 findAny 得到 if/else 的值

List<String> list = Arrays.asList("张三", "李四", "王五", "xuwujing");
String result3 = list.stream().filter(str -> "李四".equals(str)).findAny().orElse("找不到!");
String result4 = list.stream().filter(str -> "李二".equals(str)).findAny().orElse("找不到!");

System.out.println("stream 过滤之后 2:" + result3);
System.out.println("stream 过滤之后 3:" + result4);
//stream 过滤之后 2:李四
//stream 过滤之后 3:找不到!

示例二:通过与 mapToInt 计算和

 List<User> lists = new ArrayList<User>();
 lists.add(new User(6, "张三"));
 lists.add(new User(2, "李四"));
 lists.add(new User(3, "王五"));
 lists.add(new User(1, "张三"));
 // 计算这个list中出现 "张三" id的值
 int sum = lists.stream().filter(u -> "张三".equals(u.getName())).mapToInt(u -> u.getId()).sum();

 System.out.println("计算结果:" + sum);

5.Stream流的flatMap使用
flatMap 方法用于映射每个元素到对应的结果,一对多。
示例:从句子中得到单词

 String worlds = "The way of the future";
 List<String> list7 = new ArrayList<>();
 list7.add(worlds);
 List<String> list8 = list7.stream().flatMap(str -> Stream.of(str.split(" ")))
   .filter(world -> world.length() > 0).collect(Collectors.toList());
 System.out.println("单词:");
 list8.forEach(System.out::println);
 // 单词:
 // The
 // way
 // of
 // the
 // future

6.Stream流的limit使用
limit 方法用于获取指定数量的流。
示例一:获取前n条数的数据

 Random rd = new Random();
 System.out.println("取到的前三条数据:");
 rd.ints().limit(3).forEach(System.out::println);
 // 取到的前三条数据:
 // 1167267754
 // -1164558977
 // 1977868798

示例二:结合skip使用得到需要的数据
skip表示的是扔掉前n个元素。

List<User> list9 = new ArrayList<User>();
 for (int i = 1; i < 4; i++) {
  User user = new User(i, "pancm" + i);
  list9.add(user);
 }
 System.out.println("截取之前的数据:");
 // 取前3条数据,但是扔掉了前面的2条,可以理解为拿到的数据为 2<=i<3 (i 是数值下标)
 List<String> list10 = list9.stream().map(User::getName).limit(3).skip(2).collect(Collectors.toList());
 System.out.println("截取之后的数据:" + list10);
 //  截取之前的数据:
 //  姓名:pancm1
 //  姓名:pancm2
 //  姓名:pancm3
 //  截取之后的数据:[pancm3]

7.Stream流的sort使用
sorted方法用于对流进行升序排序。
示例一:随机取值排序

 Random rd2 = new Random();
 System.out.println("取到的前三条数据然后进行排序:");
 rd2.ints().limit(3).sorted().forEach(System.out::println);
 // 取到的前三条数据然后进行排序:
 // -2043456377
 // -1778595703
 // 1013369565

示例二:优化排序
tips:先获取在排序效率会更高!

//普通的排序取值
 List<User> list11 = list9.stream().sorted((u1, u2) -> u1.getName().compareTo(u2.getName())).limit(3)
   .collect(Collectors.toList());
 System.out.println("排序之后的数据:" + list11);
 //优化排序取值
 List<User> list12 = list9.stream().limit(3).sorted((u1, u2) -> u1.getName().compareTo(u2.getName()))
   .collect(Collectors.toList());
 System.out.println("优化排序之后的数据:" + list12);
 //排序之后的数据:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]
 //优化排序之后的数据:[{"id":1,"name":"pancm1"}, {"id":2,"name":"pancm2"}, {"id":3,"name":"pancm3"}]

8.Stream流的peek使用
peek对每个元素执行操作并返回一个新的Stream
示例:双重操作

 System.out.println("peek使用:");
 Stream.of("one", "two", "three", "four").filter(e -> e.length() > 3).peek(e -> System.out.println("转换之前: " + e))
   .map(String::toUpperCase).peek(e -> System.out.println("转换之后: " + e)).collect(Collectors.toList());

 // 转换之前: three
 // 转换之后: THREE
 // 转换之前: four
 // 转换之后: FOUR

9.Stream流的parallel使用
parallelStream 是流并行处理程序的代替方法。
示例:获取空字符串的数量

 List<String> strings = Arrays.asList("a", "", "c", "", "e","", " ");
 // 获取空字符串的数量
 long count =  strings.parallelStream().filter(string -> string.isEmpty()).count();
 System.out.println("空字符串的个数:"+count);

10.Stream流的max/min/distinct使用
示例一:得到最大最小值

List<String> list13 = Arrays.asList("zhangsan","lisi","wangwu","xuwujing");
 int maxLines = list13.stream().mapToInt(String::length).max().getAsInt();
 int minLines = list13.stream().mapToInt(String::length).min().getAsInt();
 System.out.println("最长字符的长度:" + maxLines+",最短字符的长度:"+minLines);
 //最长字符的长度:8,最短字符的长度:4

示例二:得到去重之后的数据

 String lines = "good good study day day up";
 List<String> list14 = new ArrayList<String>();
 list14.add(lines);
 List<String> words = list14.stream().flatMap(line -> Stream.of(line.split(" "))).filter(word -> word.length() > 0)
   .map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());
 System.out.println("去重复之后:" + words);
 //去重复之后:[day, good, study, up]

11.Stream流的Match使用
allMatch:Stream 中全部元素符合则返回 true ;
anyMatch:Stream 中只要有一个元素符合则返回 true;
noneMatch:Stream 中没有一个元素符合则返回 true。
示例:数据是否符合

boolean all = lists.stream().allMatch(u -> u.getId() > 3);
 System.out.println("是否都大于3:" + all);
 boolean any = lists.stream().anyMatch(u -> u.getId() > 3);
 System.out.println("是否有一个大于3:" + any);
 boolean none = lists.stream().noneMatch(u -> u.getId() > 3);
 System.out.println("是否没有一个大于3的:" + none);
 // 是否都大于3:false
 // 是否有一个大于3:true
 // 是否没有一个大于3的:false

12.Stream流的reduce使用
reduce 主要作用是把 Stream 元素组合起来进行操作。
示例一:字符串连接

String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
System.out.println("字符串拼接:" + concat);

示例二:得到最小值

 double minValue = Stream.of(-4.0, 1.0, 3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
 System.out.println("最小值:" + minValue);
 //最小值:-4.0

示例三:求和

 // 求和, 无起始值
 int sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
 System.out.println("有无起始值求和:" + sumValue);
 // 求和, 有起始值
  sumValue = Stream.of(1, 2, 3, 4).reduce(1, Integer::sum);
  System.out.println("有起始值求和:" + sumValue);
 // 有无起始值求和:10
 // 有起始值求和:11

示例四:过滤拼接

concat = Stream.of("a", "B", "c", "D", "e", "F").filter(x -> x.compareTo("Z") > 0).reduce("", String::concat);
System.out.println("过滤和字符串连接:" + concat);
 //过滤和字符串连接:ace

13.Stream流的iterate使用
“iterate 跟 reduce 操作很像,接受一个种子值,和一个UnaryOperator(例如 f)。然后种子值成为 Stream 的第一个元素,f(seed) 为第二个,f(f(seed)) 第三个,以此类推。在 iterate 时候管道必须有 limit 这样的操作来限制 Stream 大小。
示例:生成一个等差队列

 System.out.println("从2开始生成一个等差队列:");
 Stream.iterate(2, n -> n + 2).limit(5).forEach(x -> System.out.print(x + " "));
 // 从2开始生成一个等差队列:
 // 2 4 6 8 10

14.Stream流的Supplier使用
通过实现Supplier类的方法可以自定义流计算规则。
示例:随机获取两条用户信息

System.out.println("自定义一个流进行计算输出:");
 Stream.generate(new UserSupplier()).limit(2).forEach(u -> System.out.println(u.getId() + ", " + u.getName()));

 //第一次:
 //自定义一个流进行计算输出:
 //10, pancm7
 //11, pancm6

 //第二次:
 //自定义一个流进行计算输出:
 //10, pancm4
 //11, pancm2

 //第三次:
 //自定义一个流进行计算输出:
 //10, pancm4
 //11, pancm8


class UserSupplier implements Supplier<User> {
 private int index = 10;
 private Random random = new Random();

 @Override
 public User get() {
  return new User(index++, "pancm" + random.nextInt(10));
 }
}

15.Stream流的groupingBy/partitioningBy使用
groupingBy:分组排序;
partitioningBy:分区排序。
示例一:分组排序

  System.out.println("通过id进行分组排序:");
        Map<Integer, List<User>> personGroups = Stream.generate(new UserSupplier()).limit(5)
                .collect(Collectors.groupingBy(User::getId));
        Iterator it = personGroups.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<Integer, List<User>> persons = (Map.Entry) it.next();
            System.out.println("id " + persons.getKey() + " = " + persons.getValue());
        }


        System.out.println("通过年龄进行分区排序:");
        Map<Boolean, List<User>> children = Stream.generate(new UserSupplier()).limit(5)
                .collect(Collectors.partitioningBy(p -> p.getId() < 18));

        System.out.println("小孩: " + children.get(true));
        System.out.println("成年人: " + children.get(false));

16.Stream流的summaryStatistics使用
IntSummaryStatistics 用于收集统计信息(如count、min、max、sum和average)的状态对象。
示例:得到最大、最小、之和以及平均数。

 List<Integer> numbers = Arrays.asList(1, 5, 7, 3, 9);
        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

        System.out.println("列表中最大的数 : " + stats.getMax());
        System.out.println("列表中最小的数 : " + stats.getMin());
        System.out.println("所有数之和 : " + stats.getSum());
        System.out.println("平均数 : " + stats.getAverage());

并行迭代器

//tryAdvance 相当于普通迭代器iterator  串行处理
public void iterator(){
    AtomicInteger num = new AtomicInteger(0);
    while(true){
        boolean flag = spliterator.tryAdvance((i) ->{
            num.addAndGet((int)i);
            System.out.println(i);
        });
        if(!flag){
            break;
        }
    }
    System.out.println(num);
}
//trySplit将list分段,每段单独处理,为并行提供可能
public void spliterator(){
    AtomicInteger num = new AtomicInteger(0);
    Spliterator s1 = spliterator.trySplit();
    Spliterator s2 = spliterator.trySplit();
    spliterator.forEachRemaining((i) ->{
        num.addAndGet((int)i);
        System.out.println("spliterator:"+i);
    });
    s1.forEachRemaining((i) ->{
        num.addAndGet((int)i);
        System.out.println("s1:"+i);
    });
    s2.forEachRemaining((i) ->{
        num.addAndGet((int)i);
        System.out.println("s2:"+i);
    });
    System.out.println("最终结果:"+num);
}
//利用分段,开启多线程处理
public void spliterator2() throws InterruptedException {
    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
        run(spliterator.trySplit());
        return "future1 finished!";
    });
    CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
        run(spliterator.trySplit());
        return "future2 finished!";
    });
    CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
        run(spliterator);
        return "future3 finished!";
    });
    CompletableFuture<Void> combindFuture = CompletableFuture.allOf(future1, future2);
    try {
        combindFuture.get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    System.out.println("future1: " + future1.isDone() + " future2: " + future2.isDone());
    System.out.println("最终结果为:" + count);
}
public void run(Spliterator s1) {
    final String threadName = Thread.currentThread().getName();
    System.out.println("线程" + threadName + "开始运行-----");
    s1.forEachRemaining(new Consumer() {
        @Override
        public void accept(Object o) {
            count.addAndGet((Integer)o);
        }
    });
    System.out.println("线程" + threadName + "运行结束-----");
}

HashMap

JDK8优化了HashMap的实现, 主要优化点包括:
• 将链表方式修改成链表或者红黑树的形式
• 修改resize的过程,解决JDK7在resize在并发场景下死锁的隐患
• JDK1.7存储使用Entry数组, JDK8使用Node或者TreeNode数组存储
当链表长度大于8是链表的存储结构会被修改成红黑树的形式。
查询效率从O(N)提升到O(logN)。链表长度小于6时,红黑树的方式退化成链表。
JDK7链表插入是从链表头部插入, 在resize的时候会将原来的链表逆序。
JDK8插入从链表尾部插入, 因此在resize的时候仍然保持原来的顺序。

日期

  • Instant:瞬时时间。
  • LocalDate:本地日期,不包含具体时间, 格式 yyyy-MM-dd。
  • LocalTime:本地时间,不包含日期. 格式 yyyy-MM-dd HH:mm:ss.SSS 。
  • LocalDateTime:组合了日期和时间,但不包含时差和时区信息。
  • ZonedDateTime:最完整的日期时间,包含时区和相对UTC或格林威治的时差。

1.获取当前的日期时间
通过静态工厂方法now()来获取当前时间。

 //本地日期,不包括时分秒
 LocalDate nowDate = LocalDate.now();
 //本地日期,包括时分秒
 LocalDateTime nowDateTime = LocalDateTime.now();
 System.out.println("当前时间:"+nowDate);
 System.out.println("当前时间:"+nowDateTime);
 //  当前时间:2018-12-19
 //  当前时间:2018-12-19T15:24:35.822

2.获取当前的年月日时分秒
获取时间之后,直接get获取年月日时分秒。

//获取当前的时间,包括毫秒
  LocalDateTime ldt = LocalDateTime.now();
  System.out.println("当前年:"+ldt.getYear());   //2018
  System.out.println("当前年份天数:"+ldt.getDayOfYear());//172
  System.out.println("当前月:"+ldt.getMonthValue());
  System.out.println("当前时:"+ldt.getHour());
  System.out.println("当前分:"+ldt.getMinute());
  System.out.println("当前时间:"+ldt.toString());
 //   当前年:2018
 //   当前年份天数:353
 //   当前月:12
 //   当前时:15
 //   当前分:24

3.格式化时间
格式时间格式需要用到DateTimeFormatter类。

LocalDateTime ldt = LocalDateTime.now();
System.out.println("格式化时间: "+ ldt.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")));
//格式化时间:2018-12-19 15:37:47.119

4.时间增减
在指定的时间进行增加/减少年月日时分秒。

LocalDateTime ldt = LocalDateTime.now();
  System.out.println("后5天时间:"+ldt.plusDays(5));
  System.out.println("前5天时间并格式化:"+ldt.minusDays(5).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))); //2018-06-16
  System.out.println("前一个月的时间:"+ldt2.minusMonths(1).format(DateTimeFormatter.ofPattern("yyyyMM"))); //2018-06-16
  System.out.println("后一个月的时间:"+ldt2.plusMonths(1)); //2018-06-16
  System.out.println("指定2099年的当前时间:"+ldt.withYear(2099)); //2099-06-21T15:07:39.506
 //  后5天时间:2018-12-24T15:50:37.508
 //  前5天时间并格式化:2018-12-14
 //  前一个月的时间:201712
 //  后一个月的时间:2018-02-04T09:19:29.499
 //  指定2099年的当前时间:2099-12-19T15:50:37.508

5.时间相差比较
比较相差的年月日时分秒。
示例一: 具体相差的年月日

 LocalDate ld=LocalDate.parse("2017-11-17");
 LocalDate ld2=LocalDate.parse("2018-01-05");
 Period p=Period.between(ld, ld2);
 System.out.println("相差年: "+p.getYears()+" 相差月 :"+p.getMonths() +" 相差天:"+p.getDays());
 // 相差年: 0 相差月 :1 相差天:19

注:这里的月份是不满足一年,天数是不满足一个月的。这里实际相差的是1月19天,也就是49天。
示例二:相差总数的时间
ChronoUnit 日期周期单位的标准集合。

 LocalDate startDate = LocalDate.of(2017, 11, 17);
        LocalDate endDate = LocalDate.of(2018, 01, 05);
        System.out.println("相差月份:"+ChronoUnit.MONTHS.between(startDate, endDate));
        System.out.println("两月之间的相差的天数   : " + ChronoUnit.DAYS.between(startDate, endDate));
  //        相差月份:1
  //        两天之间的差在天数   : 49

注:ChronoUnit也可以计算相差时分秒。
示例三:精度时间相差
Duration 这个类以秒和纳秒为单位建模时间的数量或数量。

 Instant inst1 = Instant.now();
    System.out.println("当前时间戳 : " + inst1);
    Instant inst2 = inst1.plus(Duration.ofSeconds(10));
    System.out.println("增加之后的时间 : " + inst2);
    System.out.println("相差毫秒 : " + Duration.between(inst1, inst2).toMillis());
    System.out.println("相毫秒 : " + Duration.between(inst1, inst2).getSeconds());
 // 当前时间戳 : 2018-12-19T08:14:21.675Z
 // 增加之后的时间 : 2018-12-19T08:14:31.675Z
 // 相差毫秒 : 10000
 // 相毫秒 : 10

示例四:时间大小比较

 LocalDateTime ldt4 = LocalDateTime.now();
  LocalDateTime ldt5 = ldt4.plusMinutes(10);
  System.out.println("当前时间是否大于:"+ldt4.isAfter(ldt5));
  System.out.println("当前时间是否小于"+ldt4.isBefore(ldt5));
  // false
  // true
相关标签: 新特性