Java8 新特性

Java8 新特性

1. Lambda 表达式

语法：

(parameters) -> expression
或
(parameters) -> { statements; }

特征：

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
• 可选的大括号：如果主体只包含一个语句，就不需要使用大括号
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值

例子：

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester tester = new Java8Tester();

        // 类型声明
        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");
    }

    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);
    }
}

lambda 表达式中访问外层的局部变量，这个局部变量可以不显式声明为 final，但是不能在后面代码修改（即隐式具有 final 含义）。但是如果外层变量是 static 声明的话，可以在 lambda 表达式内部引用，并且在后面的代码中修改。

static变量是恒定指向内存的一个位置的，哪怕修改变量的值也是同一个位置，final 不可修改，也可以算是指向了内存中的一个位置（从创建那时候开始算的话）。变量只是引用，普通变量修改值的话会指向另一块内存位置，而 lambda 应该规定的是，只要一块不变的内存地址

lambda 和 匿名内部类的比较：

匿名内部类的格式：

new 父类或接口() {​
    重写的方法;​ 
}

在匿名内部类中很多是内容是冗余的。lambda 提取匿名内部类中最核心的内容（方法参数，方法体，返回值）。

Lambda 表达式的使用条件:

1. 必须有接口（不能是抽象类），接口中有且仅有一个需要被重写的抽象方法。
2. 必须支持上下文推导，要能够推导出来 Lambda 表达式表示的是哪个接口中的内容。
   可以使用接口当做参数，然后传递 Lambda 表达式(常用)，也可以将 Lambda 表达式赋值给一个接口类型的变量。

2. 方法引用

语法：

• 构造器引用：Class::new
• 静态方法引用：Class::static_method
• 特定类的任意对象的方法引用：Class::method
• 特定对象的方法引用：instance::method

public class Java8Tester {
    public static void main(String args[]) {
        List names = new ArrayList();
        names.add("Google");
        names.add("Runoob");
        names.add("Taobao");
        names.add("Baidu");
        names.add("Sina");
        names.forEach(System.out::println);
		// 对每一个 names 中的值，依次传递给 System.out 类下面的 println 这个方法
    }
}

3. 函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 lambda 表达式。

// Predicate <T> 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。
// 该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。
// 该接口用于测试对象是 true 或 false。

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 + " ");
            }
        }
    }
}
// 换成流计算的话
private static void eval(List<Integer> list, Predicate<Integer> predicate) {
    list.stream().filter(predicate).forEach(System.out::println);
}
// 直接填写过滤条件的话
list.stream().filter(n -> n > 3).forEach(System.out::println);

4. 接口的默认方法

接口可以有实现方法，并且不需要实现类来实现其方法。在方法名前面加 default 关键字即可实现默认方法。一个接口可以用多个默认方法。

目的：为了解决接口的修改与现有的实现不兼容的问题。之前需要修改接口的时候，需要修改全部实现该接口的类。

如果一个实现类实现了多个接口，并且多个接口中有相同的默认方法，可以在实现类中覆写掉这个默认方法，或者在实现类中通过 super 来指定接口的默认方法。

接口还可以声明（并且可以提供实现）静态方法。

public interface Vehicle {
	default void print(){
		System.out.println("我是一辆车!");
	}
	// 静态方法
	static void blowHorn(){
		System.out.println("按喇叭!!!");
	}
}

5. Stream

流计算：
stream of elements
=> 聚合操作：filter、map、reduce、find、match、sorted、collect etc

生成流：

• stream()：为集合创建串行流
• parallelStream()：为集合创建并行流

如果是 Random 的话，通过 random.ints() 来生成流

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());

6. Optional 类

目的：为了解决空指针问题

demo：

import java.util.Optional;
 
public class Java8Tester {
	public static void main(String args[]){
		Java8Tester java8Tester = new Java8Tester();
		Integer value1 = null;
		Integer value2 = new Integer(10);

		// Optional.ofNullable - 允许传递为 null 参数
		Optional<Integer> a = Optional.ofNullable(value1);

		// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
		Optional<Integer> b = Optional.of(value2);
		System.out.println(java8Tester.sum(a,b));
	}

	public Integer sum(Optional<Integer> a, Optional<Integer> b){

		// Optional.isPresent - 判断值是否存在
		
		System.out.println("第一个参数值存在: " + a.isPresent());
		System.out.println("第二个参数值存在: " + b.isPresent());
		
		// Optional.orElse - 如果值存在，返回它，否则返回默认值
		Integer value1 = a.orElse(new Integer(0));
		
		//Optional.get - 获取值，值需要存在
		Integer value2 = b.get();
		return value1 + value2;
	}
}

7. Nashorn, JavaScript 引擎

8. 新的日期时间 API

旧的日期 API 有诸多问题：

1. 非线程安全： java.util.Date 是非线程安全的，所有的日期类都是可变的
2. 设计差：java.util 和 java.sql 的包中都有日期类
3. 时区处理麻烦：没有时区支持，因此引入了 java.util.Calendar 和 java.util.TimeZone 类，但他们同样存在上述所有的问题

新的日期 API：java.time

1. 本地化日期时间 API
   LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况

   import java.time.LocalDate;
   import java.time.LocalTime;
   import java.time.LocalDateTime;
   import java.time.Month;
    
   public class Java8Tester {
   	public static void main(String args[]){
   		Java8Tester java8tester = new Java8Tester();
   		java8tester.testLocalDateTime();
   	}
   
   	public void testLocalDateTime(){
   
   		// 获取当前的日期时间
   		LocalDateTime currentTime = LocalDateTime.now();
   		System.out.println("当前时间: " + currentTime);
   		
   		LocalDate date1 = currentTime.toLocalDate();
   		System.out.println("date1: " + date1);
   		
   		Month month = currentTime.getMonth();
   		int day = currentTime.getDayOfMonth();
   		int seconds = currentTime.getSecond();
   		
   		System.out.println("月: " + month +", 日: " + day +", 秒: " + seconds);
   		
   		LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
   		System.out.println("date2: " + date2);
   		
   		// 12 december 2014
   		LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
   		System.out.println("date3: " + date3);
   		
   		// 22 小时 15 分钟
   		LocalTime date4 = LocalTime.of(22, 15);
   		System.out.println("date4: " + date4);
   		
   		// 解析字符串
   		LocalTime date5 = LocalTime.parse("20:15:30");
   		System.out.println("date5: " + date5);
   	}
   }

2. 使用时区的日期时间 API

   import java.time.ZonedDateTime;
   import java.time.ZoneId;
    
   public class Java8Tester {
   	public static void main(String args[]){
   		Java8Tester java8tester = new Java8Tester();
   		java8tester.testZonedDateTime();
   	}
   
   	public void testZonedDateTime(){
   
   		// 获取当前时间日期
   		ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
   		System.out.println("date1: " + date1);
   		
   		ZoneId id = ZoneId.of("Europe/Paris");
   		System.out.println("ZoneId: " + id);
   		
   		ZoneId currentZone = ZoneId.systemDefault();
   		System.out.println("当期时区: " + currentZone);
   	}
   }

9. Base64