精华内容
下载资源
问答
  • Java 优雅判空的方法

    2020-10-29 13:54:49
    为了避免 NullPointerException 出现,我们经常会进行如下操作。 if (object != null) { object.do(); } 那么每次使用一个不确定的对象,都需要进行一次...当然我们可以使用 JDK8 提供的 Optional 来避免判空,但是

    为了避免 NullPointerException 出现,我们经常会进行如下操作。

    if (object != null) {
        object.do();
    }
    

    那么每次使用一个不确定的对象,都需要进行一次判空。so:
    在这里插入图片描述
    可能你会想,项目中肯定不止你一个人会这样一顿操作,然后按下 Ctrl+Shift+F,真相就在眼前:
    在这里插入图片描述
    What,我们有接近一万行的代码都是在判空?

    那么我们不禁会想有什么办法可以避免在代码中写大量的判空语句呢?

    当然我们可以使用 JDK8 提供的 Optional 来避免判空,但是用起来还是有些麻烦。

    进入正题,这里将依托于一个小需求来介绍一个封装工具类,可以实现链式调用对象成员而无需判空,相比原有的if null 逻辑 和 JDK8 提供的 Optional 更加优雅易用,在工程实践中大大提高了编码效率,也让代码更加的精准和优雅。

    需求介绍

    我们有一个 User 类,里面有成员变量 School 类,School 类有字符串类型的成员变量 scName

    而我们的需求就是通过 User 对象,获取其内的 School 对象的 scName 学校名称值。此时我们势必要判断 User 对象和其内的 School 对象是否为空,才能直接获取 scName 值。

    /**
    * @author cjh
    * @date Created on 2020/10/29
    * @summary 一个 User 类定义
    * (Ps:Data 是lombok组件提供的注解,简化了get set等等的约定代码)
    */
    @Data
    public class User {
    
        private String name;
    
        private String gender;
    
        private School school;
    }
    
    @Data
    public static class School {
    
        private String scName;
    
        private String adress;
    }
    

    不优雅的判空调用

    现在想要获得School的成员变量 adress , 一般的处理方式:

    /**
     * @author cjh
     * @date Created on 2020/10/21
     * @summary 获取 User 类的 School 对象的校名值
     */
    public class Test {
        public static void main(String[] args) throws Exception {
            User cjh = new User();
            School school = new School();
            cjh.setSchool(school);
            school.setAdress("林伟华中学");
    
            if (Objects.nonNull(cjh) && Objects.nonNull(cjh.getSchool())) {
                School cjhSc = cjh.getSchool();
                System.out.println(userSc.getAdress());
            }
        }
    }
    

    OptionalBean 工具类

    /**
    * @author cjh
    * @since 2020-10-29
    * @summary 链式调用 bean 中 value 的方法
    */
    public final class OptionalBean<T> {
    	
        private static final OptionalBean<?> EMPTY = new OptionalBean<>();
    
        private final T value;
    
        private OptionalBean() {
            this.value = null;
        }
    
        /**
         * 空值会抛出空指针
         * @param value
         */
        private OptionalBean(T value) {
            this.value = Objects.requireNonNull(value);
        }
    
        /**
         * 包装一个不能为空的 bean
         * @param value
         * @param <T>
         * @return
         */
        public static <T> OptionalBean<T> of(T value) {
            return new OptionalBean<>(value);
        }
    
        /**
         * 包装一个可能为空的 bean
         * @param value
         * @param <T>
         * @return
         */
        public static <T> OptionalBean<T> ofNullable(T value) {
            return value == null ? empty() : of(value);
        }
    
        /**
         * 取出具体的值
         * @param fn
         * @param <R>
         * @return
         */
        public T get() {
            return Objects.isNull(value) ? null : value;
        }
    
        /**
         * 取出一个可能为空的对象
         * @param fn
         * @param <R>
         * @return
         */
        public <R> OptionalBean<R> getBean(Function<? super T, ? extends R> fn) {
            return Objects.isNull(value) ? OptionalBean.empty() : OptionalBean.ofNullable(fn.apply(value));
        }
    
        /**
         * 如果目标值为空 获取一个默认值
         * @param other
         * @return
         */
        public T orElse(T other) {
            return value != null ? value : other;
        }
    
        /**
         * 如果目标值为空 通过lambda表达式获取一个值
         * @param other
         * @return
         */
        public T orElseGet(Supplier<? extends T> other) {
            return value != null ? value : other.get();
        }
    
        /**
         * 如果目标值为空 抛出一个异常
         * @param exceptionSupplier
         * @param <X>
         * @return
         * @throws X
         */
        public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
            if (value != null) {
                return value;
            } else {
                throw exceptionSupplier.get();
            }
        }
    
        public boolean isPresent() {
            return value != null;
        }
    
        public void ifPresent(Consumer<? super T> consumer) {
            if (value != null)
                consumer.accept(value);
        }
    
        @Override
        public int hashCode() {
            return Objects.hashCode(value);
        }
    
        /**
         * 空值常量
         * @param <T>
         * @return
         */
        public static<T> OptionalBean<T> empty() {
            @SuppressWarnings("unchecked")
            OptionalBean<T> none = (OptionalBean<T>) EMPTY;
            return none;
        }
    
    }
    

    工具设计主要参考了 Optional 的实现,再加上对链式调用的扩展就是上述的OptionalBean。

    getBean 其实是当变量为空时返回了一个 包装空值的 OptionalBean 对象,同时泛型的使用让工具更加易用。

    链式调用成员变量:

    public static void main(String[] args) {
        User cjh = new User();
        School school = new School();
        cjh.setSchool(school);
        school.setAdress("林伟华中学");
    
        // 1. 基本调用
        String value1 = OptionalBean.ofNullable(cjh)
                .getBean(User::getSchool)
                .getBean(School::getAdress)
                .get();
        System.out.println(value1);
    
        // 2. 扩展的 isPresent方法 用法与 Optional 一样
        boolean present = OptionalBean.ofNullable(cjh)
                .getBean(User::getSchool)
                .getBean(School::getAdress)
                .isPresent();
        System.out.println(present);
    
        // 3. 扩展的 ifPresent 方法
        OptionalBean.ofNullable(cjh)
                .getBean(User::getSchool)
                .getBean(School::getAdress)
                .ifPresent(address -> System.out.println(String.format("地址存在:%s", address)));
    
        // 4. 扩展的 orElse
        String value2 = OptionalBean.ofNullable(cjh)
                .getBean(User::getSchool)
                .getBean(School::getAdress)
                .orElse("搬砖打工");
        System.out.println(value2);
    
        // 5. 扩展的 orElseThrow
        try {
            String value3 = OptionalBean.ofNullable(cjh)
                    .getBean(User::getSchool)
                    .getBean(School::getAdress)
                    .orElseThrow(() -> new RuntimeException("空指针了"));
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    
    展开全文
  • Java8 优雅判空

    2020-11-20 10:54:55
    推荐一个优雅的工具类,可以可以链式调用对象成员而无需判空,相比原有的if null逻辑 和 JDK8提供的 Optional 更加优雅易用,在工程实践中大大提高了编码效率,也让代码更加的精准和优雅。 日常编写的不优雅的判空调...

    对于Java程序员来说,null是令人头痛的东西。时常会受到空指针异常(NPE)的骚扰。连Java的发明者都承认这是他的一项巨大失误。

    那么,有什么办法可以避免在代码中写大量的判空语句呢?

    有人说可以使用 JDK8提供的 Optional 来避免判空,但是用起来还是有些麻烦。

    推荐一个优雅的工具类,可以可以链式调用对象成员而无需判空,相比原有的if null逻辑 和 JDK8提供的 Optional 更加优雅易用,在工程实践中大大提高了编码效率,也让代码更加的精准和优雅。

    日常编写的不优雅的判空调用

    各种if让人抓狂,现在有个User类,School 是它的成员变量

    @Data
    
    public class User {
    
        private String name;
    
        private String gender;
    
        private School school;
    
        @Data
    
        public static class School {
    
            private String scName;
    
            private String adress;
    
        }
    
    }
    

    现在想要获得School的成员变量 adress , 一般的处理方式:

    public static void main(String[] args) {
    
        User axin = new User();
    
        User.School school = new User.School();
    
        axin.setName("hello");
    
        if (Objects.nonNull(axin) && Objects.nonNull(axin.getSchool())) {
    
            User.School userSc = axin.getSchool();
    
            System.out.println(userSc.getAdress());
    
        }
    
    }
    

    获取adress时要对School进行判空,虽然有些麻烦,到也能用,通过 JDK8 提供的 Optional 工具也是可以,但还是有些麻烦。
    而下文的 OptionalBean 提供一种可以链式不断地调用成员变量而无需判空的方法,直接链式调用到你想要获取的目标变量,而无需担心空指针的问题。

    链式调用成员变量

    如果用了本文设计的工具 OptionalBean ,那么上述的调用可以简化成这样:

    public static void main(String[] args) {
    
        User axin = new User();
    
        User.School school = new User.School();
    
        axin.setName("hello");
    
        // 1. 基本调用
    
        String value1 = OptionalBean.ofNullable(axin)
    
                .getBean(User::getSchool)
    
                .getBean(User.School::getAdress).get();
    
        System.out.println(value1);
    
    }
    

    执行结果:
    在这里插入图片描述

    其中User的school变量为空,可以看到代码并没有空指针,而是返回了null。这个工具怎么实现的呢?

    OptionalBean 工具

    public final class OptionalBean<T> {
    
        private static final OptionalBean<?> EMPTY = new OptionalBean<>();
    
        private final T value;
    
        private OptionalBean() {
    
            this.value = null;
    
        }
    
        /**
    
         * 空值会抛出空指针
    
         * @param value
    
         */
    
        private OptionalBean(T value) {
    
            this.value = Objects.requireNonNull(value);
    
        }
    
        /**
    
         * 包装一个不能为空的 bean
    
         * @param value
    
         * @param <T>
         * @return
    
         */
    
        public static <T> OptionalBean<T> of(T value) {
    
            return new OptionalBean<>;(value);
    
        }
    
        /**
    
         * 包装一个可能为空的 bean
    
         * @param value
    
         * @param <T>     * @return
    
         */
    
        public static <T> OptionalBean<T> ofNullable(T value) {
    
            return value == null ? empty() : of(value);
    
        }
    
        /**
    
         * 取出具体的值
    
         * @param fn
    
         * @param <R>     * @return
    
         */
    
        public T get() {
    
            return Objects.isNull(value) ? null : value;
    
        }
    
        /**
    
         * 取出一个可能为空的对象
    
         * @param fn
    
         * @param <R>     * @return
    
         */
    
        public <R> OptionalBean<R> getBean(Function<? super T, ? extends R> fn) {
    
            return Objects.isNull(value) ? OptionalBean.empty() : OptionalBean.ofNullable(fn.apply(value));
    
        }
    
        /**
    
         * 如果目标值为空 获取一个默认值
    
         * @param other
    
         * @return
    
         */
    
        public T orElse(T other) {
    
            return value != null ? value : other;
    
        }
    
        /**
    
         * 如果目标值为空 通过lambda表达式获取一个值
    
         * @param other
    
         * @return
    
         */
    
        public T orElseGet(Supplier<? extends T> other) {
    
            return value != null ? value : other.get();
    
        }
    
        /**
    
         * 如果目标值为空 抛出一个异常
    
         * @param exceptionSupplier
    
         * @param <X>     * @return
    
         * @throws X
    
         */
    
        public <X extends Throwable>; T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    
            if (value != null) {
    
                return value;
    
            } else {
    
                throw exceptionSupplier.get();
    
            }
    
        }
    
        public boolean isPresent() {
    
            return value != null;
    
        }
    
        public void ifPresent(Consumer<? super T> consumer) {
    
            if (value != null)
    
                consumer.accept(value);
    
        }
    
        @Override
    
        public int hashCode() {
    
            return Objects.hashCode(value);
    
        }
    
        /**
    
         * 空值常量
    
         * @param <T>     * @return
    
         */
    
        public static <T> OptionalBean<T> empty() {
    
            @SuppressWarnings("unchecked")
    
            OptionalBean<T> none = (OptionalBean<T>) EMPTY;
    
            return none;
    
        }
    
    }
    

    工具设计主要参考了 Optional 的实现,再加上对链式调用的扩展就是上述的OptionalBean。

    getBean 其实是当变量为空时返回了一个 包装空值的 OptionalBean 对象,同时泛型的使用让工具更加易用。

    使用手册

    可以看到代码中也提供了和 Optional 一样的扩展方法,如 ifPresent()、orElse()等等:

    在这里插入代码片public static void main(String[] args) {
    
        User axin = new User();
    
        User.School school = new User.School();
    
        axin.setName("hello");
    
        // 1. 基本调用
    
        String value1 = OptionalBean.ofNullable(axin)
    
                .getBean(User::getSchool)
    
                .getBean(User.School::getAdress).get();
    
        System.out.println(value1);
    
        // 2. 扩展的 isPresent方法 用法与 Optional 一样
    
        boolean present = OptionalBean.ofNullable(axin)
    
                .getBean(User::getSchool)
    
                .getBean(User.School::getAdress).isPresent();
    
        System.out.println(present);
    
        // 3. 扩展的 ifPresent 方法
    
        OptionalBean.ofNullable(axin)
    
                .getBean(User::getSchool)
    
                .getBean(User.School::getAdress)
    
                .ifPresent(adress -> System.out.println(String.format("地址存在:%s", adress)));
    
        // 4. 扩展的 orElse
    
        String value2 = OptionalBean.ofNullable(axin)
    
                .getBean(User::getSchool)
    
                .getBean(User.School::getAdress).orElse("家里蹲");
    
        System.out.println(value2);
    
        // 5. 扩展的 orElseThrow
    
        try {
    
            String value3 = OptionalBean.ofNullable(axin)
    
                    .getBean(User::getSchool)
    
                    .getBean(User.School::getAdress).orElseThrow(() -> new RuntimeException("空指针了"));
    
        } catch (Exception e) {
    
            System.out.println(e.getMessage());
    
        }
    
    }
    

    run一下:
    在这里插入图片描述
    设计了一种可以链式调用对象成员而无需判空的工具让代码更加的精准和优雅,如果本文设计的工具满足了刚好解决你的困扰,那就在项目中使用吧!

    展开全文
  • 主要大家介绍了关于如何在Java优雅判空的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 前言 Java8新特性 :Optional ...Java8之前大家常用的判空方式 Student对象 @Data public class Student { private String name; private Hobby hobby; public Optional<Hobby> getHobbyOf...

    前言

    Java8新特性 :Optional

    它是一个可以为null的容器对象,Optional提供了很多有用的方法,这样我们就不用显式进行空值检测,可以让我们的代码更加优雅可观。

     

    Java8之前大家常用的判空方式

      Student对象

    @Data
    public class Student {
        private String name;
    
        private Hobby hobby;
    
        public Optional<Hobby> getHobbyOfNull(){
            return Optional.ofNullable(this.hobby);
        }
    
    }    

      Hobby对象

    @Data
    public class Hobby {
        private String name;
    }
    

     

    String name = student.getName();
    String hobbyName = student.getHobby().getName();
    

      当对象为空直接引用将造成NullPointerException  需要再调用每个对象前进行空判断

    // 示例一 嵌套参数
    String name ="";
    if(student != null){
        if (student.getName() != null){
            name = student.getName();
        }
    }
    
    //示例二 嵌套对象
    String hobbyName ="";
    if(student != null){
        Hobby hobby = student.getHobby();
        if (hobby != null && hobby.getName() != null){
            hobbyName = hobby.getName();
        }
    }

      当层级关系变多  代码会显得非常臃肿 

      

    Optional方式  

    示例一 
    String name = Optional.ofNullable(student).map(e -> e.getName()).orElse("");
    
    示例二
    hobbyName = Optional.ofNullable(student).flatMap(Student::getHobbyOfNull).map(Hobby::getName).orElse("");

     

     

    展开全文
  •  作为搬砖党的一族们,我们对判空一定再熟悉不过了,不要跟我说你很少进行判空,除非你喜欢NullPointerException。  不过NullPointerException对于很多猿们来说,也是Exception家族中最亲近的一员了。  为了...
    • 作者:李良逸
    • 来源:http://blog.imuxuan.com

    判空灾难

    NullPointerException

      作为搬砖党的一族们,我们对判空一定再熟悉不过了,不要跟我说你很少进行判空,除非你喜欢NullPointerException。

      不过NullPointerException对于很多猿们来说,也是Exception家族中最亲近的一员了。

    Wowo

      为了避免NullPointerException来找我们,我们经常会进行如下操作。

    if (data != null) {
        do sth.
    }
    

      如果一个类中多次使用某个对象,那你可能要一顿操作,so:

    1

      “世界第九大奇迹”就这样诞生了。Maybe你会想,项目中肯定不止你一个人会这样一顿操作,然后按下Command+Shift+F,真相就在眼前:

    2

      What,我们有接近一万行的代码都是在判空?

    3

      好了,接下来,要进入正题了。

    NullObject模式

      对于项目中无数次的判空,对代码质量整洁度产生了十分之恶劣的影响,对于这种现象,我们称之为“判空灾难”。

      那么,这种现象如何治理呢,你可能听说过NullObject模式,不过这不是我们今天的武器,但是还是需要介绍一下NullObject模式。

      什么是NullObject模式呢?

    In object-oriented computer programming, a null object is an object with no referenced value or with defined neutral ("null") behavior. The null object design pattern describes the uses of such objects and their behavior (or lack thereof).

      以上解析来自Wikipedia。

      NullObject模式首次发表在“ 程序设计模式语言 ”系列丛书中。一般的,在面向对象语言中,对对象的调用前需要使用判空检查,来判断这些对象是否为空,因为在空引用上无法调用所需方法。

      空对象模式的一种典型实现方式如下图所示(图片来自网络):

    4

      示例代码如下(命名来自网络,哈哈到底是有多懒):

      Nullable是空对象的相关操作接口,用于确定对象是否为空,因为在空对象模式中,对象为空会被包装成一个Object,成为Null Object,该对象会对原有对象的所有方法进行空实现。。

    public interface Nullable {
    
        boolean isNull();
    
    }
    

      这个接口定义了业务对象的行为。

    public interface DependencyBase extends Nullable {
    
        void Operation();
    
    }
    

      这是该对象的真实类,实现了业务行为接口DependencyBase与空对象操作接口Nullable。

    public class Dependency implements DependencyBase, Nullable {
    
        @Override
        public void Operation() {
            System.out.print("Test!");
        }
    
        @Override
        public boolean isNull() {
            return false;
        }
    
    }
    

      这是空对象,对原有对象的行为进行了空实现。

    public class NullObject implements DependencyBase{
    
        @Override
        public void Operation() {
            // do nothing
        }
    
        @Override
        public boolean isNull() {
            return true;
        }
    
    }
    

      在使用时,可以通过工厂调用方式来进行空对象的调用,也可以通过其他如反射的方式对对象进行调用(一般多耗时几毫秒)在此不进行详细叙述。

    public class Factory {
    
        public static DependencyBase get(Nullable dependencyBase){
            if (dependencyBase == null){
                return new NullObject();
            }
            return new Dependency();
        }
    
    }
    

      这是一个使用范例,通过这种模式,我们不再需要进行对象的判空操作,而是可以直接使用对象,也不必担心NPE(NullPointerException)的问题。

    public class Client {
    
        public void test(DependencyBase dependencyBase){
            Factory.get(dependencyBase).Operation();
        }
    
    }
    

      关于空对象模式,更具体的内容大家也可以多找一找资料,上述只是对NullObject的简单介绍,但是,今天我要推荐的是一款协助判空的插件NR Null Object,让我们来优雅地进行判空,不再进行一顿操作来定义繁琐的空对象接口与空独享实现类。

    .NR Null Object

      NR Null Object是一款适用于Android Studio、IntelliJ IDEA、PhpStorm、WebStorm、PyCharm、RubyMine、AppCode、CLion、GoLand、DataGrip等IDEA的Intellij插件。其可以根据现有对象,便捷快速生成其空对象模式需要的组成成分,其包含功能如下:

    • 分析所选类可声明为接口的方法;
    • 抽象出公有接口;
    • 创建空对象,自动实现公有接口;
    • 对部分函数进行可为空声明;
    • 可追加函数进行再次生成;
    • 自动的函数命名规范

      让我们来看一个使用范例:

    5

      怎么样,看起来是不是非常快速便捷,只需要在原有需要进行多次判空的对象中,邮件弹出菜单,选择Generate,并选择NR Null Object即可自动生成相应的空对象组件。

      那么如何来获得这款插件呢?

    安装方式

      可以直接通过IDEA的Preferences中的Plugins仓库进行安装。

      选择 Preferences → Plugins → Browse repositories

    6

      搜索“NR Null Oject”或者“Null Oject”进行模糊查询,点击右侧的Install,restart IDEA即可。

    7

    Optional

      还有一种方式是使用Java8特性中的Optional来进行优雅地判空,Optional来自官方的介绍如下:

    A container object which may or may not contain a non-null value. If a value is present, isPresent()will return true and get() will return the value.

      一个可能包含也可能不包含非null值的容器对象。 如果存在值,isPresent()将返回true,get()将返回该值。

      话不多说,举个例子。

    栗子

      有如下代码,需要获得Test2中的Info信息,但是参数为Test4,我们要一层层的申请,每一层都获得的对象都可能是空,最后的代码看起来就像这样。

        public String testSimple(Test4 test) {
            if (test == null) {
                return "";
            }
            if (test.getTest3() == null) {
                return "";
            }
            if (test.getTest3().getTest2() == null) {
                return "";
            }
            if (test.getTest3().getTest2().getInfo() == null) {
                return "";
            }
            return test.getTest3().getTest2().getInfo();
        }
    

      但是使用Optional后,整个就都不一样了。

        public String testOptional(Test test) {
            return Optional.ofNullable(test).flatMap(Test::getTest3)
                    .flatMap(Test3::getTest2)
                    .map(Test2::getInfo)
                    .orElse("");
        }
    

      1.Optional.ofNullable(test),如果test为空,则返回一个单例空Optional对象,如果非空则返回一个Optional包装对象,Optional将test包装;

        public static <T> Optional<T> ofNullable(T value) {
            return value == null ? empty() : of(value);
        }
    

      2.flatMap(Test::getTest3)判断test是否为空,如果为空,继续返回第一步中的单例Optional对象,否则调用Test的getTest3方法;

        public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
            Objects.requireNonNull(mapper);
            if (!isPresent())
                return empty();
            else {
                return Objects.requireNonNull(mapper.apply(value));
            }
        }
    

      3.flatMap(Test3::getTest2)同上调用Test3的getTest2方法;

      4.map(Test2::getInfo)同flatMap类似,但是flatMap要求Test3::getTest2返回值为Optional类型,而map不需要,flatMap不会多层包装,map返回会再次包装Optional;

        public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
            Objects.requireNonNull(mapper);
            if (!isPresent())
                return empty();
            else {
                return Optional.ofNullable(mapper.apply(value));
            }
        }
    

      5.orElse("");获得map中的value,不为空则直接返回value,为空则返回传入的参数作为默认值。

    public T orElse(T other) {
        return value != null ? value : other;
    }
    

      怎么样,使用Optional后我们的代码是不是瞬间变得非常整洁,或许看到这段代码你会有很多疑问,针对复杂的一长串判空,Optional有它的优势,但是对于简单的判空使用Optional也会增加代码的阅读成本、编码量以及团队新成员的学习成本。毕竟Optional在现在还并没有像RxJava那样流行,它还拥有一定的局限性。

      如果直接使用Java8中的Optional,需要保证安卓API级别在24及以上。

    image-20181124085913887.png

      你也可以直接引入Google的Guava。(啥是Guava?来自官方的提示)

    Guava is a set of core libraries that includes new collection types (such as multimap and multiset), immutable collections, a graph library, functional types, an in-memory cache, and APIs/utilities for concurrency, I/O, hashing, primitives, reflection, string processing, and much more!

      引用方式,就像这样:

        dependencies {
          compile 'com.google.guava:guava:27.0-jre'
          // or, for Android:
          api 'com.google.guava:guava:27.0-android'
        }
    

      不过IDEA默认会显示黄色,提示让你将Guava表达式迁移到Java Api上。

    image-3.png

      当然,你也可以通过在Preferences搜索"Guava"来Kill掉这个Yellow的提示。

    image-4.png

    关于Optional使用还有很多技巧,感兴趣可以查阅Guava和Java8相关书籍和文档。

    使用Optional具有如下优点:

    1. 将防御式编程代码完美包装
    2. 链式调用
    3. 有效避免程序代码中的空指针

    但是也同样具有一些缺点:

    1. 流行性不是非常理想,团队新成员需要学习成本
    2. 安卓中需要引入Guava,需要团队每个人处理IDEA默认提示,或者忍受黄色提示
    3. 有时候代码阅读看起来可能会如下图所示:

    Duang

    Kotlin

      当然,Kotlin以具有优秀的空安全性为一大特色,并可以与Java很好的混合使用,like this:

        test1?.test2?.test3?.test4
    

      如果你已经开始使用了Kotlin,可以不用再写缭乱的防御判空语句。如果你还没有使用Kotlin,并不推荐为了判空优雅而直接转向Kotlin。

    展开全文
  • 一、Java集合优雅判空/非空 来自 apache 的集合处理工具包 <dependency> <groupId>commons-collections</groupId> <artifactId>commons-collections</artifactId> <...
  • 作为搬砖党的一族们,我们对判空一定再熟悉不过了,不要跟我说你很少进行判空,除非你喜欢NullPointerException。 不过NullPointerException对于很多猿们来说,也是Exception家族中最亲近的一员了。 Wowo 为了避免...
  • java判空方法 一:java判断字符串是否为空的方法总结 方法一:开发中最常用的方法,看起来也比较高大上: if(StringUtils.isNotBlank(str))//判断字符串不为空 或if(StringUtils.isBlank(str))//判断字符串为空 ...
  • 作者:李良逸http://blog.imuxuan.com判空灾难作为搬砖党的一族们,我们对判空一定再熟悉不过了,不要跟我说你很少进行判空,除非你喜欢NullPointerExcepti...
  • java8 判空

    万次阅读 2019-05-24 18:16:51
    指针是我们最常见也最讨厌的异常,写过 Java 程序的同学,一般都遇到过 NullPointerException :) 初识null 详细可以参考【jdk 1.6Java.lang.Null.Pointer.Exception】 —— 为了不抛出这个异常,我们便会写...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,434
精华内容 573
关键字:

java优雅判空

java 订阅