<#list pageView.list as msg>
      <form name="msgForm" id="msgForm" action="findMsgById.do" method="post">
   <tr class="tr3" onMouseOver="this.style.backgroundColor='whitesmoke'"
           onMouseOut="this.style.backgroundColor='white'">
      <td align="center">
    <span class="style_blue_tableline">${msg_index+1} 
    </span>
      </td>
      <td align="center">
   <span class="style_blue_tableline">
       <a id="editmsg" name="editmsg"
    style="cursor:pointer;color:blue;text-decoration: underline">
    修改
       </a>
   </span>
   <span class="style_blue_tableline">
       <a href="logicDelMsg.do?messageId=${msg.messageId}" >删除
       </a>
   </span>
      </td>
      <input type="hidden" id="messageId" name="messageId" value="${msg.messageId}" />
      <td align="center">
   <span class="style_blue_tableline">${msg.title}nbsp;
   </span>
      </td>
      <td align="center">
   <span class="style_blue_tableline">${msg.messageContent} 
   </span>
      </td>
      <td align="center">
   <span class="style_blue_tableline">${msg.sendTime?string("yyyy-MM-dd HH:mm:ss")} 
   </span>
      </td>
      <td align="center">
   <span class="style_blue_tableline">${msg.sender} 
   </span>
       </td>
       
   </tr>
      </form>
 </#list>
 
 
 
 如以上所示，如果EL表达式中的值为空，则会报如下异常：
 
 the expression msg.title is undefine ....
 
 
 
 原因是：freemarker不像jsp那样，可以在页面上自动处理空值。
 
 这时，应该将每个EL表达式改成如下：
 
 ${(msg.title)?default("")}
 
 表示：如果这个值为空，则给一个默认值。
 
 默认值可任意指定。

Java空字符串与null的区别
 
1、类型
 
       null表示的是一个对象的值，而不是一个字符串。例如声明一个对象的引用，String a=null。 
        “”表示的是一个空字符串，也就是说它的长度为0。例如声明一个字符串String s=”“。
 
2、内存分配
 
       String a=null；表示声明一个字符串对象的引用，但指向为null，也就是说还没有指向任何的内存空间。 
        String s=”“；表示声明一个字符串类型的引用，其值为“”空字符串，这个s引用指向的是空字符串的内存空间；
 
        在java中变量和引用变量是存在栈中（stack），而对象（new产生的）都是放在堆中（heap）：
 
 就如下： 
 String str =new String（“abc”）； 
        ps：=左边的是存放在栈中（stack），=右边是存放在堆中（heap）。
 
代码示例1：
 
String str1=null;
        String str2="";

        //str1==null  为true
            System.out.println("str1和null的==比较结果为:"+(str1==null));


        //java.lang.NullPointerException    空指针异常
            System.out.println("str1的isEmpty()方法"+(str1.isEmpty()));

            //java.lang.NullPointerException    空指针异常
            System.out.println("str2的length()方法"+(str1.length()));

        //java.lang.NullPointerException    空指针异常
            System.out.println("str1和null的equals比较结果为:"+(str1.equals(null)));


        //str2==null  为false
            System.out.println("str2和null的==比较结果为:"+(str2==null));


        //str2==""      为true
            System.out.println("str2和"+""+"的==比较结果为:"+(str2==""));

        //str2.isEmpty()    为true
            System.out.println("str2的isEmpty()方法"+str2.isEmpty());


        //str2.equals(null)     为true
        System.out.println("str2和null的equals方法比较结果为:"+(str2.equals(null)));

        //str2.isEmpty()    为true
        System.out.println("str2的isEmpty()方法"+(str2.isEmpty()));

        //str2.length()     结果为0
        System.out.println("str2的length()方法"+(str2.length()));
 
代码示例2：
 
String str1 = new String() ;
        String str2 = null ;
        String str3 = "" ;
        System.out.println(str1==str2);                //内存地址的比较，返回false
        System.out.println(str1.equals(str2));         //值的比较，返回false
        System.out.println(str2==str3);                //内存地址的比较，返回false
        System.out.println(str3.equals(str2));         //值的比较，返回false
        System.out.println(str1==str3);                //内存地址的比较，返回false
        System.out.println(str1.equals(str3));         //值的比较，返回true
 
通过以上的两个代码示例可以得出以下结论：
 
        1   如果想调用一个方法，首先要有一个对象，但是null并不是一个对象，内存中都没有它的空间，所以null是不能够调用String中的方法的，isEmpty和length和equals方法都不能够调用。 
        2   字符串对象与null的值不相等，且内存地址也不相等。 
        3   空字符串对象与null的值不相等，且内存地址也不相等。 
        4   new String()创建一个字符串对象的默认值为”” （String类型成员变量的初始值为null。
 
java判断字符串是都为空的方法
 
方法1
 
       最多人使用的一个方法, 直观, 方便, 但效率很低: 
 

 if(s == null || s.equals(“”));

 
方法2
 
       比较字符串长度, 效率高, 是我知道的最好一个方法: 
 

 if(s == null || s.length() == 0);

 
方法3
 
       Java SE 6.0 才开始提供的方法, 效率和方法二几乎相等, 但出于兼容性考虑, 推荐使用方法二. 
 

 if(s == null || s.isEmpty());

 
方法4
 
       这是一种比较直观,简便的方法,而且效率也非常的高,与方法二、三的效率差不多: 
 

 if (s == null || s == “”);

 
注意：s==null是有必要存在的。
 
        如果 String 类型为null, 而去进行 equals(String) 或 length() 等操作会抛出java.lang.NullPointerException。
 
       并且s==null 的顺序必须出现在前面，不然同样会抛出java.lang.NullPointerException。
 
       如以下java代码：
 
String s = null ;
        if(s.equals("") || s == null)
        {
            System.out.println("success");
        }
 
运行结果如下：Exception in thread “main” java.lang.NullPointerException；会提示空指针异常。

Java8新特性系列我们已经介绍了Stream、Lambda表达式、DateTime日期时间处理，最后以“NullPointerException” 的克星Optional类的讲解来收尾。
 
背景
 
作为开发人员每天与NullPointerException斗智斗勇。每接收到参数或调用方法获得值得判断一下是否为null。稍不留意，空指针异常就像幽灵一样出现了。
 
这篇文章我们来学习Java8是如何通过Optional类来避免空指针异常的。
 
先来看一下不使用Optional类时，我们为了防止NullPointerException会怎么处理。
 
public String getParentName(Person son) {
	if (son != null) {
		Person parent = son.getParent();
		if (parent != null) {
			return parent.getUsername();
		} else {
			return "--";
		}
	}

	return "--";
}
 
为了防止出现异常，需要不停的判断对象是否为null。但如果业务逻辑比较复杂，会涌现出大量的ifelse。看似逻辑缜密，但易读性却并不高。
 
为了解决相关问题，在Effective Java中建议若方法返回类型为集合，则通过返回空集合以避免 NullPointerException，真是煞费苦心。
 
先看一下上面的代码使用Optional之后会变成什么样子。
 
public String getParentNameWithOptional(Person son) {
	return Optional.ofNullable(son).map(Person::getParent).map(Person::getUsername).orElse("--");
}
 
对照一下代码，看看神不神奇？！
 
Optional类简介
 
java.util.Optional类的引入很好的解决空指针异常，类声明如下：
 
public final class Optional<T> {}
 
java.util.Optional类是一个封装了Optional值的容器对象，Optional值可以为null，如果值存在，调用isPresent()方法返回true，调用get()方法可以获取值。
 
通过源代码会发现，它并没有实现java.io.Serializable接口，因此应避免在类属性中使用，防止意想不到的问题。
 
除了Optional类之外，还扩展了一些常用类型的Optional对象，比如：OptionalDouble、OptionalInt、OptionalLong。用法基本上相似。
 
下面通过具体的操作和功能来了解Optional类。
 
创建Optional对象
 
创建Optional对象有三种方法：empty()、of()、ofNullable()，均为静态方法。
 
如果Optional对象没有值则用empty()方法。
 
Optional empty = Optional.empty();
 
如果确定Optional对象的值不为null，则可用of()方法。
 
Optional stringOptional = Optional.of("Hello 公众号：程序新视界");
 
如果不确定Optional对象的值是否为null，则可用ofNullable()。比如上面，不确定Person对象是不否null，就用了ofNullable()方法。当然，也可以直接给该方法传null。
 
Optional ofNullOptional = Optional.ofNullable(null);
 
此时，通过调用其isPresent方法可以查看该Optional中是否值为null。
 
boolean bool = ofNullOptional.isPresent();
System.out.println(bool);
 
此时如果直接调用get方法获取值，则会抛出异常。
 
ofNullOptional.get();
 
get获取Optional中的值
 
通过get方法可获取Optional中的值，但如果值为null，则会抛出异常。
 
Optional ofNullOptional = Optional.ofNullable(null);
ofNullOptional.get();
 
异常信息：
 
java.util.NoSuchElementException: No value present
    at java.util.Optional.get(Optional.java:135)
...
 
此时，需要另外一个方法的辅助：isPresent()。该方法可判定Optional中是否有值，如果有则返回true，如果没有则返回false。
 
Optional ofNullOptional = Optional.ofNullable(null);
boolean bool = ofNullOptional.isPresent();
if(bool){
	ofNullOptional.get();
}
 
map获取Optional中的值
 
对于对象操作，也可以通过map来获取值，最开始简化的例子就是如此。
 
Optional<Person> sonOptional = Optional.ofNullable(son);
System.out.println(sonOptional.map(Person::getUsername));
 
map方法，如果有值，则对其执行调用映射函数得到返回值。如果返回值不为null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。
 
flatMap获取Optional中的值
 
如果有值，则返回Optional类型返回值，否则返回空Optional。flatMap与map方法类似。但flatMap中的mapper返回值必须是Optional。调用结束时，flatMap不会对结果用Optional封装。
 
Optional<Person> sonOptional = Optional.ofNullable(son);
sonOptional.flatMap(OptionalTest::getOptionalPerson);
 
调用的是当前类OptionalTest的另外一个方法：
 
public static Optional<Person> getOptionalPerson(Person person){
	return Optional.ofNullable(person);
}
 
orElse获取Optional中的值
 
orElse方法，如果有值就返回，否则返回一个给定的值作为默认值；
 
Optional.empty().orElse("--");
 
上面这种情况就会返回“–”。
 
在此，这种操作与三目运算效果一样。
 
str != null ? str : "--"
 
orElseGet获取Optional中的值
 
orElseGet()方法与orElse()方法作用类似，但生成默认值的方式不同。该方法接受一个Supplier<? extends T>函数式接口参数，用于生成默认值；
 
Optional.empty().orElseGet(() -> {
			String a = "关注";
			String b = "公众号：程序新视界";
			return a   b;
		});
 
很显然，这里可以处理更多的业务逻辑。
 
orElseThrow获取Optional中的值
 
orElseThrow()方法与get()方法类似，当值为null时调用会抛出NullPointerException异常，但该方法可以指定抛出的异常类型。
 
Optional.empty().orElseThrow(()-> new RuntimeException("请先关注公众号！"));
 
此时打印异常信息为：
 
Optional.empty().orElseThrow(()-> new RuntimeException("请先关注公众号！"));
 
判断并执行操作
 
ifPresent方法，可对值进行判断然后打印，接收参数为Consumer<? super T>函数式接口。
 
Optional.of("公众号：程序新视界").ifPresent(System.out::println);
 
当然，也可以在函数中执行其他复杂操作：
 
Optional.of("公众号：程序新视界").ifPresent((val)->{
			System.out.println("欢迎关注"   val);
		});
 
filter()方法过滤
 
filter()方法可用于判断Optional对象是否满足给定条件，一般用于条件过滤：
 
Optional.of("公众号：程序新视界").filter((val)->{
	return val.contains("程序新视界");
});
// 简化写法
Optional.of("公众号：程序新视界").filter((val)-> val.contains("程序新视界"));
 
使用误区
 
关于使用Optional的误区有以下：
 
正确的使用创建方法，不确定是否为null时尽量选择ofNullable方法。
避免用在成员变量上（原因上面已经提到）；
避免直接调用Optional对象的get和isPresent方法；
 
最后一条可能难理解，试想一下如果先用isPresent方法获得是否存在，然后决定是否调用get方法和之前的ifelse判断并无二致。
 
Java8提倡函数式编程，新增的许多API都可以用函数式编程表示，Optional类也是其中之一。
 
小结
 
至此，Java8新特性相关的内容便完结了。
 
Java8新特性系列相关文章：
 
《JAVA8新特性时间日期库DATETIME API及示例》
《JAVA8 LAMBDA表达式详解手册及实例》
《JAVA8 STREAM性能如何及评测工具推荐》
《JAVA8 STREAM新特性详解及实战》
《Java8新特性之空指针异常的克星Optional类》
 
 
 
关注公众号“程序新视界”，回复“001”，获得整个《Java8新特性系列》的PDF版本。
 
 
原文链接：《Java8新特性之空指针异常的克星Optional类》
 
 

 程序新视界
 

 

 关注程序员的职场生涯，大量优质学习资源、技术文章分享
 

 

 
文章目录
 
空指针异常
防止空指针异常
Java 注解
Java 8 中的 Optional 类型
Kotlin
   
总结
 

 
空指针异常
 
先复习下异常。
 
异常分为 Exception 和 Error，Exception 和 Error 类都继承自Throwable类。
 
Exception（程序可恢复）：表示程序可以处理的异常，可以捕获并且可恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。
Error（程序不可恢复）：一般指虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢出等。这于这类错误，Java编译器不去检查也会导致应用程序中断，仅靠程序本身无法恢复和预防，遇到这样的错误，建议程序终止。
 
Exception 又分为运行时异常和受检查的异常：
 
运行时异常：如空指针，参数错误等。
受检查异常：这类异常如果没有try/catch语句也没有throws抛出，编译不通过。
 
空指针异常（NullPointerException）属于运行时异常，当应用程序试图在需要对象的地方使用 null 时，抛出该异常。这种情况包括：
 
调用 null 对象的实例方法。
访问或修改 null 对象的字段。
将 null 作为一个数组，获得其长度。
将 null 作为一个数组，访问或修改其时间片。
将 null 作为 Throwable 值抛出。
 
遇到该异常，如果又没有try/catch语句，就将导致应用程序终止。从应用程序线上问题统计中发现，空指针异常是比较常见的。所以防止空指针异常非常有必要。
 
 
防止空指针异常
 
要防止空指针异常，可以从三方面来入手：
 
Java 注解辅助
引入 Java 8 中的 Optional 类型
使用 Kotlin 区分可空类型和非空类型
 
Java 注解
 
Java 注解可以用来表达值的可空性，帮助静态扫描工具找到可能抛出 NullPointerException 的地方。
 
Android 提供了可空注解@NonNull 和 非空注解@NonNull：
 
    @Nullable
    public Fragment findFragment(@NonNull FragmentActivity activity, @NonNull String tag) {
        FragmentManager fragmentManager = activity.getSupportFragmentManager();
        return fragmentManager.findFragmentByTag(tag);
    }
 
在使用者使用的时候，如果没有正确的使用可空类型和非空类型，就会得到编译器的提示：
 
 
 所以注解只能用来提示使用者在使用的时候是可空类型还是非空类型，但并不能限定使用者传递的是可空类型还是非空类型。
 
Java 8 中的 Optional 类型
 
Java 8 中引入了 Optional 类型，它是一个可能包含或不包含非空值的容器对象，用更优雅的方式来防止 NullPointerException 。
 
Optional 类 提供的主要方法：
 
方法名字
表示意思
of
返回具有 Optional的当前非空值的Optional。
ofNullable
返回一个 Optional指定值的Optional，如果非空，则返回一个空的 Optional 。
isPresent
如果存在值，则返回 true ，否则为 false 。
get
如果 Optional中存在值，则返回值，否则抛出 NoSuchElementException 。
map
如果存在值，则应用提供的映射函数，如果结果不为空，则返回一个Optional结果的Optional 。 否则返回一个空的Optional 。
flatMap
如果一个值存在，应用提供的Optional映射函数给它，返回该结果，否则返回一个空的Optional 。 这种方法类似于map(Function) ，但是提供的映射器是一个结果已经是Optional映射器，如果被调用， flatMap不会用额外的Optional 。
orElse
返回值如果存在，否则返回 other 。
测试例子：
 
创建一个User类：
 
public class User {
	private String nickname;
	private Address address;

	public User() {
	}

	public Optional<Address> getAddress() {
		return Optional.ofNullable(address);
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	public String getNickname() {
		return nickname;
	}

	public void setNickname(String nickname) {
		this.nickname = nickname;
	}

}
 
获取 Nickname：
 
	private String getUserNickname(User user) {
		return Optional.ofNullable(user).map(new Function<User, String>() {

			@Override
			public String apply(User t) {
				return t.getNickname();
			}
		}).orElse("default");
	}
	
	String nickname = getUserNickname(null);
    //运行结果：nickname="default"
 
ofNullable 方法主要将对象包装成一个Optional对象（用的就是组合）：
 

    private static final Optional<?> EMPTY = new Optional<>();

    private final T value;

    private Optional() {
        this.value = null;
    }

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }
 
map 方法会检测当前值是否为空，如果为空就返回一个空的Optional对象，否则将接口Function的回调方法apply的返回值包装成一个新的Optional对象。
 
    public boolean isPresent() {
        return value != null;
    }

    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));
        }
    }
 
orElse 方法检测当前值是否为空，如果为空，就返回传入的默认值：
 
    public T orElse(T other) {
        return value != null ? value : other;
    }
 
从上面可以 看出，使用 Optional 类，主要是将对象包装成 Optional 对象来防止 NullPointerException 。
 
Optional 类 还可以解决在实际开过程中，经常遇到的一些链式调用引起的NullPointerException 。
 
下面通过User 类，获取 Country 类 的属性，一般会这样写：
 
		String countryName = null;
		Address address = user.getAddress();
		if(address!=null) {
			Country country = address.getCountry();
			if(country !=null) {
				countryName = country.getName();
			}
		}
 
上面代码中不得不对过程中遇到的每一个对象做判空处理，如果调用链很长，代码就会越不友好。修改user.getAddress() 和 address.getCountry() 方法的返回值：
 
	public Optional<Address> getAddress() {
		return Optional.ofNullable(address);
	}
 
	public Optional<Country> getCountry() {
		return Optional.ofNullable(country);
	}
 
使用Optional 类 ，将链式调用中遇到的任何一个对象都包装成 Optional对象：
 
	private String  getCountryName(User user) {
		return Optional.ofNullable(user).flatMap(new Function<User, Optional<Address>>() {

			@Override
			public Optional<Address> apply(User t) {
				return t.getAddress();
			}
		}).flatMap(new Function<Address, Optional<Country>>() {

			@Override
			public Optional<Country> apply(Address t) {
				return t.getCountry();
			}
		}).map(new Function<Country, String>() {

			@Override
			public String apply(Country t) {
				return t.getName();
			}
		}).orElse("default");
	}
	
	String countryName = getCountryName(user);
	//运行结果：countryName = "default"
 
在上面链式方法调用中，中间如果有任何一个对象为空，都不可能抛出空指针异常。
 
虽然 Optional 可以防止NullPointerException，但是代码还是很冗长，并且额外的包装接口还会影响运行时的性能。
 
Kotlin
 
Kotlin 区分可空类型和非空类型，并会在编译期间对可空类型和非空类型检查。
 
可空类型，问号添加在类型的后面表示这个类型的变量可以存储 null 引用：
 
    fun findFragment(activity: FragmentActivity?, tag: String?): Fragment? {
        val fragmentManager = activity?.supportFragmentManager
        return fragmentManager?.findFragmentByTag(tag)
    }
 
如果没有正确使用，将得到编译器的错误提示，并无法编译：
 
 非空类型，没有问号添加在类型的后面表示这个类型的变量不可以存储 null 引用：
 
    fun findFragment(activity: FragmentActivity, tag: String): Fragment? {
        val fragmentManager = activity.supportFragmentManager
        return fragmentManager?.findFragmentByTag(tag)
    }
 
同样，如果没有正确使用，将得到编译器的错误提示，并无法编译：
 
 可空类型和非空类型在运行时并没有什么区别，只是在编译期间对类型进行检查。所以，使用Kotlin 的可空类型并不会在运行时带来额外的开销。
 
对于可空类型的判断，Kotlin 还提供了安全调用运算符?. ，Elvis 运算符?:，安全转换符as?，非空断言!!来防止空指针异常，这里不再一一介绍。
 
 
总结
 
防止空指针异常，有三种方法：使用Java 注解辅助，引入 Java 8 中的 Optional 类型， 使用 Kotlin 区分可空类型和非空类型。使用Java 注解辅助，只能提示使用者在使用的时候是可空类型还是非空类型，并不能限定使用者传递的是可空类型还是非空类型；引入 Java 8 中的 Optional 类型，能防止空指针异常，但是代码还是很冗长，并且额外的包装接口还会影响运行时的性能；使用 Kotlin 区分可空类型和非空类型，会在编译期间对类型进行检查，并且不会在运行时带来额外的开销。总之，使用 Kotlin 是防止空指针异常的最好方式。