Java之认识String类（万字带你了解Java的String类）
⭐️前言⭐️
博客主页： 【如风暖阳】
精品Java专栏【Javase】、【Java数据结构】
欢迎点赞 收藏 ⭐留言评论 私信必回哟本文由 【如风暖阳】 原创，首发于 CSDN
博主将持续更新学习记录收获，友友们有任何问题可以在评论区留言
博客中涉及源码及博主日常练习代码均已上传码云(gitee)
本篇文章是为了认识Java中的String类及其一些用法，篇幅可能较长，全篇文章会分布完成。
学习目标：
- 认识 String 类
- 了解 String 类的基本用法
- 熟练掌握 String 类的常见操作
- 认识字符串常量池
- 认识 StringBuffer 和 StringBuilder
Java之认识String类
内容导读
- Java之认识String类
-
- 1.认识并创建字符串
- 2. 字符串对象的比较
- 3.字符串常量池
-
- 3.1 创建对象的思考
- 3.2 字符串常量池(StringTable)
- 4.字符串不可变
- 5.转化
- 6.字符串常见操作
-
- 6.1 字符串比较
- 6.2 字符串查找
- 6.3 字符串替换
- 6.4 字符串拆分
- 6.5 字符串截取
- 6.6 其他操作方法
- 7. StringBuffer 和 StringBuilder
-
- 7.1初识
- 7.2 区别与转换
- 7.3使用与总结
- 8.小结
1.认识并创建字符串
在c语言里并没有字符串这种数据类型，而在Java中是有这种类型的。那什么叫做字符串呢？
就是用双引号引起来的若干个字符常量（也可以为一个），而字符是由单引号引起的单个字符常量。注意：在Java中没有所谓的/0作为字符串结束的标致。
常见的构造 String 的方式：
// 方式一
String str = "Hello Bit";
// 方式二 方式一二构造String的方式本质相同
String str2 = new String("Hello Bit");
// 方式三 方式三就是把数组变为了字符串
char[] array = {'a', 'b', 'c'};
String str3 = new String(array);
常见的坑：
public static void fun(String str,char[] ch) {
str="hello";
ch[0]='A';
}
public static void main(String[] args) {
String str=new String("abcd");
char[] ch={'c','s','d','n'};
fun(str,ch);
System.out.println(str);
System.out.println(Arrays.toString(ch));
}
//：运行结果
abcd
[A, s, d, n]
我们可以发现，在fun函数内改变str引用时，并没有对main函数中的str造成影响，每一个常量都会开辟一块空间，fun中的str只是将引用指向了新的常量，所以并不会对main中的str做出改变，而数组则通过[]符合角标访问，对数组内数据发生了实际改变。
【注意】
- String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：
public static void main(String[] args) {
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;
System.out.println(s1.length()); // 获取字符串长度---输出5
System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
}
- 在Java中“”引起来的也是String类型对象。
// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());
2. 字符串对象的比较
字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：
- ==比较是否引用同一个对象
注意：对于内置类型，== 比较的是变量中的值；对于引用类型 == 比较的是引用中的地址。
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
System.out.println(a == b); // false
System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("world");
String s4 = s1;
System.out.println(s1 == s2); // false
System.out.println(s2 == s3); // false
System.out.println(s1 == s4); // true
}
boolean equals(Object anObject)方法：按照字典序比较
字典序：字符大小的顺序
String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照
如下规则进行比较，比如：s1.equals(s2)
public boolean equals(Object anObject) {
// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
if (this == anObject) {
return true;
}
// 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
if (anObject instanceof String) {
// 将anObject向下转型为String类型对象
String anotherString = (String)anObject;
int n = value.length;
// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
// 4. 按照字典序，从前往后逐个字符进行比较
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
String s3 = new String("Hello");
// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
System.out.println(s1 == s2); // false
System.out.println(s1 == s3); // false
// equals比较：String对象中的逐个字符
// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
}
int compareTo(String s)方法: 按照字典序进行比较
与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("abc");
String s4 = new String("abcdef");
System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}
int compareToIgnoreCase(String str)方法：与compareTo方式相同，但是忽略大小写比较
public static void main(String[] args) {
String s1 = new String("abc");
String s2 = new String("ac");
String s3 = new String("ABc");
String s4 = new String("abcdef");
System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}
3.字符串常量池
3.1 创建对象的思考
下面两种创建String对象的方式相同吗？
public static void main(String[] args) {
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s3 == s4); // false
}
上述程序创建方式类似，为什么s1和s2引用的是同一个对象，而s3和s4不是呢？
在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。
“池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池” …
比如：家里给大家打生活费的方式
- 家里经济拮据，每月定时打生活费，有时可能会晚，最差情况下可能需要向家里张口要，速度慢
- 家里有矿，一次性打一年的生活费放到银行卡中，自己随用随取，速度非常快 方式2，就是池化技术的一种示例，钱放在卡上，随用随取，效率非常高。常见的池化技术比如：数据库连接 池、线程池等。
为了节省存储空间以及程序的运行效率，Java中引入了：
- Class文件常量池：每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息
- 运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份
- 字符串常量池
3.2 字符串常量池(StringTable)
再谈String对象创建:
- 直接使用字符串常量进行赋值
public static void main(String[] args) {
String s1 = "hello";
String s2 = "hello";
System.out.println(s1 == s2); // true
}
- 通过new创建String类对象
结论：只要是new的对象，都是唯一的。
通过上面例子可以看出：使用常量串创建String类型对象的效率更高，而且更节省空间。用户也可以将创建的字符串对象通过 intern 方式添加进字符串常量池中。
- intern方法
该方法的作用是手动将创建的String对象添加到常量池中。
public static void main(String[] args) {
char[] ch = new char[]{'a', 'b', 'c'};
String s1 = new String(ch); // s1对象并不在常量池中
//s1.intern(); // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
System.out.println(s1 == s2);
}
// 输出false
// 将上述方法打开之后，就会输出true
面试题：请解释String类中两种对象实例化的区别 JDK1.8中
- String str = “hello”
只会开辟一块堆内存空间，保存在字符串常量池中，然后str共享常量池中的String对象- String str = new String(“hello”)
会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的String对象给新开辟的String对象赋值。- String str = new String(new char[]{‘h’, ‘e’, ‘l’, ‘l’, ‘o’})
现在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到String对象中
4.字符串不可变
String类在设计时就是不可改变的，String类实现描述中已经说明了
感受下形如这样的代码:
String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：
value是由private修饰的，在类外拿不到这个变量，所以字符串不能修改
代码示例：
String str = "hello" ;
str = str + " world" ;
str += "!!!" ;
System.out.println(str);
// 执行结果
hello world!!!
形如 += 这样的操作, 表面上好像是修改了字符串, 其实不是，而是在拼接成新的字符串后，str引用指向了新的字符串。
如果真的想要改变字符串常量，只能通过反射的方式来进行，反射我们在后边将会学习。
5.转化
- 数值和字符串转化
public static void main(String[] args) {
// 数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
System.out.println(s1);
System.out.println(s2);
System.out.println("=================================");
// 字符串转数字
// 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
int data1 = Integer.parseInt("1234");
double data2 = Double.parseDouble("12.34");
System.out.println(data1);
System.out.println(data2);
}
- 大小写转换
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
// 小写转大写
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());
}
- 字符串转数组
public static void main(String[] args) {
String s = "hello";
// 字符串转数组
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i++) {
System.out.print(ch[i]);
}
System.out.println();
// 数组转字符串
String s2 = new String(ch);
System.out.println(s2);
}
- 格式化
public static void main(String[] args) {
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);
}
6.字符串常见操作
6.1 字符串比较
上面使用过String类提供的equals()方法，该方法本身是可以进行区分大小写的相等判断。除了这个方法之外，String类还提供有如下的比较操作：
代码示例: 不区分大小写比较
String str1 = "hello" ;
String str2 = "Hello" ;
System.out.println(str1.equals(str2)); // false
System.out.println(str1.equalsIgnoreCase(str2)); // true
在String类中compareTo()方法是一个非常重要的方法，该方法返回一个整型，该数据会根据大小关系返回三类内容：
- 相等：返回0.
- 小于：返回内容小于0.
- 大于：返回内容大于0。
范例：观察compareTo()比较
System.out.println("A".compareTo("a")); // -32
System.out.println("a".compareTo("A")); // 32
System.out.println("A".compareTo("A")); // 0
System.out.println("AB".compareTo("AC")); // -1
System.out.println("刘".compareTo("杨"));
compareTo()是一个可以区分大小关系的方法，是String方法里是一个非常重要的方法。
字符串的比较大小规则, 总结成三个字 “字典序” 相当于判定两个字符串在一本词典的前面还是后面. 先比较第一个字符的大小(根据
unicode 的值来判定), 如果不分胜负, 就依次比较后面的内容。
6.2 字符串查找
从一个完整的字符串之中可以判断指定内容是否存在，对于查找方法有如下定义：
代码示例: 字符串查找，最好用最方便的就是contains()
String str = "helloworld" ;
System.out.println(str.contains("world")); // true
我们可以发现contains方法内的参数类型为CharSequence，是因为String方法已经连接了CharSequence接口，此处是发生了向上转型。
代码示例: 使用indexOf()方法进行位置查找
String str = "helloworld" ;
System.out.println(str.indexOf("world")); // 5,w开始的索引
System.out.println(str.indexOf("bit")); // -1，没有查到
if (str.indexOf("hello") != -1) {
System.out.println("可以查到指定字符串！");
}
现在基本都是用contains()方法完成。
使用indexOf()需要注意的是，如果内容重复，它只能返回查找的第一个位置。
代码示例: 使用indexOf()的注意点
String str = "helloworld" ;
System.out.println(str.indexOf("l")); // 2
System.out.println(str.indexOf("l",5)); // 8
System.out.println(str.lastIndexOf("l")); // 8
在进行查找的时候往往会判断开头或结尾。
代码示例: 判断开头或结尾
String str = "**@@helloworld!!" ;
System.out.println(str.startsWith("**")); // true
System.out.println(str.startsWith("@@",2)); // ture
System.out.println(str.endsWith("!!")); // true
6.3 字符串替换
使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：
代码示例: 字符串的替换处理
String str = "helloworld" ;
System.out.println(str.replaceFirst("l", "_"));
System.out.println(str.replaceAll("l", "_"));
//运行结果
he_loworld
he__owor_d
注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串。
6.4 字符串拆分
可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。
可用方法如下：
代码示例: 实现字符串的拆分处理
String str = "hello world hello csdn" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
System.out.println(s);
}
//
hello
world
hello
csdn
代码示例: 字符串的部分拆分
String str = "hello world hello bit" ;
String[] result = str.split(" ",2) ;
for(String s: result) {
System.out.println(s);
}
//
hello
world hello csdn
拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义.
代码示例: 拆分IP地址
String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}
//
192
168
1
1
注意事项:
- 字符"|“,”*“,”+“都得加上转义字符，前面加上”".
- 而如果是"“，那么就得写成”\".
- 如果一个字符串中有多个分隔符，可以用"|"作为连字符.
代码示例: 多次拆分
String str = "name=zhangsan&age=18" ;
String[] result1 = str.split("&") ;
for(String t1 : result1) {
String[] result2=t1.split("=");
for(String t2 : result2) {
System.out.println(t2);
}
}
//
name
zhangsan
age
18
6.5 字符串截取
从一个完整的字符串之中截取出部分内容。可用方法如下：
代码示例: 观察字符串截取
String str = "helloworld" ;
System.out.println(str.substring(5)); System.out.println(str.substring(0, 5));
//
world
hello
注意事项:
- 索引从0开始
- 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标
6.6 其他操作方法
代码示例: 观察trim()方法的使用
String str = " hello world " ;
System.out.println("["+str+"]");
System.out.println("["+str.trim()+"]");
//
[ hello world ]
[hello world]
trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).
代码示例: 大小写转换
String str = " heLLo%$$%@#$%world 哈哈哈 " ;
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());
//
HELLO%$$%@#$%WORLD 哈哈哈
hello%$$%@#$%world 哈哈哈
这两个函数只转换字母。
代码示例: 字符串length()
String str = " hello%$$%@#$%world 哈哈哈 " ;
System.out.println(str.length());
//
24
**注意：**数组长度使用数组名称.length属性，而String中使用的是length()方法
代码示例: 观察isEmpty()方法
System.out.println("hello".isEmpty());
System.out.println("".isEmpty());
System.out.println(new String().isEmpty());
//
false
true
true
String类并没有提供首字母大写操作，需要自己实现
代码示例: 首字母大写
public static void main(String[] args) {
System.out.println(fistUpper("yuisama"));
System.out.println(fistUpper(""));
System.out.println(fistUpper("a"));
}
public static String fistUpper(String str) {
if ("".equals(str)||str==null) {
return str ;
}
if (str.length()>1) {
return str.substring(0, 1).toUpperCase()+str.substring(1) ;
}
return str.toUpperCase() ;
}
//
Yuisama
A
7. StringBuffer 和 StringBuilder
7.1初识
任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。
通常来讲String的操作比较简单，但是由于String的不可更改特性，为了方便字符串的修改，提供StringBuffer和StringBuilder类（这两个类不能直接拿常量来赋值，需要先实例化对象）。
以下先由StringBuilder来举例：
两种赋初值方式：
public static void main(String[] args) {
StringBuilder s1=new StringBuilder("abc");//一是构造方法赋初值
StringBuilder s2=new StringBuilder();
s2.append("abc");//二是调用append方法
System.out.println(s1);
System.out.println(s2.toString());//调不调toString方法都可以打印
}
//
abc
abc
拼接字符串：
public static void main(String[] args) {
StringBuilder s=new StringBuilder();
s.append("abc");
s.append("123");
//也可以连用s.append("abc").append("123");
System.out.println(s);
}
//
abc123
若该代码的实现要是通过String类来实现只能通过“+”，而且会产生多个对象浪费空间，最后只是把s的指向更改了而已；而通过StringBuilder类可以直接在原字符串上进行更改。
由以下代码可以更好体现：
public static void main(String[] args) {
String str="abcd";
StringBuilder s=new StringBuilder();
s.append(str);
for (int i = 0; i < 10; i++) {
s.append(i);
}
str=s.toString();
System.out.println(str);
}
//abcd0123456789
String和StringBuilder最大的区别在于：String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的
情况考虑使用StringBuilder。
7.2 区别与转换
StringBuffer 和 StringBuilder 的区别：
我们分别点进StringBuffer 和 StringBuilder 的源码
StringBuffer :
StringBuilder：
可以观察到两个类里的重写方法只是一个词（synchronized）之差，synchronized就是为了维护线程安全，所以StringBuffer 和 StringBuilder 大部分功能是相同的（只是使用场合不同：单线程-StringBuilder 多线程-StringBuffer）
StringBuffer 或StringBuilder 与String类之间的转换：
注意：String和StringBuffer类不能直接转换。如果要想互相转换，可以采用如下原则:
- String变为StringBuffer:利用StringBuffer的构造方法或append()方法
public StringBuilder func1() {
String str="abc";
StringBuilder s=new StringBuilder(str);
return s;
}
public StringBuilder func2() {
String str="abc";
StringBuilder s=new StringBuilder();
s.append(str);
return s;
}
- StringBuffer变为String:调用toString()方法
public String fun() {
StringBuilder s=new StringBuilder("abc");
return s.toString();
}
7.3使用与总结
字符串反转：
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, "你好"));
//你好hello
面试题：
1.请解释String、StringBuffer、StringBuilder的区别?
- String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
- StringBuffer与StringBuilder大部分功能是相似的
- StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作
2.以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】
String str = new String("ab"); // 会创建2个对象
String str = new String("a") + new String("b"); // 会创建6个对象
再加上常量池中的a和b两个对象，一共六个。
8.小结
字符串操作是我们以后工作中非常常用的操作. 使用起来都非常简单方便, 一定要使用熟练.
注意的点:
- 字符串的比较, ==, equals, compareTo 之间的区别.
- 了解字符串常量池, 体会 “池” 的思想.
- 理解字符串不可变
- StringBuffer 和 StringBuilder 的功能.
⚡️最后的话⚡️
总结不易，希望uu们不要吝啬你们的哟(＾Ｕ＾)ノ~ＹＯ！！如有问题，欢迎评论区批评指正
