StringUtils的源码解析

public static boolean isEmpty(Object str) {
		return (str == null || "".equals(str));
	}

public static boolean hasLength(CharSequence str) {
		return (str != null && str.length() > 0);
	}

/**
	 * StringUtils.hasText(null) = false
	 * StringUtils.hasText("") = false
	 * StringUtils.hasText(" ") = false
	 * StringUtils.hasText("12345") = true
	 * StringUtils.hasText(" 12345 ") = true
*/
public static boolean hasText(String str) {
    	//不为空并且包含指定的str返回true
		return (hasLength(str) && containsText(str));
	}

//判断当前字符串str是否存在文本内容
private static boolean containsText(CharSequence str) {
		int strLen = str.length();   //长度
		for (int i = 0; i < strLen; i++) {
            //如果不是空白字符，说明其中有文本内容，返回true即可
			if (!Character.isWhitespace(str.charAt(i))) {
				return true;
			}
		}
		return false;
	}

public static boolean containsWhitespace(String str) {
    	//如果长度为0直接返回false
		if (!hasLength(str)) {
			return false;
		}

		int strLen = str.length();
		for (int i = 0; i < strLen; i++) {
            //遍历字符串，查看是否存在空白字符，存在即返回true
			if (Character.isWhitespace(str.charAt(i))) {
				return true;
			}
		}
		return false;
	}

public static String trimWhitespace(String str) {
		if (!hasLength(str)) {
			return str;
		}

		StringBuilder sb = new StringBuilder(str);
    	//去除字符串前面的空白字符
		while (sb.length() > 0 && Character.isWhitespace(sb.charAt(0))) {
			sb.deleteCharAt(0);
		}
    	//去除字符串末尾的空白字符
		while (sb.length() > 0 && Character.isWhitespace(sb.charAt(sb.length() - 1))) {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

public static String trimAllWhitespace(String str) {
		if (!hasLength(str)) {
			return str;
		}

		int len = str.length();
    	//使用stringBuilder存储非空白字符
		StringBuilder sb = new StringBuilder(str.length());
    	//遍历字符串，如果不是空白字符，那么直接添加到sb中
		for (int i = 0; i < len; i++) {
			char c = str.charAt(i);
			if (!Character.isWhitespace(c)) {
				sb.append(c);
			}
		}
		return sb.toString();
	}

public static String trimLeadingWhitespace(String str) {
		if (!hasLength(str)) {
			return str;
		}

		StringBuilder sb = new StringBuilder(str);
    	//只是去除前面的空白字符
		while (sb.length() > 0 && Character.isWhitespace(sb.charAt(0))) {
			sb.deleteCharAt(0);
		}
		return sb.toString();
	}

public static String trimTrailingWhitespace(String str) {
		if (!hasLength(str)) {
			return str;
		}

		StringBuilder sb = new StringBuilder(str);
    	//去除末尾的
		while (sb.length() > 0 && Character.isWhitespace(sb.charAt(sb.length() - 1))) {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

public static String trimLeadingCharacter(String str, char leadingCharacter) {
		if (!hasLength(str)) {
			return str;
		}

		StringBuilder sb = new StringBuilder(str);
		while (sb.length() > 0 && sb.charAt(0) == leadingCharacter) {
			sb.deleteCharAt(0);
		}
		return sb.toString();
	}

public static String trimTrailingCharacter(String str, char trailingCharacter) {
		if (!hasLength(str)) {
			return str;
		}

		StringBuilder sb = new StringBuilder(str);
		while (sb.length() > 0 && sb.charAt(sb.length() - 1) == trailingCharacter) {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}

public static boolean startsWithIgnoreCase(String str, String prefix) {
		return (str != null && prefix != null && str.length() >= prefix.length() &&
				str.regionMatches(true, 0, prefix, 0, prefix.length()));
	}

public static boolean endsWithIgnoreCase(String str, String suffix) {
	return (str != null && suffix != null && str.length() >= suffix.length() &&
			str.regionMatches(true, str.length() - suffix.length(), suffix, 0, suffix.length()));
}

public static boolean substringMatch(CharSequence str, int index, CharSequence substring) {
    	//如果开始的索引加上匹配的子串大小大于原本的字符串的大小，表明不匹配，返回false
		if (index + substring.length() > str.length()) {
			return false;
		}
    	//逐个字符比较，一旦遇到不同的，直接返回false即可
		for (int i = 0; i < substring.length(); i++) {
			if (str.charAt(index + i) != substring.charAt(i)) {
				return false;
			}
		}
		return true;
	}

public static int countOccurrencesOf(String str, String sub) {
		if (!hasLength(str) || !hasLength(sub)) {
			return 0;
		}

		int count = 0;  //数量
  		int pos = 0;   //索引，从0开始统计
		int idx;
   		// str.indexOf(sub, pos) : 返回子串sub在str中从pos索引开始的下标
		while ((idx = str.indexOf(sub, pos)) != -1) {
			++count;
			pos = idx + sub.length();  
		}
		return count;
	}

public static String replace(String inString, String oldPattern, String newPattern) {
		if (!hasLength(inString) || !hasLength(oldPattern) || newPattern == null) {
			return inString;
		}
    	//index
		int index = inString.indexOf(oldPattern);
		if (index == -1) {
			// no occurrence -> can return input as-is
			return inString;
		}
		int capacity = inString.length();
		if (newPattern.length() > oldPattern.length()) {
			capacity += 16;
		}
		StringBuilder sb = new StringBuilder(capacity);
		int pos = 0;  // our position in the old string
		int patLen = oldPattern.length();
		while (index >= 0) {
			sb.append(inString.substring(pos, index));
			sb.append(newPattern);
			pos = index + patLen;
			index = inString.indexOf(oldPattern, pos);
		}
		// append any characters to the right of a match
		sb.append(inString.substring(pos));
		return sb.toString();
	}

public static String replace(String inString, String oldPattern, String newPattern) {
		if (!hasLength(inString) || !hasLength(oldPattern) || newPattern == null) {
			return inString;
		}
		StringBuilder sb = new StringBuilder();
		int pos = 0; // our position in the old string
		int index = inString.indexOf(oldPattern);   //获取oldpattern在instring中的开始索引
		// the index of an occurrence we've found, or -1
		int patLen = oldPattern.length(); 
    	//遍历字符串，替换
		while (index >= 0) {
			sb.append(inString.substring(pos, index));
			sb.append(newPattern);
			pos = index + patLen;
			index = inString.indexOf(oldPattern, pos);
		}
		sb.append(inString.substring(pos));
		// remember to append any characters to the right of a match
		return sb.toString();
	}

public static String delete(String inString, String pattern) {
    	//使用空字符替换删除的pattern
		return replace(inString, pattern, "");
	}

public static String deleteAny(String inString, String charsToDelete) {
		if (!hasLength(inString) || !hasLength(charsToDelete)) {
			return inString;
		}
		StringBuilder sb = new StringBuilder();
    	//遍历字符串
		for (int i = 0; i < inString.length(); i++) {
			char c = inString.charAt(i);   //获取当前的字符
            //如果当前的字符不在需要删除的charsToDelete中，那么添加到sb中
			if (charsToDelete.indexOf(c) == -1) {
				sb.append(c);
			}
		}
		return sb.toString();
	}

public static String quote(String str) {
		return (str != null ? "'" + str + "'" : null);
	}

public static String uncapitalize(String str) {
		return changeFirstCharacterCase(str, false);
	}

	private static String changeFirstCharacterCase(String str, boolean capitalize) {
		if (str == null || str.length() == 0) {
			return str;
		}
		StringBuilder sb = new StringBuilder(str.length());
		if (capitalize) {
			sb.append(Character.toUpperCase(str.charAt(0)));
		}
		else {
			sb.append(Character.toLowerCase(str.charAt(0)));
		}
		sb.append(str.substring(1));
		return sb.toString();
	}

public static String capitalize(String str) {
		return changeFirstCharacterCase(str, true);
	}

public static String getFilename(String path) {
		if (path == null) {
			return null;
		}
		int separatorIndex = path.lastIndexOf(FOLDER_SEPARATOR);
		return (separatorIndex != -1 ? path.substring(separatorIndex + 1) : path);
	}

public static String getFilenameExtension(String path) {
		if (path == null) {
			return null;
		}
		int extIndex = path.lastIndexOf(EXTENSION_SEPARATOR);   //获取最后一个.的索引
		if (extIndex == -1) {
			return null;
		}
		int folderIndex = path.lastIndexOf(FOLDER_SEPARATOR);  //获取最后一个/的索引
		if (folderIndex > extIndex) {
			return null;
		}
		return path.substring(extIndex + 1);
	}

/**
	 * Strip the filename extension from the given path,
	 * e.g. "mypath/myfile.txt" -> "mypath/myfile".
	 * @param path the file path (may be {@code null})
	 * @return the path with stripped filename extension,
	 * or {@code null} if none
	 */
	public static String stripFilenameExtension(String path) {
		if (path == null) {
			return null;
		}
		int extIndex = path.lastIndexOf(EXTENSION_SEPARATOR);
		if (extIndex == -1) {
			return path;
		}
		int folderIndex = path.lastIndexOf(FOLDER_SEPARATOR);
		if (folderIndex > extIndex) {
			return path;
		}
		return path.substring(0, extIndex);
	}

public static String[] delimitedListToStringArray(String str, String delimiter) {
		return delimitedListToStringArray(str, delimiter, null);
	}

public static String[] delimitedListToStringArray(String str, String delimiter, String charsToDelete) {
		if (str == null) {
			return new String[0];
		}
    	//没有分隔符直接返回原来字符串
		if (delimiter == null) {
			return new String[] {str};
		}
		List<String> result = new ArrayList<String>();
    	//如果分隔符为空，那么每一个字符都要分割
		if ("".equals(delimiter)) {
			for (int i = 0; i < str.length(); i++) {
                //删除指定的字符，并且添加到restult中
				result.add(deleteAny(str.substring(i, i + 1), charsToDelete));
			}
		}
		else {  //分割符不为空，并且不是空字符串
			int pos = 0;  
			int delPos;   //定义需要进行删除的字符串的最后一个index
            //str.indexOf(delimiter, pos) : 从pos位置开始，获取分割符的索引，此时的 [pos,delpos]就是一个分割的字符串，那么我们需要对其删除指定的字符
			while ((delPos = str.indexOf(delimiter, pos)) != -1) {
                //删除一个子串中的指定字符，并且添加到result中
				result.add(deleteAny(str.substring(pos, delPos), charsToDelete));
				pos = delPos + delimiter.length();  //pos后移，移到下一个需要分割的字符串，也就是剩下的字符串
			}
			if (str.length() > 0 && pos <= str.length()) {
				// Add rest of String, but not in case of empty input.
				result.add(deleteAny(str.substring(pos), charsToDelete));
			}
		}
		return toStringArray(result);   //将List转换成字符串数组
	}

public static String[] toStringArray(Collection<String> collection) {
		if (collection == null) {
			return null;
		}
    	//调用Collection中的toArray(T[] a)方法,需要指定数组的容量
		return collection.toArray(new String[collection.size()]);
	}

public static String[] sortStringArray(String[] array) {
    	//判断数组是否为空，这里的 org.springframework.util.ObjectUtils，也是一个工具类
		if (ObjectUtils.isEmpty(array)) {
			return new String[0];
		}
		Arrays.sort(array);   //使用Arrays的排序，升序
		return array;
	}

public static String[] trimArrayElements(String[] array) {
		if (ObjectUtils.isEmpty(array)) {
			return new String[0];
		}
    	//创建一个新数组保存
		String[] result = new String[array.length];
		for (int i = 0; i < array.length; i++) {
			String element = array[i];
			result[i] = (element != null ? element.trim() : null);
		}
		return result;
	}

public static String[] removeDuplicateStrings(String[] array) {
		if (ObjectUtils.isEmpty(array)) {
			return array;
		}
    	//使用集合set来去掉重复的元素
		Set<String> set = new TreeSet<String>();
		for (String element : array) {
			set.add(element);
		}
    	//将集合转换成String[]
		return toStringArray(set);
	}

public static String[] split(String toSplit, String delimiter) {
		if (!hasLength(toSplit) || !hasLength(delimiter)) {
			return null;
		}
		int offset = toSplit.indexOf(delimiter);
		if (offset < 0) {
			return null;
		}
		String beforeDelimiter = toSplit.substring(0, offset);
		String afterDelimiter = toSplit.substring(offset + delimiter.length());
		return new String[] {beforeDelimiter, afterDelimiter};
	}

public static String arrayToDelimitedString(Object[] arr, String delim) {
		if (ObjectUtils.isEmpty(arr)) {
			return "";
		}
		if (arr.length == 1) {
			return ObjectUtils.nullSafeToString(arr[0]);
		}
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < arr.length; i++) {
			if (i > 0) {
				sb.append(delim);
			}
			sb.append(arr[i]);
		}
		return sb.toString();
	}

public static String cleanPath(String path) {
		if (path == null) {
			return null;
		}
    	//将path中的\\全部替换成/
    //如果这个路径是在windows下，如 c:\\image\\file.jpg,那么经过replace，将会变成 c://image//file.jpg
		String pathToUse = replace(path, WINDOWS_FOLDER_SEPARATOR, FOLDER_SEPARATOR);
    	//获取pathToUse中:的索引
		int prefixIndex = pathToUse.indexOf(":");
		String prefix = "";   //前缀，比如  c: 或者 /
    //如果这个路径是在windows下，如 c:\\image\\file.jpg,那么经过replace，将会变成 c://image//file.jpg
		if (prefixIndex != -1) {
			prefix = pathToUse.substring(0, prefixIndex + 1);  //前缀变成 `c:`
			pathToUse = pathToUse.substring(prefixIndex + 1);  //去掉前面的前缀
		}
    	//如果pathToUse是以/开头，表示是linux下的路径
		if (pathToUse.startsWith(FOLDER_SEPARATOR)) {
			prefix = prefix + FOLDER_SEPARATOR;   //前缀就是  /
			pathToUse = pathToUse.substring(1);   //pathToUse就变成了去掉/之后的字符串
		}
		//将pathToUse使用/分割成一个字符串数组，比如pathToUse=home/chenjiabinbg/file.txt，那么数组为 ["home","chenjiabing","file.txt"]
		String[] pathArray = delimitedListToStringArray(pathToUse, FOLDER_SEPARATOR);
    
		List<String> pathElements = new LinkedList<String>();
		int tops = 0;
		
    	//遍历数组
		for (int i = pathArray.length - 1; i >= 0; i--) {
			String element = pathArray[i];
            //如果这个元素是表示当前路径的   .表示当前路径，..表示上一级路径
			if (CURRENT_PATH.equals(element)) {
				// Points to current directory - drop it.
			}
            //如果是上一级路径，tops+1
			else if (TOP_PATH.equals(element)) {
				// Registering top path found.
				tops++;
			}
			else {
				if (tops > 0) {
					// Merging path element with element corresponding to top path.
					tops--;
				}
				else {
					// Normal path element found.
					pathElements.add(0, element);
				}
			}
		}
		// Remaining top paths need to be retained.
		for (int i = 0; i < tops; i++) {
			pathElements.add(0, TOP_PATH);
		}
		
		return prefix + collectionToDelimitedString(pathElements, FOLDER_SEPARATOR);
	}