本篇主要讲述是Java中JDK1.8的一些新语法特性使用,主要是Lambda、Stream和LocalDate日期的一些使用讲解。
Lambda 表达式(lambda expression)是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数。
下面我们先使用一个简单的例子来看看Lambda的效果吧。
比如我们对Map 的遍历
传统方式遍历如下:
Map<String, String> map = new HashMap<>(); map.put("a", "a"); map.put("b", "b"); map.put("c", "c"); map.put("d", "d"); System.out.println("map普通方式遍历:"); for (String key : map.keySet()) { System.out.println("k=" + key + ",v=" + map.get(key)); }
使用Lambda进行遍历:
System.out.println("map拉姆达表达式遍历:"); map.forEach((k, v) -> { System.out.println("k=" + k + ",v=" + v); });
List也同理,不过List还可以通过双冒号运算符遍历:
List<String> list = new ArrayList<String>(); list.add("a"); list.add("bb"); list.add("ccc"); list.add("dddd"); System.out.println("list拉姆达表达式遍历:"); list.forEach(v -> { System.out.println(v); }); System.out.println("list双冒号运算符遍历:"); list.forEach(System.out::println);
输出结果:
map普通方式遍历: k=a,v=a k=b,v=b k=c,v=c k=d,v=d map拉姆达表达式遍历: k=a,v=a k=b,v=b k=c,v=c k=d,v=d list拉姆达表达式遍历: a bb ccc dddd list双冒号运算符遍历: a bb ccc dddd
Lambda除了在for循环遍历中使用外,它还可以代替匿名的内部类。
比如下面这个例子的线程创建:
//使用普通的方式创建 Runnable r1 = new Runnable() { @Override public void run() { System.out.println("普通方式创建!"); } }; //使用拉姆达方式创建 Runnable r2 = ()-> System.out.println("拉姆达方式创建!");
注: 这个例子中使用Lambda表达式的时候,编译器会自动推断:根据线程类的构造函数签名 Runnable r { },将该 Lambda 表达式赋Runnable 接口。
Lambda 表达式与匿名类的区别
使用匿名类与 Lambda 表达式的一大区别在于关键词的使用。对于匿名类,关键词 this 解读为匿名类,而对于 Lambda 表达式,关键词 this 解读为写就 Lambda 的外部类。
Lambda虽然简化了代码的编写,但同时也减少了可读性。
Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
这里我们依旧使用一个简单示例来看看吧。
在开发中,我们有时需要对一些数据进行过滤,如果是传统的方式,我们需要对这批数据进行遍历过滤,会显得比较繁琐,如果使用steam流方式的话,那么可以很方便的进行处理。
首先通过普通的方式进行过滤:
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);
输出结果:
过滤之前:[张三, 李四, 王五, xuwujing] 过滤之后:[张三, 王五, xuwujing] stream 过滤之后:[张三, 王五, xuwujing]
是不是很简洁和方便呢。
其实Stream流还有更多的使用方法,filter只是其中的一角而已。那么在这里我们就来学习了解下这些用法吧。
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();
注意:一个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(); }
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]
示例三:获取平方
List<Integer> list5 = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 }); List<Integer> list6 = list5.stream().map(n -> n * n).collect(Collectors.toList()); System.out.println("平方的数据:" + list6); // [1, 4, 9, 16, 25]
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); // 7
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
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]
注:User实体类中 getName 方法会打印姓名。
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"}]
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
parallelStream 是流并行处理程序的代替方法。
示例:获取空字符串的数量
List<String> strings = Arrays.asList("a", "", "c", "", "e","", " "); // 获取空字符串的数量 long count = strings.parallelStream().filter(string -> string.isEmpty()).count(); System.out.println("空字符串的个数:"+count);
示例一:得到最大最小值
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]
示例:数据是否符合
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
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
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
通过实现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)); } }
示例一:分组排序
System.out.println("通过id进行分组排序:"); Map<Integer, List<User>> personGroups = Stream.generate(new UserSupplier2()).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()); } // 通过id进行分组排序: // id 10 = [{"id":10,"name":"pancm1"}] // id 11 = [{"id":11,"name":"pancm3"}, {"id":11,"name":"pancm6"}, {"id":11,"name":"pancm4"}, {"id":11,"name":"pancm7"}] class UserSupplier2 implements Supplier<User> { private int index = 10; private Random random = new Random(); @Override public User get() { return new User(index % 2 == 0 ? index++ : index, "pancm" + random.nextInt(10)); } }
示例二:分区排序
System.out.println("通过年龄进行分区排序:"); Map<Boolean, List<User>> children = Stream.generate(new UserSupplier3()).limit(5) .collect(Collectors.partitioningBy(p -> p.getId() < 18)); System.out.println("小孩: " + children.get(true)); System.out.println("成年人: " + children.get(false)); // 通过年龄进行分区排序: // 小孩: [{"id":16,"name":"pancm7"}, {"id":17,"name":"pancm2"}] // 成年人: [{"id":18,"name":"pancm4"}, {"id":19,"name":"pancm9"}, {"id":20,"name":"pancm6"}] class UserSupplier3 implements Supplier<User> { private int index = 16; private Random random = new Random(); @Override public User get() { return new User(index++, "pancm" + random.nextInt(10)); } }
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()); // 列表中最大的数 : 9 // 列表中最小的数 : 1 // 所有数之和 : 25 // 平均数 : 5.0
Stream 介绍就到这里了,JDK1.8中的Stream流其实还有很多很多用法,更多的用法则需要大家去查看JDK1.8的API文档了。
JDK1.8除了新增了lambda表达式、stream流之外,它还新增了全新的日期时间API。在JDK1.8之前,Java处理日期、日历和时间的方式一直为社区所诟病,将 java.util.Date设定为可变类型,以及SimpleDateFormat的非线程安全使其应用非常受限。因此推出了java.time包,该包下的所有类都是不可变类型而且线程安全。
通过静态工厂方法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
获取时间之后,直接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 // 当前时间:2018-12-19T15:24:35.833
格式时间格式需要用到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
在指定的时间进行增加/减少年月日时分秒。
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
通过指定年月日来创建。
LocalDate ld3=LocalDate.of(2017, Month.NOVEMBER, 17); LocalDate ld4=LocalDate.of(2018, 02, 11);
比较相差的年月日时分秒。
示例一: 具体相差的年月日
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
得到其他时区的时间。
示例一:通过Clock时钟类获取计算
Clock时钟类用于获取当时的时间戳,或当前时区下的日期时间信息。
Clock clock = Clock.systemUTC(); System.out.println("当前时间戳 : " + clock.millis()); Clock clock2 = Clock.system(ZoneId.of("Asia/Shanghai")); System.out.println("亚洲上海此时的时间戳:"+clock2.millis()); Clock clock3 = Clock.system(ZoneId.of("America/New_York")); System.out.println("美国纽约此时的时间戳:"+clock3.millis()); // 当前时间戳 : 1545209277657 // 亚洲上海此时的时间戳:1545209277657 // 美国纽约此时的时间戳:1545209277658
示例二:通过ZonedDateTime类和ZoneId
ZoneId zoneId= ZoneId.of("America/New_York"); ZonedDateTime dateTime=ZonedDateTime.now(zoneId); System.out.println("美国纽约此时的时间 : " + dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"))); System.out.println("美国纽约此时的时间 和时区: " + dateTime); // 美国纽约此时的时间 : 2018-12-19 03:52:22.494 // 美国纽约此时的时间 和时区: 2018-12-19T03:52:22.494-05:00[America/New_York]
Java 8日期时间API总结:
参考:
http://blog.oneapm.com/apm-tech/226.html
https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/
http://www.importnew.com/15637.html分享一首非常带感的电音!你若想做,那么就去做吧!
java-study 是本人在学习Java过程中记录的一些代码,也包括之前博文中使用的代码。如果感觉不错,希望顺手给个start,当然如果有不足,也希望提出。
github地址: https://github.com/xuwujing/java-study
原创不易,如果感觉不错,希望给个推荐!您的支持是我写作的最大动力!
版权声明:
作者:虚无境
博客园出处: http://www.cnblogs.com/xuwujing
CSDN出处: http://blog.csdn.net/qazwsxpcm
个人博客出处: http://www.panchengming.com