Java新特征
Java5新特征
一、泛型
- 好处：
1、将运行时期的问题ClassCastException转到了编译时期。
2、避免了强制转换的麻烦。 - 擦除 & 补偿：
1、擦除
编译时，会将泛型去掉，生成的class文件中是不带泛型的，这个称为泛型的擦除。
2、补偿
在运行时，通过获取元素的类型进行转换动作。不用使用者再强制转换了。 - 应用：
1、集合中使用
2、迭代器中使用
3、比较器中使用 - 泛型实现
泛型类：
1、定义--在类后面加<T>
2、使用--在类后面加<具体类型>
泛型方法：
1、定义--在修饰符和返回值之间添加<T>
2、使用--在使用的地方用具体类型
泛型接口：
1、定义--在接口后面加<T>
2、使用的两种情况：
1）在实现的时候在接口后面加<具体类型>
2）a）实现时在类后面加<T>,创建实现类对象的时候在类后面加<具体类型>。 - 泛型限定
上限
特点：
? extends E：接收E类型或者E的子类型对象。上限!
体现：
一般在取出元素的时候都使用上限
下限
特点：
? super E：接收E类型或者E的父类型。下限！
体现：
通常对集合中的元素进行存储操作时，可以使用下限。
通配符：
依赖equals方法
二、增强循环
- 格式：
for(类型 变量 : Collection集合|数组) {...} - 传统 for 和高级 for 的区别：
传统 for 定义增量和条件；
高级 for 对数组和集合的内容进行遍历。
三、自动装箱拆箱
- 自动装箱：
基本类型byte、short、int、long、float、double、char、boolean自动转化为
它们的包装类型Byte、Short、Integer、Long、Float、Double、Character、Boolean。 - 自动拆箱：
包装类型Byte、Short、Integer、Long、Float、Double、Character、Boolean自动转化为
它们的基本类型byte、short、int、long、float、double、char、boolean。
四、枚举
- 枚举定义
public enum StatusEnum {
INIT(0, "初始值"),
START(1, "开始"),
FINISH(2, "结束");
/**
* 值
*/
private Integer value;
/**
* 名称
*/
private String name;
StatusEnum(int value, String name) {
this.value = value;
this.name = name;
}
public Integer getValue() {
return value;
}
public void setValue(Integer value) {
this.value = value;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
五、函数可变参数
- 定义：newAdd(int... arr)
- 调用：newAdd(1,2,3,4)
注意事项：可变参数类型，必须定义在参数列表的结尾处。
六、静态导入
- 直接导入静态的方法
七、注解
- 如何定义Annotation：
定义Annotation的步骤：
第一步，用@interface定义注解：
public @interface Anno {
}
第二步，添加参数、默认值：
public @interface Anno {
int code() default 0;
String value() default "";
}
第三步，用元注解配置注解：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno {
int code() default 0;
String value() default "";
} - 元注解
有一些注解可以修饰其他注解，这些注解就称为元注解（meta annotation）。
@Target
最常用的元注解是@Target。使用@Target可以定义Annotation能够被应用于源码的哪些位置：
类或接口：ElementType.TYPE；
字段：ElementType.FIELD；
方法：ElementType.METHOD；
构造方法：ElementType.CONSTRUCTOR；
方法参数：ElementType.PARAMETER。
例如，定义注解@Report可用在方法上，我们必须添加一个@Target(ElementType.METHOD)：
@Target(ElementType.METHOD)
public @interface Anno {
}
@Retention
另一个重要的元注解@Retention定义了Annotation的生命周期：
仅编译期：RetentionPolicy.SOURCE；
仅class文件：RetentionPolicy.CLASS；
运行期：RetentionPolicy.RUNTIME。
如果@Retention不存在，则该Annotation默认为CLASS。
@Retention(RetentionPolicy.RUNTIME)
public @interface Anno {
}
@Repeatable
使用@Repeatable这个元注解可以定义Annotation是否可重复。这个注解应用不是特别广泛。
@Inherited
使用@Inherited定义子类是否可继承父类定义的Annotation。
八、print输出格式化
- System.out.println("Line %d: %s%n", i++, line);
九、新的线程模型和并发库
- java.util.concurrent
十、Arrays、Queue、单线程StringBuilder
- Arrays
Arrays.sort(myArray);
Arrays.toString(myArray)
Arrays.binarySearch(myArray, 98)
Arrays.deepToString(ticTacToe)
Arrays.deepEquals(ticTacToe, ticTacToe3) - Queue
避开集合的add/remove操作，使用offer、poll操作（不抛异常）
Queue q = new LinkedList(); 采用它来实现queue - Override返回类型
支持协变返回 - 单线程StringBuilder
线程不安全，在单线程下替换string buffer提高性能。 - java.lang.instrument
JDK6新特征
一、AWT新增加了两个类:Desktop和SystemTray
- 其中前者用来通过系统默认程序来执行一个操作，如使用默认浏览器浏览指定的URL,用默认邮件客户端给指定的邮箱发邮件,
用默认应用程序打开或编辑文件(比如,用记事本打开以txt为后缀名的文件),用系统默认的打印机打印文档等。
后者可以用来在系统托盘区创建一个托盘程序。
二、使用JAXB2来实现对象与XML之间的映射。
- 可以将一个Java对象转变成为XML格式，反之亦然。
- 注解 说明
@XmlRootElement 将类或enum类型映射到XML元素，类名或名作为根节点。
@XmlAttribute 将JavaBean属性映射到XML属性。
@XmlElement 将JavaBean属性映射到源自属性名的XML元素。
@XmlAnyAttribute 将JavaBean属性映射到通配符属性的映射。
@XmlAnyElement 将JavaBean属性映射到XML infoset或JAXB。
@XmlElements 一个用于多XmlElement注解的容器。
@XmlID 将JavaBean属性映射到XML ID。
@XmlIDREF 将JavaBean属性映射到XML IDREF。
@XmlList 用来将一个属性映射到一个List。
@XmlSchema 将包映射到XML名称空间。
@XmlTransient 该属性无需映射到XML。
三、StAX
- 一种利用拉模式解析(pull-parsing)XML文档的API。类似于SAX，也基于事件驱动模型。
之所以将StAX加入到JAXP家族，是因为JDK6中的JAXB2和JAX-WS 2.0中都会用StAX。
四、使用Compiler API
- 动态编译Java源文件，如JSP编译引擎就是动态的，所以修改后无需重启服务器。
五、轻量级Http Server API
- 据此可以构建自己的嵌入式HttpServer,它支持Http和Https协议。
六、插入式注解处理API(PluggableAnnotation Processing API)
七、提供了Console类用以开发控制台程序，位于java.io包中。
- 据此可方便与Windows下的cmd或Linux下的Terminal等交互。
八、对脚本语言的支持
- 如：ruby，groovy，javascript。
九、Common Annotations
- 原是J2EE 5.0规范的一部分，现在把它的一部分放到了J2SE 6.0中。
十、嵌入式数据库 Derby
Java7新特征
一、switch语句支持字符串变量
- 之前，switch只支持byte、short、int、char；
1.7支持了String。
二、泛型实例化类型自动推断
- 下面等价：
ArrayList<String> list1 = new ArrayList<String>();
ArrayList<String> list2 = new ArrayList<>();
三、新的整数字面表达方式前缀"0b"或"0B"和连数符"_"
- 表示二进制字面值的前缀"0b"或"0B"
八进制字面值的前缀为"0"；
十六进制字面值的前缀为"0x"或"0X"；
二进制字面值的前缀为"0b"或"0B"。 - 数值型字面值的下划线。用下划线连接数值提升其可读性，自身无含义，不可用在数值的起始和末尾。
Java编码语言对给数值型的字面值加下划线有严格的规定。如上所述，你只能在数字之间用下划线。
你不能用把一个数字用下划线开头，或者已下划线结尾。这里有一些其它的不能在数值型字面值上用下划线的地方：
在数字的开始或结尾
对浮点型数字的小数点附件
F或L下标的前面
该数值型字面值是字符串类型的时候
int a = 0_x52; // 无效，不能在0x之间有下划线
int a = _52; // 这是一个下划线开头的标识符，不是个数字
int a = 0x_52; // 无效的，不能在数字开头有下划线
int a = 52_; // 无效的，不能以下划线结尾
int a = 052_; // 无效的，不能以下划线结尾
int a = 0x52_; // 无效的，不能以下划线结尾
float pi = 3_.1415F;// 无效的; 不能在小数点之前有下划线
float pi = 3._1415F;// 无效的; 不能在小数点之后有下划线
long socialSecurityNumber=999_99_9999_L;//无效的，不能在L下标之前加下划线
int a = 5_2; // 有效
int a = 5_______2; // 有效的
int a = 0x5_2; // 有效的 (16进制数字)
int a = 0_52; // 有效的（8进制数）
int a = 05_2; // 有效的（8进制数）
四、在单个catch代码块中捕获多个异常，以及用升级版的类型检查重新抛出异常
- 在单个catch代码块中捕获多个异常
catch(IOException | SQLException | Exception ex){
logger.error(ex);
throw new MyException(ex.getMessage());
} - 升级版的类型检查重新抛出异常，可以抛出多个异常
public class Java7MultipleExceptions {
static void rethrow(String s) throws FirstException, SecondException, ThirdException {
try {
if (s.equals("First"))
throw new FirstException("First");
else if (s.equals("Second"))
throw new SecondException("Second");
else
throw new ThirdException("Third");
} catch (Exception e) {
//下面的赋值没有启用重新抛出异常的类型检查功能，这是Java 7的新特性
// e=new ThirdException();
throw e;
}
}
}
五、try-with-resources语句
- 可以将资源关闭这种与业务实现没有很大直接关系的工作交给JVM完成，省去了部分开发中可能出现的代码风险。
public class JDK7 {
static String readFirstLineFromFile(String path) throws IOException {
try (BufferedReader br = new BufferedReader(new FileReader(path))) {
return br.readLine();
}
}
}
try-with-resources语句也可以声明多个资源。声明语句之间分号分割，最后一个可忽略分号。
Java8新特征
一、接口的默认方法
- Java 8允许我们给接口添加一个非抽象的方法实现，只需要使用 default关键字即可，这个特征又叫做扩展方法，示例如下：
interface Formula {
double calculate(int a);
default double sqrt(int a) {
return Math.sqrt(a);
}
}
二、Lambda 表达式
- 首先看看在Java 8之前的版本中是如何排列字符串的：
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});
只需要给静态方法 Collections.sort 传入一个List对象以及一个比较器来按指定顺序排列。
通常做法都是创建一个匿名的比较器对象然后将其传递给sort方法。 - 在Java 8中你就没必要使用这种传统的匿名对象的方式了，Java 8提供了更简洁的语法，lambda表达式：
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
}); - 看到了吧，代码变得更短且更具有可读性，但是实际上还可以写得更短：
Collections.sort(names, (String a, String b) -> b.compareTo(a)); - 对于函数体只有一行代码的，你可以去掉大括号{}以及return关键字，但是你还可以写得更短点：
Collections.sort(names, (a, b) -> b.compareTo(a)); - Java编译器可以自动推导出参数类型，所以你可以不用再写一次类型。
接下来我们看看lambda表达式还能作出什么更方便的东西来。
三、函数式接口
- Lambda表达式是如何在java的类型系统中表示的呢？每一个lambda表达式都对应一个类型，通常是接口类型。
而“函数式接口”是指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被
匹配到这个抽象方法。因为 默认方法 不算抽象方法，所以你也可以给你的函数式接口添加默认方法。 - 我们可以将lambda表达式当作任意只包含一个抽象方法的接口类型，确保你的接口一定达到这个要求，
你只需要给你的接口添加 @FunctionalInterface 注解，编译器如果发现你标注了这个注解的
接口有多于一个抽象方法的时候会报错的。
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123
需要注意如果@FunctionalInterface如果没有指定，上面的代码也是对的。
四、方法与构造函数引用
- 前一节中的代码还可以通过静态方法引用来表示：
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123 - Java 8允许你使用 :: 关键字来传递方法或者构造函数引用，上面的代码展示了如何引用一个静态方法，
我们也可以引用一个对象的方法：
converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J" - 接下来看看构造函数是如何使用::关键字来引用的，首先我们定义一个包含多个构造函数的简单类：
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
接下来我们指定一个用来创建Person对象的对象工厂接口：
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
这里我们使用构造函数引用来将他们关联起来，而不是实现一个完整的工厂：
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");
我们只需要使用 Person::new 来获取Person类构造函数的引用，Java编译器会自动根据
PersonFactory.create方法的签名来选择合适的构造函数。
五、Lambda 作用域
- 在lambda表达式中访问外层作用域和老版本的匿名对象中的方式很相似。你可以直接访问
标记了final的外层局部变量，或者实例的字段以及静态变量。
六、访问局部变量
- 我们可以直接在lambda表达式中访问外层的局部变量：
final int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3
但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确：
int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
stringConverter.convert(2); // 3 - 不过这里的num必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译：
int num = 1;
Converter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
num = 3;
在lambda表达式中试图修改num同样是不允许的。
七、访问对象字段与静态变量
- 和本地变量不同的是，lambda内部对于实例的字段以及静态变量是即可读又可写。该行为和匿名对象是一致的：
class Lambda4 {
static int outerStaticNum;
int outerNum;
void testScopes() {
Converter<Integer, String> stringConverter1 = (from) -> {
outerNum = 23;
return String.valueOf(from);
};
Converter<Integer, String> stringConverter2 = (from) -> {
outerStaticNum = 72;
return String.valueOf(from);
};
}
}
八、访问接口的默认方法
- 还记得第一节中的formula例子么，接口Formula定义了一个默认方法sqrt可以直接
被formula的实例包括匿名对象访问到，但是在lambda表达式中这个是不行的。
Lambda表达式中是无法访问到默认方法的，以下代码将无法编译：
Formula formula = (a) -> sqrt( a * 100);
Built-in Functional Interfaces
Java 8 API包含了很多内建的函数式接口，在老Java中常用到的比如Comparator或者Runnable接口，
这些接口都增加了@FunctionalInterface注解以便能用在lambda上。
Java 8 API同样还提供了很多全新的函数式接口来让工作更加方便，有一些接口是来自Google Guava库里的，
即便你对这些很熟悉了，还是有必要看看这些是如何扩展到lambda上使用的。 - Predicate接口
Predicate接口只有一个参数，返回boolean类型。该接口包含多种默认方法来
将Predicate组合成其他复杂的逻辑（比如：与，或，非）：
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate(); - Function 接口
Function 接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的
默认方法（compose, andThen）：
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123" - Supplier 接口
Supplier 接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数
Supplier<Person> personSupplier = Person::new;
personSupplier.get(); // new Person - Consumer 接口
Consumer 接口表示执行在单个参数上的操作。
Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker")); - Comparator 接口
Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法：
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0 - Optional 接口
Optional 不是函数是接口，这是个用来防止NullPointerException异常的辅助类型。
Optional 被定义为一个简单的容器，其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象
但是偶尔却可能返回了null，而在Java 8中，不推荐你返回null而是返回Optional。
创建
调用empty API，创建一个空的Optional对象：
@Test
public void whenCreatesEmptyOptional_thenCorrect() {
Optional<String> empty = Optional.empty();
assertFalse(empty.isPresent());
}
Ps: isPresent API 是用来检查Optional对象中是否有值。只有当我们创建了一个
含有非空值的Optional时才返回true。在下一部分我们将介绍这个API。
使用staticAPI创建
@Test
public void givenNonNull_whenCreatesOptional_thenCorrect() {
String name = "baeldung";
Optional<String> opt = Optional.of(name);
assertEquals("Optional[baeldung]", opt.toString());
}
然而，传递给of()的值不可以为空，否则会抛出空指针异常，如下:
@Test(expected = NullPointerException.class)
public void givenNull_whenThrowsErrorOnCreate_thenCorrect() {
String name = null;
Optional<String> opt = Optional.of(name);
}
有时我们需要传递一些空值，那我们可以使用下面这个API:
@Test
public void givenNonNull_whenCreatesNullable_thenCorrect() {
String name = "baeldung";
Optional<String> opt = Optional.ofNullable(name);
assertEquals("Optional[baeldung]", opt.toString());
}
使用ofNullable API，则当传递进去一个空值时，不会抛出异常，而只是返回一个空的Optional对象，
如同我们用Optional.empty API:
@Test
public void givenNull_whenCreatesNullable_thenCorrect() {
String name = null;
Optional<String> opt = Optional.ofNullable(name);
assertEquals("Optional.empty", opt.toString());
}
使用isPresent API 检查值
我们可以使用这个API检查一个Optional对象中是否有值，只有值非空才返回true。
@Test
public void givenOptional_whenIsPresentWorks_thenCorrect() {
Optional<String> opt = Optional.of("Baeldung");
assertTrue(opt.isPresent());
opt = Optional.ofNullable(null);
assertFalse(opt.isPresent());
}
适当情况下使用ifPresent API
传统上，我们一般这样写来检查空值:
if(name != null){
System.out.println(name.length);
}
问题在于，有时候我们会忘记了对空值进行检查，这时就可以使用这个API：
@Test
public void givenOptional_whenIfPresentWorks_thenCorrect() {
Optional<String> opt = Optional.of("baeldung");
opt.ifPresent(name -> System.out.println(name.length()));
}
orEse && orElseGet
orElse。这个API被用来检索Optional对象中的值，它被传入一个“默认参数”。如果对象中存在一个值，
则返回它，否则返回传入的“默认参数”，如下所示：
@Test
public void whenOrElseWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElse("john");
assertEquals("john", name);
}
orElseGet
与orElsel类似，但是这个函数不接收一个“默认参数”，而是一个函数接口，如下例所示：
@Test
public void whenOrElseGetWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElseGet(() -> "john");
assertEquals("john", name);
}
两者区别
要想理解这二者，首先让我们创建一个无参且返回定值的方法:
public String getMyDefault() {
System.out.println("Getting Default Value");
return "Default Value";
}
接下来，进行两个测试看看它们有什么区别:
@Test
public void whenOrElseGetAndOrElseOverlap_thenCorrect() {
String text;
System.out.println("Using orElseGet:");
String defaultText =
Optional.ofNullable(text).orElseGet(this::getMyDefault);
assertEquals("Default Value", defaultText);
System.out.println("Using orElse:");
defaultText = Optional.ofNullable(text).orElse(getMyDefault());
assertEquals("Default Value", defaultText);
}
在这里示例中，我们的Optional对象中包含的都是一个空值，让我们看看程序执行结果:
Using orElseGet:
Getting default value...
Using orElse:
Getting default value...
两个Optional对象中都不存在value，因此执行结果相同。
那么当Optional对象中值存在时又是怎样呢？
@Test
public void whenOrElseGetAndOrElseDiffer_thenCorrect() {
String text = "Text present";
System.out.println("Using orElseGet:");
String defaultText
= Optional.ofNullable(text).orElseGet(this::getMyDefault);
assertEquals("Text present", defaultText);
System.out.println("Using orElse:");
defaultText = Optional.ofNullable(text).orElse(getMyDefault());
assertEquals("Text present", defaultText);
}
让我们看看执行结果:
Using orElseGet:
Using orElse:
Getting default value...
可以看到，当使用orElseGet去检索值时，getMyDefault并不执行，因为Optional中含有值，
而使用orElse时则照常执行。所以可以看到，当值存在时，orElse相比于orElseGet，
多创建了一个对象，可能从这个实例中你感受不到影响有多大，但考虑当getDefalut
不仅仅是个简单函数，而是一个web service之类的，则多创建一个代价是比较大的。
orElseThrow
orElseThrow当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常，如下所示:
@Test(expected = IllegalArgumentException.class)
public void whenOrElseThrowWorks_thenCorrect() {
String nullName = null;
String name = Optional.ofNullable(nullName).orElseThrow(
IllegalArgumentException::new);
}
使用get()
@Test
public void givenOptional_whenGetsValue_thenCorrect() {
Optional<String> opt = Optional.of("baeldung");
String name = opt.get();
assertEquals("baeldung", name);
}
使用get() API 也可以返回被包裹着的值。但是必须是值存在时，当值不存在时，
它会抛出一个NoSuchElementException异常，如下所示:
@Test(expected = NoSuchElementException.class)
public void givenOptionalWithNull_whenGetThrowsException_thenCorrect() {
Optional<String> opt = Optional.ofNullable(null);
String name = opt.get();
}
因为这个方法与我们使用Optional的目的相违背，所以可以预见在不久将来它或许会被抛弃，
建议还是使用其他的方法。
filter()
接收一个函数式接口，当符合接口时，则返回一个Optional对象，否则返回一个空的Optional对象。
@Test
public void whenOptionalFilterWorks_thenCorrect() {
Integer year = 2016;
Optional<Integer> yearOptional = Optional.of(year);
boolean is2016 = yearOptional.filter(y -> y == 2016).isPresent();
assertTrue(is2016);
boolean is2017 = yearOptional.filter(y -> y == 2017).isPresent();
assertFalse(is2017);
}
这个API作用一般就是拒绝掉不符合条件的，比如拒绝掉错误的电子邮箱。
让我们看下一个更有意义的例子，假如我们想买一个调制解调器，并且只关心它的价格:
public class Modem {
private Double price;
public Modem(Double price) {
this.price = price;
}
//standard getters and setters
}
接下来，我们想要检查每一类调制解调器是否在我们可以承受的价格范围内，
那我们在不使用Optional时该如何做呢？
public boolean priceIsInRange1(Modem modem) {
boolean isInRange = false;
if (modem != null && modem.getPrice() != null
&& (modem.getPrice() >= 10
&& modem.getPrice() <= 15)) {
isInRange = true;
}
return isInRange;
}
我们竟然要写这么多code，尤其是if条件语句，然而对于这部分code最关键的其实是对价格范围的判断。
这是一个Test例子:
@Test
public void whenFiltersWithoutOptional_thenCorrect() {
assertTrue(priceIsInRange1(new Modem(10.0)));
assertFalse(priceIsInRange1(new Modem(9.9)));
assertFalse(priceIsInRange1(new Modem(null)));
assertFalse(priceIsInRange1(new Modem(15.5)));
assertFalse(priceIsInRange1(null));
}
如果长时间不用，那么有可能会忘记对null进行检查，那么如果使用Optional，会怎么样呢？
public boolean priceIsInRange2(Modem modem2) {
return Optional.ofNullable(modem2)
.map(Modem::getPrice)
.filter(p -> p >= 10)
.filter(p -> p <= 15)
.isPresent();
}
map()仅仅是将一个值转换为另一个值，请谨记在心，这个操作并不会改变原来的值。
让我们仔细看看这段代码，首先，当我们传入一个null时，不会发生任何问题。其次，我们在这段code所写的
唯一逻辑就如同此方法名所描述。之前的那段code为了其固有的脆弱性，必须做更多，而现在不用了。
map()
在之前的例子中，我们使用filter()来接受/拒绝一个一个值，而使用map()我们可以将一个值转换为另一个值。
@Test
public void givenOptional_whenMapWorks_thenCorrect() {
List<String> companyNames = Arrays.asList(
"paypal", "oracle", "", "microsoft", "", "apple");
Optional<List<String>> listOptional = Optional.of(companyNames);
int size = listOptional
.map(List::size)
.orElse(0);
assertEquals(6, size);
}
在这个例子中，我们使用一个List包含了一些字符串，然后再把这个List包裹起来，对其map()，
我们这里是对这个List求它的size。map()返回的结果也被包裹在一个Optional对象中，
我们必须调用合适的方法来查看其中的值。注意到filter()仅仅是对值进行一个检查
并返回一个boolean(很奇怪，照前面所述不应返回一个Optional对象吗？)，而map()
是使用现有的值进行计算，并且返回一个包裹着计算结果(映射结果)的Optional对象。
@Test
public void givenOptional_whenMapWorks_thenCorrect2() {
String name = "baeldung";
Optional<String> nameOptional = Optional.of(name);
int len = nameOptional
.map(String::length())
.orElse(0);
assertEquals(8, len);
}
将filter()与map()一起使用可以做一些很强力的事情。
假设我们现在要检查一个用户的密码，那么我们可以这样做:
@Test
public void givenOptional_whenMapWorksWithFilter_thenCorrect() {
String password = " password ";
Optional<String> passOpt = Optional.of(password);
boolean correctPassword = passOpt.filter(
pass -> pass.equals("password")).isPresent();
assertFalse(correctPassword);
correctPassword = passOpt
.map(String::trim)
.filter(pass -> pass.equals("password"))
.isPresent();
assertTrue(correctPassword);
}
注意到，如果不进行trim，则会返回false，这里我们可以使用map()进行trim。
flatmap()
有时我们可以使用flatmap()替换map()，二者不同之处在于，map()只有当值不被包裹时才进行转换，
而flatmap()接受一个被包裹着的值并且在转换之前对其解包。
我们现在有一个Person类:
public class Person {
private String name;
private int age;
private String password;
public Optional<String> getName() {
return Optional.ofNullable(name);
}
public Optional<Integer> getAge() {
return Optional.ofNullable(age);
}
public Optional<String> getPassword() {
return Optional.ofNullable(password);
}
// normal constructors and setters
}
我们可以像对待String一样将其包裹起来:
Person person = new Person("john", 26);
Optional<Person> personOptional = Optional.of(person);
注意当我们包裹一个Person对象时，它将包含一个嵌套的Optional例子:
@Test
public void givenOptional_whenFlatMapWorks_thenCorrect2() {
Person person = new Person("john", 26);
Optional<Person> personOptional = Optional.of(person);
Optional<Optional<String>> nameOptionalWrapper
= personOptional.map(Person::getName);
Optional<String> nameOptional
= nameOptionalWrapper.orElseThrow(IllegalArgumentException::new);
String name1 = nameOptional.orElse("");
assertEquals("john", name1);
String name = personOptional
.flatMap(Person::getName)
.orElse("");
assertEquals("john", name);
}
需要注意，方法getName返回的是一个Optional对象，而不是像trim那样。这样就生成了一个嵌套的
Optional对象。因此使用map，我们还需要再解包一次，而使用flatMap()就不需要了。 - Stream 接口
java.util.Stream 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种，
最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。
Stream 的创建需要指定一个数据源，比如 java.util.Collection的子类，List或者Set， Map不支持。
Stream的操作可以串行执行或者并行执行。
首先看看Stream是怎么用，首先创建实例代码的用到的数据List：
List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");
Java 8扩展了集合类，可以通过 Collection.stream() 或者 Collection.parallelStream() 来创建一个Stream。
下面几节将详细解释常用的Stream操作： - Filter 过滤
过滤通过一个predicate接口来过滤并只保留符合条件的元素，该操作属于中间操作，所以我们可以在
过滤后的结果来应用其他Stream操作（比如forEach）。forEach需要一个函数来对过滤后的元素
依次执行。forEach是一个最终操作，所以我们不能在forEach之后来执行其他Stream操作。
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println); // "aaa2", "aaa1" - Sort 排序
排序是一个中间操作，返回的是排序好后的Stream。
如果你不指定一个自定义的Comparator则会使用默认排序。
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println); // "aaa1", "aaa2"
需要注意的是，排序只创建了一个排列好后的Stream，而不会影响原有的数据源，
排序之后原数据stringCollection是不会被修改的。
System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1 - Map 映射
中间操作map会将元素根据指定的Function接口来依次将元素转成另外的对象，下面的示例
展示了将字符串转换为大写字符串。你也可以通过map来将对象转换成其他类型，
map返回的Stream类型是根据你map传递进去的函数的返回值决定的。
stringCollection
.stream()
.map(String::toUpperCase)
.sorted((a, b) -> b.compareTo(a))
.forEach(System.out::println); // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1" - Match 匹配
Stream提供了多种匹配操作，允许检测指定的Predicate是否匹配整个Stream。所有的匹配操作都是最终操作，
并返回一个boolean类型的值。
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true - Count 计数
计数是一个最终操作，返回Stream中元素的个数，返回值类型是long。
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3 - Reduce 规约
这是一个最终操作，允许通过指定的函数来将stream中的多个元素规约为一个元素，
规约后的结果是通过Optional接口表示的：
Optional<String> reduced =
stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println); // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2" - 并行Streams
前面提到过Stream有串行和并行两种，串行Stream上的操作是在一个线程中依次完成，
而并行Stream则是在多个线程上同时执行。
下面的例子展示了是如何通过并行Stream来提升性能：
首先我们创建一个没有重复元素的大表
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
然后我们计算一下排序这个Stream要耗时多久，
串行排序：
long t0 = System.nanoTime();
long count = values.stream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("sequential sort took: %d ms", millis)); // 串行耗时: 899 ms
并行排序：
long t0 = System.nanoTime();
long count = values.parallelStream().sorted().count();
System.out.println(count);
long t1 = System.nanoTime();
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("parallel sort took: %d ms", millis)); // 并行排序耗时: 472 ms
上面两个代码几乎是一样的，但是并行版的快了50%之多，
唯一需要做的改动就是将stream()改为parallelStream()。 - Map
前面提到过，Map类型不支持stream，不过Map提供了一些新的有用的方法来处理一些日常任务。
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.putIfAbsent(i, "val" + i);
}
map.forEach((id, val) -> System.out.println(val));
以上代码很容易理解， putIfAbsent 不需要我们做额外的存在性检查，
而forEach则接收一个Consumer接口来对map里的每一个键值对进行操作。
下面的例子展示了map上的其他有用的函数：
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3); // val33
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9); // false
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23); // true
map.computeIfAbsent(3, num -> "bam");
map.get(3); // val33
接下来展示如何在Map里删除一个键值全都匹配的项
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
另外一个有用的方法
map.getOrDefault(42, "not found"); // not found
对Map的元素做合并也变得很容易了：
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9); // val9
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat
Merge做的事情是如果键名不存在则插入，否则则对原键对应的值做合并操作并重新插入到map中。
九、Date API
- Java 8 在包java.time下包含了一组全新的时间日期API。新的日期API和开源的Joda-Time库差不多，
但又不完全一样，下面的例子展示了这组新API里最重要的一些部分： - Clock 时钟
Clock类提供了访问当前日期和时间的方法，Clock是时区敏感的，可以用来取代
System.currentTimeMillis() 来获取当前的微秒数。某一个特定的时间点也可以
使用Instant类来表示，Instant类也可以用来创建老的java.util.Date对象。
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // legacy java.util.Date - Timezones 时区
在新API中时区使用ZoneId来表示。时区可以很方便的使用静态方法of来获取到。
时区定义了到UTS时间的时间差，在Instant时间点对象到本地日期对象之间转换的时候是极其重要的。
System.out.println(ZoneId.getAvailableZoneIds()); // prints all available timezone ids
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules()); // ZoneRules[currentStandardOffset=+01:00]
System.out.println(zone2.getRules()); // ZoneRules[currentStandardOffset=-03:00] - LocalTime 本地时间
LocalTime 定义了一个没有时区信息的时间，例如 晚上10点，或者 17:30:15。
下面的例子使用前面代码创建的时区
创建了两个本地时间。之后比较时间并以小时和分钟为单位计算两个时间的时间差：
LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);
System.out.println(now1.isBefore(now2)); // false
long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);
System.out.println(hoursBetween); // -3
System.out.println(minutesBetween); // -239
LocalTime 提供了多种工厂方法来简化对象的创建，包括解析时间字符串。
LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late); // 23:59:59
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedTime(FormatStyle.SHORT)
.withLocale(Locale.GERMAN);
LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime); // 13:37 - LocalDate 本地日期
LocalDate 表示了一个确切的日期，比如 2014-03-11。该对象值是不可变的，用起来和LocalTime基本一致。
下面的例子展示了如何给Date对象加减天/月/年。另外要注意的是这些对象是不可变的，
操作返回的总是一个新实例。
LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
LocalDate yesterday = tomorrow.minusDays(2);
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek); // FRIDAY
从字符串解析一个LocalDate类型和解析LocalTime一样简单：
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedDate(FormatStyle.MEDIUM)
.withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas); // 2014-12-24 - LocalDateTime 本地日期时间
LocalDateTime 同时表示了时间和日期，相当于前两节内容合并到一个对象上了。LocalDateTime和LocalTime
还有LocalDate一样，都是不可变的。LocalDateTime提供了一些能访问具体字段的方法。
LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek); // WEDNESDAY
Month month = sylvester.getMonth();
System.out.println(month); // DECEMBER
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay); // 1439
只要附加上时区信息，就可以将其转换为一个时间点Instant对象，
Instant时间点对象可以很容易的转换为老式的java.util.Date。
Instant instant = sylvester
.atZone(ZoneId.systemDefault())
.toInstant();
Date legacyDate = Date.from(instant);
System.out.println(legacyDate); // Wed Dec 31 23:59:59 CET 2014
格式化LocalDateTime和格式化时间和日期一样的，除了使用预定义好的格式外，我们也可以自己定义格式：
DateTimeFormatter formatter =
DateTimeFormatter
.ofPattern("MMM dd, yyyy - HH:mm");
LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string); // Nov 03, 2014 - 07:13
和java.text.NumberFormat不一样的是新版的DateTimeFormatter是不可变的，所以它是线程安全的。
十、Annotation 注解
- 在Java 8中支持多重注解了，先看个例子来理解一下是什么意思。
首先定义一个包装类Hints注解用来放置一组具体的Hint注解：
@interface Hints {
Hint[] value();
}
@Repeatable(Hints.class)
@interface Hint {
String value();
}
Java 8允许我们把同一个类型的注解使用多次，只需要给该注解标注一下@Repeatable即可。
例 1: 使用包装类当容器来存多个注解（老方法）
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}
例 2：使用多重注解（新方法）
@Hint("hint1")
@Hint("hint2")
class Person {}
第二个例子里java编译器会隐性的帮你定义好@Hints注解，了解这一点有助于你用反射来获取这些信息：
Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint); // null
Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length); // 2
Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length); // 2
即便我们没有在Person类上定义@Hints注解，我们还是可以通过 getAnnotation(Hints.class)
来获取 @Hints注解，更加方便的方法是使用 getAnnotationsByType 可以直接获取到所有的@Hint注解。
另外Java 8的注解还增加到两种新的target上了：
@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}
扫一扫
5401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
