Sprint源码学习之StringUtils类
/*
* To change this template, choo Tools | Templates
* and open the template in the editor.
*/
package arthurv.java.spring.learn;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
/**
*/
public abstract class StringUtils {
private static final String FOLDER_SEPARATOR = "/";
private static final String WINDOWS_FOLDER_SEPARATOR = "\\";
private static final String TOP_PATH = "..";
private static final String CURRENT_PATH = ".";
private static final char EXTENSION_SEPARATOR = '.';
//---------------------------------------------------------------------
// General convenience methods for working with Strings
//---------------------------------------------------------------------
//判断str是否为空值
public static boolean hasLength(CharSequence str) {
return (str != null && str.length() > 0);
}
/**
* 判断字符串是否有长度
* 注意CharSequence是String类的上层接⼝
* @param str
* @return
*/
public static boolean hasLength(String str) {
return hasLength((CharSequence) str);
}
/**
* 判断CharSequence是否有实际内容，空格不算
* <p><pre>
* StringUtils.hasText(null) = fal
* StringUtils.hasText("") = fal
蒋子涵
* StringUtils.hasText(" ") = fal
* StringUtils.hasText("12345") = true
* StringUtils.hasText(" 12345 ") = true
*/
public static boolean hasText(CharSequence str) {
//如果str为空，返回fal
if (!hasLength(str)) {
return fal;
}
//获取str的长度
int strLen = str.length();
//循环遍历str
for (int i = 0; i < strLen; i++) {
过零丁洋古诗拼音版
//如果在0到strlen之间，有⼀个不是空格，说明有内容，返回true if (!Character.isWhitespace(str.charAt(i))) {
return true;
}
}
return fal;
}
/**
* 判断str是否是实际内容，纯空格组成的str返回fal
*/
public static boolean hasText(String str) {
return hasText((CharSequence) str);
}
/**
*检测CharSequence是否有空⽩字符
*/
public static boolean containsWhitespace(CharSequence str) {
/
/如果长度为0，则返回fal
if (!hasLength(str)) {
return fal;
}
int strLen = str.length();
//循环遍历str
for (int i = 0; i < strLen; i++) {
//如果在0到strLen之间有空⽩符，则返回true
if (Character.isWhitespace(str.charAt(i))) {
return true;
}
}
return fal;
}
/**
*判断给定的字符串str是否含有空⽩符
*/
public static boolean containsWhitespace(String str) {
return containsWhitespace((CharSequence) str);
}
/**
* 去掉str开头和结尾的空⽩符
*/
public static String trimWhitespace(String str) {
地理常识全知道//如果没有长度，则放回str
if (!hasLength(str)) {
return str;
}
StringBuilder sb = new StringBuilder(str);
//如果sb.charAt(0)是空⽩符的话，删除该空⽩符
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);
}
//返回去掉开头结尾空⽩符之后的字符串
String();
}
/**
*删除给定的字符串中所有的空⽩符
*/
public static String trimAllWhitespace(String str) {
//如果str没有长度，返回str
if (!hasLength(str)) {
return str;
}
StringBuilder sb = new StringBuilder(str);
女性魅力int index = 0;
//循环遍历sb
while (sb.length() > index) {
//如果当前位置index为空⽩符，则删除之
if (Character.isWhitespace(sb.charAt(index))) {
sb.deleteCharAt(index);
}
el {
index++;
}
}
//返回去掉空⽩符之后的字符串
String();
}
/**
*删除掉str的开头的空⽩符，如果有的话
*/
public static String trimLeadingWhitespace(String str) {
/
/如果str的长度为0，返回str
if (!hasLength(str)) {
return str;
}
StringBuilder sb = new StringBuilder(str);
//如果开头有字符串，则删除之
while (sb.length() > 0 && Character.isWhitespace(sb.charAt(0))) {
sb.deleteCharAt(0);
}
//返回删除开头空⽩符的字符串
String();
}
/**
* 删除str结尾的空⽩符，如果结尾是空⽩符的话
*/
public static String trimTrailingWhitespace(String str) {
//如果str的长度为0，返回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);
}
//返回删除开头空⽩符的字符串
String();
}
/**
*删除str中开头是字符是给定字符的那个字符
*/
public static String trimLeadingCharacter(String str, char leadingCharacter) { //如果str的长度为0，返回str
if (!hasLength(str)) {
return str;
}
StringBuilder sb = new StringBuilder(str);
//判断sb的开头是否==leadingCharacter，若是就删除，否则什么也不做 while (sb.length() > 0 && sb.charAt(0) == leadingCharacter) {
sb.deleteCharAt(0);
}
String();
}
/**
*删除结尾等于trailingCharacter的那个字符
*/
public static String trimTrailingCharacter(String str, char trailingCharacter) {
//如果str的长度为0，返回str
if (!hasLength(str)) {
return str;
}
StringBuilder sb = new StringBuilder(str);
//判断sb的开头是否==leadingCharacter，若是就删除，否则什么也不做 while (sb.length() > 0 && sb.charAt(sb.length() - 1) == trailingCharacter) {
sb.deleteCharAt(sb.length() - 1);
}
String();
}
/**
*检测str的前缀是否是prefix，⼤⼩写不敏感
*/
public static boolean startsWithIgnoreCa(String str, String prefix) {柴胡疏肝
if (str == null || prefix == null) {
return fal;
}
泰坦尼克号英文//如果是则返回true
if (str.startsWith(prefix)) {
return true;
}
/
/如果str⼩于前缀，则返回fal
if (str.length() < prefix.length()) {
return fal;
}
//设定⼤⼩写不明感
//把str的前⾯长度等于prefix的字符变⼩写
String lcStr = str.substring(0, prefix.length()).toLowerCa();
//把prefix变⼩写
String lcPrefix = LowerCa();
//判断
return lcStr.equals(lcPrefix);
}
子宫肌瘤的治疗方法
/**
*检测str的后缀是否是prefix，⼤⼩写不敏感
*/
public static boolean endsWithIgnoreCa(String str, String suffix) {
if (str == null || suffix == null) {
}
//如果后缀是suffix，返回true
if (dsWith(suffix)) {
return true;
}
if (str.length() < suffix.length()) {
return fal;
}
//设定⼤⼩写不敏感
String lcStr = str.substring(str.length() - suffix.length()).toLowerCa();
String lcSuffix = LowerCa();
return lcStr.equals(lcSuffix);
}
/**
* 判断给定的str中是否有在位置index处存在⼦序列subString
*/
public static boolean substringMatch(CharSequence str, int index, CharSequence substring) { for (int j = 0; j < substring.length(); j++) {
int i = index + j;
//如果i>=str.length说明str字符串⾃index到最后的长度⼩于subString
//str.charAt(i) != substring.charAt(j)，如果当前j位置字符和str中i位置字符不相等 if (i >= str.length() || str.charAt(i) != substring.charAt(j)) {
return fal;
}
}
return true;
}
/**
*检测str中出现sub⼦字符串的个数.
*/
public static int countOccurrencesOf(String str, String sub) {
//边界处理
if (str == null || sub == null || str.length() == 0 || sub.length() == 0) {
return 0;
}
//计数器
int count = 0;
//记录当前位置
int pos = 0;
int idx;
//indexOf(String str,int fromIndex)str - 要搜索的⼦字符串。
//fromIndex - 开始搜索的索引位置
//如果含有此sub，则计数器+1
while ((idx = str.indexOf(sub, pos)) != -1) {
++count;
//下⼀个开始⽐较的位置
pos = idx + sub.length();
}
//返回sub出现的个数
return count;
五香猪肉}
/**
* ⽤newPattern来替换inString中的oldPattern
*/
public static String replace(String inString, String oldPattern, String newPattern) {
//边界处理
if (!hasLength(inString) || !hasLength(oldPattern) || newPattern == null) {
return inString;
}
StringBuilder sb = new StringBuilder();
