下载文档原格式
JAVA8 十大新特性详解本教程将Jav a8的新特新逐一列出，并将使用简单的代码示例来指导你如何使用默认接口方法，lambda表达式，方法引用以及多重A nnot ation，之后你将会学到最新的A PI上的改进，比如流，函数式接口，Map以及全新的日期A PI“Jav aisstillnotdead—and peopleare startin g to figurethatout.”本教程将用带注释的简单代码来描述新特性，你将看不到大片吓人的文字。
一、接口的默认方法Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下：复制代码代码如下:interfa ce F ormula {doublecalcula te(int a);default doublesqrt(int a) {returnMath.sqrt(a);}}F ormula接口在拥有c alcula te方法之外同时还定义了sqrt方法，实现了F orm ula接口的子类只需要实现一个cal culate方法，默认方法sqr t将在子类上可以直接使用。
复制代码代码如下:F ormula formula = new F ormula() {@O v errid epublicdoublecalcula te(int a) {returnsqrt(a * 100);}};formula.calcula te(100); // 100.0formula.sqrt(16); // 4.0文中的form ula被实现为一个匿名类的实例，该代码非常容易理解，6行代码实现了计算sqrt(a * 100)。
在下一节中，我们将会看到实现单方法接口的更简单的做法。
Java8新特性_Stream_归约、收集、分组、分区1、归约、收集、分组、分区1、归约reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到⼀个值。
2、收集collect——将流转换为其他形式。
接收⼀个 Collector接⼝的实现，⽤于给Stream中元素做汇总的⽅法3、分组及多级分组 Collectors.groupingBy（）4、分区 Collectors.partitioningBy（）2、源码package com.atguigu.java8;import java.util.Arrays;import java.util.DoubleSummaryStatistics;import java.util.HashSet;import java.util.List;import java.util.Map;import java.util.Optional;import java.util.Set;import java.util.stream.Collectors;import org.junit.Test;import com.atguigu.java8.Employee.Status;public class TestStreamAPI3 {List<Employee> emps = Arrays.asList(new Employee(102, "李四", 79, 6666.66, Status.BUSY),new Employee(101, "张三", 18, 9999.99, Status.FREE),new Employee(103, "王五", 28, 3333.33, Status.VOCATION),new Employee(104, "赵六", 8, 7777.77, Status.BUSY),new Employee(104, "赵六", 8, 7777.77, Status.FREE),new Employee(104, "赵六", 8, 7777.77, Status.FREE),new Employee(105, "⽥七", 38, 5555.55, Status.BUSY));//3. 终⽌操作/*归约reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到⼀个值。
Java 8 新特性概述函数式接口Java 8 引入的一个核心概念是函数式接口（Functional Interfaces）。
通过在接口里面添加一个抽象方法，这些方法可以直接从接口中运行。
如果一个接口定义个唯一一个抽象方法，那么这个接口就成为函数式接口。
同时，引入了一个新的注解：@FunctionalInterface。
可以把他它放在一个接口前，表示这个接口是一个函数式接口。
这个注解是非必须的，只要接口只包含一个方法的接口，虚拟机会自动判断，不过最好在接口上使用注解@FunctionalInterface 进行声明。
在接口中添加了@FunctionalInterface 的接口，只允许有一个抽象方法，否则编译器也会报错。
ng.Runnable 就是一个函数式接口。
[java] view plain copy print?在CODE上查看代码片派生到我的代码片@FunctionalInterfacepublic interface Runnable {public abstract void run();}Lambda 表达式函数式接口的重要属性是：我们能够使用Lambda 实例化它们，Lambda 表达式让你能够将函数作为方法参数，或者将代码作为数据对待。
Lambda 表达式的引入给开发者带来了不少优点：在Java 8 之前，匿名内部类，监听器和事件处理器的使用都显得很冗长，代码可读性很差，Lambda 表达式的应用则使代码变得更加紧凑，可读性增强；Lambda 表达式使并行操作大集合变得很方便，可以充分发挥多核CPU 的优势，更易于为多核处理器编写代码；Lambda 表达式由三个部分组成：第一部分为一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数；第二部分为一个箭头符号：->；第三部分为方法体，可以是表达式和代码块。
语法如下：1. 方法体为表达式，该表达式的值作为返回值返回。
Java8新特性：Lambda、Stream和⽇期处理1. Lambda简介 Lambda表达式（Lambda Expression）是匿名函数，Lambda表达式基于数学中的λ演算得名，对应于其中的Lambda抽象（Lambda Abstraction），它是⼀个匿名函数，即没有函数名的函数。
⽰例import java.util.ArrayList;import java.util.HashMap;import java.util.HashSet;import java.util.List;import java.util.Map;import java.util.Set;import org.junit.Test;/*** 测试Java8 Lambda** @author CL**/public class TestLambda {/*** 遍历*/@Test@SuppressWarnings("serial")public void print() {// 1. 遍历ListList<Integer> list = new ArrayList<Integer>() {{add(1);add(2);add(3);}};list.forEach(n -> {System.out.println(n);});System.out.println("------------");list.forEach(System.out::println);System.out.println("------------");// 2. 遍历SetSet<Integer> set = new HashSet<Integer>() {{add(1);add(2);add(3);}};set.forEach(n -> {System.out.println(n);});System.out.println("------------");set.forEach(System.out::println);System.out.println("------------");// 3. 遍历MapMap<String, Object> map = new HashMap<String, Object>() {{put("id", 1);put("name", "张三");put("age", 18);}};map.forEach((k, v) -> {System.out.println(k + " -> " + v);}/*** 创建线程*/@Testpublic void create() {Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("r1");}};r1.run();System.out.println("------------");Runnable r2 = () -> {System.out.println("r2");};r2.run();}}2. Stream简介 Stream使⽤⼀种类似于SQL语句⽅式来提供对Java集合运算和表达的抽象。
Java8新特性（拉姆达表达式lambda）⼀、函数式接⼝ 函数式接⼝（functional interface 也叫功能性接⼝，其实是同⼀个东西）。
简单来说，函数式接⼝是只包含⼀个⽅法的接⼝。
⽐如Java 标准库中的ng.Runnable和 parator都是典型的函数式接⼝。
Java 8提供 @FunctionalInterface作为注解,这个注解是⾮必须的，只要接⼝符合函数式接⼝的标准（即只包含⼀个⽅法的接⼝），虚拟机会⾃动判断，但最好在接⼝上使⽤注解@FunctionalInterface进⾏声明，以免团队的其他⼈员错误地往接⼝中添加新的⽅法。
Java中的lambda⽆法单独出现，它需要⼀个函数式接⼝来盛放，lambda表达式⽅法体其实就是函数接⼝的实现. 下⾯的接⼝就是⼀个函数式接⼝1//添加此注解后，接⼝中只能有⼀个⽅法。
2 @FunctionalInterface3public interface A {4void call();5 }⼆、lambda语法 包含三部分： 1、⼀个括号内⽤逗号分隔的形式参数，参数是函数式接⼝⾥⾯⽅法的参数 2、⼀个箭头符号：-> 3、⽅法体，可以是表达式和代码块。
1 (parameters) -> expression 或者 (parameters) -> { statements; } 通过下⾯的代码可以看到lambda表达式设计的代码更简洁，⽽且可读性更好。
1public class Demo1 {2public static void main(String[] args) {3 runThreadByLambda();4 runThreadByInnerClass();5 }67public static void runThreadByLambda() {8/*9 Runnable就是⼀个函数式接⼝：他只有⼀个⽅法run()⽅法。
Java 8的八个新特性1、接口的默认方法和静态方法Java 8在接口方面引入了新特性。
Java 8版之前，接口只有抽象方法，而在Java 8，为接口新增了两种类型的方法。
第一种是默认方法。
此方法使用了default关键字修饰方法名。
实际上接口不包含任何实现的方法，而在Java 8中，可以通过使用default关键字来添加默认的方法实现。
接口的实现类可以直接使用这些默认的方法，同时还可以重写默认的方法，这不是强制性的重写。
package demo.ch;public interface Java8InterfaceDemo {abstract void add();default void display(){System.out.println("default method of interface");}}Java 8接口引入的第二种方法是静态方法。
这一点与类中的静态方法相似，可以在接口中使用static关键字定义静态方法。
如果我们要调用接口定义的静态方法，只需使用接口名就可以访问这些静态方法。
比如：package demo.ch;public interface Java8InterfaceDemo {abstract void add();default void display(){System.out.println("default method of interface");}public static void show(){System.out.println("static method of interface");}}2、Lambda表达式Java 8中最令人激动的特性就是Lambda表达式，它能够把函数/动作作为参数传递给方法。
package demo.ch;import java.util.Arrays;public class JavalamdaExpression {public static void main(String[] args) {Arrays.asList("j", "a", "v", "a","8").forEach(e->System.out.print(e));}}3、java.util.Optional类Java 8在java.util包中新增了Optional类，Optional类是一个可以包含或不可以包含非空值的容器对象。
Java8新特性：list.stream（）.map（）.collect（）StreamStream（流）是⼀个来⾃数据源的元素队列并⽀持聚合操作；mapmap ⽅法⽤于映射每个元素到对应的结果；CollectorsCollectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。
Collectors 可⽤于返回列表或字符串。
使⽤⽅式：1.⾸先创建⼀个实体类，添加部分属性；public class Student {public Student(String name,Integer age){=name;this.age=age;}private String name;private Integer age;public String getName() {return name;}public void setName(String name) { = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "name="+getName()+", age="+getAge();}}2. 新建实体集合并添加⼏条数据；List<Student> list = new ArrayList<>();list.add(new Student("ymw", 30));list.add(new Student("yh", 30));返回结果：[name=ymw, age=30, name=yh, age=30]3. 清空某个属性的值并返回结果：list.stream().map(it ->{it.setName("");return it;}).collect(Collectors.toList());System.out.println(list.toString());返回结果：[name=, age=30, name=, age=30]4. 获取其中某个属性的集合：List collection = list.stream().map(Student::getAge).collect(Collectors.toList());System.out.println(collection.toString());返回结果：[30, 30]。
JAVA8 十大新特性详解本教程将Java8的新特新一一列出，并将利用简单的代码例如来指导你如何利用默许接口方式，lambda表达式，方式引用和多重Annotation，以后你将会学到最新的API上的改良，比如流，函数式接口，Map和全新的日期API“Java is still not dead—and people are starting to figure that out.”本教程将用带注释的简单代码来描述新特性，你将看不到大片吓人的文字。
一、接口的默许方式Java 8许诺咱们给接口添加一个非抽象的方式实现，只需要利用 default关键字即可，那个特点又叫做扩展方式，例如如下：default double sqrt(int a) {return Math.sqrt(a);}}Formula接口在拥有calculate方式之外同时还概念了sqrt方式，实现了Formula接口的子类只需要实现一个calculate方式，默许方式sqrt将在子类上能够直接利用。
formula.calculate(100); // 100.0formula.sqrt(16);文中的formula被实现为一个匿名类的实例，该代码超级容易明白得，6行代码实现了计算sqrt(a * 100)。
在下一节中，咱们将会看到实现单方式接口的更简单的做法。
译者注：在Java中只有单继承，若是要让一个类给予新的特性，一般是利用接口来实现，在C++中支持多继承，许诺一个子类同时具有多个父类的接口与功能，在其他语言中，让一个类同时具有其他的可复用代码的方式叫做mixin。
新的Java 8 的那个特新在编译器实现的角度上来讲加倍接近Scala的trait。
在C#中也出名为扩展方式的概念，许诺给已存在的类型扩展方式，和Java 8的那个在语义上有不同。
二、Lambda 表达式第一看看在老版本的Java中是如何排列字符串的：Collections.sort(names, new Comparator<String>() {@Overridepublic int compare(String a, String b) {return bpareTo(a);}});只需要给静态方式 Collections.sort 传入一个List对象和一个比较器来按指定顺序排列。
Java 8 十大特性九、Date API (省略)Java 8 在包java.time下包含了一组全新的时间日期API。
新的日期API和开源的Joda-Time库差不多，但又不完全一样，下面的例子展示了这组新API里最重要的一些部分：Clock 时钟Clock类提供了访问当前日期和时间的方法，Clock是时区敏感的，可以用来取代System.currentTimeMillis() 来获取当前的微秒数。
某一个特定的时间点也可以使用Instant类来表示，Instant类也可以用来创建老的java.util.Date对象。
.十、Annotation 注解（省略）在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。
首先定义一个包装类Hints注解用来放置一组具体的Hint注解：使用Java 8操作压缩文件Java 8中的java.util.zip.ZipFile包中提供了stream方法，能够非常容易的获取ZIP压缩包中的条目。
使用Strean API 从Java 8开始，Java 8提供在java.util.zip.ZipFile 包中提供新的stream方法，能够返回ZIP压缩从Java 8开始，Java 8提供在java.util.zip.ZipFile包中提供新的stream方法，能够返回ZIP压缩包中的条目的有序的流，使得Java在处理ZIP压缩包时有了更多的选择。
读取压缩包的条目的代码如下形式：public class Zipper {public void printEntries(PrintStream stream, String zip) {try (ZipFile zipFile = new ZipFile(zip)) {zipFile.stream().forEach(stream::println);} catch (IOException e) {// error while opening a ZIP file}}}.Apache Tomcat 8.0.21 发布，此版本包括大量的 bug 修复，还有大量的改进和优化，值得关注的是：- Tomcat 停止运行时，WAR 文件修改可以被 Tomcat 检测- 支持 Java 8 JSSE 服务器优先 TLS 密码套件排序，要求 Java 8- 更新 Tomcat Native Library 至 1.1.33- 实现 AJP 连接器的新特性 - Tomcat Authorization.- The Apache Tomcat teamTomcat 是一个小型的轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。
java8新特性stream流的⽅式遍历集合和数组操作前⾔：在没有接触java8的时候，我们遍历⼀个集合都是⽤循环的⽅式，从第⼀条数据遍历到最后⼀条数据，现在思考⼀个问题，为什么要使⽤循环，因为要进⾏遍历，但是遍历不是唯⼀的⽅式，遍历是指每⼀个元素逐⼀进⾏处理（⽬的），⽽并不是从第⼀个到最后⼀个顺次处理的循环，前者是⽬的，后者是⽅式。
所以为了让遍历的⽅式更加优雅，出现了流（stream）！1.流的⽬的在于强掉做什么假设⼀个案例：将集合A根据条件1过滤为⼦集B,然后根据条件2过滤为⼦集C在没有引⼊流之前我们的做法可能为：public class Demo02NormalFilter {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张⽆忌");list.add("周芷若");list.add("赵敏");list.add("张强");list.add("张三丰");List<String> zhangList = new ArrayList<>();for (String name : list) {if (name.startsWith("张")) {zhangList.add(name);}}List<String> shortList = new ArrayList<>();for (String name : zhangList) {if (name.length() == 3) {shortList.add(name);}}for (String name : shortList) {System.out.println(name);}}}现在以流的⽅式实现同样的功能：public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("张⽆忌");list.add("周芷若");list.add("赵敏");list.add("张强");list.add("张三丰");list.stream().filter(s->s.startsWith("张")).filter(s-> s.length() == 3).forEach(System.out::println);从上⾯的两段代码可以看出流的存在让代码更加优雅。
java8新特性，使⽤流遍历集合 在这篇“Java 8新特性教程”系列⽂章中，我们会深⼊解释，并通过代码来展⽰，如何通过流来遍历集合，如何从集合和数组来创建流，以及怎么聚合流的值。
在之前的⽂章“遍历、过滤、处理集合及使⽤Lambda表达式增强⽅法”中，我已经深⼊解释并演⽰了通过lambda表达式和⽅法引⽤来遍历集合，使⽤predicate接⼝来过滤集合，实现接⼝的默认⽅法，最后还演⽰了接⼝静态⽅法的实现。
源代码都在我的Github上：可以从克隆。
内容列表使⽤流来遍历集合。
从集合或数组创建流。
聚合流中的值。
1. 使⽤流来遍历集合简介：Java的集合框架，如List和Map接⼝及Arraylist和HashMap类，让我们很容易地管理有序和⽆序集合。
集合框架⾃引⼊的第⼀天起就在持续的改进。
在Java SE 8中，我们可以通过流的API来管理、遍历和聚合集合。
⼀个基于流的集合与输⼊输出流是不同的。
如何⼯作？它采⽤⼀种全新的⽅式，将数据作为⼀个整体，⽽不是单独的个体来处理。
当你使⽤流时，你不需要关⼼循环或遍历的细节。
你可以直接从⼀个集合创建⼀个流。
然后你就能⽤这个流来许多事件了，如遍历、过滤及聚和。
我将从项⽬ Java8Features 的com.tm.java8.features.stream.traversing 包下的例⼦开始。
代码在⼀个SequentialStream 类中，Java SE 8 中有两种集合流，即串⾏流和并⾏流。
List<person> people = new ArrayList<>();people.add(new Person("Mohamed", 69));people.add(new Person("Doaa", 25));people.add(new Person("Malik", 6));Predicate<person> pred = (p) -> p.getAge() > 65;displayPeople(people, pred);...........private static void displayPeople(List<person> people, Predicate<person> pred) {System.out.println("Selected:");people.forEach(p -> {if (pred.test(p)) {System.out.println(p.getName());}});}在这两种流中，串⾏流相对⽐较简单，它类似⼀个迭代器，每次处理集合中的⼀个元素。
Java8新特性及常⽤⽅法集合 Stream流（1）分组(⽐如说某个pojo的某个字段的集合):List<SysOperatorLogsBean> logsBeans = logsMongoEngine.getBeans(sql);List<Long> tenantIds = logsBeans.stream().map(SysOperatorLogsBean::getTenantId).distinct().collect(Collectors.toList());（2）求和操作：List<Order> orderList = orderDao.findOrdersByUid(user.getUid());orderList.stream().mapToDouble(Order::getMoney).sum();（3）list转化为map：value为单对象：Map<Long, UserEntity> collect = userList.stream().collect(Collectors.toMap(UserEntity::getUid, (p) -> p));value为集合：Map<Long, List<ProductSkuEntity>> skuListMap = skuEntityList.stream().collect(Collectors.groupingBy(ProductSkuEntity::getProductId, Collectors.toList()));（4）将对象转为集合Collections.singletonList(user)（5）将数组转为集合Integer[] arrs = new Integer[]{};Set<Integer> values = new HashSet<>(Arrays.asList(arrs));(6) 排序Set<User> result = firstUsers.stream().sorted(paring(User::getCreateTime).reversed()).collect(toList());(7) 分组聚合 count，类似于 mysql group by countMap<Long, Long> map = list.stream().collect(Collectors.groupingBy(Bean::getId, Collectors.counting()));(8) 获取⼀段时间段内的⽇期的集合LocalDate start、end;List<String> list = Stream.iterate(start, localDate -> localDate.plusDays(1)).limit(ChronoUnit.DAYS.between(start, end) +1).map(LocalDate::toString).collect(Collectors.toList());时间：（1）可以获取当⽇的0点。
浅谈Java8新特性Predicate接⼝⽬录⼀、前⾔⼆、test(T t)三、and(Predicate<? super T> other)四、or(Predicate<? super T> other)五、negate()六、isEqual(Object targetRef)七、not(Predicate<? super T> target)⼀、前⾔Java 8中引⼊了Predicate功能接⼝。
Java Predicate表⽰⼀个参数的谓词。
Predicate是⼀个布尔值的函数。
Java Predicate是⼀个功能接⼝，属于java.util.function包。
Predicate的功能⽅法是test(T t)。
Predicate的其他⽅法是test、isEqual、and、or、negate和not。
not⽅法在Java 11中被引⼊。
在本⽂章，我们将提供Predicate的例⼦及其所有⽅法。
⼆、test(T t)boolean test(T t)test是Predicate的功能⽅法。
它在给定的参数上评估这个谓词。
例1：PredicateTestDemo1.javaimport java.util.function.Predicate;public class PredicateTestDemo1 {public static void main(String[] args) {// Is username validPredicate<String> isUserNameValid = u -> u != null && u.length() > 5 && u.length() < 10;System.out.println(isUserNameValid.test("Mahesh")); //true// Is password validPredicate<String> isPasswordValid = p -> p != null && p.length() > 8 && p.length() < 15;System.out.println(isPasswordValid.test("Mahesh123")); //true// Word matchPredicate<String> isWordMatched = s -> s.startsWith("Mr.");System.out.println(isWordMatched.test("Mr. Mahesh")); //true//Odd numbersPredicate<Integer> isEven = n -> n % 2 == 0;for(int i = 0 ; i < 5 ; i++) {System.out.println("Is "+ i + " even: " + isEven.test(i));}}}输出结果truetruetrueIs 0 even: trueIs 1 even: falseIs 2 even: trueIs 3 even: falseIs 4 even: true例2：PredicateTestDemo2.javaimport java.util.function.Function;import java.util.function.Predicate;public class PredicateTestDemo2 {public static void main(String[] args){Predicate<Student> maleStudent = s-> s.getAge() >= 20 && "male".equals(s.getGender()); Predicate<Student> femaleStudent = s-> s.getAge() > 18 && "female".equals(s.getGender()); Function<Student,String> maleStyle = s-> "Hi, You are male and age "+s.getAge();Function<Student,String> femaleStyle = s-> "Hi, You are female and age "+ s.getAge();Student s1 = new Student("Gauri", 20,"female");if(maleStudent.test(s1)){System.out.println(s1.customShow(maleStyle));}else if(femaleStudent.test(s1)){System.out.println(s1.customShow(femaleStyle));}}Student.javaimport java.util.function.Function;public class Student {private String name;private int age;private String gender;private int marks;public Student(String name, int age, String gender){ = name;this.age = age;this.gender = gender;}public Student(String name, int age, String gender, int marks){ = name;this.age = age;this.gender = gender;this.marks = marks;}public String getName() {return name;}public int getAge() {return age;}public String getGender() {return gender;}public int getMarks() {return marks;}public String customShow(Function<Student,String> fun){return fun.apply(this);}public String toString(){return name+" - "+ age +" - "+ gender + " - "+ marks;}}输出结果Hi, You are female and age 20三、and(Predicate<? super T> other)default Predicate<T> and(Predicate<? super T> other)and是Predicate的默认⽅法，它返回⼀个组成的谓词，表⽰这个谓词和其他谓词的短路逻辑AND。
本文由我司收集整编，推荐下载，如有疑问，请与我司联系Java 8 新特性小结2017/12/05 134 参考文章链接Java8 lambda 表达式10 个示例Java 8 新特性终极指南1．Lambda 表达式（闭包）；2．函数式编程支持：java.util.function.* 下的众多接口；3．流API；4．接口的默认方法和静态方法；5．新的Date和Time API。
1 Optional 接口Java 8 Optional 类深度解析Optional 类对对象的null 值检测进行包装，如果值存在则isPresent 返回true，否则false。
主要方法Optional.of：创建一个Optional，不能为null，赋值抛出NullPointerException。
Optional.ofNullable：创建一个可以为null 的Optional。
isPresent：值存在返回true，否则false。
ifPresent：值存在就调用Consumer 对象的accept 方法，否则无任何动作。
get：返回值，空Optional 抛NoSuchElementException 异常。
orElse：值存在返回，否则返回指定值。
orElseGet：值存在返回，否则调用Supplier 的get 返回。
orElseThrow：存在返回，否则抛出指定异常。
map、flatMap、filter 2 Lambda Lambda 表达式允许将函数作为一个方法参数传递，或许将代码看成数据。
用() - {} 代替整个匿名类。
new Thread( () - {int i = 9 ; System.out.println(“somting”+i) ; }).start(); () 中参数可省略类型，没有参数时() 仍然要保留。
{} 只有一条语句时{} 可以省略，语句尾的; 也可以省略。
Arrays.asList(“a”,“b”,“c”,“d”).forEach(va- System.out.println(va));3 FunctionalInterface 函数式接口，如果一个接口只有一个方法，那么编译器会将该接口视为函数式接口，如果在接口上加FunctionalInterface 注解，那么接口就会被强制要求符合函数式接口的规范（只有一个抽象方法，默认，静态方法不包括在内）。
java8新特性Stream和lambda案例（策略模式）1、Employee类package com.example.demo;public class Employee {private String name;private int age;private double salary;@Overridepublic String toString() {return "Employee{" +"name='" + name + '\'' +", age=" + age +", salary=" + salary +'}';}public Employee(String name, int age, double salary) { = name;this.age = age;this.salary = salary;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}}2、IEmployee接⼝package com.example.demo;public interface IEmployee<T> {public boolean test(T t);}3、FilterEmployeeBySalary实现类package com.example.demo;public class FilterEmployeeBySalary implements IEmployee<Employee>{@Overridepublic boolean test(Employee t) {return t.getSalary()>2;}}4、FilterEmployeeByAge实现类package com.example.demo;public class FilterEmployeeByAge implements IEmployee<Employee>{@Overridepublic boolean test(Employee t) {return t.getAge() > 18;}}5、DemoApplicationTests测试⽅法package com.example.demo;import org.junit.jupiter.api.Test;import org.springframework.boot.test.context.SpringBootTest;import java.util.ArrayList;import java.util.Arrays;import java.util.List;@SpringBootTestclass DemoApplicationTests {List<Employee> list = Arrays.asList(new Employee("A", 18, 2),new Employee("B", 20, 3),new Employee("C", 30, 4),new Employee("D", 11, 5));@Testvoid contextLoads() {List<Employee> employees = filterEmployees(list);for (Employee emp : employees) {System.out.println(emp.toString());}}//需求1：获取年龄⼤于18的员⼯public List<Employee> filterEmployees(List<Employee> list) {List<Employee> emps = new ArrayList<>();for (Employee emp : list) {if (emp.getAge() > 18) {emps.add(emp);}}return emps;}//需求2：获取⼯资⼤于2的员⼯public List<Employee> filterEmployees2(List<Employee> list) {List<Employee> emps = new ArrayList<>();for (Employee emp : list) {if (emp.getSalary() > 2) {emps.add(emp);}}return emps;}@Testvoid test1() {List<Employee> employees = filterEmployee(list, new FilterEmployeeByAge());for (Employee emp : employees) {System.out.println(emp.toString());}List<Employee> employees2 = filterEmployee(list, new FilterEmployeeBySalary());for (Employee emp : employees) {System.out.println(emp.toString());}}//优化1:策略设计模式优化public List<Employee> filterEmployee(List<Employee> list, IEmployee<Employee> mp) { List<Employee> emps = new ArrayList<>();for (Employee emp : list) {if (mp.test(emp)) {emps.add(emp);}}return emps;}//优化2:匿名内部类优化(相⽐于1不⽤创建更多的类)@Testvoid test2() {final List<Employee> employees = filterEmployee(list, new IEmployee<Employee>() { @Overridepublic boolean test(Employee employee) {return employee.getAge() > 18;}});for (Employee emp : employees) {System.out.println(emp.toString());}}//优化3:Lambada表达式(相对于匿名内部类优化)@Testvoid test3() {final List<Employee> employees = filterEmployee(list, (e) -> e.getAge() > 18);employees.forEach(System.out::println);}//优化4:Stream API@Testvoid test4() {list.stream().filter((e) -> e.getAge() > 18).forEach(System.out::println);//获取所有的名字list.stream().map(Employee::getName).forEach(System.out::println);}}。
Java8新特性Function、BiFunction使⽤闲话不多说，直接看代码，注释都写的很清楚了。
package com;import java.util.function.BiFunction;import java.util.function.Function;public class DemoFunction {public static void main(String[] args) {DemoFunction t1 = new DemoFunction();// Function函数的使⽤Integer addResult = pute(3, value -> value + value);System.out.println("加法结果：" + addResult);Integer subResult = pute(3, value -> value - 1);System.out.println("减法结果：" + subResult);Integer multipResult = pute(3, value -> value * value);System.out.println("乘法结果：" + multipResult);Integer divisionResult = pute(6, value -> value / 3);System.out.println("除法结果：" + divisionResult);// 使⽤compose场景, 从右向左处理, 这⾥就是 (6 * 6) + 10 = 46Integer composeResult = puteForCompose(6,value -> value + 10,value -> value * value);System.out.println("Function compose 结果：" + composeResult);// 使⽤andThen场景, 从左向右处理, 这⾥就是(3 + 20) - 10 = 13Integer andThenResult = puteForAndThen(3,value -> value + 20,value -> value - 10);System.out.println("Function andThen 结果：" + andThenResult);// 使⽤ BiFunctioin场景, 这⾥是 2 + 3 = 5Integer biFuncResult = puteForBiFunction(2, 3,(v1, v2) -> v1 + v2);System.out.println("BiFunction 结果：" + biFuncResult);// 使⽤ BiFunctioin andThen场景, 这⾥是 (2 * 3) + 6 = 12Integer biFuncAndThenResult = puteForBiFunctionAndThen(2, 3,(v1, v2) -> v1 * v2, v1 -> v1 + 6);System.out.println("BiFunction andThen 结果：" + biFuncAndThenResult);}/*** @param num* @param function* @return* @desc 使⽤JDK8 Function函数*/private Integer compute(Integer num, Function<Integer, Integer> function) {Integer result = function.apply(num);return result;}/*** @param num* @param function1* @param function2* @return* @desc 使⽤compose函数，简单的说，就是从右向左处理。
Java 8 (又称为jdk 1.8) 是Java 语言开发的一个主要版本。
Oracle 公司于2014 年3 月18 日发布Java 8 ，它支持函数式编程，新的JavaScript 引擎，新的日期API，新的Stream API 等。
新特性Java8 新增了非常多的特性，我们主要讨论以下几个：Lambda 表达式−Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中。
方法引用−方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。
与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
默认方法−默认方法就是一个在接口里面有了一个实现的方法。
新工具−新的编译工具，如：Nashorn引擎jjs、类依赖分析器jdeps。
Stream API −新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到Java中。
Date Time API −加强对日期与时间的处理。
Optional 类−Optional 类已经成为Java 8 类库的一部分，用来解决空指针异常。
Nashorn, JavaScript 引擎−Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。
更多的新特性可以参阅官网：What's New in JDK 8在关于Java 8 文章的实例，我们均使用jdk 1.8 环境，你可以使用以下命令查看当前jdk 的版本：编程风格Java 8 希望有自己的编程风格，并与Java 7 区别开，以下实例展示了Java 7 和Java 8 的编程格式：执行以上脚本，输出结果为：简介Java 8 的新特性：。
