package com.lyzx.concurrent.java8;

import org.junit.Test;

import java.util.Optional;

import java.util.Random;

public class OptionalTest {

/**

* Optional.of(T t)创建一个Optional

* >> 底层有一个泛型T的value，如果t不是null就赋值给value

* isPresent()判断是否存在

* >> return value != null

* get() 获取泛型T的实例t

* >>如果value != null 就返回value，否则抛出异常

* Optional.empty()返回一个空Optional对象

*

*/

@Test

public void test1(){

Optional op1 = Optional.of(new Java8("first"));

System.out.println(op1.get()+" "+op1.isPresent());

Optional op2 = Optional.empty();

System.out.println(op2.isPresent()+" "+ op2.get());

}

/**

* Optional.ofNullable(T t)

* >> return value == null ? empty() : of(value)

*

*/

@Test

public void test2(){

// Optional op1 = Optional.ofNullable(new Java8("王二狗"));

Java8 j = null;

Optional op1 = Optional.ofNullable(j);

System.out.println(op1.isPresent()+" "+op1.isPresent());

System.out.println(op1.orElse(new Java8("李铁蛋")));

}

/**

* orElseGet(fun) 如果isPresent()==false 通过一个函数生成一个泛型T的对象t

*/

@Test

public void test3(){

Java8 j = null;//new Java8("AA");//null;

Optional op1 = Optional.ofNullable(j);

Java8 j2 = op1.orElseGet(()->{

String[] arr = {"王大锤","张铁蛋","大球娃"};

Random rand = new Random();

return new Java8(arr[rand.nextInt(arr.length)]);

});

System.out.println(j2);

}

@Test

public void test4(){

Man man = new Man("余承东",new TargetPhone("P20 Pro"));

String phoneName = TralditionalMethod(man);

System.out.println(phoneName);

System.out.println(TralditionalMethod(null));

}

/**

* 通过传统的方式获取一个嵌套对象中的属性

* 需要不停的判断某个属性是否为null

* @param man

* @return

*/

public String TralditionalMethod(Man man){

if(null != man){

TargetPhone phone = man.getPhone();

if(null != phone){

String phoneName = phone.getPhoneName();

return phoneName;

}

}

return "小米Mix2S";

}

@Test

public void test5(){

// XMan xman = new XMan("罗永浩",Optional.of(new TargetPhone("锤子T3")));

// Optional op = Optional.ofNullable(xman);

Optional op = Optional.empty();

System.out.println(newMethod(op));

}

/**

* 通过新方式获取某个属性的值，

* 需要改造类的属性，把其有可能出现null的属性封装为Optional

* @param man

* @return

*/

public String newMethod(Optional man){

return man.orElse(new XMan("雷军",Optional.of(new TargetPhone("小米Mix2S"))))

.getPhone()

.get()

.getPhoneName();

}

/**

* 测试 ifPresent 方法

* 只有在op不为空时才执行,为空是不执行

*/

@Test

public void test6(){

String data = null;//"1,2,3";

Optional op = Optional.ofNullable(data);

op.ifPresent(x->{

for(String v : x.split(",")){

System.out.println("--"+v);

}

});

if(op.isPresent())

System.out.println(op.get());

}

/**

* orElse()和orElseGet()方法都是op不为空时返回get()的值，为空时返回参数里面的值

* 不同点在于

* orElse()方法op是不是为空，都会执行参数参入的方法

* orElseGet()方法在对象不为空时直接返回get()的值

*

* orElseThrow()当op为空时直接抛出异常

*/

@Test

public void test7(){

String data = null;

// String data = "youzhi";

Optional op = Optional.ofNullable(data);

String other = op.orElse(getStr());

System.out.println("1:"+other);

System.out.println("===================");

String elseGet = op.orElseGet(()->getStr());

System.out.println("2:"+elseGet);

op.orElseThrow(()->new IllegalArgumentException("参数为空"));

}

public String getStr(){

System.out.println("getStr()被调用......");

return "getStrValue";

}

/**

* map()和flatMap()方法在不为空时调用

*/

@Test

public void test8(){

Man man = new Man("提姆库克",new TargetPhone("iphoneX"));

// Man man = null;

Optional op = Optional.ofNullable(man);

String ss = op.map(x -> x.getManName()).orElseGet(() -> "默认值");

System.out.println(ss);

TargetPhone t3 = op.map(x -> x.getPhone()).orElseGet(() -> new TargetPhone("T3"));

System.out.println(t3.getPhoneName());

}

/**

* Optional的常用方法举例

* 这样做比较好的是看着很清爽而且没有烦人的空指针异常

*/

@Test

public void test9(){

// Man man = new Man("提姆库克",new TargetPhone("iphoneX"));

Man man = null;

Optional op = Optional.ofNullable(man);

String iphoneName = op.map(x->x.getPhone())

.map(x->x.getPhoneName())

.orElse("默认值");

System.out.println(iphoneName);

}

/**

* filter的过滤作用

*/

@Test

public void test10(){

Man man = new Man("提姆库克",new TargetPhone("iphoneX"));

Optional op = Optional.ofNullable(man);

Optional phone = op.map(x -> x.getPhone())

.filter(x -> x.getPhoneName().length() > 5);

System.out.println(phone.orElse(new TargetPhone("最好的战斗机")).getPhoneName());

}

}

class Java8{

private String name;

public Java8(String name){

this.name = name;

}

@Override

public String toString() {

return "Java8{" +

"name='" + name + '\'' +

'}';

}

}

class Man{

private String manName;

private TargetPhone phone;

public Man(String manName,TargetPhone phone){

this.manName=manName;

this.phone = phone;

}

public String getManName() {

return manName;

}

public TargetPhone getPhone() {

return phone;

}

@Override

public String toString() {

return "Man{" +

"manName='" + manName + '\'' +

", phone=" + phone +

'}';

}

}

class TargetPhone{

private String phoneName;

public TargetPhone(String phoneName){

this.phoneName = phoneName;

}

public String getPhoneName(){

return phoneName;

}

}

class XMan{

private String manName;

private Optional phone;

public XMan(String manName,Optional phone){

this.manName = manName;

this.phone = phone;

}

public String getManName() {

return manName;

}

public Optional getPhone() {

return phone;

}

@Override

public String toString() {

return "XMan{" +

"manName='" + manName + '\'' +

", phone=" + phone +

'}';

}

}