Java使用Optional避免NPE

最新推荐文章于 2024-04-24 23:58:21 发布
最新推荐文章于 2024-04-24 23:58:21 发布
阅读量794 收藏 4
点赞数 1
CC 4.0 BY-SA版权
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34378496/article/details/120673861
本文详细介绍了Java中的Optional类，通过多个实用场景展示了如何利用ofNullable、empty、equals、filter、flatMap、map、get、hashCode、ifPresent、orElse、orElseGet、orElseThrow和toString等方法来避免NullPointerException，提高代码的健壮性和可读性。通过Optional，开发者可以更方便地处理可能为null的对象，简化了嵌套对象和Map的空值检查流程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

实用场景1

测试场景2 ：ofNullable

测试场景3 ：empty

测试场景4 ：equals

测试场景5 ：filter

测试场景6 ：flatMap & map

测试场景7 ：get

测试场景8 ：hashCode

测试场景9 ：ifPresent & isPresent

测试场景10 ：orElse

测试场景11 ：orElseGet

测试场景12 ：orElseThrow

测试场景13 ：toString

        Java中多层对象取值时，为了避免NPE（NullPointerException） ,需要使用object!=null来进行判断，如果遇到使用场景A.getB().getC()或Map.get("k1").get("k2")等类似的情况，层层判空使人头痛（不推荐使用try-catch，try-catch本意是捕获异常，性能差，不应该作用于正常的逻辑中）。

实用场景1

import java.util.Optional;
​
//为A.getB().getC()做准备
class A{
    B b = new B() ;
    public B getB() {
        return b;
    }
}
class B{
    C c = new C() ;
    public C getC() {
        return c;
    }
}
class C{
    int intVal = 1;
    public int getIntVal() {
        return intVal;
    }
};
​
public class OptionalTest {
    public static void main(String[] args) {
        //A.getB().getC();
        //如果不使用Optional,正常我们如果希望有值就取，无值跳过，不报NPE需要
        A a = new A();
        if(a.getB()!=null){
            B b = a.getB();
            if(b.getC()!=null){
                C c = b.getC();
                System.out.println(c.getIntVal());
            }
        }
        //使用Optional
        Optional.ofNullable(a)//判断a是否为空，如果为空返回空Optional不抛异常，否则继续
                .map(aa->aa.getB())//a映射为aa
                .map(bb->bb.getC())//aa.getB()映射为bb,类似于 bb = aa.getB();
                .ifPresent(cc->System.out.println(cc.getIntVal()));//判断如果最终取出C类实例（cc=bb.getC()）如果存在，就输出cc的值，全程不抛异常，不用显示判空，有值输出，无值忽略。
        /**
        *可以将A/B/C类的任意实例赋值为null测试，不会抛异常，注意此场景适用“有值就取，无值就跳过”，不会抛异常！！
        *对于嵌套map与嵌套类相似，这里就不再举例
        */
    }
}

        场景1是笔者认为最实用的场景，没有之一。下面将一一说明Optional的所有方法使用场景，读者可以根据自己的实际情况单独使用或组合使用。首先准备测试类如下：


public class Person {
    private String name;
    private int age ;
    private int sex;
    private Optional<Person> parents;//该字段为了解释说明map方法和flatMap方法的区别，如果是该类型字段，不能使用map方法（会多包一层Optional<Optional<Person>>），
    public Person(String name, int age,  int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
​
    public Optional<Person> getParents() {
        return parents == null ? Optional.empty() : parents;
    }
​
    public void setParents(Optional<Person> parents) {
        this.parents = parents;
    }
​
    public String toString() {
        return "name=" + name + " , age=" + age + " , sex=" + sex + "{" + parents + "}";
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getSex() {
        return sex;
    }
​
    public void setSex(int sex) {
        this.sex = sex;
    }
}

测试场景2 ：ofNullable

ofNullable(obj)和of(obj)方法的区别是前者对象为空返回空的Optional，后者抛异常。

@Test
    public void ofNullable_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);//空对象返回空Optional不抛异常
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
​
        System.out.println("personOptional0: " + personOptional0);
        System.out.println("personOptional1: " + personOptional1);
        // Optional.of()方法就不再举例，读者自行测试，一测就懂
    }
//    输出结果：
//    personOptional0: Optional.empty
//    personOptional1: Optional[name=p1 , age=10 , sex=1]

与之相关的源码如下：

public final class Optional<T> {
  /**
   * Optional任何方法产生的空集都返回这个集合
   * 因此任何Optional实例调用 empty（）或ofNullable(null)方法后相互再使用equals(Object obj)方法比较都会返回true
   */
  private static final Optional<?> EMPTY = new Optional<>();
​
  private final T value;
​
  private Optional() {
    this.value = null;
  }
​
  /**
   * 该方法返回单例EMPTY，再次强调，注意如果你的Optional最终是空的，都引用的该实例，所有的空Optional相互比较都是true
   */
  public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
  }
​
  /**
   *该构造强制参数不能为空，注意Objects.requireNonNull方法，也是判断类不为空的一种方法(空则抛异常)，读者也可以使用。
   */
  private Optional(T value) {
    this.value = Objects.requireNonNull(value);
  }
​
  /**
   *看到这里就知道为什么of方法抛异常啦
   */
  public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
  }
  /**
   *看到这里就知道为什么ofNullable方法不抛异常啦，空value返回单例EMPTY.
   */
  public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
  }
}

测试场景3 ：empty

 @Test
    public void empty_Method_Test() {
​
        Person p0 = null;
​
        Optional<Person> personOptional0 = Optional.empty();//方式一
        System.out.println("personOptional0: " + personOptional0);
        personOptional0 = Optional.ofNullable(p0);//方式二
        System.out.println("personOptional0: " + personOptional0);
        //没有意外的话，方式一和二得到的是同一个Optional对象，如果比较应该返回true，读者自行测试，这里不再测试,源码上文已经提到，不再赘述。
    }
//    输出结果
//    personOptional0: Optional.empty
//    personOptional0: Optional.empty

测试场景4 ：equals

@Test
    public void equals_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
        Optional<Person> personOptional3 = Optional.ofNullable(p1);
        Optional<Person> personOptional4 = Optional.ofNullable(p0);
        //
        System.out.println(personOptional0.equals(personOptional0));//true
        System.out.println(personOptional0.equals(personOptional4));//true
        System.out.println(personOptional0.equals(Optional.empty()));//true
        System.out.println(personOptional1.equals(personOptional2));//false
        System.out.println(personOptional1.equals(personOptional3));//true
​
    }

涉及到的源码如下,常规覆写

 @Override
  public 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);
  }

测试场景5 ：filter

如果做数据统计和筛选相当有用的一个方法。

 @Test
    public void filter_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
        
        personOptional0.filter(person -> person.getAge() > 10)//条件筛选
            .filter(person -> person.getSex() == 2)//条件筛选
            .ifPresent(person -> System.out.println(person));//如果满足条件输出
       
        personOptional1.filter(person -> person.getAge() > 10)
            .filter(person -> person.getSex() == 2)
            .ifPresent(person -> System.out.println(person));
        
        personOptional2.filter(person -> person.getAge() > 10)
            .filter(person -> person.getSex() == 2)
            .ifPresent(person -> System.out.println(person));
        //优点就是，如果在流式的某一个条件不满足，不用担心下面逻辑是否空异常，非常方便
    }
//    name=p2 , age=20 , sex=2

相关源码：

  /**
   * 条件筛选时如果T为空不会报错，可以连续调用
   */
  public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
      return this;
    else
      return predicate.test(value) ? this : empty();
  }

测试场景6 ：flatMap & map

@Test
    public void flatMap_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
        
        personOptional0.flatMap(Person::getParents) //parents实例是Optional<Person>不是Person类型，使用map会报错，此时就需要使用flatMap
                .map(Person::getName)//普通字段使用map映射，函数式相当于a->a.getName(),不熟悉可以不用，自行了解
                .map(String::trim) // String str = p.getName().trim();
                .filter(str -> !"".equals(str)) //条件筛选 null对象会自动过滤，但是""不会，需要我们自己写过滤条件
                .ifPresent(person -> System.out.println(person));//如果存在输出
​
        personOptional1.flatMap(Person::getParents)
                .map(Person::getName)
                .map(String::trim)
                .filter(str -> !"".equals(str))
                .ifPresent(person -> System.out.println(person));
​
        personOptional2.flatMap(Person::getParents)
                .map(Person::getName)
                .map(String::trim)
                .filter(str -> !"".equals(str))
                .ifPresent(person -> System.out.println(personOptional2.get()));
​
    }
//    输出结果：
//    name=p2 , age=20 , sex=2{Optional[name=p1 , age=10 , sex=1{null}]}

相关源码：注意，参数类型不一样哦（似乎明白了，又不完全明白）。

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));
    }
  }
​
  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));
    }
  }

测试场景7 ：get

顾名思义，取出对象，需要注意的是如果对象为空，会抛异常！

test@Test
    public void get_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
//        System.out.println(personOptional0.get()); 抛异常
        System.out.println(personOptional1.get());
        System.out.println(personOptional2.get());
    }
//    输出结果：
//    name=p1 , age=10 , sex=1{null}
//    name=p2 , age=20 , sex=2{Optional[name=p1 , age=10 , sex=1{null}]}

相关源码：

/*
 * 对象为空直接抛异常：值不存在
 */
public T get() {
    if (value == null) {
      throw new NoSuchElementException("No value present");
    }
    return value;
  }

测试场景8 ：hashCode

这是一个众所周知的覆写方法。

@Test
    public void hashCode_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);//po2
        Optional<Person> personOptional3 = Optional.ofNullable(p2);//po3
        System.out.println(personOptional0.hashCode());
        System.out.println(personOptional1.hashCode());
        System.out.println(personOptional2.hashCode());//spo2
        System.out.println(personOptional3.hashCode());//spo3
        // po2和po3传同一个对象,所以spo2和spo3输出相同的hashCode
    }
    // equals 和hashCode方法调用的都是类的方法
//    0
//            136936250
//            593687897
//            593687897

相关源码：

  @Override
  public int hashCode() {
    return Objects.hashCode(value);
  }

测试场景9 ：ifPresent & isPresent

顾名思义，ifPresent 就是对象如果存在，接下来要做... 相当于if(满足条件){ // TODO 要做的事情};isPresent就是单纯的判断，返回布尔值。

@Test
    public void ifPresent_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
        
        personOptional0.ifPresent(person -> System.out.println(person));
        personOptional1.ifPresent(person -> System.out.println(person));
        personOptional2.ifPresent(person -> System.out.println(person));
        
        System.out.println(personOptional0.isPresent()); //false
        System.out.println(personOptional1.isPresent()); //true
        System.out.println(personOptional2.isPresent()); //true
    }

相关源码：

public boolean isPresent() {
    return value != null;
  }
​
  public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
      consumer.accept(value);
  }

测试场景10 ：orElse

顾名思义，如果Optional值为空就赋一个指定值

@Test
    public void orElse_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
​
        System.out.println(personOptional0.orElse(new Person("other",43,1)));
        System.out.println(personOptional1.orElse(new Person("other",43,1)));
        System.out.println(personOptional2.orElse(new Person("other",43,1)));
​
    }
//    name=other , age=43 , sex=1{null}
//    name=p1 , age=10 , sex=1{null}
//    name=p2 , age=20 , sex=2{Optional[name=p1 , age=10 , sex=1{null}]}

相关源码：

  //该方法仅仅是赋值而已...
  public T orElse(T other) {
    return value != null ? value : other;
  }

测试场景11 ：orElseGet

感觉仅仅就是 orElse 之后 get一下 ...

@Test
    public void orElseGet_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
      
        System.out.println(personOptional0.orElseGet(()->new Person("other",11,3)));
        System.out.println(personOptional1.orElseGet(()->new Person("other",11,3)));
        System.out.println(personOptional2.orElseGet(()->new Person("other",11,3)));
    }

相关源码：

  // 果然跟我想的一样，就是 orElse 后 get 了一下 ...
  public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
  }

测试场景12 ：orElseThrow

顾名思义，如果值为空就抛异常。

@Test
    public void orElseThrow_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
        try{
            System.out.println(personOptional0.orElseThrow(()-> new NullPointerException("obj is null")));
        }catch (NullPointerException e){
            e.printStackTrace();
        }
        try{
            System.out.println(personOptional1.orElseThrow(()-> new NullPointerException("obj is null")));
        }catch (NullPointerException e){
            e.printStackTrace();
        }
        try{
            System.out.println(personOptional2.orElseThrow(()-> new NullPointerException("obj is null")));
        }catch (NullPointerException e){
            e.printStackTrace();
        }
​
    }
//    java.lang.NullPointerException: obj is null
//    at com.xy.optional.OptionalClassTest.lambda$orElseThrow_Method_Test$21(OptionalClassTest.java:274)
//    at java.util.Optional.orElseThrow(Optional.java:290)
//    at com.xy.optional.OptionalClassTest.orElseThrow_Method_Test(OptionalClassTest.java:274)
//    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
//      ...
//    name=p1 , age=10 , sex=1{null}
//    name=p2 , age=20 , sex=2{Optional[name=p1 , age=10 , sex=1{null}]}

相关源码：

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
      return value;
    } else {
      throw exceptionSupplier.get();
    }
  }

测试场景13 ：toString

不言

@Test
    public void toString_Method_Test() {
​
        Person p0 = null;
        Person p1 = new Person("p1", 10, 1);
        Person p2 = new Person("p2", 20, 2);
        p2.setParents(Optional.of(p1));
​
        Optional<Person> personOptional0 = Optional.ofNullable(p0);
        Optional<Person> personOptional1 = Optional.ofNullable(p1);
        Optional<Person> personOptional2 = Optional.ofNullable(p2);
​
        System.out.println(personOptional0.toString());
        System.out.println(personOptional1.toString());
        System.out.println(personOptional2.toString());
    }
//    Optional.empty
//    Optional[name=p1 , age=10 , sex=1{null}]
//    Optional[name=p2 , age=20 , sex=2{Optional[name=p1 , age=10 , sex=1{null}]}]

不语

  @Override
  public String toString() {
    return value != null
      ? String.format("Optional[%s]", value)
      : "Optional.empty";
  }

Optional 使用指南：彻底告别 NPE
独泪了无痕
03-29 777
在我们的开发中，NullPointerException 可谓是随时随处可见，为了避免空指针异常，我们常常需要进行一些防御式的检查，所以在代码中常常可见if(obj!= null) 这样的判断。实际项目中会处理大量为空的值，代码会有很多的条件判断，难以阅读与维护。我们从一个简单的用例开始，在 Java 8 之前，任何访问对象方法或属性的调用都可能导致 NullPointerException。if(user!
Optional详解以及最佳实践场景
最新发布
zjh285077371的专栏
02-16 2085
检查Optional是否有值。：如果有值，执行某个操作。get()：获取实际对象值，可能会抛出异常。orElse()：如果值为null，提供默认值。：提供默认值，默认值是动态生成的。：如果Optional中没有值，抛出异常。filter()：对Optional中的值进行条件过滤。map()：将Optional中的值映射到新的类型。flatMap()：与map()类似，返回Optional类型的值，并避免嵌套。通过这些方法，我们可以更优雅、更安全地处理可能为null的值，减少代码中的。
巧用 Java 8 的 Optional 优雅的规避 NPE
m0_57042151的博客
07-27 285
先介绍一下API，与其他文章不同的是，本文采取类比的方式来讲，同时结合源码。而不像其他文章一样，一个个API罗列出来，让人找不到重点。
合理利用Optional 来避免NPE
Stronger的博客
05-18 982
在Java中什么异常最容易出现，那肯定是NullPointerException，空指针就像一个定时炸弹，总给我们带来些麻烦，在开发过程中都会碰到需要判断Null值以防止空指针的情况，以往的方式要么是抛异常，要么是if{}else{}，直到Optional的出现，你可以更优雅的解决NPE问题。
java8-23-optional 优雅的避免 NPE
热门推荐
03-26 1万+
文章目录Optional用Optional取代null如何为缺失的值建模采用防御式检查减少NullPointerExceptionnull 带来的种种问题Optional 类入门null & Optional.empty()C# 的语言设计Guava Optional应用 Optional 的几种模式创建Optional 对象声明一个空的Optional依据一个非空值创建Optional可...
JDK8-Optional类避免NPE
侠客小虎的博客
06-28 6752
1.需求分析 调用RPC返回结果、包装类转简单类型，拆箱过程最容易出现NPE问题。JDK8之前需要小心翼翼对各种类型进行判空，可通过JKD8-Optional类来预发未知的NPE错误。 2.关于避免NPE的常识 【强制】所有POJO类属性必须使用包装数据类型 【强制】所有RPC方法的返回和参数必须使用包装数据类型 【推荐】所有局部变量使用基本简单数据类型 Ps: POJO类属性没有初值是提醒...
避免NPE问题的解决方案之一 --- Optional类
DataB的博客
07-01 343
Optional类旨在解决NullPointException问题。Java 8 doc
JAVA8如何妙用Optional解决NPE问题详解
08-27
Java 8 引入了 `Optional` 类，旨在帮助开发者更优雅地处理可能出现...通过巧妙使用 `Optional`，开发者可以在 Java 8 中更优雅地处理潜在的 `null` 值，减少因意外的 `null` 而引发的错误，提高代码的健壮性和可读性。
java npe风险_NPE（java.lang.NullPointerException）防范
weixin_34893555的博客
02-24 3305
我们程序中NPE还是比较多的，下面介绍良好的编码规范防止NPE的发生NPE(java.lang.NullPointerException): 空指针异常一、【推荐】防止 NPE，是程序员的基本修养，注意 NPE 产生的场景：1) 返回类型为基本数据类型， return 包装数据类型的对象时，自动拆箱有可能产生 NPE。反例： public int f() { return Integer 对象}，...
Java 的 Optional 类的使用方法示例
qq_29454203的博客
07-29 989
Java8 - Optional 类 防止 NPE ，是程序员的基本修养，注意 NPE 产生的场景，使用 JDK8 的 Optional 类来防止 NPE 问题。 Optional 类是Java8为了解决null值判断问题，借鉴google guava类库的Optional类而引入的一个同名Optional类，使用Optional类可以避免显式的null值判断（null的防御性检查），避免null导致的NPE（NullPointerException）。 Optional类的两个构造方法都是private
【知识点】Optional 的使用 --- 避免 NPE 的利器
weixin_44801641的博客
04-24 485
简单介绍一下 Optional 的使用，后续补充更多常见方法及在项目中的使用
避免NPE错误，使用Optional的正确姿势
weixin_46841300的博客
04-11 317
为了避免NPE的频繁出现，推荐使用秘籍《Optional神功》！
JAVA避免空指针异常(NPE)的常见技巧
Skiray的博客
03-16 457
equals()方法常量在前 如果一个对象又可能为Null那么尽量不要直接使用他的方法 private Boolean isKong(String str){ //str为空会出现NPE return str.equals("kong"); //× return "kong".equals; //√ } 初始化赋默认值 对象初始化的时候赋默认值 String str = null; //X StringUtils类 StringUtils.isEmpty()..
【Java基础系列】避免NPE的方法
CSDN站内信: https://i.csdn.net/#/msg/chat/qyj19920704
11-26 767
在 Java 编程语言中，NPE 异常是指 NullPointerException 异常。当尝试访问或操作一个空对象（即 null）时，就会抛出此异常。简单来说，当您尝试在代码中引用一个未初始化的对象或变量时，就可能会遇到 NPE 异常。通常，它是由于代码中缺少必要的错误检查而导致的。处理这个异常的最佳方式是在编码过程中避免其发生。在 Java 中，NullPointerException（NPE）是最常见的异常之一。这种异常通常发生在应用程序试图使用值为 null 的引用类型变量时。
Java8新特性 使用Optional避免NPE
克己的博客
12-17 1717
前言 相信每一个Java程序员都碰到过NPE异常，每个避免NPE，往往会在代码中写很多if判断，形成代码污染。为了解决这个问题，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。 Optional类介绍 Optional类存...
避免NPE
光与热的博客
02-06 5490
在java开发中中NPE异常是常见异常,在阿里java开发手册中就明确强调防止NPE是调用者的责任是程序员基本修养,本篇博客讲解利用一些小技巧避免NPE 1.1equals方法 public void equals() { //代表未知的对象,可能会是NULL也可能不是NULL Object unKnowObject = null; //这样某些情况下可能会抛出
防止NPE
琉璃的博客
07-20 310
1. 当比较当前业务逻辑获取到的字符串变量是否等于另一个字符串时 使用org.apache.commons.lang3.StringUtils.equals方法 2. 返回对象做非空判断 3.返回集合做非空判断
java 利用Optional解决NPE问题
Samzhu
10-31 1332
NPE(NullPointerException) 问题，日常开发中很常会遇到，尤其在 OOP，像下图这种 如果我们要获取 User 的 department 信息中的 anthority 信息，我们可以这么写 User user = new User(); // ... Anthority anthority = user.getDepartment().getAnthority(); 一旦 department 为空，就会出现 java.lang.NullPointerException 的异常，此
Optional类---解决npe问题
Mutou_ren的博客
09-23 496
https://www.cnblogs.com/zhangboyu/p/7580262.html http://www.runoob.com/java/java8-optional-class.html  
JAVA8 Optional深度解析：告别NullPointerException
在传统的编程模式中，为了避免NPE，开发者通常需要编写大量的if语句来检查对象是否为null。这样的代码不仅冗长，而且降低了代码的可读性。 Optional 类提供了一种更优雅的方式来处理可能的null值。它是一个容器类，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_evenif

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值