org.springframework.util.StringUtils

知识补充

• 1. 空白字符：空格【’ ‘】、tab键【’\t’】、换行符【‘\n’】
• 2. jdk的Character.isWhitespace(char ch); 判断字符是否是空白字符
• 3. jdk的String类的regionMatches()方法用于检测两个字符串在一个区域内是否相等
  • 语法

public boolean regionMatches(int toffset,String other,int ooffset,int len) {}

public boolean regionMatches(boolean ignoreCase,int toffset,String other,int ooffset,int len ) {}

*  参数解释
*  ignoreCase  【如果为true，则比较字符时忽略大小写】
* toffset           【调用方法的字符串的起始偏移量】
* other			   【与调用方法的对象进行比较的其它字符串】
* ooffset          【other字符串的起始偏移量】
* len  			   【要比较的字符数】

代码

package org.springframework.util;

import java.io.ByteArrayOutputStream;
import java.nio.charset.Charset;
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.LinkedHashSet;
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.TimeZone;

import org.springframework.lang.Nullable;
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 CURRENT_PATH = ".";

	private static final char EXTENSION_SEPARATOR = ".";

	// 判断字符串是null或者没有内容
	public static boolean isEmpty(@Nullable Object str){
		return (str == null || "".equals(str));
	}
	
	// 判断字符串不是null并且有内容
	public static boolean hasLength(@Nullable CharSequence str) {
		return (str != null && str.length() > 0);
	}

	// 判断字符串不是null并且有内容
	public static boolean hasLength(@Nullable String str) {
		return (str != null && !str.isEmpty());
	}
	
	// 判断是否包含除空白字符外的其它字符
	private static boolean containsText(CharSequence str) {
		int strLen = str.length();
		for(int i=0;i<strLen;i++) {
			if(!Character.isWhitespace(str.charAt(i))) {
				return true;
			}
		}
		return false;
	}

	// 判断是否满足不是null并且有内容且包含除空白字符外的其它字符
	public static boolean hasText(@Nullable CharSequence str) {
		return (str != null && str.length() > 0 && containsText(str));
	}
	
	// 判断是否满足不是null并且有内容且包含除空白字符外的其它字符
	public static boolean hasText(@Nullable String str) {
		return (str != null && !str.isEmpty() && containsText(str));
	}
	
	// 判断是否包含空白字符
	public static boolean containsWhitespace(@Nullable CharSequence str) {
		if(!hasLength(str)) {
			return false;
		}
		int strLen = str.length();
		for(int i=0;i<strLen;i++) {
			if(Character.isWhitespace(str.charAt(i))) {
				return true;
			}
		}
		return false;
	}
	
	// 判断是否包含空白字符
	public static boolean containsWhitespace(@Nullable String str) {
		return containsWhitespace((CharSequence)str);
	}
	
	// 删除字符串开头和结尾的空白字符
	public static String trimWhitespace(String str){
		if(!hasLength(str)) {
			return str;
		}
		int beginIndex = 0;
		int endIndex = str.length() - 1;
		while(beginIndex <= endIndex && Character.isWhitespace(str.charAt(beginIndex))) {
			beginIndex++;
		} 
		while(endIndex > beginIndex && Character.isWhiltespace(str.charAt(endIndex))) {
			endIndex--;
		}
		return str.substring(beginIndex,endIndex + 1);
	}
	
	// 去除所有的空白字符
	public static String trimAllWhitespace() {
		if(!hasLength(str)) {
			return str;
		}
		int len = str.length();
		StringBuilder result = new StringBuilder(len);
		for(int = 0;i < len;i++) {
			char c = str.charAt(i);
			if(!Character.isWhitespace(c)) {
				result.append(c);
			}
		}
		return result.toString();
	}
	
	// 删除开头的空白字符
	public static String trimLeadingWhitespace(String str) {
		if(!hasLength(str)) {
			return str;
		}
		StringBuilder result = new StringBuilder(str);
		while(result.length() > 0 && Character.isWhitespace(result.charAt(0))) {
			result.deleteCharAt(0);
		}
		return result.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 result = new StringBuilder(str);
		while(result.length() > 0 && result.charAt(0) == leadingCharacter) {
			result.deleteCharAt(0);
		}
		return result.toString();
	}
	
	// 删除结尾的全部的指定字符
	public static String trimTrailingCharacter(String str,char trailingCharacter) {
		if(!hasLength(str)) {
			return str;
		}
		StringBuilder result = new StringBuilder(str);
		while (sb.length() > 0 && sb.charAt(sb.length() - 1) == trailingCharacter) {
			sb.deleteCharAt(sb.length() - 1);
		}
		return sb.toString();
	}
	
	// 将首字母变大写
	public static String capitalize(String str) {
		return changeFirstCharacterCase(str,true);
	}
	
	// 将首字母变小写
	public static String uncapitalize(String str) {
		return changeFirstCharacterCase(str,false);
	}

	// 是否把首字符变为大写 由参数capitalize指定
	public static String changeFirstCharacterCase(String str,boolean capitalize) {
		if(!hasLength(str)) {
			return str;
		}
		char baseChar = str.charAt(0);
		char updatedChar;
		if(capitalize) {
			updatedChar = Character.toUpperCase(baseChar);
		} else {
			updatedChar = Character.toLowerCase(baseChar);
		}
		if(baseChar == updatedChar) {
			return str;
		}
		char[] chars = str.toCharArray();
		chars[0] = updatedChar;
		return new String(chars,0,chars.length);
	}
	
	








	
}