1.字符串存储位置：字符串的存储位置在堆中；

2.创建字符串方式：

（1）使用引号来创建字符串
单独（注意是单独）使用引号来创建字符串的方式，字符串都是常量，在编译期已经确定存储在常量池中了。
用引号创建一个字符串的时候，首先会去常量池中寻找有没有相等的这个常量对象，没有的话就在常量池中创建这个常量对象；有的话就直接返回这个常量对象的引用。
所以看这个例子：

String str1 ="hello";
String str2 ="hello";
System.out.println(str1 == str2);//true
== 对比的是对象；
（2）new的方式创建字符串

String a = new String("abc")；
String str3 =new String("abc");
new这个关键字，毫无疑问会在堆中分配内存，创建一个String类的对象。因此，a这个在栈中的引用指向的是堆中的这个String对象的。
然后，因为"abc"是个常量，所以会去常量池中找，有没有这个常量存在，没的话分配一个空间，放这个"abc"常量，并将这个常量对象的空间地址给到堆中String对象里面；如果常量池中已经有了这个常量，就直接用那个常量池中的常量对象的引用呗，就只需要创建一个堆中的String对象。

String str1 = "abc";
String str2 = new String("abc")；

if (str1==str2){
Log.i("lrf","str1==str2 is true");
}else {
Log.i("lrf","str1==str2 is false");
}
if (str1.equals(str2)){
Log.i("lrf","str1.equals(str2) is true");
}else {
Log.i("lrf","str1.equals(str2) is false");
}

日志打印是：

2023-06-14 09:54:44.907 20259-20259/com.example.myapplication I/lrf: str1==str2 is false

2023-06-14 09:54:44.907 20259-20259/com.example.myapplication I/lrf: str1.equals(str2) is true
说明：str1与 str2 引用同两个 String 对象 -- "abc"!
String str2 = new String("abc")；
String str3 = new String("abc");
if (str3==str2){

Log.i("lrf","str3==str2 is true");

}else {

Log.i("lrf","str3==str2 is false");

}

if (str3.equals(str2)){

Log.i("lrf","str3.equals(str2) is true");

}else {

Log.i("lrf","str3.equals(str2) is false");

}

日志打印是：

2023-06-14 10:09:35.420 20653-20653/com.example.myapplication I/lrf: str3==str2 is false

2023-06-14 10:09:35.420 20653-20653/com.example.myapplication I/lrf: str3.equals(str2) is true
String str3 = new String("abc");
String str4 = new String();
str4 = "abc";
if (str3 == str4) {
Log.i("lrf", "str3==str4 is true");
} else {
Log.i("lrf", "str3==str4 is false");
}
if (str3.equals(str4)) {
Log.i("lrf", "str3.equals(str4) is true");
} else {
Log.i("lrf", "str3.equals(str4) is false");
}
2023-06-19 08:21:37.419 26795-26795 str3==str4 is false
2023-06-19 08:21:37.419 26795-26795 str3.equals(str4) is true
String str4 = new String();
String str5 = new String();
str4 = "abc";
str5 = "abc";
if (str5 == str4) {
Log.i("lrf", "str5==str4 is true");
} else {
Log.i("lrf", "str5==str4 is false");
}
if (str5.equals(str4)) {
Log.i("lrf", "str5.equals(str4) is true");
} else {
Log.i("lrf", "str5.equals(str4) is false");
}
2023-06-19 08:21:37.419 26795-26795 str5==str4 is true
2023-06-19 08:21:37.419 26795-26795 str5.equals(str4) is true
String str5 = new String();
String str6 = new String("abcc");
if (str5 == str6) {
Log.i("lrf", "str5==str6 is true");
} else {
Log.i("lrf", "str5==str6 is false");
}
if (str5.equals(str6)) {
Log.i("lrf", "str5.equals(str6) is true");
} else {
Log.i("lrf", "str5.equals(str6) is false");
}
2023-06-19 08:21:37.419 26795-26795 str5==str6 is true
2023-06-19 08:21:37.419 26795-26795 str5.equals(str6) is true

2.改变String发生了什么？：每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象。

String a = "a"和String a = new String("a")有什么不同？

第一个显然只有一个对象，第二个却有两个对象"a"和new String("a")。

String ab = "cd";String ac = "cd";

这里还是一个对象！

为什么？因为jvm中存在一个String池，存放着String对象，用于共享使用，提高效率。当执行ab的语句时，会调用equal去跟String池中比较看存不存在“cd”这个值得对象，如果存在，则返回这个对象给ab，如果不存在，则把这个值得对象加入String池。当执行完ab，再执行ac时，由于String池已经存在值为"cd"的ab对象，因此会把该对象的引用赋给ac。这么看，String池的存在很合理。但是String池只能添加使用引号包含文本的方式产生的对象，而不能添加使用new操作产生的对象。

利用String的split()对字符串进行切割

String text = "Hello, my name is liujianfeng";

System.out.println(Arrays.toString(text.split("\s")));//以空格为切割符

System.out.println(Arrays.toString(text.split("\W+")));//以非单词为切割符

System.out.println(Arrays.toString(text.split("m")));//以字母m为切割符

String number = "Hello, 985 or 211, I will say ssooss";

System.out.println(Arrays.toString(number.split("\d")));//以数字为切割符

System.out.println(Arrays.toString(number.split("\D")));//以非数字为切割符

System.out.println(Arrays.toString(number.split("[Ho]")));//以非数字为切割符

System.out.println(Arrays.toString(number.split("1{2}")));//以两个1为切割符

结果如下：

[Hello,, my, name, is, liujianfeng]

[Hello, my, name, is, liujianfeng]

[Hello, , y na, e is liujianfeng]

[Hello, , , , or , , , , I will say ssooss]

[, , , , , , , 985, , , , 211]

[, ell, , 985 , r 211, I will say ss, , ss]

[Hello, 985 or 2, , I will say ssooss]

原文链接：https://blog.csdn.net/suyimin2010/article/details/79890568

String str1 = "00";

String str2 = "11";

equals 对比的是值是内容，不管对象，只管值，内容是否相同；

== 对比的是对象，对比的是指向的位置，指针和值；

因为String是引用类型的，不是基本数据类型，所以它们的比较是使用地址和值(相当于C中的指针)来比较的，因为它们是不同的对象，有不同的地址，

1. 若 == 两侧都是基本数据类型，则判断的是左右两边操作数据的值是否相等

2. 若 ==两侧都是引用数据类型，则判断的是左右两边操作数的内存地址是否相同。若此时返回 true , 则该操作符作用的一定是同一个对象。

3. Object 基类的 equals 默认比较两个对象的内存地址，在构建的对象没有重写 equals 方法的时候，与 == 操作符比较的结果相同。

4. equals 用于比较引用数据类型是否相等。在满足equals 判断规则的前提下，两个对象只要规定的属性相同我们就认为两个对象是相同的,比如 String 就重写了 equals 方法，所以可以用 equals 去实现比较字符串是否相等

equal函数比较的到底是什么，很明显是比较的值，但是是什么值？与==比较的堆中的内存地址不同，其比较的是对象的值，包括各个属性的值。我们在重新overriding此方法时首先要判断是否为同一对象，如果是同一对象那么肯定返回为true，如果不是但比较的属性相同，那么对象“相等”，否则返回false。

java中的数据类型，可分为两类：

1.基本数据类型，也称原始数据类型。byte,short,int,long,float,double,boolean,char,

他们之间的比较，应用双等号（==）,比较的是他们的值。

2.复合数据类型(类)

当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。

对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

1 public class TestString {

2 public static void main(String[] args) {

3 String s1= "Monday";

4 String s2 = "Monday";

5 if (s1== s2)

6 {

7 System.out.println("s1== s2");}

8 else{

9 System.out.println("s1!= s2");}

10 }

11 }

编译并运行程序，输出：s1== s2 说明：s1与 s2 引用同一个 String 对象 -- "Monday"!

2.再稍微改动一下程序，会有更奇怪的发现：

public class TestString {

public static void main(String[] args) {

String s1= "Monday";

String s2 = new String("Monday");

if (s1== s2)

{System.out.println("s1== s2");}

else

{System.out.println("s1!= s2");}

if (s1.equals(s2)) {System.out.println("s1equals s2");}

else{

System.out.println("s1not equals s2");}

}

}

我们将s2用new操作符创建

程序输出：s1!= s2s1equals s2

说明：s1s2分别引用了两个"Monday"String对象

3. 字符串缓冲池

原来，程序在运行的时候会创建一个字符串缓冲池当使用 s2 = "Monday" 这样的表达是创建字符串的时候，程序首先会在这个String缓冲池中寻找相同值的对象，在第一个程序中，s1先被放到了池中，所以在s2被创建的时候，程序找到了具有相同值的 s1

将s2引用s1所引用的对象"Monday"

第二段程序中，使用了 new 操作符，他明白的告诉程序："我要一个新的！不要旧的！"于是一个新的"Monday"Sting对象被创建在内存中。他们的值相同，但是位置不同，一个在池中游泳一个在岸边休息。哎呀，真是资源浪费，明明是一样的非要分开做什么呢？

4.再次更改程序：

public class TestString {

public static void main(String[] args) {

String s1 = "Monday";

String s2 = new String("Monday");

s2 = s2.intern();

if (s1 == s2)

{System.out.println("s1 == s2");}

else

{System.out.println("s1 != s2");}

if (s1.equals(s2)) {System.out.println("s1 equals s2");}

else{

System.out.println("s1 not equals s2");}

}

}

这次加入：s2 = s2.intern();

程序输出：

s1 == s2

s1 equals s2

原 来，（java.lang.String的intern()方法"abc".intern()方法的返回值还是字符串"abc"，表面上看起来好像这个方 法没什么用处。但实际上，它做了个小动作：检查字符串池里是否存在"abc"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会 把"abc"添加到字符串池中，然后再返回它的引用。 ）

String.intern();

再补充介绍一点：存在于.class文件中的常量池，在运行期间被jvm装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，java查找常量池中是否有相同unicode的字符串常量，如果有，则返回其引用，如果没有，则在常量池中增加一个unicode等于str的字符串并返回它的引用。

例3：

String s0 = ”kvill”;

String s1 = new String(“kvill”);

String s2 = new String(“kvill”);

System.out.println(s0==s1);

S1.intern();

S2=s2.intern();

System.out.println(s0==s1);

System.out.prntln(s0==s1.intern());

System.out.println(s0==s2);

结果为：

False

False//虽然执行了s1.intern()，但它的返回值没有赋给s1

True

True

最后再破除一个错误的理解：

有人说，“使用String.intern()方法可以将一个String类保存到一个全局的String表中，如果具有相同值的unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果把这个全局的String表理解为常量池的话，最后一句话“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的。

例4：

String s1 = new String(“kvill”);

String s2 = s1.intern();

System.out.println(s1==s1.intern());

System.out.println(s1+””+s2);

System.out.println(s2==s1.intern());

结果是：

False

Kvillkvill

True

我们没有声明一个”kvill”常量，所以常量池中一开始没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“把自己的地址注册到常量池中”了。

例5：

String str1 =” java”;

String str2 = ”blog”;

String s =str1+str2;

System.out.println(s==”javablog”);

结果是false。Jvm确实对型如String str1=”java”;的String对象放在常量池里，但是它是在编译时那么做的，而Strings=str1+str2;是在运行时刻才能知道，也就是说str1+str2是在堆里创建的，所以结果为false了。

String，StringBuffer和StringBuilder的区分和使用场景？

一般来说，三者的速度是：StringBuilder > StringBuffer > String。

但是，在String a = "how" + "old" + "are" + "you"。这种直接拼接的情况下，String速度最高。这是因为jvm的优化问题，jvm会自动识别，把"how" + "old" + "are" + "you"直接当做'how old are you"。

StringBuilder是jdk1.5引入的，1.5之前只能使用StringBuffer。

StringBuffer是线程安全的，StringBuilder是非线程安全的。

String的使用场景：在字符串不常变化的情况下，例如进行字符串的复制和简单得拼接

StringBuffer的使用场景：在字符串经常进行运算的，且在多线程的情况下，例如xml解析和StringBuffer参数的拼接

StringBuilder的使用场景：在字符串经常进行运算的，且在单线程的情况下，例如SQL语句的拼装。