前言：
在Java编程语言中，String是一种特殊的数据类型，它被广泛应用于存储文本和字符串。与其他一些编程语言不同，Java中的String是不可修改的，也就是说一旦创建，就无法更改其内容。那么，为什么String被设计成不可修改的呢？
源码，可以看出String类是final类修饰的，这就是为public final class String implements java.io.Serializable, Comparable // 字符串内部使用 private final char[] value 存储字符序列
private final char[] value;
// 字符串长度
private final int length;
// 构造方法：通过字符数组构造字符串对象
public String(char[] value) {
this.value = Arrays.copyOf(value, value.length);
this.length = value.length;
}
// 构造方法：通过字符数组的一部分构造字符串对象
public String(char[] value, int offset, int count) {
if (offset < 0 || count < 0 || offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
this.value = Arrays.copyOfRange(value, offset, offset + count);
this.length = count;
}
// 构造方法：通过字符串对象构造新的字符串对象
public String(String original) {
this.value = original.value;
this.length = original.length;
}
// 获取字符串的长度
public int length() {
return length;
}
// 根据索引获取字符串中的字符
public char charAt(int index) {
if (index < 0 || index >= length) {
throw new IndexOutOfBoundsException(index);
}
return value[index];
}
// 比较字符串是否相等
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String) anObject;
int n = length;
if (n == anotherString.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;
}
// 返回字符串的哈希码
public int hashCode() {
int h = 0;
for (char c : value) {
h = 31 * h + c;
}
return h;
}
// 返回字符串的子串
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
if (beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
}
return ((beginIndex == 0) && (endIndex == length)) ? this
: new String(value, beginIndex, endIndex - beginIndex);
}
// 字符串拼接
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
char buf[] = new char[length + otherLen];
System.arraycopy(value, 0, buf, 0, length);
System.arraycopy(str.value, 0, buf, length, otherLen);
return new String(buf);
}
// 获取字符串的字节数组表示形式
public byte[] getBytes() {
return StringCoding.encode(value, 0, length);
}
// 将字符串转换为大写
public String toUpperCase(Locale locale) {
// 省略具体实现
}
// 将字符串转换为小写
public String toLowerCase(Locale locale) {
// 省略具体实现
}
// 比较字符串的大小
public int compareTo(String anotherString) {
int len1 = length;
int len2 = anotherString.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;
}
public inte intchar charAt(int String substring(int beginIndex, int endIndex);
// ...
}
public class StringProxy implements StringOperations {
private String string;
public StringProxy(String string) {
this.string = string;
}
// 实现String类的方法
public int length() {
// 添加额外的功能
System.out.println("调用length()方法");
// 调用被代理对象的方法
return string.length();
}
public char charAt(int index) {
// 添加额外的功能
System.out.println("调用charAt()方法");
// 调用被代理对象的方法
return string.charAt(index);
}
public String substring(int beginIndex, int endIndex) {
// 添加额外的功能
System.out.println("调用substring()方法");
// 调用被代理对象的方法
return string.substring(beginIndex, endIndex);
}
// ...
}
public class Main {
public static void main(String[] args) {
// 创建被代理对象
String original = "Hello, World!";
// 创建代理对象
StringOperations proxy = new StringProxy(original);
// 调用代理对象的方法...
}
}