JAVA8新特性总结及案例.docx
《JAVA8新特性总结及案例.docx》由会员分享，可在线阅读，更多相关《JAVA8新特性总结及案例.docx（39页珍藏版）》请在冰点文库上搜索。
JAVA8新特性总结及案例
一Lambda函数〔箭头函数〕
Lambda表达式，也可称为闭包，它是推动Java8发布的最重要新特性。
Lambda允许把函数作为一个方法的参数〔函数作为参数传递进方法中〕。
使用Lambda表达式可以使代码变的更加简洁紧凑。
（parameters）->expression或（parameters）->{
statement1;
statement2;
......}
lambda表达式的重要特征:
●可选类型声明：
不需要声明参数类型，编译器可以统一识别参数值。
●可选的参数圆括号：
一个参数无需定义圆括号，但多个参数需要定义圆括号。
●可选的大括号：
如果主体包含了一个语句，就不需要使用大括号。
●可选的返回关键字：
如果主体只有一个表达式返回值那么编译器会自动返回，大括号需指定表达式返回数值。
本质上，Lambda函数是对匿名部类对象的简写。
应用举例1〔比拟JAVA7与JAVA8〕：
Lambda函数做类的属性
运行结果：
应用举例2〔比拟JAVA7与JAVA8〕：
Lambda函数做main函数变量
应用举例3：
应用举例4：
多线程启动时使用Lambda函数
应用举例5：
在1.7中，匿名部类只能使用定义为final的外部变量，1.8会自动为Lambda函数使用的外部变量加上final，因此final可以省略不写。
二方法引用〔:
:
方法名----?
调用了方法对象〕
应用举例1：
应用举例2：
三函数式接口
函数式接口（FunctionalInterface）就是一个具有一个方法的普通接口。
函数式接口可以被隐式转换为lambda表达式。
函数式接口可以现有的函数友好地支持lambda。
JDK1.8之前已有的函数式接口:
●java.lang.Runnable
●java.util.concurrent.Callable
●java.security.PrivilegedAction
●java.util.parator
●java.io.FileFilter
●java.nio.file.PathMatcher
●java.lang.reflect.InvocationHandler
●java.beans.PropertyChangeListener
●java.awt.event.ActionListener
●javax.swing.event.ChangeListener
JDK1.8新增加的函数接口：
●java.util.function
java.util.function它包含了很多类，用来支持Java的函数式编程，该包中的函数式接口有：
序号
接口&描述
1
BiConsumer
代表了一个承受两个输入参数的操作，并且不返回任何结果
2
BiFunction
代表了一个承受两个输入参数的方法，并且返回一个结果
3
BinaryOperator
代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
4
BiPredicate
代表了一个两个参数的boolean值方法
5
BooleanSupplier
代表了boolean值结果的提供方
6
Consumer
代表了承受一个输入参数并且无返回的操作
7
DoubleBinaryOperator
代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。
8
DoubleConsumer
代表一个承受double值参数的操作，并且不返回结果。
9
DoubleFunction
代表承受一个double值参数的方法，并且返回结果
10
DoublePredicate
代表一个拥有double值参数的boolean值方法
11
DoubleSupplier
代表一个double值构造的提供方
12
DoubleToIntFunction
承受一个double类型输入，返回一个int类型结果。
13
DoubleToLongFunction
承受一个double类型输入，返回一个long类型结果
14
DoubleUnaryOperator
承受一个参数同为类型double,返回值类型也为double。
15
Function
承受一个输入参数，返回一个结果。
16
IntBinaryOperator
承受两个参数同为类型int,返回值类型也为int。
17
IntConsumer
承受一个int类型的输入参数，无返回值。
18
IntFunction
承受一个int类型输入参数，返回一个结果。
19
IntPredicate
：
承受一个int输入参数，返回一个布尔值的结果。
20
IntSupplier
无参数，返回一个int类型结果。
21
IntToDoubleFunction
承受一个int类型输入，返回一个double类型结果。
22
IntToLongFunction
承受一个int类型输入，返回一个long类型结果。
23
IntUnaryOperator
承受一个参数同为类型int,返回值类型也为int。
24
LongBinaryOperator
承受两个参数同为类型long,返回值类型也为long。
25
LongConsumer
承受一个long类型的输入参数，无返回值。
26
LongFunction
承受一个long类型输入参数，返回一个结果。
27
LongPredicate
R承受一个long输入参数，返回一个布尔值类型结果。
28
LongSupplier
无参数，返回一个结果long类型的值。
29
LongToDoubleFunction
承受一个long类型输入，返回一个double类型结果。
30
LongToIntFunction
承受一个long类型输入，返回一个int类型结果。
31
LongUnaryOperator
承受一个参数同为类型long,返回值类型也为long。
32
ObjDoubleConsumer
承受一个object类型和一个double类型的输入参数，无返回值。
33
ObjIntConsumer
承受一个object类型和一个int类型的输入参数，无返回值。
34
ObjLongConsumer
承受一个object类型和一个long类型的输入参数，无返回值。
35
Predicate
承受一个输入参数，返回一个布尔值结果。
36
Supplier
无参数，返回一个结果。
37
ToDoubleBiFunction
承受两个输入参数，返回一个double类型结果
38
ToDoubleFunction
承受一个输入参数，返回一个double类型结果
39
ToIntBiFunction
承受两个输入参数，返回一个int类型结果。
40
ToIntFunction
承受一个输入参数，返回一个int类型结果。
41
ToLongBiFunction
承受两个输入参数，返回一个long类型结果。
42
ToLongFunction
承受一个输入参数，返回一个long类型结果。
43
UnaryOperator
承受一个参数为类型T,返回值类型也为T。
四接口的默认方法
默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。
我们只需在方法名前面加个default关键字即可实现默认方法。
为什么要有这个特性？
1.8之前，修改接口意味着要修改全部实现该接口的类，例如，java8之前的集合框架没有foreach方法，通常的解决方法是在JDK里给相关的接口添加新的方法及实现类。
对于已经发布的版本，会影响已有的实现。
接口引进了的默认方法的机制。
最大化的解决了接口的修改与现有的实现不兼容的问题。
需求变更，需要修改接口，此时使用java8新特性中的接口默认方法，实现类TestImpl无需改变代码，ITest接口即可提供效劳。
当然TestImpl也可以覆盖接口中的变更方法print
五JAVA8Stream
Stream使用一种类似用SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高阶抽象。
StreamAPI可以极大提供Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进展处理，比方筛选，排序，聚合等，最后由最终操作（terminaloperation）得到前面处理的结果。
+--------------------++------++------++---++-------+|streamofelements+----->|filter+->|sorted+->|map+->|collect|+--------------------++------++------++---++-------+
以上的流程转换为Java代码为：
ListtransactionsIds=widgets.stream（）.filter（b->b.getColor（）==RED）.sorted（（x,y）->x.getWeight（）-y.getWeight（））.mapToInt（Widget:
:
getWeight）.sum（）;
5.1生成流：
在Java8中,集合接口有两个方法来生成流：
●stream（） −为集合创立串行流。
●parallelStream（） −为集合创立并行流。
【串行与并行】
5.2forEach遍历方法
5.3map方法
map用于映射每个元素到对应的运行结果
5.4filter、limit、sorted、parallelStream
filter方法用于通过设置的条件过滤出元素。
limit获取指定数量的流
sorted对流对象进展排序
parallelStream并行流替代串行流
5.5collect方法及Collectors类
Collectors.toList方法由流转变为List集合
Collectors.joining（","）方法,由流转变为字符串
5.6IntSummaryStatistics统计收集器
5.7综合比拟JAVA7与JAVA8
package.pany.java8.stream;
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.IntSummaryStatistics;
importjava.util.List;
importjava.util.Random;
importjava.util.stream.Collectors;
publicclassStream7{
//Java7计算空字符串数量
privatestaticintgetCountEmptyStringUsingJava7（Liststrings）{
intcount=0;
for（Stringstring:
strings）{
if（string.isEmpty（））{
count++;
}
}
returncount;
}
//Java7计算长度为3的字符串数量
privatestaticintgetCountLength3UsingJava7（Liststrings）{
intcount=0;
for（Stringstring:
strings）{
if（string.length（）==3）{
count++;
}
}
returncount;
}
//Java7将非空字符串整合成List集合
privatestaticListdeleteEmptyStringsUsingJava7（Liststrings）{
ListfilteredList=newArrayList（）;
for（Stringstring:
strings）{
if（!
string.isEmpty（））{
filteredList.add（string）;
}
}
returnfilteredList;
}
//Java7将非空字符串合并成指定分隔符的字符串
privatestaticStringgetMergedStringUsingJava7（Liststrings,Stringseparator）{
StringBuilderstringBuilder=newStringBuilder（）;
for（Stringstring:
strings）{
if（!
string.isEmpty（））{
stringBuilder.append（string）;
stringBuilder.append（separator）;
}
}
StringmergedString=stringBuilder.toString（）;
returnmergedString.substring（0,mergedString.length（）-2）;
}
//Java7获取平方集合
privatestaticListgetSquares（Listnumbers）{
ListsquaresList=newArrayList（）;
for（Integernumber:
numbers）{
Integersquare=newInteger（number.intValue（）*number.intValue（））;
if（!
squaresList.contains（square））{
squaresList.add（square）;
}
}
returnsquaresList;
}
//Java7获取最大值
privatestaticintgetMax（Listnumbers）{
intmax=numbers.get（0）;
for（inti=1;iIntegernumber=numbers.get（i）;
if（number.intValue（）>max）{
max=number.intValue（）;
}
}
returnmax;
}
//Java7获取最小值
privatestaticintgetMin（Listnumbers）{
intmin=numbers.get（0）;
for（inti=1;iIntegernumber=numbers.get（i）;
if（number.intValue（）min=number.intValue（）;
}
}
returnmin;
}
//Java7获取总数
privatestaticintgetSum（Listnumbers）{
intsum=（int）（numbers.get（0））;
for（inti=1;isum+=（int）numbers.get（i）;
}
returnsum;
}
//Java7获取平均值
privatestaticintgetAverage（Listnumbers）{
returngetSum（numbers）/numbers.size（）;
}
//主函数
publicstaticvoidmain（Stringargs[]）{
System.out.println（"*****************************************************************"）;
System.out.println（"使用Java7:
"）;
//计算空字符串
Liststrings=Arrays.asList（"abc","","bc","efg","abcd","","jkl"）;
System.out.println（"列表:
"+strings）;
longcount=getCountEmptyStringUsingJava7（strings）;
System.out.println（"空字符数量为:
"+count）;
count=getCountLength3UsingJava7（strings）;
System.out.println（"字符串长度为3的数量为:
"+count）;
//删除空字符串
Listfiltered=deleteEmptyStringsUsingJava7（strings）;
System.out.println（"筛选后的列表:
"+filtered）;
//删除空字符串，并使用逗号把它们合并起来
StringmergedString=getMergedStringUsingJava7（strings,","）;
System.out.println（"合并字符串:
"+mergedString）;
Listnumbers=Arrays.asList（3,2,2,3,7,3,5）;
//获取列表元素平方数
ListsquaresList=getSquares（numbers）;
System.out.println（"平方数列表:
"+squaresList）;
Listintegers=Arrays.asList（1,2,13,4,15,6,17,8,19）;
System.out.println（"列表:
"+integers）;
System.out.println（"列表中最大的数:
"+getMax（integers））;
System.out.println（"列表中最小的数:
"+getMin（integers））;
System.out.println（"所有数之和:
"+getSum（integers））;
System.out.println（"平均数:
"+getAverage（integers））;
System.out.println（"随机数:
"）;
//输出10个随机数
Randomrandom=newRandom（）;
for（inti=0;i<10;i++）{
System.out.println（random.nextInt（））;
}
System.out.println（"************************************************"）;
System.out.println（"使用Java8:
"）;
System.out.println（"列表:
"+strings）;
count=strings.stream（）.filter（string->string.isEmpty（））.count（）;
System.out.println（"空字符串数量为:
"+count）;
count=strings.stream（）.filter（string->string.length（）==3）.count（）;
System.out.println（"字符串长度为3的数量为:
"+count）;
filtered=strings.stream（）.filter（string->!
string.isEmpty（））.collect（Collectors.toList（））;
System.out.println（"筛选后的列表:
"+filtered）;
mergedString=strings.stream（）.filter（string->!
string.isEmpty（））.collect（Collectors.joining（","））;
System.out.println（"合并字符串:
"+mergedString）;
squaresList=numbers.stream（）.map（i->i*i）.distinct（）.collect（Collectors.toList（））;
System.out.println（"SquaresList:
"+squaresList）;
System.out.println（"列表:
"+integers）;
IntSummaryStatisticsstats=integers.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（））;
System.out.println（"随机数:
"）;
random.ints（）.limit（10）.sorted（）.forEach（System.out:
:
println）;
//并行处理
count=strings.parallelStream（）.filter（string->string.isEmpty（））.count（）;
System.out.println（"空字符串的数量为:
"+count）;
}
}
六JAVA8Optional类
Optional类是一个可以为null的容器对象,它可以保存类型T的值，或者仅仅保存null。
如果值存在,那么isPresent（）方法会返回true，调用get（）方法会返回该对象。
升级会员 