数字类 default 0和 default 0_04Optional类和接口中的default、static方法
這篇文章,介紹Jave8的 Optional 類和接口的 default、static 方法。
1、Optional類
Optional:Java8 java.util包中提供的一個可以包含或者不包含非null值的容器對象。
通過 Optional 我們不用顯式進行空值檢測 ( if( T == null ) )也很好的解決空指針異常
1.1 Optional API
| static?Optional?empty() | 返回一個空Optional(值為null) |
| boolean equals(Object obj) | 指示給定的對象是否 equals 此Optional的value |
| Optional?filter(Predicate super?predicate) | 如果 Optional 的值存在而且匹配給定的 predicate(斷定型函數式接口),返回當前Optional,否則返回一個空Optional(值為null) |
| Optional flatMap(Function super T,Optional> mapper) | 如果 Optional 的值存在,應用提供的映射方法并返回結果 Optional,否則返回一個空的Optional |
| T get() | 如果此 Optional 存在值,則返回值,否則拋出NoSuchElementException |
| int hashCode() | 返回當前值的哈希碼值(如果有),如果沒有值,則返回0。 |
| void ifPresent(Consumer super T> consumer) | 如果存在值,對該值應用指定的 Consumer(消費型函數式接口),否則不執行任何操作。 |
| boolean isPresent() | 如果存在值,返回true,否則返回false |
| Optional map(Function super T,? extends U> mapper) | 如果值存在,對該值應用給定的映射方法,如果是非null的結果,返回一個描述該值的 optional,否則返回一個空Optional(值為null) |
| static?Optional?of(T value) | 通過給定的value,返回一個值為給定value的Optional實例,value不能為null,若value為null,則拋出NullPointerException |
| static?Optional?ofNullable(T value) | 通過給定的value,返回一個值為給定value的Optional實例,value可為null |
| T orElse(T other) | 如果此Optional的value不為null,則返回value,否則返回給定的other對象 |
| T orElseGet(Supplier extends T> other) | 如果此Optional的value不為null,則返回value,否則通過調用給定的Supplier(供給型函數式接口)返回一個T類型的對象 |
| T orElseThrow(Supplier extends X> exceptionSupplier) | 如果此Optional的value不為null,則返回value,否則通過調用給定的Supplier創建一個Throwable |
| String toString() | 返回非空字符串表示此Optional,適用于調試。 |
項目中常用的實例方法,用于解決空指針異常
isPresent()方法,如果存在值,將返回true,否則返回false。
orElse(T other)方法,如果存在值,則返回當前Optional的value,否則返回 other
ifPresent(Consumer super T> consumer),如果存在值,對該值應用指定的 Consumer,執行代碼塊,否則不做任何操作
1.2 Optional 源碼
public final class Optional<T> {/**
* empty()方法的公共實例
*/
private static final Optional> EMPTY = new Optional<>();
/**
* Optional的值,類型為T
*/
private final T value;
/**
* 私有構造器
*/
private Optional() {
this.value = null;
}
/**
* 返回一個空Optional(值為null)
*/
public static Optionalempty() {@SuppressWarnings("unchecked")
Optional t = (Optional) EMPTY;return t;
}/**
* value為入參的構造器,value不能為null,若value為null,則拋出NullPointerException
*/private Optional(T value) {this.value = Objects.requireNonNull(value);
}/**
* 通過給定的value,返回一個值為給定value的Optional實例,value不能為null,若value為null,則拋出NullPointerException
*/public static Optionalof(T value) {return new Optional<>(value);
}/**
* 通過給定的value,返回一個值為給定value的Optional實例,value可為null,若value為null,則返回 EMPTY
*/public static OptionalofNullable(T value) {return value == null ? empty() : of(value);
}/**
* 如果此 Optional 存在值,則返回值,否則拋出NoSuchElementException
*/public T get() {if (value == null) {throw new NoSuchElementException("No value present");
}return value;
}/**
* 如果存在值 value!=null,返回true,否則返回false
*/public boolean isPresent() {return value != null;
}/**
* 如果存在值,對該值應用指定的 Consumer(消費型函數式接口),否則不執行任何操作。
*/public void ifPresent(Consumer super T> consumer) {if (value != null)
consumer.accept(value);
}/**
* 如果 Optional 的值存在而且匹配給定的 predicate(斷定型函數式接口),返回當前Optional,否則返回一個空Optional(值為null)
*/public Optionalfilter(Predicate super T> predicate) {
Objects.requireNonNull(predicate);if (!isPresent())return this;elsereturn predicate.test(value) ? this : empty();
}/**
* 如果值存在,對該值應用給定的映射方法,如果是非null的結果,返回一個描述該值的 optional,否則返回一個空Optional(值為null)
*/public Optional map(Function super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);if (!isPresent())return empty();else {return Optional.ofNullable(mapper.apply(value));
}
}/**
* 如果 Optional 的值存在,應用提供的映射方法并返回結果Optional,否則返回一個空的Optional
*/public Optional flatMap(Function super T, Optional> mapper) {
Objects.requireNonNull(mapper);if (!isPresent())return empty();else {return Objects.requireNonNull(mapper.apply(value));
}
}/**
* 如果此Optional的value不為null,則返回value,否則返回給定的other對象
*/public T orElse(T other) {return value != null ? value : other;
}/**
* 如果此Optional的value不為null,則返回value,否則通過調用給定的Supplier(供給型函數式接口)返回一個T類型的對象
*/public T orElseGet(Supplier extends T> other) {return value != null ? value : other.get();
}/**
* 如果此Optional的value不為null,則返回value,否則通過調用給定的Supplier創建一個Throwable
*/public T orElseThrow(Supplier extends X> exceptionSupplier) throws X {if (value != null) {return value;
} else {throw exceptionSupplier.get();
}
}/**
* 指示給定的對象是否 equals 此Optional的value
*/@Overridepublic boolean equals(Object obj) {if (this == obj) {return true;
}if (!(obj instanceof Optional)) {return false;
}
Optional> other = (Optional>) obj;return Objects.equals(value, other.value);
}/**
* 返回當前值的哈希碼值(如果有),如果沒有值,則返回0。
*/@Overridepublic int hashCode() {return Objects.hashCode(value);
}/**
* 返回非空字符串表示此Optional,適用于調試。
*/@Overridepublic String toString() {return value != null
? String.format("Optional[%s]", value)
: "Optional.empty";
}
}
1.3 Optional 簡單使用
public class Person {
//姓名
private String name;
//年齡
private long age;
public Person(String name, long age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getAge() {
return age;
}
public void setAge(long age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
@Test
public void test() {
Person p = new Person("張三", 18);
// 通過給定的value,返回一個值為給定value的Optional實例,若value為null,則拋出NullPointerException
// Optional o = Optional.of(null);
Optional opPerson = Optional.of(p);
System.out.println("of(T value): " + opPerson);// 通過給定的value,返回一個值為給定value的Optional實例,value可為null,若value為null,則返回 Optional.EMPTY
Optional opNull = Optional.ofNullable(null);
System.out.println("ofNullable(T value): " + opNull);// 如果此 Optional 存在值,則返回值,否則拋出NoSuchElementException// Person person = opNull.get();// 拋出NoSuchElementException
Person person = opPerson.get();
System.out.println("T get(): " + person);// 如果存在值 value!=null,返回true,否則返回falseboolean opNullPresent = opNull.isPresent();
System.out.println("opNull persent: " + opNullPresent);if (!opNull.isPresent()) {
System.out.println("opNull 的 value == null");
} else {
System.out.println("opNull 的 value = " + opNull.get());
}boolean opPersonPresent = opPerson.isPresent();
System.out.println("opPerson persent: " + opPersonPresent);// 如果 opPerson 的 value != null,輸出下面語句
opPerson.ifPresent(value -> System.out.println(value.getName() + "的年齡是" + value.getAge()));// 如果 Optional 的值存在而且匹配給定的 predicate(斷定型函數式接口),返回當前Optional,否則返回一個空Optional(值為null)
System.out.println("opNull.filter(): " + opNull.filter(value -> value.getAge() == 18));
System.out.println("opPerson.filter() 匹配age==18: " + opPerson.filter(value -> value.getAge() == 18));
System.out.println("opPerson.filter() 匹配age==19: " + opPerson.filter(value -> value.getAge() == 19));// 如果值存在,對該值應用給定的映射方法,如果是非null的結果,返回一個描述該值的 optional,否則返回一個空Optional(值為null)// Person::getName 方法引用等同于 lambda表達式:value->value.getName()// Function funcGetName = value->value.getName();
Function funcGetName = Person::getName;
Optional opNameofOpNull = opNull.map(funcGetName);
Optional opNameofOpPerson = opPerson.map(funcGetName);
System.out.println("opNull.map(): " + opNameofOpNull);
System.out.println("opPerson.map(): " + opNameofOpPerson);// 如果 Optional 的值存在,應用提供的映射方法并返回結果 Optional,否則返回一個空的Optional
Optional op1 = opNull.flatMap(value -> Optional.of(new Person("李四", 20)));
Optional op2 = opPerson.flatMap(value -> Optional.of(new Person("李四", 20)));
System.out.println("opNull.flatMap(): " + op1);
System.out.println("opPerson.flatMap(): " + op2);// 如果此Optional的value不為null,則返回value,否則返回給定的other對象
Person wangwu = new Person("王五", 25);
System.out.println("opNull.orElse(): " + opNull.orElse(wangwu));
System.out.println("opPerson.orElse(): " + opPerson.orElse(wangwu));// 如果此Optional的value不為null,則返回value,否則通過調用給定的Supplier(供給型函數式接口)返回一個T類型的對象
Supplier supplier = () -> new Person("趙六", 26);
System.out.println("opNull.orElseGet(): " + opNull.orElseGet(supplier));
System.out.println("opPerson.orElseGet(): " + opPerson.orElseGet(supplier));// 如果此Optional的value不為null,則返回value,否則通過調用給定的Supplier創建一個Throwable
Supplier nullPointerExceptionSupplier = () -> new NullPointerException("value is null");
System.out.println("opPerson.orElseThrow(): " + opPerson.orElseThrow(nullPointerExceptionSupplier));
System.out.println("opNull.orElseThrow(): " + opNull.orElseThrow(nullPointerExceptionSupplier));
}
運行結果:
of(T value): Optional[Person{name='張三', age=18}]ofNullable(T value): Optional.empty
T get(): Person{name='張三', age=18}
opNull persent: false
opNull 的 value == null
opPerson persent: true
張三的年齡是18
opNull.filter(): Optional.empty
opPerson.filter() 匹配age==18: Optional[Person{name='張三', age=18}]
opPerson.filter() 匹配age==19: Optional.empty
opNull.map(): Optional.empty
opPerson.map(): Optional[張三]
opNull.flatMap(): Optional.empty
opPerson.flatMap(): Optional[Person{name='李四', age=20}]
opNull.orElse(): Person{name='王五', age=25}
opPerson.orElse(): Person{name='張三', age=18}
opNull.orElseGet(): Person{name='趙六', age=26}
opPerson.orElseGet(): Person{name='張三', age=18}
opPerson.orElseThrow(): Person{name='張三', age=18}
java.lang.NullPointerException: value is null
at com.xander.java8._optional.OptionalTest.lambda$test$7(OptionalTest.java:83)
at java.util.Optional.orElseThrow(Optional.java:290)
...
2 接口的增強:default 和 static 方法
2.1 default方法
java8中允許接口中包含具有具體實現的方法,用default關鍵字修飾,這類型方法稱為“默認方法”。
不用被default關鍵字嚇到,default?方法也是普通方法,只不過它遵循?"類優先"?原則(下面介紹)
我們看JDK源碼時,可以經常看到 default 方法,如?Consumer類:
@FunctionalInterfacepublic interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
/**
* 這就是一個default方法
*/
default ConsumerandThen(Consumer super T> after) {
Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };
}
}
default方法的調用遵循?"類優先"?原則
接口中定義了default方法,如果實現類中重寫了該方法,則調用的是實現類中重寫后的方法,如果實現類中沒有重寫default方法,則執行的是接口中定義的default方法。
如果實現類實現了一個接口和繼承了一個父類,接口的默認方法和父類中某一個方法具有相同名稱和參數列表,而且實現類沒有進行該方法的重寫,則使用的是父類的方法。
方法沖突,實現類中實現了兩個接口,這兩個接口中具有相同名稱和參數列表的方法(不管是不是default方法),如果實現類中沒有對default方法進行重寫,則編譯出錯。實現類中必須必須重寫覆蓋該方法來解決沖突。
2.2 default方法簡單使用
public interface DefaultIntf {/**
* default 方法
*/
default void sayHello() {
System.out.println("DefaultIntf say hello 2 you");
}
}
public interface SayHelloIntf {
/**
* default 方法
*/
default void sayHello() {
System.out.println("SayHelloIntf hello");
}
}
public class Animal {
public void sayHello() {
System.out.println("Animal say hello");
}
}
public class Cat implements DefaultIntf {
@Override
public void sayHello() {
System.out.println("Hello I am Cat sayHello");
}
}
public class Dog implements DefaultIntf {
}
public class Bird extends Animal implements DefaultIntf {
}
public class Fish implements SayHelloIntf, DefaultIntf {
/**
* **方法沖突**,類中實現了兩個接口,這兩個接口中具有相同名稱和參數列表的方法(不管是不是default方法),
* 如類中沒有對default方法進行重寫,則編譯出錯。子類中必須必須覆蓋該方法來解決沖突。
*/
@Override
public void sayHello() {
System.out.println("Hello this is Fish");
}
}
@Test
public void testDefaultMethod() {
DefaultIntf dog = new Dog();
DefaultIntf cat = new Cat();
Bird bird = new Bird();
Fish fish = new Fish();
// 執行默認方法
// 實現類中沒有重寫default方法,執行的是接口中的default
dog.sayHello();
// 實現類中對default進行重寫,則執行的是重寫后的方法
cat.sayHello();
// 如果類實現了一個接口和繼承了一個父類,接口的默認方法和父類中某一個方法具有相同名稱和參數列表,而且子類沒有進行該方法的重寫,則使用的是父類的方法。
bird.sayHello();
// 類中實現了兩個接口,這兩個接口中具有相同名稱和參數列表的方法(不管是不是default方法),子類中必須必須覆蓋該方法,否則編譯異常。
fish.sayHello();
}
運行結果:
DefaultIntf say hello 2 youHello I am Cat sayHello
Animal say hello
Hello this is Fish
2.3 項目實戰場景
獲取接口實例的泛型Class
/*** Description: 接口:包含一個default方法,該接口所有的實例都可以通過該default獲取泛型類型
*
* @author Xander
* datetime: 2020/9/7
*/
public interface GenericIntf<T> {
/**
* 默認方法:獲取泛型T的 Class
*
* @return
*/
default ClassgetGenericClass() {
Type[] types = this.getClass().getGenericInterfaces();
ParameterizedType parameterizedType = (ParameterizedType) types[0];
Class tClass = (Class) parameterizedType.getActualTypeArguments()[0];return tClass;
}
}/**
* Description: GenericIntf的實現類,泛型類型是Double
*
* @author Xander
* datetime: 2020/9/7
*/public class GenericDouble implements GenericIntf<Double> {
}/**
* Description: GenericIntf的實現類,泛型類型是Integer
*
* @author Xander
* datetime: 2020/9/7
*/public class GenericInteger implements GenericIntf<Integer> {
}@Testpublic void testGeneric() {// 獲取 GenericIntf接口實例的 泛型類型
GenericIntf genericInt = new GenericInteger();
GenericIntf genericDouble = new GenericDouble();
Class genericIntClass = genericInt.getGenericClass();//泛型類型是 Integer
Class genericDoubleClass = genericDouble.getGenericClass();//泛型類型是 Double
System.out.println("GenericInteger的泛型類型:" + genericIntClass);
System.out.println("genericDouble的泛型類型:" + genericDoubleClass);
}
運行結果:
GenericInteger 的泛型類型:class java.lang.IntegerGenericDouble 的泛型類型:class java.lang.Double
2.4 static 方法簡單使用
java8允許接口像普通類一樣定義和使用靜態方法。
public interface StaticIntf {static void printInfo() {
System.out.println("執行接口中的static方法:" + StaticIntf.class);
}
}
@Test
public void test(){
// 執行接口中 static 方法
StaticIntf.printInfo();
}
運行結果:
執行接口中的static方法:interface com.xander.java8._06default_static_method.StaticIntf結語:?Optional類和接口的default、static可以作為很好的編程手段用來實現業務邏輯,Optional可以優雅地解決空指針異常,而接口的default和static方法,能夠讓我們定義在接口層級公共的方法,希望Java8的這兩個特性能夠幫助到大家。
代碼:
https://github.com/wengxingxia/001java8.git
[慕課手記同步:04-Optional類和接口中的default、static方法]?https://www.imooc.com/article/310370
提示:?根據相關法律法規和平臺規則要求,自2018年2月12日起,新注冊的微信公眾帳號無法再開通留言功能。
有問題或希望交流的朋友,可以到 [慕課手記同步:04-Optional類和接口中的default、static方法]?https://www.imooc.com/article/310370?下評論留言,一起學習進步。
歡迎關注公眾號"黑桃"
總結
以上是生活随笔為你收集整理的数字类 default 0和 default 0_04Optional类和接口中的default、static方法的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: 【ES11(2020)】String 扩
- 下一篇: python3.6.5安装tensorf