复制下来的java.lang.String源码。在此基础上添加自己的注释，偷懒了，用来加深印象吧。英语不好，没有翻译，不理解的方法直接百度的。然后按照自己的理解描述。
/** @(#)String.java 1.205 09/02/26** Copyright 2006 Sun Microsystems, Inc. All rights reserved.* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.*/package java.lang;import java.io.ObjectStreamClass; import java.io.ObjectStreamField; import java.io.UnsupportedEncodingException;
nio和io的区别：
nio是非阻塞的，有缓存机制，
import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Arrays; import java.util.Comparator; import java.util.Formatter; import java.util.Locale; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException;/*** The <code>String</code> class represents character strings. All* string literals in Java programs, such as <code>"abc"</code>, are* implemented as instances of this class.* <p>
string 类型当他们被创建后就不会再改变* Strings are constant; their values cannot be changed after they* are created. String buffers support mutable strings.* Because String objects are immutable they can be shared. For example:* <p><blockquote><pre>* String str = "abc";* </pre></blockquote><p>* is equivalent to:* <p><blockquote><pre>* char data[] = {'a', 'b', 'c'};* String str = new String(data);* </pre></blockquote><p>* Here are some more examples of how strings can be used:* <p><blockquote><pre>* System.out.println("abc");* String cde = "cde";* System.out.println("abc" + cde);* String c = "abc".substring(2,3);* String d = cde.substring(1, 2);* </pre></blockquote>* <p>* The class <code>String</code> includes methods for examining* individual characters of the sequence, for comparing strings, for* searching strings, for extracting substrings, and for creating a* copy of a string with all characters translated to uppercase or to* lowercase. Case mapping is based on the Unicode Standard version* specified by the {@link java.lang.Character Character} class.* <p>* The Java language provides special support for the string* concatenation operator ( + ), and for conversion of* other objects to strings. String concatenation is implemented* through the <code>StringBuilder</code>(or <code>StringBuffer</code>)* class and its <code>append</code> method.* String conversions are implemented through the method* <code>toString</code>, defined by <code>Object</code> and* inherited by all classes in Java. For additional information on* string concatenation and conversion, see Gosling, Joy, and Steele,* <i>The Java Language Specification</i>.** <p> Unless otherwise noted, passing a <tt>null</tt> argument to a constructor* or method in this class will cause a {@link NullPointerException} to be* thrown.** <p>A <code>String</code> represents a string in the UTF-16 format* in which <em>supplementary characters</em> are represented by <em>surrogate* pairs</em> (see the section <a href="Character.html#unicode">Unicode* Character Representations</a> in the <code>Character</code> class for* more information).* Index values refer to <code>char</code> code units, so a supplementary* character uses two positions in a <code>String</code>.* <p>The <code>String</code> class provides methods for dealing with* Unicode code points (i.e., characters), in addition to those for* dealing with Unicode code units (i.e., <code>char</code> values).** @author Lee Boynton* @author Arthur van Hoff* @version 1.205, 02/26/09* @see java.lang.Object#toString()* @see java.lang.StringBuffer* @see java.lang.StringBuilder* @see java.nio.charset.Charset* @since JDK1.0*/public final class Stringimplements java.io.Serializable, Comparable<String>, CharSequence {
用来存储字符串的数组/** The value is used for character storage. */private final char value[];
第一个有效的字符的偏移量。默认为0/** The offset is the first index of the storage that is used. */private final int offset;
字符串的长度/** The count is the number of characters in the String. */private final int count; 字符串的hash值/** Cache the hash code for the string */private int hash; // Default to 0
序列化编号，我的理解是在储存到硬盘的时候用的/** use serialVersionUID from JDK 1.0.2 for interoperability */private static final long serialVersionUID = -6849794470754667710L;/*** Class String is special cased within the Serialization Stream Protocol.** A String instance is written initially into an ObjectOutputStream in the* following format:* <pre>* <code>TC_STRING</code> (utf String)* </pre>* The String is written by method <code>DataOutput.writeUTF</code>.* A new handle is generated to refer to all future references to the* string instance within the stream.*/返回的是字符串的序列化编号private static final ObjectStreamField[] serialPersistentFields =new ObjectStreamField[0];/*** Initializes a newly created {@code String} object so that it represents* an empty character sequence. Note that use of this constructor is* unnecessary since Strings are immutable.*/
构造方法，无参数
public String() {this.offset = 0;this.count = 0;this.value = new char[0];}/*** Initializes a newly created {@code String} object so that it represents* the same sequence of characters as the argument; in other words, the* newly created string is a copy of the argument string. Unless an* explicit copy of {@code original} is needed, use of this constructor is* unnecessary since Strings are immutable.** @param original* A {@code String}*/public String(String original) {int size = original.count;char[] originalValue = original.value;char[] v;if (originalValue.length > size) {// The array representing the String is bigger than the new// String itself. Perhaps this constructor is being called// in order to trim the baggage, so make a copy of the array.int off = original.offset;v = Arrays.copyOfRange(originalValue, off, off+size);} else {// The array representing the String is the same// size as the String, so no point in making a copy.v = originalValue;}this.offset = 0;this.count = size;this.value = v;} 分配一个新的string，它表示当前包含在字符数组参数中的字符序列。/*** Allocates a new {@code String} so that it represents the sequence of* characters currently contained in the character array argument. The* contents of the character array are copied; subsequent modification of* the character array does not affect the newly created string.** @param value* The initial value of the string*/
构造函数，传入一个字符型的数组，返回一个字符串。public String(char value[]) {this.offset = 0;this.count = value.length;this.value = StringValue.from(value);}/*** Allocates a new {@code String} that contains characters from a subarray* of the character array argument. The {@code offset} argument is the* index of the first character of the subarray and the {@code count}* argument specifies the length of the subarray. The contents of the* subarray are copied; subsequent modification of the character array does* not affect the newly created string.** @param value* Array that is the source of characters** @param offset* The initial offset** @param count* The length** @throws IndexOutOfBoundsException* If the {@code offset} and {@code count} arguments index* characters outside the bounds of the {@code value} array*/
例如：
char[] b = ['a','b','c']
String a = new String(b,0,2)// a = "ab"
public String(char value[], int offset, int count) {if (offset < 0) {throw new StringIndexOutOfBoundsException(offset);}if (count < 0) {throw new StringIndexOutOfBoundsException(count);}// Note: offset or count might be near -1>>>1.if (offset > value.length - count) {throw new StringIndexOutOfBoundsException(offset + count);}this.offset = 0;this.count = count;this.value = Arrays.copyOfRange(value, offset, offset+count);}/*** Allocates a new {@code String} that contains characters from a subarray* of the Unicode code point array argument. The {@code offset} argument* is the index of the first code point of the subarray and the* {@code count} argument specifies the length of the subarray. The* contents of the subarray are converted to {@code char}s; subsequent* modification of the {@code int} array does not affect the newly created* string.** @param codePoints* Array that is the source of Unicode code points** @param offset* The initial offset** @param count* The length** @throws IllegalArgumentException* If any invalid Unicode code point is found in {@code* codePoints}** @throws IndexOutOfBoundsException* If the {@code offset} and {@code count} arguments index* characters outside the bounds of the {@code codePoints} array** @since 1.5*/
构造函数，传入一个int类型的数组，开始的位置和长度，返回一个字符串 public String(int[] codePoints, int offset, int count) {if (offset < 0) {throw new StringIndexOutOfBoundsException(offset);}if (count < 0) {throw new StringIndexOutOfBoundsException(count);}// Note: offset or count might be near -1>>>1.if (offset > codePoints.length - count) {throw new StringIndexOutOfBoundsException(offset + count);}int expansion = 0;int margin = 1;char[] v = new char[count + margin];int x = offset;int j = 0;for (int i = 0; i < count; i++) {int c = codePoints[x++];if (c < 0) {throw new IllegalArgumentException();}if (margin <= 0 && (j+1) >= v.length) {if (expansion == 0) {expansion = (((-margin + 1) * count) << 10) / i;expansion >>= 10;if (expansion <= 0) {expansion = 1;}} else {expansion *= 2;}int newLen = Math.min(v.length+expansion, count*2);margin = (newLen - v.length) - (count - i);v = Arrays.copyOf(v, newLen);}if (c < Character.MIN_SUPPLEMENTARY_CODE_POINT) {v[j++] = (char) c;} else if (c <= Character.MAX_CODE_POINT) {Character.toSurrogates(c, v, j);j += 2;margin--;} else {throw new IllegalArgumentException();}}this.offset = 0;this.value = v;this.count = j;}/*** Allocates a new {@code String} constructed from a subarray of an array* of 8-bit integer values.** <p> The {@code offset} argument is the index of the first byte of the* subarray, and the {@code count} argument specifies the length of the* subarray.** <p> Each {@code byte} in the subarray is converted to a {@code char} as* specified in the method above.** @deprecated This method does not properly convert bytes into characters.* As of JDK 1.1, the preferred way to do this is via the* {@code String} constructors that take a {@link* java.nio.charset.Charset}, charset name, or that use the platform's* default charset.** @param ascii* The bytes to be converted to characters** @param hibyte* The top 8 bits of each 16-bit Unicode code unit** @param offset* The initial offset* @param count* The length** @throws IndexOutOfBoundsException* If the {@code offset} or {@code count} argument is invalid** @see #String(byte[], int)* @see #String(byte[], int, int, java.lang.String)* @see #String(byte[], int, int, java.nio.charset.Charset)* @see #String(byte[], int, int)* @see #String(byte[], java.lang.String)* @see #String(byte[], java.nio.charset.Charset)* @see #String(byte[])*/@Deprecatedpublic String(byte ascii[], int hibyte, int offset, int count) {checkBounds(ascii, offset, count);char value[] = new char[count];if (hibyte == 0) {for (int i = count ; i-- > 0 ;) {value[i] = (char) (ascii[i + offset] & 0xff);}} else {hibyte <<= 8;for (int i = count ; i-- > 0 ;) {value[i] = (char) (hibyte | (ascii[i + offset] & 0xff));}}this.offset = 0;this.count = count;this.value = value;}/*** Allocates a new {@code String} containing characters constructed from* an array of 8-bit integer values. Each character <i>c</i>in the* resulting string is constructed from the corresponding component* <i>b</i> in the byte array such that:** <blockquote><pre>* <b><i>c</i></b> == (char)(((hibyte & 0xff) << 8)* | (<b><i>b</i></b> & 0xff))* </pre></blockquote>** @deprecated This method does not properly convert bytes into* characters. As of JDK 1.1, the preferred way to do this is via the* {@code String} constructors that take a {@link* java.nio.charset.Charset}, charset name, or that use the platform's* default charset.** @param ascii* The bytes to be converted to characters** @param hibyte* The top 8 bits of each 16-bit Unicode code unit** @see #String(byte[], int, int, java.lang.String)* @see #String(byte[], int, int, java.nio.charset.Charset)* @see #String(byte[], int, int)* @see #String(byte[], java.lang.String)* @see #String(byte[], java.nio.charset.Charset)* @see #String(byte[])*/@Deprecated 表示不建议使用了public String(byte ascii[], int hibyte) {this(ascii, hibyte, 0, ascii.length);}/* Common private utility method used to bounds check the byte array* and requested offset & length values used by the String(byte[],..)* constructors.*/private static void checkBounds(byte[] bytes, int offset, int length) {if (length < 0)throw new StringIndexOutOfBoundsException(length);if (offset < 0)throw new StringIndexOutOfBoundsException(offset);if (offset > bytes.length - length)throw new StringIndexOutOfBoundsException(offset + length);}/*** Constructs a new {@code String} by decoding the specified subarray of* bytes using the specified charset. The length of the new {@code String}* is a function of the charset, and hence may not be equal to the length* of the subarray.** <p> The behavior of this constructor when the given bytes are not valid* in the given charset is unspecified. The {@link* java.nio.charset.CharsetDecoder} class should be used when more control* over the decoding process is required.** @param bytes* The bytes to be decoded into characters** @param offset* The index of the first byte to decode** @param length* The number of bytes to decode* @param charsetName* The name of a supported {@linkplain java.nio.charset.Charset* charset}** @throws UnsupportedEncodingException* If the named charset is not supported** @throws IndexOutOfBoundsException* If the {@code offset} and {@code length} arguments index* characters outside the bounds of the {@code bytes} array** @since JDK1.1*/
charsetName 表示字符集，将byte类型的数组，按照当天字符集转为string类型，charsetName为空的时候会调用另一个构造方法，默认是使用当前系统的字符集表示返回一个字符串
public String(byte bytes[], int offset, int length, String charsetName)throws UnsupportedEncodingException{if (charsetName == null)throw new NullPointerException("charsetName");checkBounds(bytes, offset, length);char[] v = StringCoding.decode(charsetName, bytes, offset, length);this.offset = 0;this.count = v.length;this.value = v;}/*** Constructs a new {@code String} by decoding the specified subarray of* bytes using the specified {@linkplain java.nio.charset.Charset charset}.* The length of the new {@code String} is a function of the charset, and* hence may not be equal to the length of the subarray.** <p> This method always replaces malformed-input and unmappable-character* sequences with this charset's default replacement string. The {@link* java.nio.charset.CharsetDecoder} class should be used when more control* over the decoding process is required.** @param bytes* The bytes to be decoded into characters** @param offset* The index of the first byte to decode** @param length* The number of bytes to decode** @param charset* The {@linkplain java.nio.charset.Charset charset} to be used to* decode the {@code bytes}** @throws IndexOutOfBoundsException* If the {@code offset} and {@code length} arguments index* characters outside the bounds of the {@code bytes} array** @since 1.6*/public String(byte bytes[], int offset, int length, Charset charset) {if (charset == null)throw new NullPointerException("charset");checkBounds(bytes, offset, length);char[] v = StringCoding.decode(charset, bytes, offset, length);this.offset = 0;this.count = v.length;this.value = v;}/*** Constructs a new {@code String} by decoding the specified array of bytes* using the specified {@linkplain java.nio.charset.Charset charset}. The* length of the new {@code String} is a function of the charset, and hence* may not be equal to the length of the byte array.** <p> The behavior of this constructor when the given bytes are not valid* in the given charset is unspecified. The {@link* java.nio.charset.CharsetDecoder} class should be used when more control* over the decoding process is required.** @param bytes* The bytes to be decoded into characters** @param charsetName* The name of a supported {@linkplain java.nio.charset.Charset* charset}** @throws UnsupportedEncodingException* If the named charset is not supported** @since JDK1.1*/public String(byte bytes[], String charsetName)throws UnsupportedEncodingException{this(bytes, 0, bytes.length, charsetName);}/*** Constructs a new {@code String} by decoding the specified array of* bytes using the specified {@linkplain java.nio.charset.Charset charset}.* The length of the new {@code String} is a function of the charset, and* hence may not be equal to the length of the byte array.** <p> This method always replaces malformed-input and unmappable-character* sequences with this charset's default replacement string. The {@link* java.nio.charset.CharsetDecoder} class should be used when more control* over the decoding process is required.** @param bytes* The bytes to be decoded into characters** @param charset* The {@linkplain java.nio.charset.Charset charset} to be used to* decode the {@code bytes}** @since 1.6*/public String(byte bytes[], Charset charset) {this(bytes, 0, bytes.length, charset);}/*** Constructs a new {@code String} by decoding the specified subarray of* bytes using the platform's default charset. The length of the new* {@code String} is a function of the charset, and hence may not be equal* to the length of the subarray.** <p> The behavior of this constructor when the given bytes are not valid* in the default charset is unspecified. The {@link* java.nio.charset.CharsetDecoder} class should be used when more control* over the decoding process is required.** @param bytes* The bytes to be decoded into characters** @param offset* The index of the first byte to decode** @param length* The number of bytes to decode** @throws IndexOutOfBoundsException* If the {@code offset} and the {@code length} arguments index* characters outside the bounds of the {@code bytes} array** @since JDK1.1*/public String(byte bytes[], int offset, int length) {checkBounds(bytes, offset, length);char[] v = StringCoding.decode(bytes, offset, length);this.offset = 0;this.count = v.length;this.value = v;}/*** Constructs a new {@code String} by decoding the specified array of bytes* using the platform's default charset. The length of the new {@code* String} is a function of the charset, and hence may not be equal to the* length of the byte array.** <p> The behavior of this constructor when the given bytes are not valid* in the default charset is unspecified. The {@link* java.nio.charset.CharsetDecoder} class should be used when more control* over the decoding process is required.** @param bytes* The bytes to be decoded into characters** @since JDK1.1*/public String(byte bytes[]) {this(bytes, 0, bytes.length);}/*** Allocates a new string that contains the sequence of characters* currently contained in the string buffer argument. The contents of the* string buffer are copied; subsequent modification of the string buffer* does not affect the newly created string.** @param buffer* A {@code StringBuffer}*/
将一个stringBuffer类型的字符串转为string类型的字符串。
stringBuffer是线程安全的。效率低一点。
在stringBuffer类中，对外公开的方法，都使用了synchroniczed关键字。所以任何线程对stringBuffer对象进行操作的时候都会锁住当前方法。其他线程调用的时候等待执行完成后才能调用方法对stringBuffer对象进行操作。所以线程安全。因为每次都要检测是否被其他线程锁住，所以效率较低。
stringBuilder不是线程安全的。效率更高
public String(StringBuffer buffer) {String result = buffer.toString();this.value = result.value;this.count = result.count;this.offset = result.offset;}/*** Allocates a new string that contains the sequence of characters* currently contained in the string builder argument. The contents of the* string builder are copied; subsequent modification of the string builder* does not affect the newly created string.** <p> This constructor is provided to ease migration to {@code* StringBuilder}. Obtaining a string from a string builder via the {@code* toString} method is likely to run faster and is generally preferred.** @param builder* A {@code StringBuilder}** @since 1.5*/
将一个stringBuilder类型的字符串转为string类型的字符串。
public String(StringBuilder builder) {String result = builder.toString();this.value = result.value;this.count = result.count;this.offset = result.offset;}// Package private constructor which shares value array for speed.String(int offset, int count, char value[]) {this.value = value;this.offset = offset;this.count = count;}/*** Returns the length of this string.* The length is equal to the number of <a href="Character.html#unicode">Unicode* code units</a> in the string.** @return the length of the sequence of characters represented by this* object.*/
公共方法。返回字符串的长度。
public int length() {return count;}/*** Returns <tt>true</tt> if, and only if, {@link #length()} is <tt>0</tt>.** @return <tt>true</tt> if {@link #length()} is <tt>0</tt>, otherwise* <tt>false</tt>** @since 1.6*/public boolean isEmpty() {return count == 0;}/*** Returns the <code>char</code> value at the* specified index. An index ranges from <code>0</code> to* <code>length() - 1</code>. The first <code>char</code> value of the sequence* is at index <code>0</code>, the next at index <code>1</code>,* and so on, as for array indexing.** <p>If the <code>char</code> value specified by the index is a* <a href="Character.html#unicode">surrogate</a>, the surrogate* value is returned.** @param index the index of the <code>char</code> value.* @return the <code>char</code> value at the specified index of this string.* The first <code>char</code> value is at index <code>0</code>.* @exception IndexOutOfBoundsException if the <code>index</code>* argument is negative or not less than the length of this* string.*/
此公共方法，返回下标为index位置的字符。下标越界会返回错误。
public char charAt(int index) {if ((index < 0) || (index >= count)) {throw new StringIndexOutOfBoundsException(index);}return value[index + offset];}/*** Returns the character (Unicode code point) at the specified* index. The index refers to <code>char</code> values* (Unicode code units) and ranges from <code>0</code> to* {@link #length()}<code> - 1</code>.** <p> If the <code>char</code> value specified at the given index* is in the high-surrogate range, the following index is less* than the length of this <code>String</code>, and the* <code>char</code> value at the following index is in the* low-surrogate range, then the supplementary code point* corresponding to this surrogate pair is returned. Otherwise,* the <code>char</code> value at the given index is returned.** @param index the index to the <code>char</code> values* @return the code point value of the character at the* <code>index</code>* @exception IndexOutOfBoundsException if the <code>index</code>* argument is negative or not less than the length of this* string.* @since 1.5*/
String abc = "abc";
int codePointCount = abc.codePointCount(0, 1); // 1 返回的是起始位置到结束位置之间的字符个数。
int codePointBefore = abc.codePointBefore(1); //97 返回指定下标位置前一个字符的字符集数字
int codePointAt = abc.codePointAt(1); //98 返回指定位置的字符的字符集数字
char charAt = abc.charAt(1); //b 返回指定位置的字符
print(codePointCount);
print(codePointBefore);
print(codePointAt);
print(charAt);
public int codePointAt(int index) {if ((index < 0) || (index >= count)) {throw new StringIndexOutOfBoundsException(index);}return Character.codePointAtImpl(value, offset + index, offset + count);}/*** Returns the character (Unicode code point) before the specified* index. The index refers to <code>char</code> values* (Unicode code units) and ranges from <code>1</code> to {@link* CharSequence#length() length}.** <p> If the <code>char</code> value at <code>(index - 1)</code>* is in the low-surrogate range, <code>(index - 2)</code> is not* negative, and the <code>char</code> value at <code>(index -* 2)</code> is in the high-surrogate range, then the* supplementary code point value of the surrogate pair is* returned. If the <code>char</code> value at <code>index -* 1</code> is an unpaired low-surrogate or a high-surrogate, the* surrogate value is returned.** @param index the index following the code point that should be returned* @return the Unicode code point value before the given index.* @exception IndexOutOfBoundsException if the <code>index</code>* argument is less than 1 or greater than the length* of this string.* @since 1.5*/public int codePointBefore(int index) {int i = index - 1;if ((i < 0) || (i >= count)) {throw new StringIndexOutOfBoundsException(index);}return Character.codePointBeforeImpl(value, offset + index, offset);}/*** Returns the number of Unicode code points in the specified text* range of this <code>String</code>. The text range begins at the* specified <code>beginIndex</code> and extends to the* <code>char</code> at index <code>endIndex - 1</code>. Thus the* length (in <code>char</code>s) of the text range is* <code>endIndex-beginIndex</code>. Unpaired surrogates within* the text range count as one code point each.** @param beginIndex the index to the first <code>char</code> of* the text range.* @param endIndex the index after the last <code>char</code> of* the text range.* @return the number of Unicode code points in the specified text* range* @exception IndexOutOfBoundsException if the* <code>beginIndex</code> is negative, or <code>endIndex</code>* is larger than the length of this <code>String</code>, or* <code>beginIndex</code> is larger than <code>endIndex</code>.* @since 1.5*/public int codePointCount(int beginIndex, int endIndex) {if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) {throw new IndexOutOfBoundsException();}return Character.codePointCountImpl(value, offset+beginIndex, endIndex-beginIndex);}/*** Returns the index within this <code>String</code> that is* offset from the given <code>index</code> by* <code>codePointOffset</code> code points. Unpaired surrogates* within the text range given by <code>index</code> and* <code>codePointOffset</code> count as one code point each.** @param index the index to be offset* @param codePointOffset the offset in code points* @return the index within this <code>String</code>* @exception IndexOutOfBoundsException if <code>index</code>* is negative or larger then the length of this* <code>String</code>, or if <code>codePointOffset</code> is positive* and the substring starting with <code>index</code> has fewer* than <code>codePointOffset</code> code points,* or if <code>codePointOffset</code> is negative and the substring* before <code>index</code> has fewer than the absolute value* of <code>codePointOffset</code> code points.* @since 1.5*/
这个方法用在一个未知长度的字符串。
从下标开始偏移多少个字符后的字符的索引（下标），百度了一下说，有的辅助字符可能占有两个字符单元。不是很懂
public int offsetByCodePoints(int index, int codePointOffset) {if (index < 0 || index > count) {throw new IndexOutOfBoundsException();}return Character.offsetByCodePointsImpl(value, offset, count,offset+index, codePointOffset) - offset;}/*** Copy characters from this string into dst starting at dstBegin.* This method doesn't perform any range checking.*/void getChars(char dst[], int dstBegin) {System.arraycopy(value, offset, dst, dstBegin, count);}/*** Copies characters from this string into the destination character* array.* <p>* The first character to be copied is at index <code>srcBegin</code>;* the last character to be copied is at index <code>srcEnd-1</code>* (thus the total number of characters to be copied is* <code>srcEnd-srcBegin</code>). The characters are copied into the* subarray of <code>dst</code> starting at index <code>dstBegin</code>* and ending at index:* <p><blockquote><pre>* dstbegin + (srcEnd-srcBegin) - 1* </pre></blockquote>** @param srcBegin index of the first character in the string* to copy.* @param srcEnd index after the last character in the string* to copy.* @param dst the destination array.* @param dstBegin the start offset in the destination array.* @exception IndexOutOfBoundsException If any of the following* is true:* <ul><li><code>srcBegin</code> is negative.* <li><code>srcBegin</code> is greater than <code>srcEnd</code>* <li><code>srcEnd</code> is greater than the length of this* string* <li><code>dstBegin</code> is negative* <li><code>dstBegin+(srcEnd-srcBegin)</code> is larger than* <code>dst.length</code></ul>*/
将字符串从指定位置到结束位置的字符保存到参数中的字符数组中。最后一个参数表示从字符数组中的当前下标位置开始插入。
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {if (srcBegin < 0) {throw new StringIndexOutOfBoundsException(srcBegin);}if (srcEnd > count) {throw new StringIndexOutOfBoundsException(srcEnd);}if (srcBegin > srcEnd) {throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);}System.arraycopy(value, offset + srcBegin, dst, dstBegin,srcEnd - srcBegin);}/*** Copies characters from this string into the destination byte array. Each* byte receives the 8 low-order bits of the corresponding character. The* eight high-order bits of each character are not copied and do not* participate in the transfer in any way.** <p> The first character to be copied is at index {@code srcBegin}; the* last character to be copied is at index {@code srcEnd-1}. The total* number of characters to be copied is {@code srcEnd-srcBegin}. The* characters, converted to bytes, are copied into the subarray of {@code* dst} starting at index {@code dstBegin} and ending at index:** <blockquote><pre>* dstbegin + (srcEnd-srcBegin) - 1* </pre></blockquote>** @deprecated This method does not properly convert characters into* bytes. As of JDK 1.1, the preferred way to do this is via the* {@link #getBytes()} method, which uses the platform's default charset.** @param srcBegin* Index of the first character in the string to copy** @param srcEnd* Index after the last character in the string to copy** @param dst* The destination array** @param dstBegin* The start offset in the destination array** @throws IndexOutOfBoundsException* If any of the following is true:* <ul>* <li> {@code srcBegin} is negative* <li> {@code srcBegin} is greater than {@code srcEnd}* <li> {@code srcEnd} is greater than the length of this String* <li> {@code dstBegin} is negative* <li> {@code dstBegin+(srcEnd-srcBegin)} is larger than {@code* dst.length}* </ul>*/@Deprecated
同上面getchars类似，只不过将字符的unicode值保存到bytes数组中public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {if (srcBegin < 0) {throw new StringIndexOutOfBoundsException(srcBegin);}if (srcEnd > count) {throw new StringIndexOutOfBoundsException(srcEnd);}if (srcBegin > srcEnd) {throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);}int j = dstBegin;int n = offset + srcEnd;int i = offset + srcBegin;char[] val = value; /* avoid getfield opcode */while (i < n) {dst[j++] = (byte)val[i++];}}/*** Encodes this {@code String} into a sequence of bytes using the named* charset, storing the result into a new byte array.** <p> The behavior of this method when this string cannot be encoded in* the given charset is unspecified. The {@link* java.nio.charset.CharsetEncoder} class should be used when more control* over the encoding process is required.** @param charsetName* The name of a supported {@linkplain java.nio.charset.Charset* charset}** @return The resultant byte array** @throws UnsupportedEncodingException* If the named charset is not supported** @since JDK1.1*/public byte[] getBytes(String charsetName)throws UnsupportedEncodingException{if (charsetName == null) throw new NullPointerException();return StringCoding.encode(charsetName, value, offset, count);}/*** Encodes this {@code String} into a sequence of bytes using the given* {@linkplain java.nio.charset.Charset charset}, storing the result into a* new byte array.** <p> This method always replaces malformed-input and unmappable-character* sequences with this charset's default replacement byte array. The* {@link java.nio.charset.CharsetEncoder} class should be used when more* control over the encoding process is required.** @param charset* The {@linkplain java.nio.charset.Charset} to be used to encode* the {@code String}** @return The resultant byte array** @since 1.6*/public byte[] getBytes(Charset charset) {if (charset == null) throw new NullPointerException();return StringCoding.encode(charset, value, offset, count);}/*** Encodes this {@code String} into a sequence of bytes using the* platform's default charset, storing the result into a new byte array.** <p> The behavior of this method when this string cannot be encoded in* the default charset is unspecified. The {@link* java.nio.charset.CharsetEncoder} class should be used when more control* over the encoding process is required.** @return The resultant byte array** @since JDK1.1*/public byte[] getBytes() {return StringCoding.encode(value, offset, count);}/*** Compares this string to the specified object. The result is {@code* true} if and only if the argument is not {@code null} and is a {@code* String} object that represents the same sequence of characters as this* object.** @param anObject* The object to compare this {@code String} against** @return {@code true} if the given object represents a {@code String}* equivalent to this string, {@code false} otherwise** @see #compareTo(String)* @see #equalsIgnoreCase(String)*/
比较两个字符串内容是否相同，而且必须都是string类型，和stringbuilder或者stringbuffer对象比较的时候，就算字符串内容相同，也会返回false
== 比较的是两个字符串的地址。两个string的地址必然不同，因为字符串创建后就不再改变。当有创建新的String对象时候会再开辟一块内存。即使两个字符串内容相同，地址页不同。。
创建string对象的时候调用一下intern()方法，jvm虚拟机会去内存中是否存在存在和当前字符串内容相同的字符串是否相同，如果有相同的就会使用原来的字符串内容，不再重新创建。
public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = count;if (n == anotherString.count) {char v1[] = value;char v2[] = anotherString.value;int i = offset;int j = anotherString.offset;while (n-- != 0) {if (v1[i++] != v2[j++])return false;}return true;}}return false;}/*** Compares this string to the specified {@code StringBuffer}. The result* is {@code true} if and only if this {@code String} represents the same* sequence of characters as the specified {@code StringBuffer}.** @param sb* The {@code StringBuffer} to compare this {@code String} against** @return {@code true} if this {@code String} represents the same* sequence of characters as the specified {@code StringBuffer},* {@code false} otherwise** @since 1.4*/
不比较字符串的类型，
public boolean contentEquals(StringBuffer sb) {synchronized(sb) {return contentEquals((CharSequence)sb);}}/*** Compares this string to the specified {@code CharSequence}. The result* is {@code true} if and only if this {@code String} represents the same* sequence of char values as the specified sequence.** @param cs* The sequence to compare this {@code String} against** @return {@code true} if this {@code String} represents the same* sequence of char values as the specified sequence, {@code* false} otherwise** @since 1.5*/public boolean contentEquals(CharSequence cs) {if (count != cs.length())return false;// Argument is a StringBuffer, StringBuilderif (cs instanceof AbstractStringBuilder) {char v1[] = value;char v2[] = ((AbstractStringBuilder)cs).getValue();int i = offset;int j = 0;int n = count;while (n-- != 0) {if (v1[i++] != v2[j++])return false;}}// Argument is a Stringif (cs.equals(this))return true;// Argument is a generic CharSequencechar v1[] = value;int i = offset;int j = 0;int n = count;while (n-- != 0) {if (v1[i++] != cs.charAt(j++))return false;}return true;}/*** Compares this {@code String} to another {@code String}, ignoring case* considerations. Two strings are considered equal ignoring case if they* are of the same length and corresponding characters in the two strings* are equal ignoring case.** <p> Two characters {@code c1} and {@code c2} are considered the same* ignoring case if at least one of the following is true:* <ul>* <li> The two characters are the same (as compared by the* {@code ==} operator)* <li> Applying the method {@link* java.lang.Character#toUpperCase(char)} to each character* produces the same result* <li> Applying the method {@link* java.lang.Character#toLowerCase(char)} to each character* produces the same result* </ul>** @param anotherString* The {@code String} to compare this {@code String} against** @return {@code true} if the argument is not {@code null} and it* represents an equivalent {@code String} ignoring case; {@code* false} otherwise** @see #equals(Object)*/
忽略两个字符串的大小写，的比较
public boolean equalsIgnoreCase(String anotherString) {return (this == anotherString) ? true :(anotherString != null) && (anotherString.count == count) &®ionMatches(true, 0, anotherString, 0, count);}/*** Compares two strings lexicographically.* The comparison is based on the Unicode value of each character in* the strings. The character sequence represented by this* <code>String</code> object is compared lexicographically to the* character sequence represented by the argument string. The result is* a negative integer if this <code>String</code> object* lexicographically precedes the argument string. The result is a* positive integer if this <code>String</code> object lexicographically* follows the argument string. The result is zero if the strings* are equal; <code>compareTo</code> returns <code>0</code> exactly when* the {@link #equals(Object)} method would return <code>true</code>.* <p>* This is the definition of lexicographic ordering. If two strings are* different, then either they have different characters at some index* that is a valid index for both strings, or their lengths are different,* or both. If they have different characters at one or more index* positions, let <i>k</i> be the smallest such index; then the string* whose character at position <i>k</i> has the smaller value, as* determined by using the < operator, lexicographically precedes the* other string. In this case, <code>compareTo</code> returns the* difference of the two character values at position <code>k</code> in* the two string -- that is, the value:* <blockquote><pre>* this.charAt(k)-anotherString.charAt(k)* </pre></blockquote>* If there is no index position at which they differ, then the shorter* string lexicographically precedes the longer string. In this case,* <code>compareTo</code> returns the difference of the lengths of the* strings -- that is, the value:* <blockquote><pre>* this.length()-anotherString.length()* </pre></blockquote>** @param anotherString the <code>String</code> to be compared.* @return the value <code>0</code> if the argument string is equal to* this string; a value less than <code>0</code> if this string* is lexicographically less than the string argument; and a* value greater than <code>0</code> if this string is* lexicographically greater than the string argument.*/
和另一个字符串进行比较，从第一个字符串开始比较，如果不同就返回两个字符的差值，如果相同，就比较第二个，依次类推，如果都一样，返回的是两个字符串的长度差值
public int compareTo(String anotherString) {int len1 = count;int len2 = anotherString.count;int n = Math.min(len1, len2);char v1[] = value;char v2[] = anotherString.value;int i = offset;int j = anotherString.offset;if (i == j) {int k = i;int lim = n + i;while (k < lim) {char c1 = v1[k];char c2 = v2[k];if (c1 != c2) {return c1 - c2;}k++;}} else {while (n-- != 0) {char c1 = v1[i++];char c2 = v2[j++];if (c1 != c2) {return c1 - c2;}}}return len1 - len2;}/*** A Comparator that orders <code>String</code> objects as by* <code>compareToIgnoreCase</code>. This comparator is serializable.* <p>* Note that this Comparator does <em>not</em> take locale into account,* and will result in an unsatisfactory ordering for certain locales.* The java.text package provides <em>Collators</em> to allow* locale-sensitive ordering.** @see java.text.Collator#compare(String, String)* @since 1.2*/public static final Comparator<String> CASE_INSENSITIVE_ORDER= new CaseInsensitiveComparator();
内部类private static class CaseInsensitiveComparatorimplements Comparator<String>, java.io.Serializable {// use serialVersionUID from JDK 1.2.2 for interoperabilityprivate static final long serialVersionUID = 8575799808933029326L;public int compare(String s1, String s2) {int n1=s1.length(), n2=s2.length();for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {char c1 = s1.charAt(i1);char c2 = s2.charAt(i2);if (c1 != c2) {c1 = Character.toUpperCase(c1);c2 = Character.toUpperCase(c2);if (c1 != c2) {c1 = Character.toLowerCase(c1);c2 = Character.toLowerCase(c2);if (c1 != c2) {return c1 - c2;}}}}return n1 - n2;}}/*** Compares two strings lexicographically, ignoring case* differences. This method returns an integer whose sign is that of* calling <code>compareTo</code> with normalized versions of the strings* where case differences have been eliminated by calling* <code>Character.toLowerCase(Character.toUpperCase(character))</code> on* each character.* <p>* Note that this method does <em>not</em> take locale into account,* and will result in an unsatisfactory ordering for certain locales.* The java.text package provides <em>collators</em> to allow* locale-sensitive ordering.** @param str the <code>String</code> to be compared.* @return a negative integer, zero, or a positive integer as the* specified String is greater than, equal to, or less* than this String, ignoring case considerations.* @see java.text.Collator#compare(String, String)* @since 1.2*/
比较的时候忽略大小写
public int compareToIgnoreCase(String str) {return CASE_INSENSITIVE_ORDER.compare(this, str);}/*** Tests if two string regions are equal.* <p>* A substring of this <tt>String</tt> object is compared to a substring* of the argument other. The result is true if these substrings* represent identical character sequences. The substring of this* <tt>String</tt> object to be compared begins at index <tt>toffset</tt>* and has length <tt>len</tt>. The substring of other to be compared* begins at index <tt>ooffset</tt> and has length <tt>len</tt>. The* result is <tt>false</tt> if and only if at least one of the following* is true:* <ul><li><tt>toffset</tt> is negative.* <li><tt>ooffset</tt> is negative.* <li><tt>toffset+len</tt> is greater than the length of this* <tt>String</tt> object.* <li><tt>ooffset+len</tt> is greater than the length of the other* argument.* <li>There is some nonnegative integer <i>k</i> less than <tt>len</tt>* such that:* <tt>this.charAt(toffset+<i>k</i>) != other.charAt(ooffset+<i>k</i>)</tt>* </ul>** @param toffset the starting offset of the subregion in this string.* @param other the string argument.* @param ooffset the starting offset of the subregion in the string* argument.* @param len the number of characters to compare.* @return <code>true</code> if the specified subregion of this string* exactly matches the specified subregion of the string argument;* <code>false</code> otherwise.*/public boolean regionMatches(int toffset, String other, int ooffset,int len) {char ta[] = value;int to = offset + toffset;char pa[] = other.value;int po = other.offset + ooffset;// Note: toffset, ooffset, or len might be near -1>>>1.if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len)|| (ooffset > (long)other.count - len)) {return false;}while (len-- > 0) {if (ta[to++] != pa[po++]) {return false;}}return true;}/*** Tests if two string regions are equal.* <p>* A substring of this <tt>String</tt> object is compared to a substring* of the argument <tt>other</tt>. The result is <tt>true</tt> if these* substrings represent character sequences that are the same, ignoring* case if and only if <tt>ignoreCase</tt> is true. The substring of* this <tt>String</tt> object to be compared begins at index* <tt>toffset</tt> and has length <tt>len</tt>. The substring of* <tt>other</tt> to be compared begins at index <tt>ooffset</tt> and* has length <tt>len</tt>. The result is <tt>false</tt> if and only if* at least one of the following is true:* <ul><li><tt>toffset</tt> is negative.* <li><tt>ooffset</tt> is negative.* <li><tt>toffset+len</tt> is greater than the length of this* <tt>String</tt> object.* <li><tt>ooffset+len</tt> is greater than the length of the other* argument.* <li><tt>ignoreCase</tt> is <tt>false</tt> and there is some nonnegative* integer <i>k</i> less than <tt>len</tt> such that:* <blockquote><pre>* this.charAt(toffset+k) != other.charAt(ooffset+k)* </pre></blockquote>* <li><tt>ignoreCase</tt> is <tt>true</tt> and there is some nonnegative* integer <i>k</i> less than <tt>len</tt> such that:* <blockquote><pre>* Character.toLowerCase(this.charAt(toffset+k)) !=Character.toLowerCase(other.charAt(ooffset+k))* </pre></blockquote>* and:* <blockquote><pre>* Character.toUpperCase(this.charAt(toffset+k)) !=* Character.toUpperCase(other.charAt(ooffset+k))* </pre></blockquote>* </ul>** @param ignoreCase if <code>true</code>, ignore case when comparing* characters.* @param toffset the starting offset of the subregion in this* string.* @param other the string argument.* @param ooffset the starting offset of the subregion in the string* argument.* @param len the number of characters to compare.* @return <code>true</code> if the specified subregion of this string* matches the specified subregion of the string argument;* <code>false</code> otherwise. Whether the matching is exact* or case insensitive depends on the <code>ignoreCase</code>* argument.*/
比较两个字符串指定区域的子字符串是否相同。
public boolean regionMatches(boolean ignoreCase, int toffset,String other, int ooffset, int len) {char ta[] = value;int to = offset + toffset;char pa[] = other.value;int po = other.offset + ooffset;// Note: toffset, ooffset, or len might be near -1>>>1.if ((ooffset < 0) || (toffset < 0) || (toffset > (long)count - len) ||(ooffset > (long)other.count - len)) {return false;}while (len-- > 0) {char c1 = ta[to++];char c2 = pa[po++];if (c1 == c2) {continue;}if (ignoreCase) {// If characters don't match but case may be ignored,// try converting both characters to uppercase.// If the results match, then the comparison scan should// continue.char u1 = Character.toUpperCase(c1);char u2 = Character.toUpperCase(c2);if (u1 == u2) {continue;}// Unfortunately, conversion to uppercase does not work properly// for the Georgian alphabet, which has strange rules about case// conversion. So we need to make one last check before// exiting.if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {continue;}}return false;}return true;}/*** Tests if the substring of this string beginning at the* specified index starts with the specified prefix.** @param prefix the prefix.* @param toffset where to begin looking in this string.* @return <code>true</code> if the character sequence represented by the* argument is a prefix of the substring of this object starting* at index <code>toffset</code>; <code>false</code> otherwise.* The result is <code>false</code> if <code>toffset</code> is* negative or greater than the length of this* <code>String</code> object; otherwise the result is the same* as the result of the expression* <pre>* this.substring(toffset).startsWith(prefix)* </pre>*/
判断当前字符串是否是以某个字符开头，或者指定偏移量位置开始的子字符串是否是以这个字符开始。
public boolean startsWith(String prefix, int toffset) {char ta[] = value;int to = offset + toffset;char pa[] = prefix.value;int po = prefix.offset;int pc = prefix.count;// Note: toffset might be near -1>>>1.if ((toffset < 0) || (toffset > count - pc)) {return false;}while (--pc >= 0) {if (ta[to++] != pa[po++]) {return false;}}return true;}/*** Tests if this string starts with the specified prefix.** @param prefix the prefix.* @return <code>true</code> if the character sequence represented by the* argument is a prefix of the character sequence represented by* this string; <code>false</code> otherwise.* Note also that <code>true</code> will be returned if the* argument is an empty string or is equal to this* <code>String</code> object as determined by the* {@link #equals(Object)} method.* @since 1. 0*/public boolean startsWith(String prefix) {return startsWith(prefix, 0);}/*** Tests if this string ends with the specified suffix.** @param suffix the suffix.* @return <code>true</code> if the character sequence represented by the* argument is a suffix of the character sequence represented by* this object; <code>false</code> otherwise. Note that the* result will be <code>true</code> if the argument is the* empty string or is equal to this <code>String</code> object* as determined by the {@link #equals(Object)} method.*/public boolean endsWith(String suffix) {return startsWith(suffix, count - suffix.count);}/*** Returns a hash code for this string. The hash code for a* <code>String</code> object is computed as* <blockquote><pre>* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]* </pre></blockquote>* using <code>int</code> arithmetic, where <code>s[i]</code> is the* <i>i</i>th character of the string, <code>n</code> is the length of* the string, and <code>^</code> indicates exponentiation.* (The hash value of the empty string is zero.)** @return a hash code value for this object.*/
返回这个字符串的hashcode值，
hashcode我的理解就是，为每个字符串一个唯一的标识，在查找的时候，可以根据查找hashcode的规则快速查找到当前字符串，这是计算机内部为了效率而采取的办法。不知道理解的对不对。
public int hashCode() {int h = hash;if (h == 0) {int off = offset;char val[] = value;int len = count;for (int i = 0; i < len; i++) {h = 31*h + val[off++];}hash = h;}return h;}/*** Returns the index within this string of the first occurrence of* the specified character. If a character with value* <code>ch</code> occurs in the character sequence represented by* this <code>String</code> object, then the index (in Unicode* code units) of the first such occurrence is returned. For* values of <code>ch</code> in the range from 0 to 0xFFFF* (inclusive), this is the smallest value <i>k</i> such that:* <blockquote><pre>* this.charAt(<i>k</i>) == ch* </pre></blockquote>* is true. For other values of <code>ch</code>, it is the* smallest value <i>k</i> such that:* <blockquote><pre>* this.codePointAt(<i>k</i>) == ch* </pre></blockquote>* is true. In either case, if no such character occurs in this* string, then <code>-1</code> is returned.** @param ch a character (Unicode code point).* @return the index of the first occurrence of the character in the* character sequence represented by this object, or* <code>-1</code> if the character does not occur.*/
根据字符的编码值，返回从字符串第一个开始查找到的第一个这个字符的下标
public int indexOf(int ch) {return indexOf(ch, 0);}/*** Returns the index within this string of the first occurrence of the* specified character, starting the search at the specified index.* <p>* If a character with value <code>ch</code> occurs in the* character sequence represented by this <code>String</code>* object at an index no smaller than <code>fromIndex</code>, then* the index of the first such occurrence is returned. For values* of <code>ch</code> in the range from 0 to 0xFFFF (inclusive),* this is the smallest value <i>k</i> such that:* <blockquote><pre>* (this.charAt(<i>k</i>) == ch) && (<i>k</i> >= fromIndex)* </pre></blockquote>* is true. For other values of <code>ch</code>, it is the* smallest value <i>k</i> such that:* <blockquote><pre>* (this.codePointAt(<i>k</i>) == ch) && (<i>k</i> >= fromIndex)* </pre></blockquote>* is true. In either case, if no such character occurs in this* string at or after position <code>fromIndex</code>, then* <code>-1</code> is returned.** <p>* There is no restriction on the value of <code>fromIndex</code>. If it* is negative, it has the same effect as if it were zero: this entire* string may be searched. If it is greater than the length of this* string, it has the same effect as if it were equal to the length of* this string: <code>-1</code> is returned.** <p>All indices are specified in <code>char</code> values* (Unicode code units).** @param ch a character (Unicode code point).* @param fromIndex the index to start the search from.* @return the index of the first occurrence of the character in the* character sequence represented by this object that is greater* than or equal to <code>fromIndex</code>, or <code>-1</code>* if the character does not occur.*/
根据字符的编码值。以及从下标开始的位置开始查找。
public int indexOf(int ch, int fromIndex) {int max = offset + count;char v[] = value;if (fromIndex < 0) {fromIndex = 0;} else if (fromIndex >= count) {// Note: fromIndex might be near -1>>>1.return -1;}int i = offset + fromIndex;if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {// handle most cases here (ch is a BMP code point or a// negative value (invalid code point))for (; i < max ; i++) {if (v[i] == ch) {return i - offset;}}return -1;}if (ch <= Character.MAX_CODE_POINT) {// handle supplementary characters herechar[] surrogates = Character.toChars(ch);for (; i < max; i++) {if (v[i] == surrogates[0]) {if (i + 1 == max) {break;}if (v[i+1] == surrogates[1]) {return i - offset;}}}}return -1;}/*** Returns the index within this string of the last occurrence of* the specified character. For values of <code>ch</code> in the* range from 0 to 0xFFFF (inclusive), the index (in Unicode code* units) returned is the largest value <i>k</i> such that:* <blockquote><pre>* this.charAt(<i>k</i>) == ch* </pre></blockquote>* is true. For other values of <code>ch</code>, it is the* largest value <i>k</i> such that:* <blockquote><pre>* this.codePointAt(<i>k</i>) == ch* </pre></blockquote>* is true. In either case, if no such character occurs in this* string, then <code>-1</code> is returned. The* <code>String</code> is searched backwards starting at the last* character.** @param ch a character (Unicode code point).* @return the index of the last occurrence of the character in the* character sequence represented by this object, or* <code>-1</code> if the character does not occur.*/
字符串中最后一个当前字符的下标。
public int lastIndexOf(int ch) {return lastIndexOf(ch, count - 1);}/*** Returns the index within this string of the last occurrence of* the specified character, searching backward starting at the* specified index. For values of <code>ch</code> in the range* from 0 to 0xFFFF (inclusive), the index returned is the largest* value <i>k</i> such that:* <blockquote><pre>* (this.charAt(<i>k</i>) == ch) && (<i>k</i> <= fromIndex)* </pre></blockquote>* is true. For other values of <code>ch</code>, it is the* largest value <i>k</i> such that:* <blockquote><pre>* (this.codePointAt(<i>k</i>) == ch) && (<i>k</i> <= fromIndex)* </pre></blockquote>* is true. In either case, if no such character occurs in this* string at or before position <code>fromIndex</code>, then* <code>-1</code> is returned.** <p>All indices are specified in <code>char</code> values* (Unicode code units).** @param ch a character (Unicode code point).* @param fromIndex the index to start the search from. There is no* restriction on the value of <code>fromIndex</code>. If it is* greater than or equal to the length of this string, it has* the same effect as if it were equal to one less than the* length of this string: this entire string may be searched.* If it is negative, it has the same effect as if it were -1:* -1 is returned.* @return the index of the last occurrence of the character in the* character sequence represented by this object that is less* than or equal to <code>fromIndex</code>, or <code>-1</code>* if the character does not occur before that point.*/
从指定下标位置开始查找。
public int lastIndexOf(int ch, int fromIndex) {int min = offset;char v[] = value;int i = offset + ((fromIndex >= count) ? count - 1 : fromIndex);if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {// handle most cases here (ch is a BMP code point or a// negative value (invalid code point))for (; i >= min ; i--) {if (v[i] == ch) {return i - offset;}}return -1;}int max = offset + count;if (ch <= Character.MAX_CODE_POINT) {// handle supplementary characters herechar[] surrogates = Character.toChars(ch);for (; i >= min; i--) {if (v[i] == surrogates[0]) {if (i + 1 == max) {break;}if (v[i+1] == surrogates[1]) {return i - offset;}}}}return -1;}/*** Returns the index within this string of the first occurrence of the* specified substring. The integer returned is the smallest value* <i>k</i> such that:* <blockquote><pre>* this.startsWith(str, <i>k</i>)* </pre></blockquote>* is <code>true</code>.** @param str any string.* @return if the string argument occurs as a substring within this* object, then the index of the first character of the first* such substring is returned; if it does not occur as a* substring, <code>-1</code> is returned.*/public int indexOf(String str) {return indexOf(str, 0);}/*** Returns the index within this string of the first occurrence of the* specified substring, starting at the specified index. The integer* returned is the smallest value <tt>k</tt> for which:* <blockquote><pre>* k >= Math.min(fromIndex, this.length()) && this.startsWith(str, k)* </pre></blockquote>* If no such value of <i>k</i> exists, then -1 is returned.** @param str the substring for which to search.* @param fromIndex the index from which to start the search.* @return the index within this string of the first occurrence of the* specified substring, starting at the specified index.*/public int indexOf(String str, int fromIndex) {return indexOf(value, offset, count,str.value, str.offset, str.count, fromIndex);}/*** Code shared by String and StringBuffer to do searches. The* source is the character array being searched, and the target* is the string being searched for.** @param source the characters being searched.* @param sourceOffset offset of the source string.* @param sourceCount count of the source string.* @param target the characters being searched for.* @param targetOffset offset of the target string.* @param targetCount count of the target string.* @param fromIndex the index to begin searching from.*/
string的内部方法。只哟string类中自己使用的。查找某个字符在字符串中的下标
static int indexOf(char[] source, int sourceOffset, int sourceCount,char[] target, int targetOffset, int targetCount,int fromIndex) {if (fromIndex >= sourceCount) {return (targetCount == 0 ? sourceCount : -1);}if (fromIndex < 0) {fromIndex = 0;}if (targetCount == 0) {return fromIndex;}char first = target[targetOffset];int max = sourceOffset + (sourceCount - targetCount);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) {int j = i + 1;int end = j + targetCount - 1;for (int k = targetOffset + 1; j < end && source[j] ==target[k]; j++, k++);if (j == end) {/* Found whole string. */return i - sourceOffset;}}}return -1;}/*** Returns the index within this string of the rightmost occurrence* of the specified substring. The rightmost empty string "" is* considered to occur at the index value <code>this.length()</code>.* The returned index is the largest value <i>k</i> such that* <blockquote><pre>* this.startsWith(str, k)* </pre></blockquote>* is true.** @param str the substring to search for.* @return if the string argument occurs one or more times as a substring* within this object, then the index of the first character of* the last such substring is returned. If it does not occur as* a substring, <code>-1</code> is returned.*/public int lastIndexOf(String str) {return lastIndexOf(str, count);}/*** Returns the index within this string of the last occurrence of the* specified substring, searching backward starting at the specified index.* The integer returned is the largest value <i>k</i> such that:* <blockquote><pre>* k <= Math.min(fromIndex, this.length()) && this.startsWith(str, k)* </pre></blockquote>* If no such value of <i>k</i> exists, then -1 is returned.** @param str the substring to search for.* @param fromIndex the index to start the search from.* @return the index within this string of the last occurrence of the* specified substring.*/public int lastIndexOf(String str, int fromIndex) {return lastIndexOf(value, offset, count,str.value, str.offset, str.count, fromIndex);}/*** Code shared by String and StringBuffer to do searches. The* source is the character array being searched, and the target* is the string being searched for.** @param source the characters being searched.* @param sourceOffset offset of the source string.* @param sourceCount count of the source string.* @param target the characters being searched for.* @param targetOffset offset of the target string.* @param targetCount count of the target string.* @param fromIndex the index to begin searching from.*/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;}}/*** Returns a new string that is a substring of this string. The* substring begins with the character at the specified index and* extends to the end of this string. <p>* Examples:* <blockquote><pre>* "unhappy".substring(2) returns "happy"* "Harbison".substring(3) returns "bison"* "emptiness".substring(9) returns "" (an empty string)* </pre></blockquote>** @param beginIndex the beginning index, inclusive.* @return the specified substring.* @exception IndexOutOfBoundsException if* <code>beginIndex</code> is negative or larger than the* length of this <code>String</code> object.*/
根据下标开始截取下标到结束的字符串
public String substring(int beginIndex) {return substring(beginIndex, count);}/*** Returns a new string that is a substring of this string. The* substring begins at the specified <code>beginIndex</code> and* extends to the character at index <code>endIndex - 1</code>.* Thus the length of the substring is <code>endIndex-beginIndex</code>.* <p>* Examples:* <blockquote><pre>* "hamburger".substring(4, 8) returns "urge"* "smiles".substring(1, 5) returns "mile"* </pre></blockquote>** @param beginIndex the beginning index, inclusive.* @param endIndex the ending index, exclusive.* @return the specified substring.* @exception IndexOutOfBoundsException if the* <code>beginIndex</code> is negative, or* <code>endIndex</code> is larger than the length of* this <code>String</code> object, or* <code>beginIndex</code> is larger than* <code>endIndex</code>.*/
截取从下标开始到结束下标之间的字符串。
public String substring(int beginIndex, int endIndex) {if (beginIndex < 0) {throw new StringIndexOutOfBoundsException(beginIndex);}if (endIndex > count) {throw new StringIndexOutOfBoundsException(endIndex);}if (beginIndex > endIndex) {throw new StringIndexOutOfBoundsException(endIndex - beginIndex);}return ((beginIndex == 0) && (endIndex == count)) ? this :new String(offset + beginIndex, endIndex - beginIndex, value);}/*** Returns a new character sequence that is a subsequence of this sequence.** <p> An invocation of this method of the form** <blockquote><pre>* str.subSequence(begin, end)</pre></blockquote>** behaves in exactly the same way as the invocation** <blockquote><pre>* str.substring(begin, end)</pre></blockquote>** This method is defined so that the <tt>String</tt> class can implement* the {@link CharSequence} interface. </p>** @param beginIndex the begin index, inclusive.* @param endIndex the end index, exclusive.* @return the specified subsequence.** @throws IndexOutOfBoundsException* if <tt>beginIndex</tt> or <tt>endIndex</tt> are negative,* if <tt>endIndex</tt> is greater than <tt>length()</tt>,* or if <tt>beginIndex</tt> is greater than <tt>startIndex</tt>** @since 1.4* @spec JSR-51*/
返回的是charSequence对象的字符串。可以调用charSequence类的方法。至于charSequence接口有什么用。charSequence的字符串应该可以改变。，没有final修饰。
public CharSequence subSequence(int beginIndex, int endIndex) {return this.substring(beginIndex, endIndex);}/*** Concatenates the specified string to the end of this string.* <p>* If the length of the argument string is <code>0</code>, then this* <code>String</code> object is returned. Otherwise, a new* <code>String</code> object is created, representing a character* sequence that is the concatenation of the character sequence* represented by this <code>String</code> object and the character* sequence represented by the argument string.<p>* Examples:* <blockquote><pre>* "cares".concat("s") returns "caress"* "to".concat("get").concat("her") returns "together"* </pre></blockquote>** @param str the <code>String</code> that is concatenated to the end* of this <code>String</code>.* @return a string that represents the concatenation of this object's* characters followed by the string argument's characters.*/
只能将两个字符串拼接到一起，
+号也可以将两个字符串拼接到一起，同时，+号也可以将数字和字符拼接到一起。
public String concat(String str) {int otherLen = str.length();if (otherLen == 0) {return this;}char buf[] = new char[count + otherLen];getChars(0, count, buf, 0);str.getChars(0, otherLen, buf, count);return new String(0, count + otherLen, buf);}/*** Returns a new string resulting from replacing all occurrences of* <code>oldChar</code> in this string with <code>newChar</code>.* <p>* If the character <code>oldChar</code> does not occur in the* character sequence represented by this <code>String</code> object,* then a reference to this <code>String</code> object is returned.* Otherwise, a new <code>String</code> object is created that* represents a character sequence identical to the character sequence* represented by this <code>String</code> object, except that every* occurrence of <code>oldChar</code> is replaced by an occurrence* of <code>newChar</code>.* <p>* Examples:* <blockquote><pre>* "mesquite in your cellar".replace('e', 'o')* returns "mosquito in your collar"* "the war of baronets".replace('r', 'y')* returns "the way of bayonets"* "sparring with a purple porpoise".replace('p', 't')* returns "starring with a turtle tortoise"* "JonL".replace('q', 'x') returns "JonL" (no change)* </pre></blockquote>** @param oldChar the old character.* @param newChar the new character.* @return a string derived from this string by replacing every* occurrence of <code>oldChar</code> with <code>newChar</code>.*/
经常用的替换字符串中某个字符。
public String replace(char oldChar, char newChar) {if (oldChar != newChar) {int len = count;int i = -1;char[] val = value; /* avoid getfield opcode */int off = offset; /* avoid getfield opcode */while (++i < len) {if (val[off + i] == oldChar) {break;}}if (i < len) {char buf[] = new char[len];for (int j = 0 ; j < i ; j++) {buf[j] = val[off+j];}while (i < len) {char c = val[off + i];buf[i] = (c == oldChar) ? newChar : c;i++;}return new String(0, len, buf);}}return this;}/*** Tells whether or not this string matches the given <a* href="../util/regex/Pattern.html#sum">regular expression</a>.** <p> An invocation of this method of the form* <i>str</i><tt>.matches(</tt><i>regex</i><tt>)</tt> yields exactly the* same result as the expression** <blockquote><tt> {@link java.util.regex.Pattern}.{@link* java.util.regex.Pattern#matches(String,CharSequence)* matches}(</tt><i>regex</i><tt>,</tt> <i>str</i><tt>)</tt></blockquote>** @param regex* the regular expression to which this string is to be matched** @return <tt>true</tt> if, and only if, this string matches the* given regular expression** @throws PatternSyntaxException* if the regular expression's syntax is invalid** @see java.util.regex.Pattern** @since 1.4* @spec JSR-51*/
参数中可以写正则表达式，判断后返回这个字符串是否符合这个正则表达式。
public boolean matches(String regex) {return Pattern.matches(regex, this);}/*** Returns true if and only if this string contains the specified* sequence of char values.** @param s the sequence to search for* @return true if this string contains <code>s</code>, false otherwise* @throws NullPointerException if <code>s</code> is <code>null</code>* @since 1.5*/
判断是否包含某个charSquence类型的字符串。
public boolean contains(CharSequence s) {return indexOf(s.toString()) > -1;}/*** Replaces the first substring of this string that matches the given <a* href="../util/regex/Pattern.html#sum">regular expression</a> with the* given replacement.** <p> An invocation of this method of the form* <i>str</i><tt>.replaceFirst(</tt><i>regex</i><tt>,</tt> <i>repl</i><tt>)</tt>* yields exactly the same result as the expression** <blockquote><tt>* {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile* compile}(</tt><i>regex</i><tt>).{@link* java.util.regex.Pattern#matcher(java.lang.CharSequence)* matcher}(</tt><i>str</i><tt>).{@link java.util.regex.Matcher#replaceFirst* replaceFirst}(</tt><i>repl</i><tt>)</tt></blockquote>**<p>* Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in the* replacement string may cause the results to be different than if it were* being treated as a literal replacement string; see* {@link java.util.regex.Matcher#replaceFirst}.* Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special* meaning of these characters, if desired.** @param regex* the regular expression to which this string is to be matched* @param replacement* the string to be substituted for the first match** @return The resulting <tt>String</tt>** @throws PatternSyntaxException* if the regular expression's syntax is invalid** @see java.util.regex.Pattern** @since 1.4* @spec JSR-51*/public String replaceFirst(String regex, String replacement) {return Pattern.compile(regex).matcher(this).replaceFirst(replacement);}/*** Replaces each substring of this string that matches the given <a* href="../util/regex/Pattern.html#sum">regular expression</a> with the* given replacement.** <p> An invocation of this method of the form* <i>str</i><tt>.replaceAll(</tt><i>regex</i><tt>,</tt> <i>repl</i><tt>)</tt>* yields exactly the same result as the expression** <blockquote><tt>* {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile* compile}(</tt><i>regex</i><tt>).{@link* java.util.regex.Pattern#matcher(java.lang.CharSequence)* matcher}(</tt><i>str</i><tt>).{@link java.util.regex.Matcher#replaceAll* replaceAll}(</tt><i>repl</i><tt>)</tt></blockquote>**<p>* Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in the* replacement string may cause the results to be different than if it were* being treated as a literal replacement string; see* {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}.* Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special* meaning of these characters, if desired.** @param regex* the regular expression to which this string is to be matched* @param replacement* the string to be substituted for each match** @return The resulting <tt>String</tt>** @throws PatternSyntaxException* if the regular expression's syntax is invalid** @see java.util.regex.Pattern** @since 1.4* @spec JSR-51*/public String replaceAll(String regex, String replacement) {return Pattern.compile(regex).matcher(this).replaceAll(replacement);}/*** Replaces each substring of this string that matches the literal target* sequence with the specified literal replacement sequence. The* replacement proceeds from the beginning of the string to the end, for* example, replacing "aa" with "b" in the string "aaa" will result in* "ba" rather than "ab".** @param target The sequence of char values to be replaced* @param replacement The replacement sequence of char values* @return The resulting string* @throws NullPointerException if <code>target</code> or* <code>replacement</code> is <code>null</code>.* @since 1.5*/public String replace(CharSequence target, CharSequence replacement) {return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(this).replaceAll(Matcher.quoteReplacement(replacement.toString()));}/*** Splits this string around matches of the given* <a href="../util/regex/Pattern.html#sum">regular expression</a>.** <p> The array returned by this method contains each substring of this* string that is terminated by another substring that matches the given* expression or is terminated by the end of the string. The substrings in* the array are in the order in which they occur in this string. If the* expression does not match any part of the input then the resulting array* has just one element, namely this string.** <p> The <tt>limit</tt> parameter controls the number of times the* pattern is applied and therefore affects the length of the resulting* array. If the limit <i>n</i> is greater than zero then the pattern* will be applied at most <i>n</i> - 1 times, the array's* length will be no greater than <i>n</i>, and the array's last entry* will contain all input beyond the last matched delimiter. If <i>n</i>* is non-positive then the pattern will be applied as many times as* possible and the array can have any length. If <i>n</i> is zero then* the pattern will be applied as many times as possible, the array can* have any length, and trailing empty strings will be discarded.** <p> The string <tt>"boo:and:foo"</tt>, for example, yields the* following results with these parameters:** <blockquote><table cellpadding=1 cellspacing=0 summary="Split example showing regex, limit, and result">* <tr>* <th>Regex</th>* <th>Limit</th>* <th>Result</th>* </tr>* <tr><td align=center>:</td>* <td align=center>2</td>* <td><tt>{ "boo", "and:foo" }</tt></td></tr>* <tr><td align=center>:</td>* <td align=center>5</td>* <td><tt>{ "boo", "and", "foo" }</tt></td></tr>* <tr><td align=center>:</td>* <td align=center>-2</td>* <td><tt>{ "boo", "and", "foo" }</tt></td></tr>* <tr><td align=center>o</td>* <td align=center>5</td>* <td><tt>{ "b", "", ":and:f", "", "" }</tt></td></tr>* <tr><td align=center>o</td>* <td align=center>-2</td>* <td><tt>{ "b", "", ":and:f", "", "" }</tt></td></tr>* <tr><td align=center>o</td>* <td align=center>0</td>* <td><tt>{ "b", "", ":and:f" }</tt></td></tr>* </table></blockquote>** <p> An invocation of this method of the form* <i>str.</i><tt>split(</tt><i>regex</i><tt>,</tt> <i>n</i><tt>)</tt>* yields the same result as the expression** <blockquote>* {@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#compile* compile}<tt>(</tt><i>regex</i><tt>)</tt>.{@link* java.util.regex.Pattern#split(java.lang.CharSequence,int)* split}<tt>(</tt><i>str</i><tt>,</tt> <i>n</i><tt>)</tt>* </blockquote>*** @param regex* the delimiting regular expression** @param limit* the result threshold, as described above** @return the array of strings computed by splitting this string* around matches of the given regular expression** @throws PatternSyntaxException* if the regular expression's syntax is invalid** @see java.util.regex.Pattern** @since 1.4* @spec JSR-51*/
根据某个字符串分割字符串，后面的数字类型的参数表示分割多少次。即如果limit为1的话返回的数组的长度为最多为2.
public String[] split(String regex, int limit) {return Pattern.compile(regex).split(this, limit);}/*** Splits this string around matches of the given <a* href="../util/regex/Pattern.html#sum">regular expression</a>.** <p> This method works as if by invoking the two-argument {@link* #split(String, int) split} method with the given expression and a limit* argument of zero. Trailing empty strings are therefore not included in* the resulting array.** <p> The string <tt>"boo:and:foo"</tt>, for example, yields the following* results with these expressions:** <blockquote><table cellpadding=1 cellspacing=0 summary="Split examples showing regex and result">* <tr>* <th>Regex</th>* <th>Result</th>* </tr>* <tr><td align=center>:</td>* <td><tt>{ "boo", "and", "foo" }</tt></td></tr>* <tr><td align=center>o</td>* <td><tt>{ "b", "", ":and:f" }</tt></td></tr>* </table></blockquote>*** @param regex* the delimiting regular expression** @return the array of strings computed by splitting this string* around matches of the given regular expression** @throws PatternSyntaxException* if the regular expression's syntax is invalid** @see java.util.regex.Pattern** @since 1.4* @spec JSR-51*/
拆分字符串。
public String[] split(String regex) {return split(regex, 0);}/*** Converts all of the characters in this <code>String</code> to lower* case using the rules of the given <code>Locale</code>. Case mapping is based* on the Unicode Standard version specified by the {@link java.lang.Character Character}* class. Since case mappings are not always 1:1 char mappings, the resulting* <code>String</code> may be a different length than the original <code>String</code>.* <p>* Examples of lowercase mappings are in the following table:* <table border="1" summary="Lowercase mapping examples showing language code of locale, upper case, lower case, and description">* <tr>* <th>Language Code of Locale</th>* <th>Upper Case</th>* <th>Lower Case</th>* <th>Description</th>* </tr>* <tr>* <td>tr (Turkish)</td>* <td>\u0130</td>* <td>\u0069</td>* <td>capital letter I with dot above -> small letter i</td>* </tr>* <tr>* <td>tr (Turkish)</td>* <td>\u0049</td>* <td>\u0131</td>* <td>capital letter I -> small letter dotless i </td>* </tr>* <tr>* <td>(all)</td>* <td>French Fries</td>* <td>french fries</td>* <td>lowercased all chars in String</td>* </tr>* <tr>* <td>(all)</td>* <td><img src="doc-files/capiota.gif" alt="capiota"><img src="doc-files/capchi.gif" alt="capchi">* <img src="doc-files/captheta.gif" alt="captheta"><img src="doc-files/capupsil.gif" alt="capupsil">* <img src="doc-files/capsigma.gif" alt="capsigma"></td>* <td><img src="doc-files/iota.gif" alt="iota"><img src="doc-files/chi.gif" alt="chi">* <img src="doc-files/theta.gif" alt="theta"><img src="doc-files/upsilon.gif" alt="upsilon">* <img src="doc-files/sigma1.gif" alt="sigma"></td>* <td>lowercased all chars in String</td>* </tr>* </table>** @param locale use the case transformation rules for this locale* @return the <code>String</code>, converted to lowercase.* @see java.lang.String#toLowerCase()* @see java.lang.String#toUpperCase()* @see java.lang.String#toUpperCase(Locale)* @since 1.1*/
将大写字符改为小写，参数表示、可以传入一个编码形式。不传的时候根据本地的默认编码方式
public String toLowerCase(Locale locale) {if (locale == null) {throw new NullPointerException();}int firstUpper;/* Now check if there are any characters that need to be changed. */scan: {for (firstUpper = 0 ; firstUpper < count; ) {char c = value[offset+firstUpper];if ((c >= Character.MIN_HIGH_SURROGATE) &&(c <= Character.MAX_HIGH_SURROGATE)) {int supplChar = codePointAt(firstUpper);if (supplChar != Character.toLowerCase(supplChar)) {break scan;}firstUpper += Character.charCount(supplChar);} else {if (c != Character.toLowerCase(c)) {break scan;}firstUpper++;}}return this;}char[] result = new char[count];int resultOffset = 0; /* result may grow, so i+resultOffset* is the write location in result *//* Just copy the first few lowerCase characters. */System.arraycopy(value, offset, result, 0, firstUpper);String lang = locale.getLanguage();boolean localeDependent =(lang == "tr" || lang == "az" || lang == "lt");char[] lowerCharArray;int lowerChar;int srcChar;int srcCount;for (int i = firstUpper; i < count; i += srcCount) {srcChar = (int)value[offset+i];if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&(char)srcChar <= Character.MAX_HIGH_SURROGATE) {srcChar = codePointAt(i);srcCount = Character.charCount(srcChar);} else {srcCount = 1;}if (localeDependent || srcChar == '\u03A3') { // GREEK CAPITAL LETTER SIGMAlowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);} else {lowerChar = Character.toLowerCase(srcChar);}if ((lowerChar == Character.ERROR) ||(lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {if (lowerChar == Character.ERROR) {lowerCharArray =ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);} else if (srcCount == 2) {resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;continue;} else {lowerCharArray = Character.toChars(lowerChar);}/* Grow result if needed */int mapLen = lowerCharArray.length;if (mapLen > srcCount) {char[] result2 = new char[result.length + mapLen - srcCount];System.arraycopy(result, 0, result2, 0,i + resultOffset);result = result2;}for (int x=0; x<mapLen; ++x) {result[i+resultOffset+x] = lowerCharArray[x];}resultOffset += (mapLen - srcCount);} else {result[i+resultOffset] = (char)lowerChar;}}return new String(0, count+resultOffset, result);}/*** Converts all of the characters in this <code>String</code> to lower* case using the rules of the default locale. This is equivalent to calling* <code>toLowerCase(Locale.getDefault())</code>.* <p>* <b>Note:</b> This method is locale sensitive, and may produce unexpected* results if used for strings that are intended to be interpreted locale* independently.* Examples are programming language identifiers, protocol keys, and HTML* tags.* For instance, <code>"TITLE".toLowerCase()</code> in a Turkish locale* returns <code>"t\u0131tle"</code>, where '\u0131' is the LATIN SMALL* LETTER DOTLESS I character.* To obtain correct results for locale insensitive strings, use* <code>toLowerCase(Locale.ENGLISH)</code>.* <p>* @return the <code>String</code>, converted to lowercase.* @see java.lang.String#toLowerCase(Locale)*/public String toLowerCase() {return toLowerCase(Locale.getDefault());}/*** Converts all of the characters in this <code>String</code> to upper* case using the rules of the given <code>Locale</code>. Case mapping is based* on the Unicode Standard version specified by the {@link java.lang.Character Character}* class. Since case mappings are not always 1:1 char mappings, the resulting* <code>String</code> may be a different length than the original <code>String</code>.* <p>* Examples of locale-sensitive and 1:M case mappings are in the following table.* <p>* <table border="1" summary="Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description.">* <tr>* <th>Language Code of Locale</th>* <th>Lower Case</th>* <th>Upper Case</th>* <th>Description</th>* </tr>* <tr>* <td>tr (Turkish)</td>* <td>\u0069</td>* <td>\u0130</td>* <td>small letter i -> capital letter I with dot above</td>* </tr>* <tr>* <td>tr (Turkish)</td>* <td>\u0131</td>* <td>\u0049</td>* <td>small letter dotless i -> capital letter I</td>* </tr>* <tr>* <td>(all)</td>* <td>\u00df</td>* <td>\u0053 \u0053</td>* <td>small letter sharp s -> two letters: SS</td>* </tr>* <tr>* <td>(all)</td>* <td>Fahrvergnügen</td>* <td>FAHRVERGNÜGEN</td>* <td></td>* </tr>* </table>* @param locale use the case transformation rules for this locale* @return the <code>String</code>, converted to uppercase.* @see java.lang.String#toUpperCase()* @see java.lang.String#toLowerCase()* @see java.lang.String#toLowerCase(Locale)* @since 1.1*/
将小写字符转为大写字符
public String toUpperCase(Locale locale) {if (locale == null) {throw new NullPointerException();}int firstLower;/* Now check if there are any characters that need to be changed. */scan: {for (firstLower = 0 ; firstLower < count; ) {int c = (int)value[offset+firstLower];int srcCount;if ((c >= Character.MIN_HIGH_SURROGATE) &&(c <= Character.MAX_HIGH_SURROGATE)) {c = codePointAt(firstLower);srcCount = Character.charCount(c);} else {srcCount = 1;}int upperCaseChar = Character.toUpperCaseEx(c);if ((upperCaseChar == Character.ERROR) ||(c != upperCaseChar)) {break scan;}firstLower += srcCount;}return this;}char[] result = new char[count]; /* may grow */int resultOffset = 0; /* result may grow, so i+resultOffset* is the write location in result *//* Just copy the first few upperCase characters. */System.arraycopy(value, offset, result, 0, firstLower);String lang = locale.getLanguage();boolean localeDependent =(lang == "tr" || lang == "az" || lang == "lt");char[] upperCharArray;int upperChar;int srcChar;int srcCount;for (int i = firstLower; i < count; i += srcCount) {srcChar = (int)value[offset+i];if ((char)srcChar >= Character.MIN_HIGH_SURROGATE &&(char)srcChar <= Character.MAX_HIGH_SURROGATE) {srcChar = codePointAt(i);srcCount = Character.charCount(srcChar);} else {srcCount = 1;}if (localeDependent) {upperChar = ConditionalSpecialCasing.toUpperCaseEx(this, i, locale);} else {upperChar = Character.toUpperCaseEx(srcChar);}if ((upperChar == Character.ERROR) ||(upperChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {if (upperChar == Character.ERROR) {if (localeDependent) {upperCharArray =ConditionalSpecialCasing.toUpperCaseCharArray(this, i, locale);} else {upperCharArray = Character.toUpperCaseCharArray(srcChar);}} else if (srcCount == 2) {resultOffset += Character.toChars(upperChar, result, i + resultOffset) - srcCount;continue;} else {upperCharArray = Character.toChars(upperChar);}/* Grow result if needed */int mapLen = upperCharArray.length;if (mapLen > srcCount) {char[] result2 = new char[result.length + mapLen - srcCount];System.arraycopy(result, 0, result2, 0,i + resultOffset);result = result2;}for (int x=0; x<mapLen; ++x) {result[i+resultOffset+x] = upperCharArray[x];}resultOffset += (mapLen - srcCount);} else {result[i+resultOffset] = (char)upperChar;}}return new String(0, count+resultOffset, result);}/*** Converts all of the characters in this <code>String</code> to upper* case using the rules of the default locale. This method is equivalent to* <code>toUpperCase(Locale.getDefault())</code>.* <p>* <b>Note:</b> This method is locale sensitive, and may produce unexpected* results if used for strings that are intended to be interpreted locale* independently.* Examples are programming language identifiers, protocol keys, and HTML* tags.* For instance, <code>"title".toUpperCase()</code> in a Turkish locale* returns <code>"T\u0130TLE"</code>, where '\u0130' is the LATIN CAPITAL* LETTER I WITH DOT ABOVE character.* To obtain correct results for locale insensitive strings, use* <code>toUpperCase(Locale.ENGLISH)</code>.* <p>* @return the <code>String</code>, converted to uppercase.* @see java.lang.String#toUpperCase(Locale)*/public String toUpperCase() {return toUpperCase(Locale.getDefault());}/*** Returns a copy of the string, with leading and trailing whitespace* omitted.* <p>* If this <code>String</code> object represents an empty character* sequence, or the first and last characters of character sequence* represented by this <code>String</code> object both have codes* greater than <code>'\u0020'</code> (the space character), then a* reference to this <code>String</code> object is returned.* <p>* Otherwise, if there is no character with a code greater than* <code>'\u0020'</code> in the string, then a new* <code>String</code> object representing an empty string is created* and returned.* <p>* Otherwise, let <i>k</i> be the index of the first character in the* string whose code is greater than <code>'\u0020'</code>, and let* <i>m</i> be the index of the last character in the string whose code* is greater than <code>'\u0020'</code>. A new <code>String</code>* object is created, representing the substring of this string that* begins with the character at index <i>k</i> and ends with the* character at index <i>m</i>-that is, the result of* <code>this.substring(<i>k</i>, <i>m</i>+1)</code>.* <p>* This method may be used to trim whitespace (as defined above) from* the beginning and end of a string.** @return A copy of this string with leading and trailing white* space removed, or this string if it has no leading or* trailing white space.*/
去除字符串中前后的空格，中间的空格不会去除
public String trim() {int len = count;int st = 0;int off = offset; /* avoid getfield opcode */char[] val = value; /* avoid getfield opcode */while ((st < len) && (val[off + st] <= ' ')) {st++;}while ((st < len) && (val[off + len - 1] <= ' ')) {len--;}return ((st > 0) || (len < count)) ? substring(st, len) : this;}/*** This object (which is already a string!) is itself returned.** @return the string itself.*/public String toString() {return this;}/*** Converts this string to a new character array.** @return a newly allocated character array whose length is the length* of this string and whose contents are initialized to contain* the character sequence represented by this string.*/
将字符串转为字符型的数组
public char[] toCharArray() {char result[] = new char[count];getChars(0, count, result, 0);return result;}/*** Returns a formatted string using the specified format string and* arguments.** <p> The locale always used is the one returned by {@link* java.util.Locale#getDefault() Locale.getDefault()}.** @param format* A <a href="../util/Formatter.html#syntax">format string</a>** @param args* Arguments referenced by the format specifiers in the format* string. If there are more arguments than format specifiers, the* extra arguments are ignored. The number of arguments is* variable and may be zero. The maximum number of arguments is* limited by the maximum dimension of a Java array as defined by* the <a href="http://java.sun.com/docs/books/vmspec/">Java* Virtual Machine Specification</a>. The behaviour on a* <tt>null</tt> argument depends on the <a* href="../util/Formatter.html#syntax">conversion</a>.** @throws IllegalFormatException* If a format string contains an illegal syntax, a format* specifier that is incompatible with the given arguments,* insufficient arguments given the format string, or other* illegal conditions. For specification of all possible* formatting errors, see the <a* href="../util/Formatter.html#detail">Details</a> section of the* formatter class specification.** @throws NullPointerException* If the <tt>format</tt> is <tt>null</tt>** @return A formatted string** @see java.util.Formatter* @since 1.5*/
格式化字符串，还不会用
public static String format(String format, Object ... args) {return new Formatter().format(format, args).toString();}/*** Returns a formatted string using the specified locale, format string,* and arguments.** @param l* The {@linkplain java.util.Locale locale} to apply during* formatting. If <tt>l</tt> is <tt>null</tt> then no localization* is applied.** @param format* A <a href="../util/Formatter.html#syntax">format string</a>** @param args* Arguments referenced by the format specifiers in the format* string. If there are more arguments than format specifiers, the* extra arguments are ignored. The number of arguments is* variable and may be zero. The maximum number of arguments is* limited by the maximum dimension of a Java array as defined by* the <a href="http://java.sun.com/docs/books/vmspec/">Java* Virtual Machine Specification</a>. The behaviour on a* <tt>null</tt> argument depends on the <a* href="../util/Formatter.html#syntax">conversion</a>.** @throws IllegalFormatException* If a format string contains an illegal syntax, a format* specifier that is incompatible with the given arguments,* insufficient arguments given the format string, or other* illegal conditions. For specification of all possible* formatting errors, see the <a* href="../util/Formatter.html#detail">Details</a> section of the* formatter class specification** @throws NullPointerException* If the <tt>format</tt> is <tt>null</tt>** @return A formatted string** @see java.util.Formatter* @since 1.5*/public static String format(Locale l, String format, Object ... args) {return new Formatter(l).format(format, args).toString();}/*** Returns the string representation of the <code>Object</code> argument.** @param obj an <code>Object</code>.* @return if the argument is <code>null</code>, then a string equal to* <code>"null"</code>; otherwise, the value of* <code>obj.toString()</code> is returned.* @see java.lang.Object#toString()*/
将基本类型转换为string类型。
public static String valueOf(Object obj) {return (obj == null) ? "null" : obj.toString();}/*** Returns the string representation of the <code>char</code> array* argument. The contents of the character array are copied; subsequent* modification of the character array does not affect the newly* created string.** @param data a <code>char</code> array.* @return a newly allocated string representing the same sequence of* characters contained in the character array argument.*/public static String valueOf(char data[]) {return new String(data);}/*** Returns the string representation of a specific subarray of the* <code>char</code> array argument.* <p>* The <code>offset</code> argument is the index of the first* character of the subarray. The <code>count</code> argument* specifies the length of the subarray. The contents of the subarray* are copied; subsequent modification of the character array does not* affect the newly created string.** @param data the character array.* @param offset the initial offset into the value of the* <code>String</code>.* @param count the length of the value of the <code>String</code>.* @return a string representing the sequence of characters contained* in the subarray of the character array argument.* @exception IndexOutOfBoundsException if <code>offset</code> is* negative, or <code>count</code> is negative, or* <code>offset+count</code> is larger than* <code>data.length</code>.*/public static String valueOf(char data[], int offset, int count) {return new String(data, offset, count);}/*** Returns a String that represents the character sequence in the* array specified.** @param data the character array.* @param offset initial offset of the subarray.* @param count length of the subarray.* @return a <code>String</code> that contains the characters of the* specified subarray of the character array.*/public static String copyValueOf(char data[], int offset, int count) {// All public String constructors now copy the data.return new String(data, offset, count);}/*** Returns a String that represents the character sequence in the* array specified.** @param data the character array.* @return a <code>String</code> that contains the characters of the* character array.*/public static String copyValueOf(char data[]) {return copyValueOf(data, 0, data.length);}/*** Returns the string representation of the <code>boolean</code> argument.** @param b a <code>boolean</code>.* @return if the argument is <code>true</code>, a string equal to* <code>"true"</code> is returned; otherwise, a string equal to* <code>"false"</code> is returned.*/public static String valueOf(boolean b) {return b ? "true" : "false";}/*** Returns the string representation of the <code>char</code>* argument.** @param c a <code>char</code>.* @return a string of length <code>1</code> containing* as its single character the argument <code>c</code>.*/public static String valueOf(char c) {char data[] = {c};return new String(0, 1, data);}/*** Returns the string representation of the <code>int</code> argument.* <p>* The representation is exactly the one returned by the* <code>Integer.toString</code> method of one argument.** @param i an <code>int</code>.* @return a string representation of the <code>int</code> argument.* @see java.lang.Integer#toString(int, int)*/public static String valueOf(int i) {return Integer.toString(i, 10);}/*** Returns the string representation of the <code>long</code> argument.* <p>* The representation is exactly the one returned by the* <code>Long.toString</code> method of one argument.** @param l a <code>long</code>.* @return a string representation of the <code>long</code> argument.* @see java.lang.Long#toString(long)*/public static String valueOf(long l) {return Long.toString(l, 10);}/*** Returns the string representation of the <code>float</code> argument.* <p>* The representation is exactly the one returned by the* <code>Float.toString</code> method of one argument.** @param f a <code>float</code>.* @return a string representation of the <code>float</code> argument.* @see java.lang.Float#toString(float)*/public static String valueOf(float f) {return Float.toString(f);}/*** Returns the string representation of the <code>double</code> argument.* <p>* The representation is exactly the one returned by the* <code>Double.toString</code> method of one argument.** @param d a <code>double</code>.* @return a string representation of the <code>double</code> argument.* @see java.lang.Double#toString(double)*/public static String valueOf(double d) {return Double.toString(d);}/*** Returns a canonical representation for the string object.* <p>* A pool of strings, initially empty, is maintained privately by the* class <code>String</code>.* <p>* When the intern method is invoked, if the pool already contains a* string equal to this <code>String</code> object as determined by* the {@link #equals(Object)} method, then the string from the pool is* returned. Otherwise, this <code>String</code> object is added to the* pool and a reference to this <code>String</code> object is returned.* <p>* It follows that for any two strings <code>s</code> and <code>t</code>,* <code>s.intern() == t.intern()</code> is <code>true</code>* if and only if <code>s.equals(t)</code> is <code>true</code>.* <p>* All literal strings and string-valued constant expressions are* interned. String literals are defined in §3.10.5 of the* <a href="http://java.sun.com/docs/books/jls/html/">Java Language* Specification</a>** @return a string that has the same contents as this string, but is* guaranteed to be from a pool of unique strings.*/
这个方法之前说过，即新创建string类型对象的时候，后面如果加个这个方法，系统会去当前内存中查找是否存在和新创建的字符串内容相同的字符串。如果存在的话，就不会新开辟内存重新创建一个新的字符串，而是将当前对象指向内存中已经存在的字符串的位置。。虽说对象名称不同，但是内存中时同一个东西。
public native String intern();}
开发的初步集成01--依赖)
![[Hnoi2006]马步距离](http://pic.xiahunao.cn/[Hnoi2006]马步距离)
)
