java 8 新特性
Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。Java 8是Java自Java 5（发布于2004年）之后的最重要的版本。这个版本包含语言、编译器、库、工具和JVM等方面的十多个新特性。本文主要介绍一下几种：
- Lambda 表达式
- 方法引用
- 函数式接口
- 默认方法
- Stream
具体介绍
Lambda 表达式
使用 Lambda 表达式可以使代码变的更加简洁紧凑。Lambda表达式（也称为闭包）它是推动 Java 8 发布的最重要新特性。它允许我们将函数当成参数传递给某个方法，或者把代码本身当作数据处理：函数式开发者非常熟悉这些概念。很多JVM平台上的语言（Groovy、Scala等）从诞生之日就支持Lambda表达式，但是Java开发者没有选择，只能使用匿名内部类代替Lambda表达式
lambda 表达式的语法格式如下：
(parameters) -> expression
或
(parameters) ->{ statements; }
示例
public class Lambda_test {
//定义interface
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
//定义方法
private int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
public static void main(String args[]){
Lambda_test tester = new Lambda_test();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> { return a * b; };
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
注意事项：
1.lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 2.lambda 内部修改定义在域外的局部变量，否则会编译错误
Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
3.Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力
方法引用
Java 8 允许你使用 :: 关键字来传递方法或者构造函数引用。方法引用使得开发者可以直接引用现存的方法、Java类的构造方法或者实例对象。方法引用和Lambda表达式配合使用，使得java类的构造方法看起来紧凑而简洁，没有很多复杂的模板代码。主要分为以下四种
构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
final Car car = Car.create( Car::new );
final List< Car > cars = Arrays.asList( car );
静态方法引用：它的语法是Class::static_method，实例如下：
cars.forEach( Car::collide );
特定类的任意对象的方法引用：它的语法是Class::method实例如下：
cars.forEach( Car::repair )；
特定对象的方法引用：它的语法是instance::method实例如下：
final Car police = Car.create( Car::new );
cars.forEach( police::follow );
函数式接口
函数接口指的是只有一个函数的接口，这样的接口可以隐式转换为Lambda表达式。java.lang.Runnable和java.util.concurrent.Callable是函数式接口的最佳例子。在实践中，函数式接口非常脆弱：只要某个开发者在该接口中添加一个函数，则该接口就不再是函数式接口进而导致编译失败。为了克服这种代码层面的脆弱性，并显式说明某个接口是函数式接口，Java 8 提供了一个特殊的注解@FunctionalInterface（Java 库中的所有相关接口都已经带有这个注解了），举个简单的函数式接口的定义：
@FunctionalInterface
public interface Functional_example {
void method();
}
函数i接口示例
public class Java8Tester {
public static void main(String args[]){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// Predicate<Integer> predicate = n -> true
// n 是一个参数传递到 Predicate 接口的 test 方法
// n 如果存在则 test 方法返回 true
System.out.println("输出所有数据:");
// 传递参数 n
eval(list, n->true);
// Predicate<Integer> predicate1 = n -> n%2 == 0
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n%2 为 0 test 方法返回 true
System.out.println("输出所有偶数:");
eval(list, n-> n%2 == 0 );
// Predicate<Integer> predicate2 = n -> n > 3
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n 大于 3 test 方法返回 true
System.out.println("输出大于 3 的所有数字:");
eval(list, n-> n > 3 );
}
public static void eval(List<Integer> list, Predicate<Integer> predicate) {
for(Integer n: list) {
if(predicate.test(n)) {
System.out.println(n + " ");
}
}
}
默认方法
Java 8 新增了接口的默认方法。简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。我们只需在方法名前面加个 default 关键字即可实现默认方法。
默认方法示例
public interface People{
default void print(){
System.out.println("i am a teacher");
}
}
Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法
public interface People{
default void print(){
System.out.println("i am a teacher");
}
// 静态方法
static void talk(){
System.out.println("i can talk");
}
}
标注： 在Java中只有单继承，如果要让一个类赋予新的特性，通常是使用接口来实现，在C++中支持多继承，允许一个子类同时具有多个父类的接口与功能，在其他语言中，让一个类同时具有其他的可复用代码的方法叫做mixin。新的Java 8 的这个特新在编译器实现的角度上来说更加接近Scala的trait。 在C#中也有名为扩展方法的概念，允许给已存在的类型扩展方法，和Java 8的这个在语义上有差别。
stream
Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一 个则是 Stream API(java.util.stream.*)。
Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对
集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。
使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数
据库查询。也可以使用 Stream API 来并行执行操作。简而言之，
Stream API 提供了一种高效且易于使用的处理数据的方式。
+--------------------+ +------+ +------+ +---+ +-------+ | stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect| +--------------------+ +------+ +------+ +---+ +-------+
以上的流程转换为 Java 代码为：
List<Integer> transactionsIds =
widgets.stream()
.filter(b -> b.getColor() == RED)
.sorted((x,y) -> x.getWeight() - y.getWeight())
.mapToInt(Widget::getWeight)
.sum();
生成流
在 Java 8 中, 集合接口有两个方法来生成流：
stream() − 为集合创建串行流。
parallelStream() − 为集合创建并行流。
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
forEach
Stream 提供了新的方法 ‘forEach’ 来迭代流中的每个数据。以下代码片段使用 forEach 输出了10个随机数：
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
map
map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());
filter
filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.stream().filter(string -> string.isEmpty()).count();
limit
limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);
sorted
sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：
Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);
并行（parallel）程序
parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
int count = strings.parallelStream().filter(string -> string.isEmpty()).count();
我们可以很容易的在顺序运行和并行直接切换。
Collectors
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);
统计
另外，一些产生统计结果的收集器也非常有用。它们主要用于int、double、long等基本类型上，它们可以用来产生类似如下的统计结果。
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
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());
Optional 类
Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
Optional的方法如下
| 序号 | 方法 & 描述 |
|---|---|
| 1 | static <T> Optional<T> empty() 返回空的 Optional 实例。 |
| 2 | boolean equals(Object obj) 判断其他对象是否等于 Optional。 |
| 3 | Optional<T> filter(Predicate<? super <T> predicate) 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。 |
| 4 | <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper) 如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional |
| 5 | T get() 如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException |
| 6 | int hashCode() 返回存在值的哈希码，如果值不存在 返回 0。 |
| 7 | void ifPresent(Consumer<? super T> consumer) 如果值存在则使用该值调用 consumer , 否则不做任何事情。 |
| 8 | boolean isPresent() 如果值存在则方法会返回true，否则返回 false。 |
| 9 | <U>Optional<U> map(Function<? super T,? extends U> mapper) 如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。 |
| 10 | static <T> Optional<T> of(T value) 返回一个指定非null值的Optional。 |
| 11 | static <T> Optional<T> ofNullable(T value) 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。 |
| 12 | T orElse(T other) 如果存在该值，返回值， 否则返回 other。 |
| 13 | T orElseGet(Supplier<? extends T> other) 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。 |
| 14 | <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) 如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常 |
| 15 | String toString() 返回一个Optional的非空字符串，用来调试 |
optinal 示例
public class Optional_test {
private static Integer sum(Integer a, Integer b){
Optional<Integer> num1 = Optional.ofNullable(a);
Optional<Integer> num2 = Optional.ofNullable(b);
System.out.println("第一个参数值存在: " + num1.isPresent());
System.out.println("第二个参数值存在: " + num2.isPresent());
System.out.println( "First Name: " + num1.orElseGet(()->15) );
System.out.println( num1.map( s -> "firstNum is " + s + "!" ).orElse( "no set number" ) );
// Optional.orElse - 如果值存在，返回它，否则返回默认值
Integer value1 = num1.orElse(new Integer(10));
//Optional.get - 获取值，值需要存在
Integer value2 = num2.get();
return value1 + value2;
}
public static void main(String[] args) {
Integer firstNum = null;
Integer secondNum = new Integer( 12);
Integer Result = sum(firstNum,secondNum);
System.out.println("result is " + Result);
}
输出结果
第一个参数值存在: false
第二个参数值存在: true
First Name: 15
no set number
result is 22
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
