源碼分析八(org.springframework.util包之StringUtils類))

一：spring框架util包中的StringUtils類主要是處理關於字符串

的功能方法，下面直接結合代碼分析：

//判斷字符串是否為空，如果為nul或者""則返回true，否則返回false
public static boolean isEmpty(Object str)
    {
        return str == null || "".equals(str);
    }

　　

//判斷字符串是否有長度，不等於null同時長度大於0，則為true
//這里重載兩個hasLength方法，其中CharSequence是String的父類，是接口
public static boolean hasLength(CharSequence str)
    {
        return str != null && str.length() > 0;
    }

    public static boolean hasLength(String str)
    {
        return hasLength(((CharSequence) (str)));
    }

　　

//如果為空則直接返回false，如果字符串中有一個不是空白，則表示
//有內容，返回true 
public static boolean hasText(CharSequence str)
    {
        if(!hasLength(str))
            return false;
        int strLen = str.length();
        //遍歷字符序列，如果其中有一個不是空白，則返回true
        for(int i = 0; i < strLen; i++)
            if(!Character.isWhitespace(str.charAt(i)))
                return true;

        return false;
    }

    public static boolean hasText(String str)
    {
        return hasText(((CharSequence) (str)));
    }

　　

//判斷字符串是否包含空白，如果為空則直接返回false，，遍歷字符序列，如果其中
//有一個字符是空白，則返回true，如果都不是，返回false
public static boolean containsWhitespace(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(String str)
    {
        return containsWhitespace(((CharSequence) (str)));
    }

　　

//去除字符串前后的空白
public static String trimWhitespace(String str)
    {
        if(!hasLength(str))
            return str;
        StringBuilder sb;
        //去除字符串前導空白
        for(sb = new StringBuilder(str); sb.length() > 0 && Character.isWhitespace(sb.charAt(0)); sb.deleteCharAt(0));
        //去除字符串后導空白
        for(; 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;
        StringBuilder sb = new StringBuilder(str);
        //從第一個字符開始判斷，是否為空白，如果是則刪除，如果不是則index加1
        //判斷第二個，然后一直到sb.length=index,則跳出循環
        for(int index = 0; sb.length() > index;)
            if(Character.isWhitespace(sb.charAt(index)))
                sb.deleteCharAt(index);
            else
                index++;

        return sb.toString();
    }

　　

//去除前導空白，只取空白的前一部分 
public static String trimLeadingWhitespace(String str)
    {
        if(!hasLength(str))
            return str;
        StringBuilder sb;
        //去除前導空白
        for(sb = new StringBuilder(str); 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;
        //去除后導空白
        for(sb = new StringBuilder(str); sb.length() > 0 && Character.isWhitespace(sb.charAt(sb.length() - 1)); sb.deleteCharAt(sb.length() - 1));
        return sb.toString();
    }

　　

//刪除前導為leadingCharacter的字符
 public static String trimLeadingCharacter(String str, char leadingCharacter)
    {
        if(!hasLength(str))
            return str;
        StringBuilder sb;
        //只要前導是指定字符則刪除
        for(sb = new StringBuilder(str); sb.length() > 0 && sb.charAt(0) == leadingCharacter; sb.deleteCharAt(0));
        return sb.toString();
    }

　　

//刪除后導字符trailingCharacter
 public static String trimTrailingCharacter(String str, char trailingCharacter)
    {
        if(!hasLength(str))
            return str;
        StringBuilder sb;
        //只要后導是指定字符則刪除
        for(sb = new StringBuilder(str); sb.length() > 0 && sb.charAt(sb.length() - 1) == trailingCharacter; sb.deleteCharAt(sb.length() - 1));
        return sb.toString();
    }

　　

//忽略大小寫，判斷字符串是否已prefix開始 
public static boolean startsWithIgnoreCase(String str, String prefix)
    { 
        //如果源字符串str或者前綴字符串prefix為null，則返回false
        if(str == null || prefix == null)
            return false;
        //如果str以prefix開始，return true
        if(str.startsWith(prefix))
            return true;
       //如果源字符串的長度小於prefix的長度，返回false
        if(str.length() < prefix.length())
        {
            return false;
        } else
        {
            將源字符串prefix長度轉換為小寫，前綴字符串也轉換為小寫，比較是否相等
            String lcStr = str.substring(0, prefix.length()).toLowerCase();
            String lcPrefix = prefix.toLowerCase();
            return lcStr.equals(lcPrefix);
        }
    }

　　

//忽略大小寫，判斷源字符串str是否以suffix結尾，處理邏輯類似上一個方法 
public static boolean endsWithIgnoreCase(String str, String suffix)
    {
        if(str == null || suffix == null)
            return false;
        if(str.endsWith(suffix))
            return true;
        if(str.length() < suffix.length())
        {
            return false;
        } else
        {
            String lcStr = str.substring(str.length() - suffix.length()).toLowerCase();
            String lcSuffix = suffix.toLowerCase();
            return lcStr.equals(lcSuffix);
        }
    }