- 1. String类的定义
- 2. 字段属性
- 3. 常用构造方法
- 4. 其他常用方法
public final class String implements Serializable, Comparable, CharSequence
根据String类的定义,可以得出:
1、String类是被final关键字修饰的类:
① final修饰的类不能被继承,final类中的成员变量可以根据需要设为final,但final类中的所有成员方法都会被隐式地指定为final方法。
② 当final关键字用来修饰一个方法的时候,这个方法就是最终方法,不能够被覆盖重写。
2、String类实现了java.io.Serializable接口,可以实现序列化:
① 序列化是指把对象转换为字节序列的过程,我们称之为对象的序列化,就是把内存中的这些对象变成一连串的字节(bytes)描述的过程。
② 反序列化则相反,就是把持久化的字节文件数据恢复为对象的过程。
3、String类实现了Comparable
// 这个接口只有一个compareTo(T 0)方法,用于对两个实例化对象比较大小。 public interface Comparable{ int compareTo(T var1); }
2. 字段属性
private final char value[]; private int hash; // Default to 0
① 被final修饰的变量一旦被赋初始值,final变量的值以后将不会被改变。
② value[]是存储String的内容的,即当使用String str = "abc";的时候,本质上,"abc"是存储在一个char类型的数组中的。
③ hash是String实例化的hashcode的一个缓存。因为String经常被用于比较,比如在HashMap中。如果每次进行比较都重新计算hashcode的值的话,那无疑是比较麻烦的,而保存一个hashcode的缓存无疑能优化这样的 *** 作。
3. 常用构造方法
1、 构造方法:String()
// 初始化一个新创建的String 对象,使其代表空字符序列。请注意,此构造函数的使用是不必要,因为字符串是不可变的。 public String() { this.value = new char[0]; }
2、 构造方法:String(char value[])
public String(char value[]) { this.value = Arrays.copyOf(value, value.length); }
3、构造方法:String(char value[], int offset, int count)
public String(char value[], int offset, int count) { // 参数校验 if (offset < 0) { throw new StringIndexOutOfBoundsException(offset); } if (count < 0) { throw new StringIndexOutOfBoundsException(count); } if (offset > value.length - count) { throw new StringIndexOutOfBoundsException(offset + count); } // 数组的拷贝 this.value = Arrays.copyOfRange(value, offset, offset+count); }
public static char[] copyOfRange(char[] original, int from, int to) { int newLength = to - from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); char[] copy = new char[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; }
4、构造方法:String(byte bytes[], int offset, int length)
public String(byte bytes[], int offset, int length) { checkBounds(bytes, offset, length); this.value = StringCoding.decode(bytes, offset, length); }
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); }
5、构造方法:String(byte bytes[])
public String(byte bytes[]) { this(bytes, 0, bytes.length); }
6 、构造方法:String(byte bytes[], Charset charset)
public String(byte bytes[], Charset charset) { this(bytes, 0, bytes.length, charset); }
7、构造方法:String(byte bytes[], int offset, int length, Charset charset)
public String(byte bytes[], int offset, int length, Charset charset) { if (charset == null) throw new NullPointerException("charset"); checkBounds(bytes, offset, length); this.value = StringCoding.decode(charset, bytes, offset, length); }
8、构造方法:String(StringBuffer buffer)
public String(StringBuffer buffer) { // 加了synchronized,说明是线程安全的,同一时间只有一个线程可以 *** 作 synchronized(buffer) { this.value = Arrays.copyOf(buffer.getValue(), buffer.length()); } }
public static char[] copyOf(char[] original, int newLength) { char[] copy = new char[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }
9、构造方法:String(StringBuilder builder)
public String(StringBuilder builder) { this.value = Arrays.copyOf(builder.getValue(), builder.length()); }
String支持多种构造方法,包括接收String,char[],byte[],StringBuffer,StringBuilder等多种参数类型的初始化方法。但本质上,其实就是将接收到的参数传递给全局变量value[]。
4. 其他常用方法
1、int length()
// 存放字符串中的字符 private final char value[]; // 返回字符串的长度 public int length() { return value.length; }
2、boolean isEmpty()
// 存放字符串中的字符 private final char value[]; // 判断字符串是否为空,就是判断value的长度是否为空 public boolean isEmpty() { return value.length == 0; }
3、char charAt(int index)
// 存放字符串中指定索引处的字符 private final char value[]; // 返回指定索引处的 char 值 public char charAt(int index) { // 参数校验 if ((index < 0) || (index >= value.length)) { throw new StringIndexOutOfBoundsException(index); } return value[index]; }
4、getChars(char dst[], int dstBegin
// 从 dstBegin 开始,将此字符串中的字符复制到字符数组 dst 中, 此方法不执行任何范围检查。 void getChars(char dst[], int dstBegin) { System.arraycopy(value, 0, dst, dstBegin, value.length); }
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
5、void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin)
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) { if (srcBegin < 0) { throw new StringIndexOutOfBoundsException(srcBegin); } if (srcEnd > value.length) { throw new StringIndexOutOfBoundsException(srcEnd); } if (srcBegin > srcEnd) { throw new StringIndexOutOfBoundsException(srcEnd - srcBegin); } System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin); }
6、byte[] getBytes(String charsetName)
// 使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。 public byte[] getBytes(String charsetName) throws UnsupportedEncodingException { if (charsetName == null) throw new NullPointerException(); return StringCoding.encode(charsetName, value, 0, value.length); }
7、byte[] getBytes(Charset charset)
// 使用给定的 charset 将此 String 编码到 byte 序列,并将结果存储到新的 byte 数组。 public byte[] getBytes(Charset charset) { if (charset == null) throw new NullPointerException(); return StringCoding.encode(charset, value, 0, value.length); }
8、 byte[] getBytes()
// 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。 public byte[] getBytes() { return StringCoding.encode(value, 0, value.length); }
9、equals(Object anObject)
// 判断两个字符串是否相等 public boolean equals(Object anObject) { // 比较对象的内存地址,当两个对象的内存地址相同时,说明是同一个对象,因此返回true if (this == anObject) { return true; } // 在 Java 中可以使用 instanceof 关键字判断一个对象是否为一个类(或接口、抽象类、父类)的实例 // anObject对象是String类的实例或者子类实例时,则返回true,一般在强制转换之前判断 if (anObject instanceof String) { // 强制转换为String类型 String anotherString = (String)anObject; int n = value.length; // 判断当前字符串和传入字符串的长度是否相等,不相等直接返回false if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; // 判断两个字符数组的每个字符是否相等 while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }
10、boolean equalsIgnoreCase(String anotherString)
// 判断两个字符串是否相等,忽略字符串的大小写 public boolean equalsIgnoreCase(String anotherString) { // 1、判断两个字符串对象的内存地址是否相同,如果相同直接返回true // 2、否则继续判断: // 1、字符串不能为null // 2、两个字符串的长度相同 // 3、将两个字符串中的字符转换为大写,小写后再比较两个字符串的字符串是否相等 return (this == anotherString) ? true : (anotherString != null) && (anotherString.value.length == value.length) && regionMatches(true, 0, anotherString, 0, value.length); }
public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) { // 此字符串对应的字符数组 char ta[] = value; // 此字符串的起始指针 int to = toffset; // 参数字符串的起始指针 char pa[] = other.value; // 参数字符串对应的字符数组 int po = ooffset; // 参数校验 if ((ooffset < 0) || (toffset < 0) || (toffset > (long)value.length - len) || (ooffset > (long)other.value.length - len)) { return false; } // 比较字符数组中的每个字符是否相同 while (len-- > 0) { // 获取此字符指针指向的字符 char c1 = ta[to++]; // 获取参数字符串指针指向的字符 char c2 = pa[po++]; // 判断两个字符是否相同,如果相同,则比较扫描继续 if (c1 == c2) { continue; } if (ignoreCase) { // 如果字符不匹配但大小写可能会被忽略,尝试将两个字符都转换为大写, 如果结果匹配,那么比较扫描应该继续 char u1 = Character.toUpperCase(c1); char u2 = Character.toUpperCase(c2); if (u1 == u2) { continue; } //不幸的是,Georgian alphabet不能正常转换为大写字母,Georgian alphabet对大小写转换有奇怪的规则。 所以我们需要在退出前做最后一次检查。 if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) { continue; } } return false; } return true; }
11、int compareTo(String anotherString)
// 按字典顺序比较两个字符串。该方法实现了Comparable接口的方法 // 按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。 // 按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。 // 如果按字典顺序此 String 对象位于参数字符串之前,则比较结果为一个负整数。 // 如果按字典顺序此 String 对象位于参数字符串之后,则比较结果为一个正整数。 // 如果这两个字符串相等,则结果为 0; // compareTo 只在方法 equals(Object) 返回 true 时才返回 0。 public int compareTo(String anotherString) { int len1 = value.length; int len2 = anotherString.value.length; int lim = Math.min(len1, len2); char v1[] = value; char v2[] = anotherString.value; int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; if (c1 != c2) { return c1 - c2; } k++; } return len1 - len2; }
12、boolean startsWith(String prefix, int toffset)
public boolean startsWith(String prefix, int toffset) { // 当前字符串对应的字符数组 char ta[] = value; // 字符串中开查找的位置 int to = toffset; // 指定索引开始的子字符串对应的字符数组 char pa[] = prefix.value; int po = 0; int pc = prefix.value.length; // 参数校验 if ((toffset < 0) || (toffset > value.length - pc)) { return false; } // 判断每个字符是否相同 while (--pc >= 0) { if (ta[to++] != pa[po++]) { return false; } } return true; }
13、boolean startsWith(String prefix)
public boolean startsWith(String prefix) { // 索引从0开始 return startsWith(prefix, 0); }
14、boolean endsWith(String suffix)
public boolean endsWith(String suffix) { return startsWith(suffix, value.length - suffix.value.length); }
15、int hashCode()
public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char val[] = value; for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; } return h; }
16、int indexOf(int ch, int fromIndex)
public int indexOf(int ch, int fromIndex) { final int max = value.length; // 参数校验,如果索引小于0,设置为0, if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= max) { // 如果索引大于字符串字符的长度,返回-1,代表此字符串中没有这样的字符。 return -1; } if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { // 当前字符串对应的字符数组 final char[] value = this.value; // 从从指定的索引开始遍历字符数组,判断字符数组中的字符是否等于指定字符,如果找到,直接返回索引 for (int i = fromIndex; i < max; i++) { if (value[i] == ch) { // 此时返回的就是字符串中第一次出现指定字符的索引 return i; } } return -1; } else { // 使用补充字符处理(罕见)对 indexOf 的调用。 return indexOfSupplementary(ch, fromIndex); } }
17、int indexOf(int ch)
public int indexOf(int ch) { return indexOf(ch, 0); }
18、int lastIndexOf(int ch, int fromIndex)
public int lastIndexOf(int ch, int fromIndex) { if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) { // 当前字符串对应的字符数组 final char[] value = this.value; // 没有做参数处理,当参数fromIndex的值大于value.length - 1时,取 i=value.length - 1 int i = Math.min(fromIndex, value.length - 1); // 遍历整个字符串 for (; i >= 0; i--) { // 从字符产的最后一个字符往前遍历,判断遍历到的字符与指定字符是否相同 if (value[i] == ch) { // 此时返回的是字符串中最后一次出现指定字符的索引 return i; } } // 如果此字符串中 fromIndex 或之前的位置没有这样的字符出现,则返回 -1。 return -1; } else { return lastIndexOfSupplementary(ch, fromIndex); } }
19、int lastIndexOf(int ch)
public int lastIndexOf(int ch) { return lastIndexOf(ch, value.length - 1); }
20、String substring(int beginIndex)
public String substring(int beginIndex) { // 参数校验 if (beginIndex < 0) { throw new StringIndexOutOfBoundsException(beginIndex); } int subLen = value.length - beginIndex; if (subLen < 0) { throw new StringIndexOutOfBoundsException(subLen); } // 如果beginIndex==0,直接返回字符串,否则重新创建一个子字符串 // 因为字符串一旦创建后就是不变的 return (beginIndex == 0) ? this : new String(value, beginIndex, subLen); }
21、String substring(int beginIndex, int endIndex)
public String substring(int beginIndex, int endIndex) { if (beginIndex < 0) { throw new StringIndexOutOfBoundsException(beginIndex); } if (endIndex > value.length) { throw new StringIndexOutOfBoundsException(endIndex); } int subLen = endIndex - beginIndex; if (subLen < 0) { throw new StringIndexOutOfBoundsException(subLen); } // 创建一个新的字符串,新字符串是原始字符串的子串 return ((beginIndex == 0) && (endIndex == value.length)) ? this : new String(value, beginIndex, subLen); }
22、String concat(String str)
public String concat(String str) { int otherLen = str.length(); if (otherLen == 0) { return this; } int len = value.length; // 创建一个长度为len+otherLen的数组,然后将String对应的字符数组value拷贝到该数组中 char buf[] = Arrays.copyOf(value, len + otherLen); // 将字符从此字符串复制到目标字符数组,目标数组中的起始拷贝位置为len str.getChars(buf, len); // 创建一个新的字符串 return new String(buf, true); }
void getChars(char dst[], int dstBegin) { System.arraycopy(value, 0, dst, dstBegin, value.length); }
public static char[] copyOf(char[] original, int newLength) { //创建一个长度为newLength的目标数组 char[] copy = new char[newLength]; // 将原数组original中的字符拷贝到目标数组中 System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }
23、String replace(char oldChar, char newChar)
public String replace(char oldChar, char newChar) { // 如果旧字符和新字符不相等,就执行替换 if (oldChar != newChar) { int len = value.length; int i = -1; char[] val = value; // 从字符串中找到当前要替换字符的索引 while (++i < len) { if (val[i] == oldChar) { break; } } if (i < len) { // 创建一个长度为len字符数组 char buf[] = new char[len]; // 将val字符数组下标从0到i(不包括i)之间的字符复制到新的字符数组buf中 // 即将0~i之间的字符复制到新字符数组buf中 for (int j = 0; j < i; j++) { buf[j] = val[j]; } // 取出val数组中的每一个字符, 判断是否是oldChar,如果是就将其替换为newChar放进数组buf中 // 如果不是oldChar,就直接把这个字符放进buf中 while (i < len) { char c = val[i]; buf[i] = (c == oldChar) ? newChar : c; i++; } // 创建一个字符串,即将buf数组赋值给String的value数组 return new String(buf, true); } } return this; }
24、String replaceAll(String regex, String replacement)
public String replaceAll(String regex, String replacement) { return Pattern.compile(regex).matcher(this).replaceAll(replacement); }
25、String trim()
public String trim() { // int len = value.length; int st = 0; char[] val = value; while ((st < len) && (val[st] <= ' ')) { st++; } while ((st < len) && (val[len - 1] <= ' ')) { len--; } return ((st > 0) || (len < value.length)) ? substring(st, len) : this; }
26、char[] toCharArray()
public char[] toCharArray() { // 创建一个长度等于value.length的字符数组 char result[] = new char[value.length]; // 将value数组拷贝到result数组中 System.arraycopy(value, 0, result, 0, value.length); return result; }
27、String valueOf(char c)
public static String valueOf(char c) { char data[] = {c}; return new String(data, true); }
28、String valueOf(boolean b)
// 返回boolean参数的字符串表示形式。 public static String valueOf(boolean b) { return b ? "true" : "false"; }
29、String valueOf(int i)
// 返回int参数的字符串表示形式。 public static String valueOf(int i) { return Integer.toString(i); }
30、String valueOf(long l)
// 返回long参数的字符串表示形式。 public static String valueOf(long l) { return Long.toString(l); }
31、String valueOf(float f)
public static String valueOf(float f) { return Float.toString(f); }
32、String valueOf(double d)
public static String valueOf(double d) { return Double.toString(d); }
33、String intern()
public native String intern();
欢迎分享,转载请注明来源:内存溢出
评论列表(0条)