Optional类

Author: MyHerux

src/main/java/com/xu/java8/interface_new/Formula.java

@@ -18,4 +18,20 @@ public Person(String firstName, String lastName) {
     public String toString(){
         return firstName+lastName;
     }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
 }

src/main/java/com/xu/java8/lambda/Person.java

@@ -0,0 +1,40 @@
+package com.xu.java8.stream;
+
+import com.xu.java8.lambda.Person;
+
+import java.util.Optional;
+
+/**
+ * Class java8-Optional类:解决空引用的问题
+ *
+ * @author hua xu
+ * @version 1.0.0
+ * @date 16/08/31
+ */
+public class Optional1 {
+    public static void main(String[] args) {
+
+        /**创建一个空Optional对象*/
+        Optional<String> optional = Optional.empty();
+
+        /**创建Optional对象有一个非空值*/
+        Person person = new Person("xu","hua");
+        Optional<Person> optional2 = Optional.of(person);//如果person是null，将会立即抛出，而不是访问person的属性时获得一个潜在的错误
+        System.out.println(optional2);
+
+        /**判断对象是否存在*/
+        System.out.println(optional.isPresent());
+        System.out.println(optional2.isPresent());
+
+        /**获取Optional里面的值*/
+        System.out.println(optional2.get());
+
+        /**如果Optional为空返回默认值*/
+        System.out.println(optional.orElse("fallback"));
+        optional.ifPresent(System.out::println);
+        optional2.ifPresent(System.out::println);
+    }
+}
+
+
+

src/main/java/com/xu/java8/stream/Optional1.java

@@ -0,0 +1,70 @@
+package com.xu.java8.stream;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+
+/**
+ * Created by xu on 2016/8/31.
+ */
+public class Optional2 {
+    static class Outer {
+        Nested nested = new Nested();
+
+        public Nested getNested() {
+            return nested;
+        }
+    }
+
+    static class Nested {
+        Inner inner = new Inner();
+
+        public Inner getInner() {
+            return inner;
+        }
+    }
+
+    static class Inner {
+        String foo = "boo";
+
+        public String getFoo() {
+            return foo;
+        }
+    }
+
+    public static void main(String[] args) {
+        test1();
+        test2();
+        test3();
+    }
+
+    public static <T> Optional<T> resolve(Supplier<T> resolver) {
+        try {
+            T result = resolver.get();
+            return Optional.ofNullable(result);
+        } catch (NullPointerException e) {
+            return Optional.empty();
+        }
+    }
+
+    private static void test3() {
+        Outer outer = new Outer();
+        resolve(() -> outer.getNested().getInner().getFoo())
+                .ifPresent(System.out::println);
+    }
+
+    private static void test2() {
+        Optional.of(new Outer())
+                .map(Outer::getNested)
+                .map(Nested::getInner)
+                .map(Inner::getFoo)
+                .ifPresent(System.out::println);
+    }
+
+    private static void test1() {
+        Optional<Outer> optional=Optional.of(new Outer());
+        optional.flatMap(o -> Optional.ofNullable(o.nested))
+                .flatMap(n -> Optional.ofNullable(n.inner))
+                .flatMap(i -> Optional.ofNullable(i.foo))
+                .ifPresent(System.out::println);
+    }
+}