一、String类

- 初始化

```

public final class String

implements java.io.Serializable, Comparable<String>, CharSequence {

//数组定义为常量，不可修改

private final char value[];

public String() {

this.value = "".value;

}

```

- 实例化字符串

```

// //实例化字符串（传入字符串）

public String(String original) {

this.value = original.value;

this.hash = original.hash;

}

//字符数组的实例化构造方法（传入字符数组）

public String(char value[]) {

this.value = Arrays.copyOf(value, value.length);

}

```

判断两个字符串是否相等（在string中重写了equals的方法，object的equals方法相当于“==”）

```

//判断两个字符串是否相等

public boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

//判断是不是String类型

if (anObject instanceof String) {

String anotherString = (String)anObject;

int n = value.length;

if (n == anotherString.value.length) {

char v1[] = value;

char v2[] = anotherString.value;

int i = 0;

//循环判断字符是否相等

while (n-- != 0) {

if (v1[i] != v2[i])

return false;

i++;

}

return true;

}

}

return false;

}

//重写equals时需要重写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;

}

```

注意：在重写equals()时也必须要重写hashCode()方法，以保证相同对象的hash值也是一样的，否则会出现意想不到的问题的。因为如果我们对一个对象重写了equals，意思是只要对象的成员变量值都相等那么equals就等于true，但不重写hashcode，那么我们再new一个新的对象， 当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致，导致混淆

二、字符串的三种拼接方法

① 加号

② concat方法

③ append方法

代码案例

```

public class StringConnect {

public static void main(String[] args) {

String str = "a";

long time = System.currentTimeMillis();

for (int i = 0; i < 10000; i++) {

str += "c";

}

System.out.println("加号所花费的时间：");

System.out.println(System.currentTimeMillis()-time);

String str2 = "a";

time = System.currentTimeMillis();

for (int i = 0; i < 10000; i++) {

str2.concat("c");

}

System.out.println("cancat方法所花费的时间：");

System.out.println(System.currentTimeMillis()-time);

time = System.currentTimeMillis();

StringBuilder stringBuilder = new StringBuilder("a");

for (int i = 0; i < 10000; i++) {

stringBuilder.append("c");

}

String str3 = stringBuilder.toString();

System.out.println("StringBuilder的append方法：");

System.out.println(System.currentTimeMillis()-time);

}

}

```

输出结果：


主要的部分字节码如下:

```

0 ldc <String "a"> [16]

2 astore_1 [str]

3 invokestatic java.lang.System.currentTimeMillis() : long [18]

6 lstore_2 [time]

7 iconst_0

8 istore 4 [i]

10 goto 36

13 new java.lang.StringBuilder [24]

16 dup

17 aload_1 [str]

18 invokestatic java.lang.String.valueOf(java.lang.Object) : java.lang.String [26]

21 invokespecial java.lang.StringBuilder(java.lang.String) [32]

24 ldc <String "c"> [35]

26 invokevirtual java.lang.StringBuilder.append(java.lang.String) : java.lang.StringBuilder [37]

29 invokevirtual java.lang.StringBuilder.toString() : java.lang.String [41]

```

结论：append方法最快、concat次之、加号最慢

1.当使用+进行多个字符串连接时，实际上是产生了一个StringBuilder对象和一个String对象。

2.每次concat操作都会创建一个新的String对象，限制速度

3.整个方法内并没有生成对象。只是最后toString返回一个对象