文章目录
1. JDK8简介
1.1 简述
Java 8由Oracle从2014年3月18日发布,此版本是自Java 5(发布于2004年)之后的一个重量级版本,也是java发展史上的一个里程碑式的版本。这个版本在JVM、编译器、库、Java语法特性等方面都做了很大改进,同时在语言的表达力、简洁性等个方面也有了很大的提高。目前几乎所有的JAVA框架也都已升级到支持JDK8,打开框架源码想了解其设计,假如不理解JDK8的这些特性看起来就会非常吃力。所以我们设计了这个专题,我们将在这个专题中讲解JDK8中的部分关键特性,并用实际案例讲解这些特性应用,希望同学们在JDK8技术的应用上有一个很好的提高。
1.2 新特性介绍
Java 8这个版本提供了很多实用的新特性,针对接口推出了接口默认方法,接口静态方法以及函数式接口,同时为了简化代码编写,推出了lambda表达式,为了增强对数据的操作,还定义了Stream操作等。这个版本目前是市场上一个应用最广泛,也是最重要的一个版本。
2. JDK8接口新特性
2.1 概述
JDK8中对接口规范进行了新的定义,允许在接口中定义默认方法(使用default关键字修饰),静态方法,同时还推出了函数式接口(使用@FunctionInterface注解描述)设计。
2.2 应用场景
基于JDK8中接口新规范的定义,不仅可以扩展接口新功能(新的标准),还能保持接口向前兼容的特性。例如Java API中的集合操作规范。
2.3 快速入门分析
default方法设计及实现
JDK8中为了对接口业务进行扩展,但又不影响实现类,提供了默认方法。此类型的方法实用default关键字修饰,可以有方法体的实现。例如list接口中的sort方法:
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
说明:一个接口中可以有多个默认方法,在实现类中可以有选择的对方法进行重写。例如:
interface IA{
default void doMethod01() {
System.out.println("doMethod01");
}
default void doMethod02() {
System.out.println("doMethod02");
}
}
class ClassA implements IA{
}
static方法设计及实现
JDK8的接口中还支持静态方法,例如:
interface IB{
static void doMethod() {
System.out.println("doMethod()");
}
}
函数式接口设计及实现
Java8引入了一个是函数式接口(Functional Interfaces),此接口使用
@FunctionalInterface修饰,并且此接口内部只能包含一个抽象方法。
@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2); // public abstract
}
说明:函数式接口推出的目的主要是为了配合后续Lambda表达式的应用。
2.4 应用案例增强分析及实现
在JDK中的java.util.function包中定义了大量函数式接口。常用的有如下几个:
消费型接口。
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
函数式接口。
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
判定式接口。
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}
供给式接口。
@FunctionalInterface
public interface Supplier<T> {
T get();
}
3. JDK8中Lambda 表达式应用
3.1 概述
Java中的Lambda表达式是JDK8中的一种新特性,它允许我们将一段代码(这段代码可以理解为一个接口的实现)当成参数传递给某个方法,然后进行业务处理,这种方式更像是一种函数式编程风格,可以让代码结构更简洁,开发效率更高。
3.2 应用场景
Java中的Lambda为JAVA编程注入了函数式编程思想,在迭代操作,映射操作,聚合操作等很多方面的实现上做出了很大努力。并从语法角度简化了程序员对特定代码的编写,通过底层的类型推断,方法引用等特性让代码表现的更加优雅。现在已成为我们编程过程中常用的一种编程方式。
3.2 快速入门分析
最简单的Lambda表达式可由逗号分隔的参数列表、“->” 符号和语句块组成,例如:
Arrays.asList( "a", "b", "d" )
.forEach( e -> System.out.println( e ) );
在上面这个代码中的参数e的类型是由编译器推理得出的,你也可以显式指定该参数的类型,例如:
Arrays.asList( "a", "b", "d" )
.forEach( ( String e ) -> System.out.println( e ) );
如果Lambda表达式需要更复杂的语句块,则可以使用花括号将该语句块括起来,类似于Java中的函数体,例如:
Arrays.asList( "a", "b", "d" ).forEach( e -> {
System.out.print( e );
System.out.println( );
} );
lambda 表达式可以让代码编写更加简洁。我们先来思考下普通的函数或方法具备的几个元素:
- 访问修饰符。
- 返回值类型。
- 方法名。
- 参数列表。
- 代码块。
在lambda表达式应用过程中,一般只有两个元素:
(parameter list) -> body
其中“->” 将参数列表与函数主体分离,旨在对给定参数进行处理。函数的主体可能是一条或多条语句。例如其常见结构如下:
() -> statement
arg -> statement
(arg1, arg2, ...) -> { body-block }
(Type1 arg1, Type2 arg2, ...) -> {
method-body-block;return value;
}
Lambda表达式有返回值,返回值的类型也由编译器推理得出。如果Lambda表达式中的语句块只有一行,则可以不用使用return语句,下列两个代码片段效果相同:
Arrays.asList( "a", "b", "d" )
.sort( ( e1, e2 ) -> e1.compareTo( e2 ) );
Arrays.asList( "a", "b", "d" ).sort( ( e1, e2 ) -> {
int result = e1.compareTo( e2 );
return result;
} );
3.3 应用案例增强实现
结合对lambda表达式基本语法的认识,通过如下案例在对lambda表达式继续强化分析和实现。
**案例1:**构建一个线程对象,执行Runnable类型的任务。
传统方式的实现,其关键代码如下:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
}).start();
基于JDK8中的Lambda表达式实现方式,对传统方式线程对象的创建进行简化,其关键代码如下:
new Thread(()->{
System.out.println("hello");
}).start();
**案例2:**通过lambda表达式演示排序过程中代码的简化。
定义一字符串数组,然后对字符串数组中的内容,按字符串元素的长度对其进行排序。代码如下:
String[] strArray= {"abcd","ab","abc"};
在JDK8之前传统的实现方案,基于Arrays类对数组中的元素进行排序操作,关
键代码实现如下:
Arrays.sort(strArray,new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length()-o2.length();
}
});
基于JDK8中的Lambda表达式,对排序如上排序方案的代码实现过程进行简化
,关键代码如下:
Arrays.sort(strArray, (s1, s2) -> s1.length() - s2.length());
4. JDK8中方法引用
4.1 概述
方法引用是用来直接引用类方法、实例方法或者构造方法的一种新的方式。这里要特别强调一点的是“方法引用”提供的是一种对方法的引用而不是执行方法的方式,简单点理解的话就是可以将方法作为参数进行传递,我们还可以将方法引用理解为lambda的一种深层表达。
4.2 应用场景
方法引用是一种更简洁易懂的Lambda表达式,操作符是双冒号"::",也可以将方法引用看成是一个更加紧凑,易读的Lambda表达式。
4.3 快速入门分析
方法引用是一种更简洁易懂的Lambda表达式,操作符是双冒号"::",也可以将方法引用定义一个list集合,然后基于Lambda表达式迭代集合中的内容进行输出,关键代码如下
List<String> list = Arrays.asList("a","b","c");
list.forEach(str -> System.out.println(str));
基于方法引用的方式,输出list集合中的具体内容的,然后与传统Lambda表达式方式,进行对比分析,关键代码如下:
list.forEach(System.out::println);
说明:当你要访问的接口方法与执行的方法引用参数相同,返回值也相同即可直接使用方法引用。
4.4 应用案例增强分析
JDK8方法的引用可分为如下几类:
构造方法引用
格式:ClassName::new,应用默认构造函数。
package com.cy.java8.methodref;
import java.util.function.Supplier;
public class TestConstructorMethodRef01 {
public static void main(String[] args) {
//1.传统方式
Supplier<Object> s1=new Supplier<Object>() {
@Override
public Object get() {
return new Object();
}
};
System.out.println(s1.get());
//2.Lambda方式
Supplier<Object> s2=()->new Object();
System.out.println(s2.get());
//3.构造方法引用"类名::new"
Supplier<Object> obj=Object::new;
System.out.println(obj.get());
}
}
类静态方法引用
格式:ClassName::static_method。
package com.cy.java8.methodref;
import java.util.function.Function;
public class TestClassMethodRef01 {
public static void main(String[] args) {
//1.传统应用方式
Function<String, Integer> f1=
new Function<String, Integer>() {
@Override
public Integer apply(String t) {
return Integer.parseInt(t);
}
};
Integer result=f1.apply("100");
System.out.println(result);
//2.lambda应用方式
Function<String, Integer> f2=(t)->Integer.parseInt(t);
System.out.println(f2.apply("200"));
//3.类方法引用应用方式"类名::方法名"
Function<String,Integer> f3=Integer::parseInt;
System.out.println(f3.apply("300"));
}
}
练习:比较两个整数大小。
Comparator<Integer> com=Integer::compare;
System.out.println(com.compare(39, 20));
类实例方法引用
格式:ClassName::method,方法不能带参数。
package com.cy.java8.methodref;
import java.io.File;
import java.util.function.Function;
public class TestClassInstanceMethodRef01 {
public static void main(String[] args) {
//1.传统方式
Function<File,String> f1=new Function<File,String>() {
@Override
public String apply(File f) {
return f.getAbsolutePath();
}
};
System.out.println(f1.apply(new File("pom.xml")));
//2.Lambda方式
Function<File,String> f2=file->file.getAbsolutePath();
System.out.println(f2.apply(new File("pom.xml")));
//3.类实例方法引用"类名::实例方法名"
Function<File,String> f3=File::getAbsolutePath;
System.out.println(f3.apply(new File("pom.xml")));
}
}
练习:堆数组中内容进行排序,通过方法引用简化编写。
Arrays.sort(strArray,(s1,s2)->s1.compareToIgnoreCase(s2));
Arrays.sort(strArray, String::compareToIgnoreCase);
对象实例方法引用
格式:对象实例::method,方法不能带参数。
public class TestObjectInstanceMethodRef01 {
public static void main(String[] args) {
List<String> list=Arrays.asList("A","B","C");
//传统方式
list.forEach(new Consumer<String>() {
@Override
public void accept(String t) {
System.out.println(t);
}
});
//Lambda表达式方式
list.forEach(t->System.out.println(t));
//方法引用方式
PrintStream ps=System.out;
list.forEach(ps::println);
list.forEach(System.out::println);
}
}
练习:获取集合中元素的个数。
List<Integer> list=Arrays.asList(10,20);
Supplier<Integer> supplier=(list::size);
System.out.println(supplier.get());
5. JDK8中Stream API应用
5.1 概述
Stream 作为 Java 8 的一大亮点,它与 java.io 包里的 InputStream 和 OutputStream 是完全不同的概念。Java 8 中的 Stream 是对集合(Collection)对象功能的增强,它专注于对集合对象进行各种非常便利、高效的聚合操作,或者大批量数据操作。
5.2 应用场景
在当今这个数据爆炸的时代,数据来源多样化、数据海量化,很多时候不得不脱离 RDBMS,以底层返回的数据为基础进行更上层的数据统计。而原有 Java 的集合 API 中,仅仅有极少量的辅助型方法,更多的时候是程序员需要用 Iterator 来遍历集合,然后完成相关的聚合应用逻辑。这是一种远不够高效而且相对比较笨拙的方法。在JDK8中使用 Stream 对象,不仅丰富了在业务层面对数据处理的方式,还可以让代码更加简洁、易读和高效。
5.3 快速入门分析
我们在使用Stream对象时,一般会按照如下为三个步骤进行操作:
- 第一步:创建Stream流对象。
- 第二步:Stream流中间操作。
- 第三步:Stream流终止操作。
Stream对象的操作过程,可通过下图进行进一步分析。
Steam对象简易应用,代码如下:
List<Integer> list = Arrays.asList(3, 2, 12, 5, 6, 11, 13);
long count = list.stream()
.filter(i -> i % 2 == 0)
.count();
System.out.println(count);
5.3 应用案例增强分析
Stream对象创建。
Stream对象的创建,常见方式有如下几种:
- 借助Collection接口中的stream()或parallelStream()方法。
- 借助Arrays类中的stream(…)方法。
- 借助Stream类中的of(…)方法。
- 借助Stream类中的iterator和generator方法(无限操作)。
Stream对象创建,案例分析如下:
Collection<Integer> col=new ArrayList<>();
...
Stream<Integer> s1=col.stream();
Stream<Integer> s2=col.parallelStream();
IntStream s3=Arrays.stream(new int[] {1,2,3,4});
Stream<Integer> s4=Stream.of(10,20,30,40);
Stream<Integer> s5=Stream.iterate(2, (x)->x+2);
s5.forEach(System.out::println);
Stream<Double> s6=Stream.generate(()->Math.random());
s6.forEach(System.out::println);
Stream中间操作
Stream 对象创建以后可以基于业务执行一些中间操作,但这些操作的结果需要借助终止操作进行输出,案例分析如下:
初始条件:给定list集合作为Stream操作的对象,代码如下:
List<Integer> list=Arrays.asList(100,101,102,200);
对数据进行过滤:
//输出集合中所有的偶数
//1.创建流
Stream<Integer> s1=list.stream();
//2.中间操作(过滤)
Stream<Integer> s2=s1.filter((n)->n%2==0);
//3.终止操作
s2.forEach(System.out::println);
//也可以将多个操作合在一起
list.stream().filter(n->n%2==0).forEach(System.out::println);
限定操作(limit):
list.stream()
.filter(n->n%2==0)
.limit(2)
.forEach(System.out::println);
跳过操作(skip):
list.stream()
.filter(n->n%2==0)
.skip(2)
.forEach(System.out::println);
去重操作(distinct):
list.stream()
.distinct()
.forEach(System.out::println);
排序操作(sorted):底层基于内部比较器Comparable或外部Comparator比较器进行比对。
list.stream()
.sorted()
.forEach(System.out::println);
list.stream()
.sorted((s1,s2)->{//Comparator
return s1-s2;
}).forEach(System.out::println);
映射操作(map):
List<String> list=Arrays.asList("a","bc","def");
list.stream()
.map((x)->x.toUpperCase())
.forEach(System.out::println);
list.stream()
.map((x)->x.length())
.forEach(System.out::println);
Stream终止操作。
Stream终止操作是Stream的结束操作,案例分析如下:
List<String> list=Arrays.asList("a","bc","def");
list.stream()
.map((x)->x.toUpperCase())
.forEach(System.out::println);
list.stream()
.map((x)->x.length())
.forEach(System.out::println);
案例:初始条件定义,给定一个list集合:
List<Integer> list=Arrays.asList(10,11,12,13,14,15);
1
match操作:
boolean flag=list.stream().allMatch((x)->x%2==0);
System.out.println(flag);
flag=list.stream().anyMatch((x)->x%2==0);
System.out.println(flag);
flag=list.stream().noneMatch((x)->x>20);
System.out.println(flag);
find操作:
Optional<Integer> optional=list.stream().sorted().findFirst();
System.out.println(optional.get());
optional=list.parallelStream().filter((x)->x%2!=0).findAny();
System.out.println(optional.get());
count操作:
long count=list.stream().count();
System.out.println(count);
求最大,最小值:
optional=list.stream().max((x,y)->{return x-y;});
System.out.println(optional.get());
optional=list.stream().min((x,y)->{return x-y;});
System.out.println(optional.get());
forEach迭代操作:
list.stream().forEach(System.out::println);
Reduce(规约)操作:
//计算集合中所有元素的和,其中第一个参数0为初始值,然后与后面每个值累加
Integer sum=list.stream().reduce(0,(x,y)->{return x+y;});
System.out.println(sum);
Collector(收集)操作:
List<Integer> result=
list.stream()
.map(x->x*2)
.collect(Collectors.toList());
System.out.println(result);
list.stream().map(x->x*2).collect(Collectors.toSet());
System.out.println(result);
double avg=
list.stream()
.collect(Collectors.averagingDouble(x->x));
System.out.println(avg);
Optional<Integer> max=
list.stream().collect(Collectors.maxBy((x,y)->{return x-y;}));
System.out.println(max.get());
Map<Object,List<Integer>> map=
list.stream().collect(Collectors.groupingBy(x->x%2==0));
System.out.println(map);
6 JDK8中Stream 练习
6.1 reduce操作
**案例1:**计算多个整数的和。
static void doTestReduce01() {
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
Optional<Integer> count =
list.stream().reduce((a, b) -> (a + b));
System.out.println(count.get()); // 21
}
**案例2:**计算多个整数乘积,然后再乘以2。
static void doTestReduce02() {
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
Integer count = list.stream().reduce(2, (a, b) -> (a * b));
System.out.println(count); // 1440
}
**案例3:**计算多个整数的和,假如超出范围,则对其进行类型转换。
案例1和2的缺点在于返回的数据都只能和 Stream 流中元素类型一致,但假如求和或乘积之后的数值超过了 Integer 能够表示的范围怎么办?例如,需要使用 Long 类型接收,这就用到了我们下面reduce() 方法的应用形式了。
static void doTestReduce03() {
List<Integer> list =
Arrays.asList(Integer.MAX_VALUE, Integer.MAX_VALUE);
long count =
list.stream().reduce(0L, (a, b) -> (a + b), (a,b) -> 0L);
System.out.println(count);
}
6.2 collect操作实现
获取指定目录下所有目录文件的文件名。
List<String> allDirNames =
Arrays.stream(new File("d:\\")
.listFiles())
.filter(File::isDirectory)
.map(File::getName)
.collect(Collectors.toList());
System.out.println(allDirNames);
6.3 并行流的简易应用
并行流应用的目的主要借助多核处理器优势,提高的操作性能。
public static void main (String[] args) {
String[] strings = {"1", "2", "3", "4", "5"};
doPrint(Arrays.stream(strings).sequential());
doPrint(Arrays.stream(strings).parallel());
}
public static void doPrint (Stream<String> stream) {
stream.forEach(s -> {
System.out.println(
Thread.currentThread().getName()+"->"+s);
});
}
7. JDK8中新日期对象应用
7.1概述
在Java8之前,日期和时间的管理一直是令Java开发者很痛苦的一个的问题。java.util.Date、java.util.Calendar,SimpleDateFormat都一直没有很好解决这个问题。故此,Java8引入了一套全新的日期时间处理API,新的API基于ISO标准日历系统,解决了以前日期和时间类的很多弊端问题。
7.2应用场景
Java8中的时间处理API定义在java.time包中,这些API具备不可变且线程安全特性,具备准确和灵活特性。所以现在基本可以使用这组API替换所有原有历史版本中时间API的应用。
7.3 快速入门分析
新日器对象类型中,常用API应用分析:
Instant 时间戳对象应用,默认是0时区,比北京少8个时区。
//获取瞬时对象(当前时间年月日时分秒),Instant是绝对时间,没有时区的概念
Instant instant1 ==Instant.now();//Clock.systemUTC().instant();
System.out.println(instant1);
//通过这种方式获取的时间戳与北京时间相差8个时区,需要修正为北京时间
instant1=instant1.plusMillis(TimeUnit.HOURS.toMillis(8));;
//输出系统可用时区
System.out.println(ZoneId.getAvailableZoneIds());
//输出系统默认时区
System.out.println(ZoneId.systemDefault());
//输出系统默认时区时间
System.out.println(Instant.now().atZone(ZoneId.systemDefault()));
获取时间间隔。
Instant start = Instant.now();
...
Instant end = Instant.now();
Duration timeElapsed = Duration.between(start, end);
System.out.println("Milliseconds: " + timeElapsed.toMillis());
LocalDate 日期对象,不包含具体时间。
LocalDate ld1=LocalDate.now();
System.out.println(ld1);
LocalDate ld2 = LocalDate.of(2019, Month.JANUARY, 8);
System.out.println(ld2);
LocalDate ld3=LocalDate.parse("2019-12-12");
System.out.println(ld3);
LocalTime 时间对象,不包含日期。
LocalTime lt1=LocalTime.now();
System.out.println(lt1);
LocalTime lt2=LocalTime.now(ZoneId.systemDefault());
System.out.println(lt2);
long t=ChronoUnit.HOURS.between(lt1, lt2);
System.out.println(t);
LocalDateTime 包含了日期和时间对象,没有时区信息。
LocalDateTime ldt02 =
LocalDateTime.of(2019, Month.DECEMBER, 31, 23, 59, 59);
System.out.println(ldt02);//2019-12-31T23:59:59
DayOfWeek dayOfWeek = ldt02.getDayOfWeek();
System.out.println(dayOfWeek); // WEDNESDAY
ZoneDateTime 包含时区的完整日期时间对象,偏移量以UTC时间为基准。
ZonedDateTime zdt01=ZonedDateTime.now();
System.out.println(zdt01);
ZoneId zd01=TimeZone.getDefault().toZoneId();
System.out.println(zd01);
7.4 应用案例增强分析
项目中我们经常会用到日期类型转换,在JDK8中的实现方式如下:
LocalDateTime ld4 =
LocalDateTime.parse("2019/12/12 12:12:12",
DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
System.out.println(ld4);
说明:jdk8之前的日期与字符串之间的转换通常会借助SimpleDateFormat对象,但是此对象线程不安全,通常要借助ThreadLocal对象,保证SimpleDateFormat对象每个线程一份。
8. JDK8新特性总结
重难点分析
接口新特性?(默认方法,函数式接口,静态方法)
Lambda表达式?(函数式,简化语法,开发效率)
方法引用(MethodReference)
Stream应用实践分析?(数据操作更方便,创建,中间操作,终止操作)
常用新的日期对象应用?(灵活,安全,准确)
FAQ分析
常用的函数式接口有哪些?(消费型,供给型,判定型,函数式)
Lambda表达式关键作用是什么?(简洁,开发效率)
Stream应用中有哪些常用操作?(过滤,统计,映射,规约,收集,…)
JDK8中常用的日期API有哪些?(Instant,LocalDateTime,DateTimeFormater)
……