StringUtils源码理解（上）

StringUtils 源码，使用的是commons-lang3-3.1包。

下载地址 http://commons.apache.org/lang/download_lang.cgi

 

在看的时候建议简单的看一下标题即可 ，知道一下这个类中有哪些方法就够了。

 

1.构造方法

public StringUtils() {
        super();
}

 它的父类是Object。

2.isBlank() 判断字符串是否为空白 （isNotBank()）

//传入的CharSequence是String的接口，同样StringBuffer这些也是，可适用这里。Sequence的英语是序列的意思。
public static boolean isBlank(CharSequence cs) {
        //标记字符长度，
        int strLen;
        //字符串不存在或者长度为0
        if (cs == null || (strLen = cs.length()) == 0) {
            return true;
        }
        for (int i = 0; i < strLen; i++) {
            //判断空格，回车，换行等，如果有一个不是上述字符，就返回false
            if (Character.isWhitespace(cs.charAt(i)) == false) {
                return false;
            }
        }
        return true;
}
//这个是isNotBlank()
public static boolean isNotBlank(CharSequence cs) {
        return !StringUtils.isBlank(cs);
} 

 3.isEmpty 是否为空，为空或者字符串长度为0。（isNotEmpty）

public static boolean isEmpty(CharSequence cs) {
        return cs == null || cs.length() == 0;
}

 public static boolean isNotEmpty(CharSequence cs) {
        return !StringUtils.isEmpty(cs);
}

 4.trim 去前后空格

//直接采用的是字符串的去空格方法，多加了一个判空
public static String trim(String str) {
        return str == null ? null : str.trim();
}


//下面看一下String类里面的trim方法
 public String trim() {
	int len = count;
	int st = 0;
	int off = offset;      /* avoid getfield opcode */
	char[] val = value;    /* avoid getfield opcode */
        //从开始往后，到第一个不是空格的位置
	while ((st < len) && (val[off + st] <= ' ')) {
	    st++;
	}
        //从最后往前，到第一个不是空格的位置
	while ((st < len) && (val[off + len - 1] <= ' ')) {
	    len--;
	}
        //切割这个字符串
	return ((st > 0) || (len < count)) ? substring(st, len) : this;
}

 4.1 trimToNull 去前后空格后，判断empty，

//去前后空格后，如果为空的话就返回null
public static String trimToNull(String str) {
        String ts = trim(str);
        return isEmpty(ts) ? null : ts;
}

 4.2 trimToEmpty 空的话返回""，不返回null，并且去前后空格

public static String trimToEmpty(String str) {
        //这个Empty 是字符串 ""
        return str == null ? EMPTY : str.trim();
}

5.stripStart(str, stripChars) 去掉前端包含stripsChars的字符。

strip的英语意思是：去除，剥去

这个方法有点难理解，我先举两个官方例子

第二个参数是null的时候就会把第一个str的前端去空格
StringUtils.stripStart(" abc ", null)    = "abc "
第二个参数是""的时候不处理
StringUtils.stripStart(" abc", "")        = " abc"
y出现在第二个参数里，所以去掉，x也一样，到a时就比对停止了。
StringUtils.stripStart("yxazbc  ", "xyz") = "azbc  "

 下面是源码，一看就能理解上面三个例子了

//去除str里包含前端包含stripChars的字符
public static String stripStart(String str, String stripChars) {
        int strLen;
        //str为空或为""立即返回本身。
        if (str == null || (strLen = str.length()) == 0) {
            return str;
        }
        int start = 0;
        if (stripChars == null) {
            //如果stripChars不存在的话，去空格和类似空格的换行等符号。这里去除的方式只是用start记录下来有几位。在最后之际substring切割(这个sunstring没有大写，看来是一个单词）
            while (start != strLen && Character.isWhitespace(str.charAt(start))) {
                start++;
            }
        } else if (stripChars.length() == 0) {
            //如果为空的话，不做任何处理
            return str;
        } else {
            //剩下的情况，比对每一个字符，用str里面的每一个字符比对stripChars，只要stripChars里包含字符，就start++。INDEX_NOT_FOUUD 的值是-1，
            while (start != strLen && stripChars.indexOf(str.charAt(start)) != INDEX_NOT_FOUND) {
                start++;
            }
        }
        //进行切割，start在String类里的substring里表示起点beginIndex。
        return str.substring(start);
    }

 String的substring也简单举两个例字

"unhappy".substring(2) 结果： "happy"
"Harbison".substring(3) 结果： "bison"

 5.1 stripEnd(str, stripChars) 去除后端包含stripsChars的字符

//去除末尾的包含stripChars的字符
public static String stripEnd(String str, String stripChars) {
        int end;
        //str 为空直接结束
        if (str == null || (end = str.length()) == 0) {
            return str;
        }

        if (stripChars == null) {
            //stripChars为空的时候，去后端的空格和类空格字符，这里end是--，end的初值在上面判空的时候就赋值了，（感觉这样写的不错）
            while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) {
                end--;
            }
        } else if (stripChars.length() == 0) {
           ///stripChars为"",直接返回，结束
            return str;
        } else {
            //一样比较，使用的常量 INDEX_NOT_FOUND依旧是-1
            while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != INDEX_NOT_FOUND) {
                end--;
            }
        }
        //切割
        return str.substring(0, end);
    }

 和上面一样，就不举例了。

5.2 strip (str, stripChars) 前后都去除

//前后都去的操作
public static String strip(String str, String stripChars) {
        //判空
        if (isEmpty(str)) {
            return str;
        }
        str = stripStart(str, stripChars);
        return stripEnd(str, stripChars);
}

//默认第二个参数为null，去前后空格和类空格的字符
public static String strip(String str) {
        return strip(str, null);
}

5.3 stripAll(String[] strs,String stripChars) 对字符数组进行批量处理

//对字符数组进行批量过滤
public static String[] stripAll(String[] strs, String stripChars) {
        int strsLen;
        //如果字符数组为空，直接返回
        if (strs == null || (strsLen = strs.length) == 0) {
            return strs;
        }
        //新建一个字符数组，用于返回(这样方便管理)
        String[] newArr = new String[strsLen];
        for (int i = 0; i < strsLen; i++) {
            //处理
            newArr[i] = strip(strs[i], stripChars);
        }
        return newArr;
}

 5.4 一些其他和strip相关方法

//null返回"" ，非null返回去空格的str
 public static String stripToEmpty(String str) {
       //EMPTY是空字符串 ""
        return str == null ? EMPTY : strip(str, null);
}

//null和""都返回null
public static String stripToNull(String str) {
        if (str == null) {
            return null;
        }
        str = strip(str, null);
        return str.length() == 0 ? null : str;
}

//对任意个参数字符串进行处理
public static String[] stripAll(String... strs) {
        return stripAll(strs, null);
}

 

6.equals（cs1,cs2) 比较两个字符串是否相等。

//在原有基础上只是做了null处理，这里写的很有意思。
public static boolean equals(CharSequence cs1, CharSequence cs2) {
        return cs1 == null ? cs2 == null : cs1.equals(cs2);
}

6.1 equalsIgnoreCase  忽略大小写，Ignore的英语：忽略

//大小写忽略比较
public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) {
        if (str1 == null || str2 == null) {
            return str1 == str2;
        } else {
            //这个方法实际上使用的String的regionMatches ，方法很复杂，里面很绕，大概就是全变成小写，使用Character.toUpperCase，就能变成小写了。
            return CharSequenceUtils.regionMatches(str1, true, 0, str2, 0, Math.max(str1.length(), str2.length()));
        }
}

7.indexof(cs1,cs2)判断前一个参数是否包含后一个参数

public static int indexOf(CharSequence seq, CharSequence searchSeq) {
        if (seq == null || searchSeq == null) {
            //INDEX_NOT_FOUND是-1，即没有包含
            return INDEX_NOT_FOUND;
        }
        //这个其实调用的是seq.indexOf(searchSeq,0),后面的0是开始匹配的地方
        return CharSequenceUtils.indexOf(seq, searchSeq, 0);
}

//下面的是多传入一个起点
public static int indexOf(CharSequence seq, CharSequence searchSeq, int startPos) {}

7.1 ordinalIndexOf 返回字符串 searchStr 在字符串 str 中第 ordinal 次出现的位置，

//返回出现几次的位置，正向查
public static int ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal) {
        //最后的参数fasle是正向查找
        return ordinalIndexOf(str, searchStr, ordinal, false);
}
//返回出现几次的位置，反向查
public static int lastOrdinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal) {
        //这里是true，反向查
        return ordinalIndexOf(str, searchStr, ordinal, true);
}

//私有，
private static int ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal, boolean lastIndex) {
        if (str == null || searchStr == null || ordinal <= 0) {
            return INDEX_NOT_FOUND;//-1
        }
        if (searchStr.length() == 0) {
            //要查询的字符为空
            return lastIndex ? str.length() : 0;
        }
        int found = 0;
        int index = lastIndex ? str.length() : INDEX_NOT_FOUND;
        do {
            if (lastIndex) {
                //方向查找
                index = CharSequenceUtils.lastIndexOf(str, searchStr, index - 1);
            } else {
                //正向查找
                index = CharSequenceUtils.indexOf(str, searchStr, index + 1);
            }
            if (index < 0) {
                //-1的话机没找到，直接可返回
                return index;
            }
            //找到了一次++。
            found++;
        } while (found < ordinal);
        //知道都找到为止。
        return index;
}

7.2 lastIndexOf 最后出现的位置

public static int lastIndexOf(CharSequence seq, int searchChar) {
        if (isEmpty(seq)) {
            return INDEX_NOT_FOUND;
        }
        //这里的其实位置是seq的长度，使用的str.lastIndexOf
        return CharSequenceUtils.lastIndexOf(seq, searchChar, seq.length());
}

//忽略大小写
public static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr) {
        if (str == null || searchStr == null) {
            return INDEX_NOT_FOUND;
        }
        return lastIndexOfIgnoreCase(str, searchStr, str.length());
}

8.contains  包含

下面是包含空字符的一个方法，其他店的都很类似，什么大小写，去空等等方法，就不列出来了

//是否包含白色空格，即相当于空格和空格类似字符
public static boolean containsWhitespace(CharSequence seq) {
        if (isEmpty(seq)) {
            return false;
        }
        int strLen = seq.length();
        for (int i = 0; i < strLen; i++) {
            if (Character.isWhitespace(seq.charAt(i))) {
                return true;
            }
        }
        return false;
}

 

9.休息

突然发现这个StringUtils有6000行代码，只看了四分之一。今天就先到这里吧。