Java 空值对象强制类型转换 java中空类型参数

Java1.8新特性学习

第一部分:Optional

简单介绍Optional的API

• empty:返回一个空的Optional对象
• of:入参:Object,返回一个Optional对象,如果入参是一个null,就会报空指针异常
• ofNullable:入参Object,返回一个Optional对象,如果入参是一个null,会返回一个空的Optional对象
• get: 如果Optional对象中有值就返回相应的值,如果没有值就报空指针异常
• orElse:入参:Object,如果Optional对象中有个值得话,就返回这个值,不会返回入参;如果没有值,就会返回入参

测试代码:
Optional<Object> empty = Optional.ofNullable(null);
System.out.println("empty:"+empty.orElse("李四"));
Optional<String> optional = Optional.ofNullable("张三");
System.out.println("optional:"+optional.orElse("zhangsan"));
结果:
empty:李四
optional:张三

• orElseGet :入参Supplier,如果optional对象中有数据,就会返回这个值,不会返回入参;如果没有值,就会返回入参

//测试orElseGet功能
System.out.println("==================测试orElseGet功能======================");
Optional<Object> empty_orElseGet = Optional.ofNullable(null);
System.out.println("empty:"+empty.orElseGet(()->"李四"));
Optional<String> optional_orElseGet = Optional.ofNullable("张三");
System.out.println("optional:"+optional.orElseGet(()->"zhangsan"));
结果:
empty:李四
optional:张三
源码:
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}

• orElseThrow:入参:指定一个异常;如果optional对象中有数据,就会返回这个值,不会报异常信息,如果没有值,就会报指定的异常信息

//测试orElseThrow功能
System.out.println("==================测试orElseThrow功能======================");
Optional<String> optional_orElseThrow = Optional.ofNullable("张三");
System.out.println("optional_orElseThrow:"+optional.orElseThrow(RuntimeException::new));
Optional<Object> empty_orElseThrow = Optional.ofNullable(null);
System.out.println("empty_orElseThrow:"+empty.orElseThrow(RuntimeException::new));

• filter:入参Predicate,如果optional中的值满足条件,就返回一个含有这个值得optional对象,否则返回一个空的option对象

System.out.println("==================测试filter功能======================");
Optional<String> stringOptional = Optional.ofNullable("zhangsan");
System.out.println(stringOptional.filter(temp->temp.length()>5));
stringOptional=Optional.empty();
System.out.println(stringOptional.filter(temp->temp.length()>5));
结果:
zhangsan
Optional.empty

• filter注意事项:Optional中的filter方法和Stream中的filter方法是有点不一样的，Stream中的filter方法是对一堆元素进
  行过滤，而Optional中的filter方法只是对一个元素进行过滤，可以把Optional看成是最多只包含一个元素
  的Stream
• map:如果Option对象中有值可以对其进行修改,.返回值是一个含有这个值得Optional对象

//测试map功能
System.out.println("==================测试map功能======================");
Optional<String> stringOptional_map = Optional.ofNullable("zhangsan");
System.out.println(stringOptional_map.map(temp->temp.toUpperCase()).orElse("失败"));
stringOptional_map=Optional.empty();
System.out.println(stringOptional.map(temp->temp.toUpperCase()).orElse("失败"));
结果:
ZHANGSAN
失败

• flagMap:如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，否
  则就返回一个空的Optional对象.flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回
  值必须是Optional，map方法的mapping函数返回值可以是任何类型T。调用结束时，flatMap不会对结果
  用Optional封装。

System.out.println("==================测试flagMap功能======================");
Optional<String> stringOptional_flagMap = Optional.ofNullable("zhangsan");
System.out.println(stringOptional_flagMap.flatMap(temp-> Optional.of("list")));
stringOptional_flagMap=Optional.ofNullable(null);
System.out.println(stringOptional_flagMap.flatMap(temp-> Optional.of("list")));

• ifPresent://ifPresent方法的参数是一个Consumer的实现类，Consumer类包含一个抽象方法，该抽象方法对传入的值进行处理，只处理没有返回值。

Optional stringOptional = Optional.of(“zhangsan”); 
stringOptional.ifPresent(e-> System.out.println(“我被处理了。。。”+e));

第二部分:Lambda表达式

Lambda 基本语法

(parameters) -> expression
或
(parameters) ->{ statements; }

- 做几点说明:
1. 可选的参数声明:可以声明参数的类型,编辑器可以统一识别
2. 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
3. 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
4. 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

第一个实例:开启一个线程

//第一个例子,开启一个线程
new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println(addNum(1,2));
        }
    }).start();
    new Thread(()-> System.out.println(addNum(1,2))).start();
//私有方法
private static int addNum(int arg1,int arg2){
    return arg1+arg2;
}

第二个例子:使用表示对集合进行迭代

//对集合进行迭代
    List<Integer> list = list();
    for (Integer integer : list) {
        System.out.println(integer);
    }

    list.forEach(System.out::println);
//生成一个随机数集合
private static List<Integer> list (){
    List<Integer> listNum = new ArrayList<>();
    for (int i= 0 ; i<10 ;i++){
        int  random = new Random().nextInt(100);
        listNum.add(random);
    }
    return listNum;
}

第三个例子:使用表达式filter过滤

** List<String> list = stringList();
    list.forEach(System.out::println);
    //过滤的条件
    Predicate<String>startWith=(n)->n.length()>3;
    list.stream().filter(startWith).collect(Collectors.toList()).forEach(System.out::println);**
//随机生成一个字符串
private static String string(){

    String str ="ABCDEFGHIJKMNOPQRSTUVWSYZ";
    StringBuilder stringBuilder = new StringBuilder();
    int r = new Random().nextInt(5);
    for (int i = 0; i <r+1 ; i++) {
       int random = new Random().nextInt(str.length());
        char charAt = str.charAt(random);
        stringBuilder.append(charAt);
    }
    return stringBuilder.toString();
}
//生成一个字符创的集合
private static List<String> stringList(){
    List<String> list = new ArrayList<>();
    for (int i = 0; i <10 ; i++) {
        list.add(string());
    }
    return list;
}