判断字符串是否为空的org.apache.commons.lang3.StringUtils类方法isBlank()源码查看

转发请注明出处与作者。个人分析的，正确性欢迎大家一起探讨，有错误还希望指正和批评

首先说结论：isBlank() 会把制表符（tab键 \t，换行符 \n ，回车键等一系列字符格式的unicode编码）等作为空来处理；而我们平时使用的 if(s == null ||"".equals(s)); 不会把特殊字符作为空处理。

判断字符串是否为空，有很多种方法，下面是其中一种： 

 if(s == null ||"".equals(s));

但这样写看起来是不能从代码本身看到代码本身的业务含义，于是很多追求代码可读性的代码编写者会使用org.apache.commons.lang3.StringUtils类的isBlank()方法。该方法一看就知道代码是在判断是不是空，但该方法的存在难道只是为了可读性吗？这个方法仅仅是封装了下判断逻辑吗，还是还有其他的优势？为了搞懂这个问题，我查找了下源代码。

    /**     * <p>Checks if a CharSequence is whitespace, empty ("") or null.</p>     *     * <pre>     * StringUtils.isBlank(null)      = true     * StringUtils.isBlank("")        = true     * StringUtils.isBlank(" ")       = true     * StringUtils.isBlank("bob")     = false     * StringUtils.isBlank("  bob  ") = false     * </pre>     *     * @param cs  the CharSequence to check, may be null     * @return {@code true} if the CharSequence is null, empty or whitespace     * @since 2.0     * @since 3.0 Changed signature from isBlank(String) to isBlank(CharSequence)     */    public static boolean isBlank(CharSequence cs) {        int strLen;        if (cs == null || (strLen = cs.length()) == 0) {            return true;        }        for (int i = 0; i < strLen; i++) {            if (Character.isWhitespace(cs.charAt(i)) == false) {                return false;            }        }        return true;    }

该方法的形参，是CharSequence类型，我们判断的是字符串，却用了这个类型接收。我们先看下该类型是类还是接口。

通过api查找，jdk7在线文档，可以看到，CharSequence是java.long包下的接口。那么按照向上转型的原理，我们可以猜测，字符串实现了该接口。查看api 

确实是String实现了该接口。

读到这里，就可以判断，isBlank()方法不仅是通过简单的封装了 if(s == null ||"".equals(s));这个逻辑实现可读性而存在的。

那么这样做的原因还有什么？我继续看了下源码实现：

int strLen;        if (cs == null || (strLen = cs.length()) == 0) {            return true;        }

这一步，先判断CharSequence对象是不是null，如果是null，那么肯定是空，就不需要判断长度，直接返回true，表示字符串是空；如果不是null，那么就判断长度，如果长度是0，那么也返回true，表示字符串是空。

判断字符串是否是null这种情况两种实现方式都有判断。那么这两种实现方式是否是完全等价的？

"".equals(s)这个判断，跟后面一系列的判断是否本质上是一样的呢？

我继续查看了下String的equals()方法。

   /**     * Compares this string to the specified object.  The result is {@code     * true} if and only if the argument is not {@code null} and is a {@code     * String} object that represents the same sequence of characters as this     * object.     *     * @param  anObject     *         The object to compare this {@code String} against     *     * @return  {@code true} if the given object represents a {@code String}     *          equivalent to this string, {@code false} otherwise     *     * @see  #compareTo(String)     * @see  #equalsIgnoreCase(String)     */    public boolean equals(Object anObject) {        if (this == anObject) {            return true;        }        if (anObject instanceof String) {            String anotherString = (String) anObject;            int n = value.length;            if (n == anotherString.value.length) {                char v1[] = value;                char v2[] = anotherString.value;                int i = 0;                while (n-- != 0) {                    if (v1[i] != v2[i])                            return false;                    i++;                }                return true;            }        }        return false;    }

equals方法的判断，是先判断是不是同一个引用，如果引用相同，那么直接返回true。（这里可以看到，对于String类型变量，同一个引用地址，指向的是同一个对象。这个容易理解，不可能指向的同一块内存地址了，还不是同一个对象。但反过来，相同的对象，不一定存放在同一块内存地址中）。接着判断传递过来的对象是不是String类型，即便是StringBuffer或者StringBuilder也不行，因为StringBuffer和String都实现了CharSequence，但两者并不存在继承关系。如果不是，直接返回false。只有是string类型的对象，才会进行比较。然后比较两个字符串的长度，如果不同，返回false，表示不是同一个字符串。如果长度相同，再转换为字符，挨个比较字符。

看一下这段代码

while (n-- != 0) {                    if (v1[i] != v2[i])                            return false;                    i++;                }

之前知道，判断为空，"".equals(str) 这种比str.equals("")效率要高。这里可以看到，如果判断为空的情况，"".equals(str)不会进入循环，而后者会进入循环判断一下。如果字符串的各个字符都相同，就认为是相同的字符串。

上面对equals的判断，我们可以看到，对于"".equals(str)判断，就是根据类型和长度进行判断是否是空的。

那么再继续看isBlank()方法后续的实现：

for (int i = 0; i < strLen; i++) {            if (Character.isWhitespace(cs.charAt(i)) == false) {                return false;            }        }

首先判断长度，如果长度是0，直接返回是空；如果长度不为0，那么依次判断字符是否是表示空格的字符，继续查看

isWhitespace（）方法：

    

/**     * Determines if the specified character (Unicode code point) is     * white space according to Java.  A character is a Java     * whitespace character if and only if it satisfies one of the     * following criteria:     * <ul>     * <li> It is a Unicode space character ({@link #SPACE_SEPARATOR},     *      {@link #LINE_SEPARATOR}, or {@link #PARAGRAPH_SEPARATOR})     *      but is not also a non-breaking space ({@code '\u005Cu00A0'},     *      {@code '\u005Cu2007'}, {@code '\u005Cu202F'}).     * <li> It is {@code '\u005Ct'}, U+0009 HORIZONTAL TABULATION.     * <li> It is {@code '\u005Cn'}, U+000A LINE FEED.     * <li> It is {@code '\u005Cu000B'}, U+000B VERTICAL TABULATION.     * <li> It is {@code '\u005Cf'}, U+000C FORM FEED.     * <li> It is {@code '\u005Cr'}, U+000D CARRIAGE RETURN.     * <li> It is {@code '\u005Cu001C'}, U+001C FILE SEPARATOR.     * <li> It is {@code '\u005Cu001D'}, U+001D GROUP SEPARATOR.     * <li> It is {@code '\u005Cu001E'}, U+001E RECORD SEPARATOR.     * <li> It is {@code '\u005Cu001F'}, U+001F UNIT SEPARATOR.     * </ul>     * <p>     *     * @param   codePoint the character (Unicode code point) to be tested.     * @return  {@code true} if the character is a Java whitespace     *          character; {@code false} otherwise.     * @see     Character#isSpaceChar(int)     * @since   1.5     */    public static boolean isWhitespace(int codePoint) {        return CharacterData.of(codePoint).isWhitespace(codePoint);    }

注释全是unicode编码，看不懂，继续查看，

    // Character <= 0xff (basic latin) is handled by internal fast-path    // to avoid initializing large tables.    // Note: performance of this "fast-path" code may be sub-optimal    // in negative cases for some accessors due to complicated ranges.    // Should revisit after optimization of table initialization.    static final CharacterData of(int ch) {        if (ch >>> 8 == 0) {     // fast-path            return CharacterDataLatin1.instance;        } else {            switch(ch >>> 16) {  //plane 00-16            case(0):                return CharacterData00.instance;            case(1):                return CharacterData01.instance;            case(2):                return CharacterData02.instance;            case(14):                return CharacterData0E.instance;            case(15):   // Private Use            case(16):   // Private Use                return CharacterDataPrivateUse.instance;            default:                return CharacterDataUndefined.instance;            }        }    }

往下再继续看，就是字符编码的处理了，看不懂了。回头看下api文档，

• It is a Unicode space character (SPACE_SEPARATOR, LINE_SEPARATOR, orPARAGRAPH_SEPARATOR) but is not also a non-breaking space ('\u00A0','\u2007','\u202F').
• It is '\t', U+0009 HORIZONTAL TABULATION.
• It is '\n', U+000A LINE FEED.
• It is '\u000B', U+000B VERTICAL TABULATION.
• It is '\f', U+000C FORM FEED.
• It is '\r', U+000D CARRIAGE RETURN.
• It is '\u001C', U+001C FILE SEPARATOR.
• It is '\u001D', U+001D GROUP SEPARATOR.
• It is '\u001E', U+001E RECORD SEPARATOR.
• It is '\u001F', U+001F UNIT SEPARATOR. 

判断的就是这些字符，如果是这些字符，那么就作为空字符串返回true。有哪些会被认为是空呢？

1.\t (tab键)

2.\n(换行符)

3.\r(软空格)

4.\f(...)

...

也就是说，isBlank()方法不仅判断的是空格，还判断了各种换行符，制表符，enter键等的unicode编码表示。

由于 if(s == null ||"".equals(s)); 这种判断字符串为空的方式，最终是通过判断字符串长度进行比较的。那么如果\t \n \r  \f 等特殊字符不占长度的话，两种实现方式是等价的；否则，两种判断方式是不等价的。

写了一个测试类

public class BlankTest {    public static void main(String[] args) {        char c = '\n';        String str = String.valueOf(c);        System.out.println(str.length());        String ss = "a"+str+"dd";        System.out.println(ss);    }}

输出结果如下：

1add

说明换行起作用了，并且占用字节为一个字节。

继续测试：

public class BlankTest {    public static void main(String[] args) {        System.out.println("换行符是否是空字符："+newLineCharIsOrNotBlank());    }        public static boolean newLineCharIsOrNotBlank(){        return "".equals('\n');    }}

结果：

换行符是否是空字符：false

至此可以得出结论：

1.换行符等字符 使用 if(s == null ||"".equals(s));语句判断，结果不是空字符串。

2.换行符等字符 使用org.apache.commons.lang3.StringUtils类的isBlank()方法判断，结果是空字符串。

因此，使用StringUtils的isBlank()进行字符串为空的判断时，会考虑换行符，制表符，回车键等。这些特殊字符都会作为空字符串进行处理；而if(s == null ||"".equals(s));把换行符，制表符，回车键等字符作为非空字符进行处理了。

结果验证：

    public static void main(String[] args) {        System.out.println("s==null||\"\".equals('\\n')换行符是否是空字符："+newLineCharIsOrNotBlank(String.valueOf('\n')));        System.out.println("isBlank（）判断换行符是否是空字符："+StringUtils.isBlank(String.valueOf('\n')));    }        public static boolean newLineCharIsOrNotBlank(String s){        return s==null||"".equals('\n');    }

结果：

s==null||"".equals('\n')换行符是否是空字符：false
isBlank（）判断换行符是否是空字符：true