java1.8新特性
1. Lambda 表达式
Lambda 表达式，也称为闭包，允许把函数作为一个方法的参数，使用Lambda 表达式可以使代码变的更加简洁紧凑。
1.1 语法
lambda 表达式的语法格式如下：
(parameters) -> expression或(parameters) ->{statements; }
以下是lambda表达式的重要特征：
- 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
- 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
- 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
- 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。
1.2 代码示例
public class Java8Demo {
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) {
Java8Demo tester = new Java8Demo();
// 类型声明
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.3 变量作用域
lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在lambda 内部修改定义在域外的局部变量，否则会编译错误。
也可以直接在lambda 表达式中访问外层的局部变量：
interface Converter<T1, T2> {
void convert(int i);
}
public void test2() {
final int num = 2;
Converter<Integer, Integer> zz = param -> System.out.println(num+param);
zz.convert(1);
}lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有final 的语义)
2. java8方法引用
方法引用通过方法的名字来指向一个方法。方法引用可以使语言的构造更紧凑简洁，减少冗余代码。方法引用使用一对冒号 :: 。
示例代码：
import java.util.Arrays;
import java.util.List;
import java.util.function.Supplier;
public class Car {
public static Car create(final Supplier<Car> supplier) {
return supplier.get();
}
public static void collide(final Car car) {
System.out.println("Collided " + car.toString());
}
public void follow(final Car another) {
System.out.println("Following the " + another.toString());
}
public void repair() {
System.out.println("Repaired " + this.toString());
}
public static void main(String[] args) {
//构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
Car car = Car.create(Car::new);
Car car1 = Car.create(Car::new);
Car car2 = Car.create(Car::new);
Car car3 = new Car();
List<Car> cars = Arrays.asList(car,car1,car2,car3);
System.out.println("===================构造器引用========================");
//静态方法引用：它的语法是Class::static_method，实例如下：
cars.forEach(Car::collide);
System.out.println("===================静态方法引用========================");
//特定类的任意对象的方法引用：它的语法是Class::method实例如下：
cars.forEach(Car::repair);
System.out.println("==============特定类的任意对象的方法引用================");
//特定对象的方法引用：它的语法是instance::method实例如下：
final Car police = Car.create(Car::new);
cars.forEach(police::follow);
System.out.println("===================特定对象的方法引用===================");
}
}3. Java 8 函数式接口
3.1 函数式接口
函数式接口(FunctionalInterface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为lambda表达式。
JDK 1.8之前已有的函数式接口:
• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListenerJDK 1.8 新增加的函数接口：
- java.util.function
java.util.function 它包含了很多类，用来支持 Java的函数式编程，该包中的函数式接口有：
3.2 示例代码Predicate、Supplier、Function、Consumer
/**
* Predicate接口：断言接口，断言可理解为测试的意思
* 测试给定字符串列表中哪些字符串包含小写字母m
*/
private static void predicate() {
List<String> list = Arrays.asList("Mikey", "Lily", "Jimy", "Tom");
// 有没有参数取决于接口中的方法有没有参数 boolean test(T t);
List<String> results = filter(list, (str) -> str.contains("m"));
results.forEach(System.out::println);
}
private static List<String> filter(List<String> list, Predicate<String> p) {
List<String> results = new ArrayList<>();
for (String str : list) {
if (p.test(str)) { // 测试是否符合要求
results.add(str);
}
}
return results;
}
/**
* Supplier接口：代表结果供应商
*/
private static void supplier() {
List<Integer> list = getNums(10, () -> (int) (Math.random() * 100));
list.forEach(System.out::println);
}
// 获取num个随机数，由调用者给出具体实现
private static List<Integer> getNums(int num, Supplier<Integer> sup) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < num; i++) {
list.add(sup.get());
}
return list;
}
/**
* Function<T, R>接口：表示接收一个参数并产生结果的函数
*/
private static void function() {
String s = strToUpp("lowercase", (str) -> str.toUpperCase());
System.out.println(s);
}
// 将给定字符串转为大写，由调用者给出具体实现
private static String strToUpp(String str, Function<String, String> f) {
return f.apply(str);
}
/**
* Consumer接口：消费者接口
* jdk 1.8中的新的迭代方法
*/
private static void foreach() {
List<String> list = new ArrayList<>();
list.add("Tom");
list.add("Mikey");
list.add("Lily");
list.forEach((String s) -> {
System.out.println(s);
});
// 只有一行代码，可简写为
list.forEach(s -> System.out.println(s));
// 进一步可用新语法写为
list.forEach(System.out::println);
List<String> list1 = Collections.synchronizedList(list);
}4. Java 8 默认方法
Java 8 新增了接口的默认方法。简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。我们只需在方法名前面加个default关键字即可实现默认方法。
为什么要有这个特性？
首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的java 8之前的集合框架没有foreach方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。
4.1 语法
默认方法语法格式如下：
public interface vehicle {
default void print() {
System.out.println("我是一辆车!");
}
}4.2 多个默认方法
一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法。
public interface vehicle {
default void print() {
System.out.println("我是一辆车!");
}
}public interface fourWheeler {
default void print() {
System.out.println("我是一辆四轮车!");
}
}第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：
public class Car implements vehicle, fourWheeler {
@Override
public void print() {
System.out.println("我是一辆四轮汽车!");
}
}第二种解决方案可以使用 super 来调用指定接口的默认方法：
public class Car implements vehicle, fourWheeler {
@Override
public void print() {
vehicle.super.print();
}
}4.3 静态默认方法
Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：
public interface vehicle {
default void print() {
System.out.println("我是一辆车!");
}
// 静态方法
static void blowHorn() {
System.out.println("按喇叭!!!");
}
}4.5 示例代码
public class Java8Tester {
public static void main(String args[]) {
Vehicle vehicle = new Car();
vehicle.print();
}
}
interface Vehicle {
default void print() {
System.out.println("我是一辆车!");
}
static void blowHorn() {
System.out.println("按喇叭!!!");
}
}
interface FourWheeler {
default void print() {
System.out.println("我是一辆四轮车!");
}
}
class Car implements Vehicle, FourWheeler {
public void print() {
Vehicle.super.print();
FourWheeler.super.print();
Vehicle.blowHorn();
System.out.println("我是一辆汽车!");
}
}结果输出：
我是一辆车!
我是一辆四轮车!
按喇叭!!!
我是一辆汽车!5. Java 8 Stream
6. Java 8 Optional 类
Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
7. Java 8 日期时间 API
Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。
在旧版的Java 中，日期时间API 存在诸多问题，其中有：
- 非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
- 设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
- 时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。
Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：
- Local(本地) − 简化了日期时间的处理，没有时区的问题。
- Zoned(时区) − 通过制定的时区处理日期时间。
新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。
7.1 本地化日期时间 API
LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况。代码如下：
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);
}
}7.2 使用时区的日期时间API
如果我们需要考虑到时区，就可以使用时区的日期时间API：
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);
}
}8. Java8 Base64
在Java8中，Base64编码已经成为Java类库的标准。Java 8 内置了 Base64 编码的编码器和解码器。
Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：
- 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
- URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
- MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。
示例代码：
public class Java8Tester {
public static void main(String args[]) {
try {
// 使用基本编码
String base64encodedString = Base64.getEncoder().encodeToString("runoob?java8".getBytes("utf-8"));
System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);
// 解码
byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));
base64encodedString = Base64.getUrlEncoder().encodeToString("TutorialsPoint?java8".getBytes("utf-8"));
System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < 10; ++i) {
stringBuilder.append(UUID.randomUUID().toString());
}
byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);
} catch (UnsupportedEncodingException e) {
System.out.println("Error :" + e.getMessage());
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
