【小白日记】String类常用---API

常用API

自定义StringUtils类

1. StringUtils.isEmpty(str);

   返回类型：boolean
   A P I效果：判断指定字符串是否为空或null
   底层实现：

	public static boolean isEmpty(String str) {
	        if (str == null)
	            return true;
	        return "".equals(str.trim());
	}

延伸：

1. str.trim()

   返回类型：String
   A P I效果：删除字符串首尾的空格，并返回字符串
   底层实现:

	public String trim() {
	        int len = value.length;
	        int st = 0;
	        char[] val = value;    /* avoid getfield opcode */
	 
	        //寻找第一个不是‘ ’(空格)的字符的索引值
	        while ((st < len) && (val[st] <= ' ')) {
	            st++;
	        }
	        //寻找最后一个不是‘ ’(空格)的字符的索引值
	        while ((st < len) && (val[len - 1] <= ' ')) {
	            len--;
	        }
	        //截取字符串并返回，如无空格，返回原有字符串
	        return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
	    }

2. “”.equals(str.trim())
   此equals()方法针对String字符串类型

   返回类型：boolean
   A P I效果：比较两个字符串内容是否相同
   底层实现：

	public boolean equals(Object anObject) {
	        if (this == anObject) {
	            return true;
	        }
	        
	        // 判断校验对象是否为String类型
	        if (anObject instanceof String) {
	        
	        	// anotherString为传入equals方法的字符串
	            String anotherString = (String)anObject;
	            
	            // 此处value为equals方法前的字符串
	            int n = value.length;

				// 先判断比较的两个字符串长度是否相同
	            if (n == anotherString.value.length) {
	                char v1[] = value;
	                char v2[] = anotherString.value;
	                int i = 0;

					// 挨个字符进行比较
	                while (n-- != 0) {
	                    if (v1[i] != v2[i])
	                        return false;
	                    i++;
	                }
	                return true;
	            }
	        }
	        return false;
	    }

2. StringUtils.contains(str,searchStr)
   返回类型：boolean
   A P I效果：(类模糊查询)查询一个字符串中是否存在某个字符或字符串
   底层实现：

	public static boolean contains(String str, String searchStr) {

			//  查询和被查询的字符串不能为null
	        if (str == null || searchStr == null) {
	            return false;
	        }

			//  根据查询到的索引判断是否存在
	        return str.indexOf(searchStr) >= 0;
	    }

拓展：

1. str.indexOf(searchStr)
   返回类型：int
   A P I效果：查询某个字符串(searchStr)在一个字符串(str)中的索引位置
   底层实现：

	public int indexOf(String str) {
	        return indexOf(str, 0);
	    }

	public int indexOf(String str, int fromIndex) {
	
		// value为调用valueOf方法的字符串str，str.value为传入方法的字符串str
        return indexOf(value, 0, value.length,
                str.value, 0, str.value.length, fromIndex);
  		}

	static int indexOf(char[] source, int sourceOffset, int sourceCount,
            char[] target, int targetOffset, int targetCount,
            int fromIndex) {

		// fromIndex = 0 , sourcceCount为调用方法的字符串的长度
		// 字符串是否为空
        if (fromIndex >= sourceCount) {
        
        	// 如果字符串为空，则判断传入字符串是否也为空，为空返0，否则返-1
            return (targetCount == 0 ? sourceCount : -1);
        }
        if (fromIndex < 0) {
            fromIndex = 0;
        }
        
        // targetCount为传入字符串的长度
        // 校验传入字符串是否为空
        if (targetCount == 0) {
        	// 如果传入字符串为空，则返回0
            return fromIndex;
        }
		
		// 字符串首位字符， targetOffset = 0
        char first = target[targetOffset];
        
        // 计算字符串最大尾音·索引
        int max = sourceOffset + (sourceCount - targetCount);

		// sourceOffset = 0, fromIndex = 0, i = 0+0 = 0
		
		// 遍历调用方法的字符串中的第一个与传入字符串首位字符相同的字符的索引 i
        for (int i = sourceOffset + fromIndex; i <= max; i++) {
            /* Look for first character. */
            if (source[i] != first) {
                while (++i <= max && source[i] != first);
            }

            /* Found first character, now look at the rest of v2 */
            if (i <= max) {
            	
            	// j为调用方法字符串的下一位索引
                int j = i + 1;
                
                // end为计算传入的字符串尾部字符在调用方法字符串中的索引位置的下一位
                int end = j + targetCount - 1;

				// 遍历传入字符串和调用方法字符串对应字符是否相同
                for (int k = targetOffset + 1; j < end && source[j]
                        == target[k]; j++, k++);
                        
				// 如果j和计算的值相等，则说明两个字符串相同，则返回传入字符串首位字符在调用方法字符串中的索引
                if (j == end) {
                    /* Found whole string. */
                    return i - sourceOffset;
                }
            }
        }
        return -1;
    }