读String源码所思所得

读String源码所思所得

• I.String类型最大的特点是String对象在创建之后是不可变的，因此String对象之间是可以共享的，即具有相同字符串的String对象都引用自同一个String。
  原因在于，装载字符的value声明的时候被final修饰，private final char value[]。
  如String str = “abc” 和char data[] = {‘a’, ‘b’, ‘c’};String str = new String(data)是等价的

  		//测试代码：	
  			public static void main(String[] args) {
  				String string="abc";
  				String string2=string;
  				System.out.println(string.equals(string2));
  				System.out.println(string==string2);
  				
  				char [] data= {'a','b','c'};
  				String dataStr=new String(data);
  				
  				System.out.println(string.equals(dataStr));
  				System.out.println(string==dataStr);
  				
  				String string3=new String(string);
  				
  				System.out.println(string.equals(string3));
  				System.out.println(string==string3);
  				
  				/*
  				 * 运行结果：
  					true
  					true
  					true
  					false
  					true
  					false
  					表明：赋值得到的String与被赋值的String指向的是同一个String对象，两者不仅等价且相等
  						   而new出来的String虽然与传入构造器的string等价但不相等，不是同一个对象
  				*/
  		
  				string2=string2+"d";
  				System.out.println(string);
  				
  				dataStr=dataStr+"e";		
  				System.out.println(string);
  				/*
  				 * 运行结果：
  					abc
  					abc
  					表明：不论是赋值得到的String还是new出来的String，其本身的变化都无法影响提供字符串的String
  				*/
  		
  			}
  

  这个特点在String类的原生方法intern()的注释中有解释:String类会维护一个私有的字符串池，而我们在代码中使用的String对象时引用对象，创建一个新的String对象时intern()方法会被调用，字符串池会从池中已有的字符串对象里查找跟新对象等价(即字符串完成匹配)的对象，如果有则该新对象会直接引用匹配的对象，如果没有则会创建新对象需要引用的字符串对象并加入字符串池，最后引用给新对象。注释原文如下：

  				 Returns a canonical representation for the string object.
  			     * <p>
  			     * A pool of strings, initially empty, is maintained privately by the
  			     * class {@code String}.
  			     * <p>
  			     * When the intern method is invoked, if the pool already contains a
  			     * string equal to this {@code String} object as determined by
  			     * the {@link #equals(Object)} method, then the string from the pool is
  			     * returned. Otherwise, this {@code String} object is added to the
  			     * pool and a reference to this {@code String} object is returned.
  			     * <p>
  			     * It follows that for any two strings {@code s} and {@code t},
  			     * {@code s.intern() == t.intern()} is {@code true}
  			     * if and only if {@code s.equals(t)} is {@code true}.
  			     * <p>
  			     * All literal strings and string-valued constant expressions are
  			     * interned. String literals are defined in section 3.10.5 of the
  			     * <cite>The Java&trade; Language Specification</cite>.
  			     *
  			     * @return  a string that has the same contents as this string, but is
  			     *          guaranteed to be from a pool of unique strings.
  			     */
  			     public native String intern();
  

• II.Strin类中提供了多个构造器，其中最为特别的是为截取扩展字符数值数组并转换成字符的构造器，因为一个扩展字符占用两个char大小，所以需要在数组长度上下功夫。自然，很多方法都需要考虑到扩展字符长度的问题，因此String中一种方法会有两个版本：针对BMP和针对扩展字符

  		public String(int[] codePoints, int offset, int count) {
  	        if (offset < 0) {
  	            throw new StringIndexOutOfBoundsException(offset);
  	        }
  	        if (count <= 0) {
  	            if (count < 0) {
  	                throw new StringIndexOutOfBoundsException(count);
  	            }
  	            if (offset <= codePoints.length) {
  	                this.value = "".value;
  	                return;
  	            }
  	        }
  	        // Note: offset or count might be near -1>>>1.
  	        if (offset > codePoints.length - count) {
  	            throw new StringIndexOutOfBoundsException(offset + count);
  	        }
  	
  	        final int end = offset + count;
  	
  	        // Pass 1: Compute precise size of char[]
  			//计算扩展字符数量，字符长度为count+扩展字符数量	        
  			int n = count;
  	        for (int i = offset; i < end; i++) {
  	            int c = codePoints[i];
  	            if (Character.isBmpCodePoint(c))
  	                continue;
  	            else if (Character.isValidCodePoint(c))
  	                n++;
  	            else throw new IllegalArgumentException(Integer.toString(c));
  	        }
  	
  	        // Pass 2: Allocate and fill in char[]
  	        final char[] v = new char[n];
  	
  	        for (int i = offset, j = 0; i < end; i++, j++) {
  	            int c = codePoints[i];
  	            if (Character.isBmpCodePoint(c))
  	                v[j] = (char)c;
  	            else
  	                Character.toSurrogates(c, v, j++);
  	        }
  	
  	        this.value = v;
  	    }
  

• III.String提供了查找目标字符或字符串在某个字符串中的索引号，其中比较特别的是LastIndexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex)方法，也就是从尾查找目标字符串在指定字符串中的结束索引号，特别之处在于如果目标字符串为空字符串时返回指定字符串的结束索引号，这里应该使用了集合概念，空集是任意集合的子集。

		//代码清单：
	
			static int lastIndexOf(char[] source, int sourceOffset, int sourceCount,
		            char[] target, int targetOffset, int targetCount,
		            int fromIndex) {
		        /*
		         * Check arguments; return immediately where possible. For
		         * consistency, don't check for null str.
		         */
		        int rightIndex = sourceCount - targetCount;
		        if (fromIndex < 0) {
		            return -1;
		        }
		        if (fromIndex > rightIndex) {
		            fromIndex = rightIndex;
		        }
		        /* Empty string always matches. */
		        if (targetCount == 0) {
		            return fromIndex;
		        }
		
		        int strLastIndex = targetOffset + targetCount - 1;
		        char strLastChar = target[strLastIndex];
		        int min = sourceOffset + targetCount - 1;
		        int i = min + fromIndex;
		
		    startSearchForLastChar:
		        while (true) {
		            while (i >= min && source[i] != strLastChar) {
		                i--;
		            }
		            if (i < min) {
		                return -1;
		            }
		            int j = i - 1;
		            int start = j - (targetCount - 1);
		            int k = strLastIndex - 1;
		
		            while (j > start) {
		                if (source[j--] != target[k--]) {
		                    i--;
		                    continue startSearchForLastChar;
		                }
		            }
		            return start - sourceOffset + 1;
		        }
		    }