文章目录

一、创建字符串
- 1.1创建字符串时的内存布局
二、字符串比较相等
- 2.1equals方法
三、字符串常量池
- 3.1实例化操作的内存布局
- 3.2intern手动入池
四、理解字符串不可变
- 4.1+=操作的内存变化
- 4.2修改字符串
- 4.3为什么 String 要不可变?
五、字符串相关操作
六、StringBuffer 和 StringBuilder
- 6.1从继承结构理解
- 6.2StringBuffer相关方法
- 6.3String、StringBuffer、StringBuilder的区别
总结

一、创建字符串

常见的构造 String 的方式：

// 方式一
String str = “Hello TC”;
// 方式二
String str2 = new String(“Hello TC”);
// 方式三
char[] array = {‘a’, ‘b’, ‘c’};
String str3 = new String(array);

1.1创建字符串时的内存布局

注意事项:
“hello” 这样的字符串字面值常量, 类型也是 String.
String 也是引用类型. String str = “Hello”; 这样的代码内存布局如下：

String str1 = “Hello”;String str2 = str1;内存布局如下：

那么有同学可能会说, 是不是修改 str1 , str2 也会随之变化呢?

str1 = “world”;
System.out.println(str2);
// 执行结果
Hello

我们发现, “修改” str1 之后, str2 也没发生变化, 还是 hello?事实上, str1 = “world” 这样的代码并不算 “修改” 字符串, 而是让 str1 这个引用指向了一个新的 String 对象，内存布局如下：

二、字符串比较相等

String类对象上使用 == 比较字符串相等吗？

String str1 = “Hello”;
String str2 = “Hello”;
System.out.println(str1 == str2);
// 执行结果
true

结果为true，那我们换一种形式再来比较呢

String str1 = new String(“Hello”);
String str2 = new String(“Hello”);
System.out.println(str1 == str2);
// 执行结果
false

为什么两次的结果不一样呢？我们从内存布局来分析：

代码一：

我们发现, str1 和 str2 是指向同一个对象的. 此时如 “Hello” 这样的字符串常量是在 字符串常量池 中。关于字符串常量池，我们下面会讲解

代码二：

通过 String str1 = new String(“Hello”); 的方式创建的 String 对象相当于再堆上另外开辟了空间来存储"Hello" 的内容, 也就是内存中存在两份 “Hello”

2.1equals方法

注意事项：
String 使用 == 比较并不是在比较字符串内容, 而是比较两个引用是否是指向同一个对象，Java 中要想比较字符串的内容, 必须采用String类提供的equals方法！

代码如下：

String str = new String(“Hello”);
// 方式一
System.out.println(str.equals(“Hello”));
// 方式二
System.out.println(“Hello”.equals(str));

在上面的代码中, 哪种方式更好呢?
我们更推荐使用 “方式二”. 一旦 str 是 null, 方式一的代码会抛出异常, 而方式二不会

三、字符串常量池

本质上是哈希表

如 “Hello” 这样的字符串字面值常量, 也是需要一定的内存空间来存储的. 这样的常量具有一个特点, 就是不需要修改(常量嘛). 所以如果代码中有多个地方引用都需要使用 “Hello” 的话, 就直接引用到常量池的这个位置就行了, 而没必要把 “Hello” 在内存中存储两次.

3.1实例化操作的内存布局

在上面, String类的两种实例化操作, 直接赋值和 new 一个新的 String
a）直接赋值

String str1 = “hello” ;
String str2 = “hello” ;
System.out.println(str1 == str2); // true

我们从更详细的内存布局分析：

为什么现在并没有开辟新的堆内存空间呢？

String类的设计使用了共享设计模式
在JVM底层实际上会自动维护一个对象池（字符串常量池)，如果现在采用了直接赋值的模式进行String类的对象实例化操作，那么该实例化对象（字符串内容）将自动保存到这个对象池之中.如果下次继续使用直接赋值的模式声明String类对象，此时对象池之中如若有指定内容，将直接进行引用如若没有，则开辟新的字符串对象而后将其保存在对象池之中以供下次使用

b) 采用构造方法

String str2 = new String(“hello”) ;

同样，从内存布局分析：

由此可知构造方法又在堆中创建了一个内存，该内存指向了存储在字符串常量池中的"hello"

所以，以下代码会返回false！

String str2 = new String(“hello”) ;
String str1 = “hello” ;
System.out.println(str1 == str2);
// 执行结果
false

3.2intern手动入池

我们可以使用 intern 方法来手动把 String 对象加入到字符串常量池中

String str1 = new String(“hello”).intern() ;
String str2 = “hello” ;
System.out.println(str1 == str2);
// 执行结果
true

四、理解字符串不可变

字符串是一种不可变对象. 它的内容不可改变.

String 类的内部实现也是基于 char[] 来实现的, 但是 String 类并没有提供 set 方法之类的来修改内部的字符数组.

4.1+=操作的内存变化

感受下形如这样的代码:

String str = “hello” ;
str = str + " world" ;
str += “!!!” ;
System.out.println(str);
// 执行结果
hello world!!!

形如 += 这样的操作, 表面上好像是修改了字符串, 其实不是. 内存变化如下:

+= 之后 str 打印的结果却是变了, 但是不是 String 对象本身发生改变, 而是 str 引用到了其他的对象.

注意: 如下代码不应在你的开发中出, 会产生大量的临时对象, 效率比较低

String str = “hello” ;
for(int x = 0; x < 1000; x++) {
str += x ;
}
System.out.println(str);

回顾引用:
引用相当于一个指针, 里面存的内容是一个地址. 我们要区分清楚当前修改到底是修改了地址对应内存的内容发生改变了, 还是引用中存的地址改变了

那么如果实在需要修改字符串, 例如, 现有字符串 str = “Hello” , 想改成 str = “hello” , 该怎么办?

4.2修改字符串

a) 常见办法: 借助原字符串, 创建新的字符串

String str = “Hello”;
str = “h” + str.substring(1);
System.out.println(str);
// 执行结果
hello
String str = “Hello”;

b) 特殊办法(选学): 使用 “反射” 这样的操作可以破坏封装, 访问一个类内部的 private 成员

关于反射:
反射是面向对象编程的一种重要特性, 有些编程语言也称为 “自省”.指的是程序运行过程中, 获取/修改某个对象的详细信息(类型信息, 属性信息等), 相当于让一个对象更好的 “认清自己” .Java 中使用反射比较麻烦一些. 我们后面的课程中会详细介绍反射的具体用法

4.3为什么 String 要不可变?

为什么 String 要不可变?(不可变对象的好处是什么?) (选学)

方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑何时深拷贝字符串的问题了.

不可变对象是线程安全的.

不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中

五、字符串相关操作

具体代码如下（内容较长，供自己复习）：

 public static void main1(String[] args) {//将一个字符串数组转换成了字符串char[] chars = {'a', 'b', 'c'};String str2 = new String(chars);System.out.println(str2);}public static void main5(String[] args) {//数组的整体赋值只有一次机会 就是在定义的时候    字符串的不可变final int[] array = {1, 2, 3, 4, 5};// array = new int[]{4,5,6};}public static void main6(String[] args) {//整个数组变成字符串/*char[] value = {'a','b','c','d'};String str = new String(value);System.out.println(str);*///数组部分变成字符串char[] value = {'a', 'b', 'c', 'd'};String str = new String(value, 1, 3);System.out.println(str);//取出字符串的某个字符String str1 = "hello";char ch = str1.charAt(2);System.out.println(ch);//整个字符串变成数组char[] vc = str1.toCharArray();System.out.println(Arrays.toString(vc));//打印数组}public static void main8(String[] args) {//将字节转换成字符串byte[] bytes = {97, 98, 99, 100};String str = new String(bytes);System.out.println(str);//将字符串变成字节String str1 = "bit";byte[] bytes1 = str1.getBytes();System.out.println(Arrays.toString(bytes1));}//字符串的比较public static void main9(String[] args) {String str1 = "asdfgh";String str2 = "zxcvbn";System.out.println(str1.equals(str2));//比较String str3 = "asdfgh";String str4 = "ASDFGH";System.out.println(str3.equalsIgnoreCase(str4));//比较大小，忽略字母大小写String str5 = "abc";String str6 = "ABC";int ret = str5.compareTo(str6);//通过相减得正负判断大小System.out.println(ret);String str7 = "abacabcd";String str8 = "abc";boolean flg = str7.contains(str8);//是否包含System.out.println(flg);String str9 = "abacabcd";String str10 = "abc";          //fromindex:从哪个位置找int index = str9.indexOf(str10, 2);//在主串当中找到字串出现的位置 类似于C得struct->KMP算法System.out.println(index);      //lastindexof:从后往前找System.out.println(str9.startsWith("a"));//判断是否是以它开头//endsWith 以什么结尾的}//替换replacepublic static void main10(String[] args) {String str = "addadadadfffsw";String ret = str.replace('d', 'b');//将d替换为b  也可以选择其他替换模式System.out.println(ret);}//分割public static void main11(String[] args) {/*String str = "name=zhangsan&age=19";String[] strings = str.split("&");for (String s:strings){System.out.println(s);}*///特殊情况String str = "192.168.1.0";String[] strings = str.split("\\.", 2);//特殊情况，需要加上转义字符   给2分两组for (String s : strings) {System.out.println(s);System.out.println("=======================================");String str1 = "java20 69&125#hello";String[] strings1 = str1.split(" |&|#");//从每一个分隔符for (String s1 : strings1) {System.out.println(s1);}}}//字符串的截取public static void main12(String[] args) {String str = "asdcfv";//String ret = str.substring(2);//从下标为2处提取String ret = str.substring(2, 4);//左闭右开System.out.println(ret);}public static void main13(String[] args) {String str = "     abc     def    ";String ret = str.trim();System.out.println(ret);//去除两边的空格，中间不会}public static void main14(String[] args) {String str = "abcdefBFGH";String ret = str.toUpperCase(Locale.ROOT);//转大写，也有转小写System.out.println(ret);}public static void main15(String[] args) {String str = "adfdsa";String ret = str.concat("bitt");//拼接    拼接的结果不会入池System.out.println(ret);}

六、StringBuffer 和 StringBuilder

首先来回顾下String类的特点：

任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。通常来讲String的操作比较简单，但是由于String的不可更改特性，为了方便字符串的修改，提供StringBuffer和StringBuilder类。StringBuffer 和 StringBuilder 大部分功能是相同的，我们主要介绍 StringBuffer在String中使用"+"来进行字符串连接，但是这个操作在StringBuffer类中需要更改为append()方法：

public synchronized StringBuffer append(各种数据类型 b)

范例：观察StringBuffer使用

public class Test {public static void main(String[] args) {StringBuffer sb = new StringBuffer();sb.append("Hello").append("World");fun(sb);System.out.println(sb);}public static void fun(StringBuffer temp) {temp.append("\n").append("www.baidu.com.cn");}}

String和StringBuffer最大的区别在于：String的内容无法修改，而StringBuffer的内容可以修改。频繁修改字符串，考虑使用StingBuffer。

6.1从继承结构理解

为了更好理解String和StringBuffer，我们来看这两个类的继承结构:

可以发现两个类都是"CharSequence"接口的子类。这个接口描述的是一系列的字符集。所以字符串是字符集的子类，如果看见CharSequence，最简单的联想就是字符串。

注意：String和StringBuffer类不能直接转换。如果要想互相转换，可以采用如下原则:
1、String变为StringBuffer:利用StringBuffer的构造方法或append()方法
2、StringBuffer变为String:调用toString()方法。

6.2StringBuffer相关方法

除了append()方法外，StringBuffer也有一些String类没有的方法，如下

字符串反转：
public synchronized StringBuffer reverse()
代码示例: 字符串反转
StringBuffer sb = new StringBuffer(“helloworld”);
System.out.println(sb.reverse());

删除指定范围的数据:
public synchronized StringBuffer delete(int start, int end)
代码示例: 观察删除操作
StringBuffer sb = new StringBuffer(“helloworld”);
System.out.println(sb.delete(5, 10));

插入数据
public synchronized StringBuffer insert(int offset, 各种数据类型 b)
代码示例: 观察插入操作
StringBuffer sb = new StringBuffer(“helloworld”);
System.out.println(sb.delete(5, 10).insert(0, “你好”));

6.3String、StringBuffer、StringBuilder的区别

面试题：请解释String、StringBuffer、StringBuilder的区别:
1、String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
2、StringBuffer与StringBuilder大部分功能是相似的
3、StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

总结

字符串操作是我们以后工作中非常常用的操作. 使用起来都非常简单方便, 一定要使用熟练.

值得注意的点:

字符串的比较, ==, equals, compareTo 之间的区别.
了解字符串常量池, 体会 “池” 的思想.
理解字符串不可变
split 的应用场景
StringBuffer 和 StringBuilder 的功能

【JAVA中String类的相关知识】相关推荐

利用JAVA中关于继承的相关知识求得圆柱体体积并输出
利用JAVA中关于继承的相关知识求得圆柱体体积并输出 Write a program: 1)Define a Circle class and a Cylinder class, which is d ...
Java中String类的方法及说明
String : 字符串类型一.构造函数 String(byte[ ] bytes):通过byte数组构造字符串对象. String(char[ ] value):通过char数 ...
Java中String类的concat方法___java的String字符串的concat()方法连接字符串和“+“连接字符串解释
Java中String类的concat方法在了解concat()之前,首先需要明确的是String的两点特殊性. 长度不可变值不可变这两点从源码中对String的声明可以体现: private ...
【转载】Java中String类的方法及说明
转载自:http://www.cnblogs.com/YSO1983/archive/2009/12/07/1618564.html String : 字符串类型一.构造函数 String ...
在java中String类为什么要设计成final
在java中String类为什么要设计成final? - 胖胖的回答 - 知乎 https://www.zhihu.com/question/31345592/answer/114126087 转载于 ...
java中string类面试题_java中String类的面试题大全含答案
1.下面程序的运行结果是()(选择一项) String str1="hello"; String str2=new String("hello"); Syste ...
c++ 输出string_来讲讲Java中String 类的知识点
本文来总结一下Stirng 的有关知识点 1.String中的引用 String 可以通过new和构造方法来创建一个对象,用s来引用它(也就是相当于把asdf这个字符串赋值给s String s = ...
JAVA中String类
1.String类定义的变量是不可变得 eg:String s0="kvill"; String s1 = new String("kvill"); 为什么要设 ...
java中String类的常用方法总结
String类: String类在java.lang包中,java使用String类创建一个字符串变量,字符串变量属于对象.String类对象创建后不能修改,StringBuffer & St ...

【JAVA中String类的相关知识】