【Java】String类
目录
1.前言
2.常用方法
2.1字符串的构造
2.2String在内存中的存储
3.String对象的比较
4.字符串查找
5.转化
5.1数值与字符串转化
5.2大小写转换
5.3字符串转数组
6.替换
7.拆分
8.截取
编辑
9.字符串转大小写和去掉左右空格
10.字符串的不可变性
11.字符串的修改
12. StringBuilder和StringBuffer
1.前言
在C语言中，我们已经涉及到了字符串的知识。但是C语言中并没有一个真正来描述字符串的关键字，我们一般用char*p来间接的描述字符串，使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。而且在面试中也频繁被问到，比如：String、StringBuff和StringBulider之间的区别等。而且在以后的开发环境中，也会频繁的使用到字符串，可见字符串的重要性。所以今天这篇博客，我将给大家详细介绍一下String类。带大家走进字符串的世界。
2.常用方法
2.1字符串的构造
String类提供的构造方法有很多种，常用的有以下三种。
public static void main(String[] args) {
// 使用常量串构造
String s1 = "hello ";
System.out.println(s1);
// 直接newString对象
String s2 = new String("hello");
System.out.println(s2);
// 使用字符数组进行构造
char[] array = {'h','e','l','l','o'};
String s3 = new String(array);
System.out.println(s3);2.2String在内存中的存储
1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下
3.String对象的比较
我们都知道在基本数据类型中，如果我们想要比较两个数据，直接使用==就可以了，但是对于String来说，直接用==比较的是引用的地址。所以自然不能这样比较。
我们可以使用equals方法(Object anObject)来进行比较String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照如下规则进行比较，比如： s1.equals(s2）
public class Test2 {
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类型。具体比较方式：
1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前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方式相同，但是忽略大小写比较
4.字符串查找
我们在查找字符串的时候，String会提供一些常用的查找方法如
char charAt（int index）返回index位置上的字符。具体用法如下
public static void main(String[] args) {
String s1="abcdef";
System.out.println(s1.charAt(2));
}结果如下：
int indexOf(),返回第一次出现的位置可以查找字符串，数字，也可以指定位置查找,具体使用如下：
public static void main(String[] args) {
String s1="abcd114eaf";
System.out.println(s1.indexOf("a",3));
}
int lastIndex(),可以从后往前找，与Index()的用法一样。
5.转化
5.1数值与字符串转化
//数字转字符串
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
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);5.2大小写转换
//小写字母转大写字母
String s1 = "abc";
System.out.println(s1.toUpperCase());
//大写字母转小写字母
String s2="ABC";
System.out.println(s2.toLowerCase());
}5.3字符串转数组
String s1 = "abc";
char[] array=s1.toCharArray();//数组用char类型来保存
for (char X:array){
System.out.println(X);打印结果：
6.替换
使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：
String replaceAll(String regex, String replacement)，替换所有内容，
String replaceFirst(String regex, String replacement)，替换首个内容，
public static void main(String[] args) {
String str = "helloworld" ;
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));
}
7.拆分
String[] split(String regex)使用该方法拆分全部的字符串，也可以使用String[] split(String regex, int limit)拆分为limit组。
public static void main(String[] args) {
String str = "hello world hello Java";
String[] result = str.split(" "); // 按照空格拆分
for (String s : result) {
System.out.println(s);
}
}
也可以使用“|”，如果一个字符串需要多个分隔符，可以使用它来进行连接。
String str = "name=zhangsan&age=18" ;
String[] s1=str.split("&");
for (int i = 0; i < s1.length; i++) {
String[] s2=s1[i].split("=");
System.out.println(s2[0]+"="+s2[1]);
}
}
8.截取
从一个完整的字符串之中截取部分内容，可以用以下方法：String substring(int beginIndex）从指定位置截取到结尾；如果需要截取部分内容，只需在括号里再加入截取到的末位置即可。
public static void main(String[] args) {
String str = "helloworld";
System.out.println(str.substring(0, 5));
}
9.字符串转大小写和去掉左右空格
| 方法 | 功能 |
| String trim() | 去掉字符串中的左右空格,保留中间空格 |
| String toUpperCase() | 字符串转大写 |
| String toLowerCase() | 字符串转小写 |
public static void main(String[] args) {
String str = " hello world ";
System.out.println(str.trim());//去掉左右空格
}
10.字符串的不可变性
String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：
1. String类在设计时就是不可改变的，String类实现描述中已经说明了
String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出
1. String类被final修饰，表明该类不能被继承
2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改
2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
比如 replace 方法：
注意： 有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。
这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。
final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。
public static void main(String[] args) {
final int array[] = {1,2,3,4,5};
array[0] = 100;
System.out.println(Arrays.toString(array));
// array = new int[]{4,5,6}; // 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
} 为什么 String 要设计成不可变的?(不可变对象的好处是什么?)
1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.
2. 不可变对象是线程安全的.
3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.
那如果想要修改字符串中内容，该如何操作呢？
11.字符串的修改
注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。
public static void main(String[] args) {
String s = "hello";
s += " world";
s += " hah ";
System.out.println(s); // 输出：hello world
}这种直接+=字符串，会创建很多新的对象，所以会占用大量内存空间，所以我们并不推荐使用。
因此：尽量避免对String的直接需要，如果要修改建议尽量使用StringBuffer或者StringBuilder。
12. StringBuilder和StringBuffer
由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法
| 方法 | 说明 |
| StringBuff append(String str) |
在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、 double、float、int、long、Object、String、StringBuff的变量 |
| char charAt(int index) | 获取index位置的字符 |
| int length() | 获取字符串的长度 |
| int capacity() | 获取底层保存字符串空间总的大小 |
| void ensureCapacity(int mininmumCapacity) |
扩容 |
| void setCharAt(int index, char ch) |
将index位置的字符设置为ch |
| int indexOf(String str) | 返回str第一次出现的位置 |
| int indexOf(String str, int fromIndex) |
从fromIndex位置开始查找str第一次出现的位置 |
| int lastIndexOf(String str) | 返回最后一次出现str的位置 |
| int lastIndexOf(String str, int fromIndex) |
从fromIndex位置开始找str最后一次出现的位置 |
| StringBuff insert(int offset, String str) |
在offset位置插入：八种基类类型 & String类型 & Object类型数据 |
| StringBuffer deleteCharAt(int index) |
删除index位置字符 |
| StringBuffer delete(int start, int end) |
删除[start, end)区间内的字符 |
| StringBuffer replace(int start, int end, String str) |
将[start, end)位置的字符替换为str |
| String substring(int start) | 从start开始一直到末尾的字符以String的方式返回 |
| String substring(int start，int end) |
将[start, end)范围内的字符以String的方式返回 |
| StringBuffer reverse() | 反转字符串 |
| String toString() | 将所有字符按照String的方式返回 |
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder("hello");
StringBuilder sb2 = sb1;
// 追加：即尾插-->字符、字符串、整形数字
sb1.append(' '); // hello
sb1.append("world"); // hello world
sb1.append(123); // hello world123
System.out.println(sb1); // hello world123
System.out.println(sb1 == sb2); // true
System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
System.out.println(sb1.length()); // 获取字符串的有效长度14
System.out.println(sb1.capacity()); // 获取底层数组的总大小
sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
System.out.println(sb1);
System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
sb1.deleteCharAt(0); // 删除首字符
sb1.delete(0,5); // 删除[0, 5)范围内的字符
String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
System.out.println(str);
sb1.reverse(); // 字符串逆转
str = sb1.toString(); // 将StringBuffer以String的方式返回
System.out.println(str);
}
从上述例子可以看出：String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。
注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法