判断字符串是否为空的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

, or

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

}

输出结果如下：

1
a
dd

说明换行起作用了，并且占用字节为一个字节。
继续测试：

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