1、String 类
1.1 String 字符串
-
字符串是常量，代表不可变的字符序列。
-
常量与不可变的变量不同。虽然都是不能改变。一个是常量，一个还是变量
-
字符串的值在创建之后就不能更改。
-
String 对象的字符内容是存储在一个字符数组 value[] 中的
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** final 的 字符数组 来存储所有字符 */
private final char value[];
。。。
}String 是一个final 类，意味着不能被继承，没有子类。
实现了 Serializable 、Comparable、CharSequence 三个接口。
Serializable 表示字符串支持序列化，可以进行传输
Comparable ：支持比较大小
public interface Comparable<T> {
// 比较大小
public int compareTo(T o);
}CharSequence ：字符序列接口
public interface CharSequence {
// 长度
int length();
char charAt(int index);
CharSequence subSequence(int start, int end);
public String toString();
/**
* @since 1.8
*/
public default IntStream chars() {
class CharIterator implements PrimitiveIterator.OfInt {
int cur = 0;
public boolean hasNext() {
return cur < length();
}
public int nextInt() {
if (hasNext()) {
return charAt(cur++);
} else {
throw new NoSuchElementException();
}
}
@Override
public void forEachRemaining(IntConsumer block) {
for (; cur < length(); cur++) {
block.accept(charAt(cur));
}
}
}
return StreamSupport.intStream(() ->
Spliterators.spliterator(
new CharIterator(),
length(),
Spliterator.ORDERED),
Spliterator.SUBSIZED | Spliterator.SIZED | Spliterator.ORDERED,
false);
}
/**
*/
public default IntStream codePoints() {
class CodePointIterator implements PrimitiveIterator.OfInt {
int cur = 0;
@Override
public void forEachRemaining(IntConsumer block) {
final int length = length();
int i = cur;
try {
while (i < length) {
char c1 = charAt(i++);
if (!Character.isHighSurrogate(c1) || i >= length) {
block.accept(c1);
} else {
char c2 = charAt(i);
if (Character.isLowSurrogate(c2)) {
i++;
block.accept(Character.toCodePoint(c1, c2));
} else {
block.accept(c1);
}
}
}
} finally {
cur = i;
}
}
public boolean hasNext() {
return cur < length();
}
public int nextInt() {
final int length = length();
if (cur >= length) {
throw new NoSuchElementException();
}
char c1 = charAt(cur++);
if (Character.isHighSurrogate(c1) && cur < length) {
char c2 = charAt(cur);
if (Character.isLowSurrogate(c2)) {
cur++;
return Character.toCodePoint(c1, c2);
}
}
return c1;
}
}
return StreamSupport.intStream(() ->
Spliterators.spliteratorUnknownSize(
new CodePointIterator(),
Spliterator.ORDERED),
Spliterator.ORDERED,
false);
}
}String 内部是用 字符串数组存储数据，这字符串数组也是final的。意味着每一个元素也是不可变的。
/** final 的 字符数组 来存储所有字符 */
private final char value[];看下面的例子：
public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
s1 = "hello";
System.out.println(s1); // hello
System.out.println(s2); // abc
}
}String 是一个类 居然像基本数据类型一样，直接写值，而不是new出来。String的这种赋值方式叫做字面量定义
public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2); // true
}
}比较s1与s2的地址值，你会发现是同一个。
在JVM的内存结构中，字符串是保存在方法区中的字符串常量池的，而不是像其他对象一样，保存在堆空间。
当首次使用 "abc" 给s1时，常量池没有 "abc" 就会创建一个。然后将地址值给 栈空间的s1保存。
当第二次使用 "abc" 给s2时，由于常量池已经有了"abc",就不会再造一个，而是直接将地址值给s2保存。
通过字面量的方式【与new不同】给字符串赋值，此时字符串是放在字符串常量池中，常量池不会存储2个相同的字符串。
public class StringTest {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
s1 = "hello";
System.out.println(s1); // hello
System.out.println(s2); // abc
}
}上面的代码执行了 s1 = "hello";
如果String是普通类，那么赋值就是通过s1保存的地址值，将这个地址里面保存的abc改为hello。而String是这样进行赋值的：当定义了"hello"时，常量池中没有hello，就创建一个hello，并把地址给s1，修改的是栈中s1保存的地址值。而不是常量池中的"abc"
因为字符串是final的，不可变。这就体现了字符串的不可变性。
s3 = s1 + "world";当执行上面的代码，进行字符串连接再赋值时，也是先去看看常量池有没有 "helloworld",有就将地址值给s3，没有就创建一个，将地址值给s3。 常量池中原有的 "hello" 不会变，hello的地址值也不会变。
对字符串的任何修改操作，都不会在原值上进行修改。而是看一看常量池有没有,没有就新建。
1.1.1 String对象的创建
// 字面量方式：直接赋值
String str = "hello";
// 对象方式：等价于 this.value = new char[0];
String s1 = new String();
// 对象方式: this.value = original.value;
String s2 = new String("hello");
// 对象方式：this.value = Arrays.copyof(value, value.length);
String s3 = new String(new char[]{'h','e','l','l','o'});
// 对象方式：String(char value[], int offset, int count)
String s4 = new String(new char[]{'h','e','l','l','o'}, 2, 2);
对象方式 创建的String对象 都是在堆里面的。只有字面量方式赋值才是在方法区中的常量池。看下面的代码：
public class StringTest {
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(s2 == s3); // false
System.out.println(s3 == s4); // false
}
}那是不是只要创建在堆空间了，就与常量池没关系？
不是的，以s3为例，s3这个对象在堆空间，但是堆空间保存的并不是hello这个字符串，而是 常量池中的 hello字符串的地址。就是说， 用new的方式最终还是用的常量池里面的东西，new方式反而多转了1到手。
因为这个原因，字面量的方式定义是效率最高的。
1.1.2 字符串拼接
public class StringTest {
public static void main(String[] args) {
String s1 = "hello";
String s2 = " world";
String s3 = "hello world";
String s4 = "hello" + " world";
String s5 = s1 + " world";
String s6 = "hello" + s2;
String s7 = s1 + s2;
System.out.println(s3 == s4); // true
System.out.println(s3 == s5); // false
System.out.println(s3 == s6); // false
System.out.println(s3 == s7); // false
System.out.println(s5 == s6); // false
System.out.println(s5 == s7); // false
System.out.println(s6 == s7); // false
}
}原因是 只要有变量参与拼接，都相当于是new 的方式创建字符串，结果在堆中。
只要常量与常量拼接结果在常量池中。
如果拼接的结果调用intern方法，返回值就在常量池中。
String s8 = s5.intern();
System.out.println(s3==s8); // true练习：
public class StringTest {
String str = new String("good");
char[] ch = {'t', 'e','s','t'};
public void change(String str, char ch[]){
str = "test ok";
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest ex = new StringTest();
ex.change(ex.str, ex.ch);
System.out.println(ex.str + " and "); // good and
System.out.println(ex.ch); // best
}
}
// ex.ch 肯定是 best。引用数据类型值传递传递的是地址值，会修改地址值里面指向的堆空间里面的值。
// 字符串是不可变量，值传递不会修改原来的值。上面的解析你肯定不懂。哈哈
分析一下调用change的过程。
已知：成员属性str是使用new方法创建的，存储的是堆空间字符串对象的地址值，假设地址为a。堆空间字符串对象存储的是常量池中 good 的地址值假设地址为b。
如果是字面量赋值，就是直接存储的是常量池中good 的地址值。
字符数组ch我不分析，详情见前面值传递那一部分内容。
当调用change时，方法的形参str 接收 成员属性str的值。注意形参 str 与成员属性str虽然名字一样，但是不是同一个。为了区分，我带上this。 这个过程就是 String str = this.str 形参str 保存的就是this.str原来保存的地址值a。即str 保存了 地址值 a
在方法中，将"test ok"赋值给了 str，此时str变量保存的值由地址值a变成了"test ok"的地址值 假设为c
整个过程只有形参str保存的值在变。 成员属性this.str保存的东西始终没变。所以输出理所当然。
1.1.3 内存结构
上图可以看到 方法区域堆区是2个并列的结构。
堆空间还可以具体划分：
永久区又有点问题，上图是规范。但是事实上，在实际中永久区又不属于堆，永久区就是方法区。
实际上，方法区和堆一样，是各个线程共享的内存区域。用于存储
-
类信息
-
普通常量
-
静态变量
-
编译器编译后的代码等
虽然规范上是属于堆，但是还有一个名字叫做Non-Heap，目的是为了与堆区分。
永久区是方法区的一个实现。JDK1.7 版本将原本放在永久区的字符串常量池移走了，移到堆里面去了。
1.8 又拿回来到永久区，但是永久区改名了，叫元空间，方法区的体现叫元空间了。
即1.7 以前，永久区就是方法区。1.7 版本 永久区与方法区不同了。1.7与1.8 之后又不同
常量池是方法区的一部分，class文件除了有类的版本、字段、方法、接口等描述信息，还有一项信息是常量池。这部分内容在类加载后进入方法区的运行时常量池中存储
1.1.4 常用方法
-
length()方法：返回底层的char数组的长度即字符串的长度。
String str = "hello world";
int length = str.length();
System.out.println(length); // 11-
charAt(int index) 方法：取指定索引处的字符
String str = "hello world";
int length = str.length();
char c = str.charAt(5);
// 输入的索引不能超过 长度-1，即最大索引。否则报错。
// "hello world"的最大索引是 10
char c1 = str.charAt(20);-
isEmpty() 判断字符串是否为空，实质是字符数组的长度是否为0
String str = "hello world";
String s1 = "";
boolean empty = str.isEmpty();
System.out.println(empty); // false
System.out.println(s1.isEmpty()); // true-
toLowerCase() 全部小写/ toUpperCase()全部大写
String s1 = "hello world";
String s2 = "HELLO WORLD";
String s = s1.toUpperCase();
System.out.println(s); // HELLO WORLD
System.out.println(s1); // hello world
System.out.println(s2.toLowerCase(Locale.ROOT)); // hello world-
trim() 干掉开头、末尾的全部空格，中间的空格保留
String s1 = " hello world ";
System.out.println("==="+s1+"===");
System.out.println("==="+s1.trim()+"===");
// 输出。 加上 === 是为了看得出空格。
=== hello world ===
===hello world===-
equals() 比较字符串内容相等；equalsIgnoreCase() 忽略大小写比较内容相等。
String s1 = "hello world";
String s2 = "hello world";
String s3 = "hEllo WoRld";
System.out.println(s1.equals(s2)); // true
System.out.println(s1.equals(s3)); // false
System.out.println(s1.equalsIgnoreCase(s3)); // true-
concat() 字符串拼接，+ 号可以替代这玩意，用的不多
String s1 = "hello world";
String s3 = s1.concat("xxx");
System.out.println(s3); // hello worldxxx-
compareTo() 比较字符串大小,一个一个字符比较。实际比较的是字符对应的编码大小。相等为返回0，大于返回1，小于返回-1
compareToIgnoreCase() 忽略大小写比较大小。
String s1 = "abc";
String s2 = "abc";
String s3 = "abd";
System.out.println(s1.compareTo(s2)); // 0
System.out.println(s1.compareTo(s3)); // -1-
substring() 取字符串的子串。有2个重写的方法。
substring(int beginIndex) 取指定索引到字符串末尾的所有字符作为子串 substring(int beginIndex, int endIndex) 取开始索引到结束索引之间的字符作为子串。 [左闭 右开)：包含起始索引，不包含结尾索引
String s1 = "hello world";
String substring = s1.substring(2);
String substring2 = s1.substring(2,6);
System.out.println(substring); // llo world
System.out.println(substring2); // llo-
endsWith() 以什么结尾 startsWith() 以什么开头
startsWith() 还有1个重载方法 startsWith(String prefix, int toffset) ，可以指定从哪个位置开始判断。
String s1 = "hello world";
System.out.println(s1.endsWith("ld")); // true
System.out.println(s1.startsWith("h")); // false
System.out.println(s1.startsWith("ll")); // false
System.out.println(s1.startsWith("ll", 2)); // true 从索引为2开始判断，是否以ll开头-
contains(CharSequence s) 是否包含某个字符序列,参数是CharSequence接口。String实现了这个接口。所以传入字符串就可。
String s1 = "hello world";
boolean ll = s1.contains("ll");
System.out.println(ll); // true-
indexof(String str) 返回 输入的字符串首次出现的位置，如果没有就返回-1
lastIndexOf(String str) 返回输入的字符串最后出现的位置，没有就返回-1
String s1 = "hello world";
int ll = s1.indexOf("ll");
System.out.println(ll); // 2
int oo = s1.indexOf("oo");
System.out.println(oo); // -1
int l = s1.lastIndexOf("l");
System.out.println(l); // 9
indexof 和 lastIndexOf 都各有4个重载方法。
各自的前2个是 可以传入 字符或者字符串。后2个方法的第一个参数也是字符或者字符串，第二个参数是指定寻找的起始位置。即从这个位置开始找。
int l1 = s1.lastIndexOf('l'); // 9
int l2 = s1.lastIndexOf("l", 5); // 3
int l3 = s1.indexOf('l'); // 2
int l4 = s1.indexOf("l", 2); // 2
int l5 = s1.indexOf("l", 3); // 3
int l6 = s1.indexOf("l", 4); // 9-
replace(CharSequence target, CharSequence replacement) 字符串替换
replace(char oldChar, char newChar) 字符替换
String s1 = "hello world";
String replace = s1.replace("l", "aa");
System.out.println(replace); // heaaaao woraad
String s1 = "hello world";
String replace = s1.replace('l', 'a');
System.out.println(replace); // heaao woradreplaceAll(String regex, String replacement) 输入正则表达式，进行字符传替换,全部替换
replaceFirst(String regex, String replacement) 输入正则表达式，进行字符传替换,只替换第一个
String s1 = "234hello world43255";
String s = s1.replaceAll("\\d", "");
String s2 = s1.replaceFirst("\\d", "");
System.out.println(s); // hello world
System.out.println(s2); // 34hello world43255-
matches(String regex) 输入正则表达式匹配，返回是否匹配成功。
String s1 = "234hello world43255";
String s2 = "0791-8888888";
boolean matches1 = s1.matches("\\d+");
boolean matches2 = s2.matches("0791-\\d{7,8}");
System.out.println(matches1); // false
System.out.println(matches2); // true-
split(String regex) 输入正则表达式，进行切割，返回数组。
String s1 = "234hello world43255";
String s2 = "0791-8888888-444";
String s3 = "hello|world|java";
String[] hellos = s1.split("hello");
String[] split = s2.split("-");
String[] split1 = s3.split("\\|");
for (int i = 0; i < hellos.length; i++) {
System.out.println(i);
}
for (int i = 0; i < split.length; i++) {
System.out.println(i);
}
for (String s : split1) {
System.out.println(s);
}1.1.5 与其他类型的转换
-
与基本数据类型、包装类之间的转换。前部分内容已经讲过，此处复习。
1、String 转 基本类型、包装类
String s = "123";
// String 转 包装类 调用 包装类的valueOf方法
Integer integer = Integer.valueOf(s);
// String 转 包装类 调用 包装类的parseXXX方法
int i = Integer.parseInt(s);2、基本数据类型、包装类 转换为 String
Integer a = 5;
int b = 5;
// 调用 String 的valueOf方法
String s = String.valueOf(a);
String s1 = String.valueOf(b);
// 利用 + 自动类型转换
String s2 = a + "";
String s3 = b + "";
// 调用包装类的 toString 方法
String s4 = a.toString();-
与 char[] 之间的转换
1、String 转 char[] 数组
String s1 = "123abc";
char [] charArray = s1.toCharArray();
for (char c : charArray) {
System.out.print(c + "\t");
}
// 输出：1 2 3 a b c 2、char[] 转 String
char [] charArray = new char[]{'1', '2', '3', 'a', 'b', 'c'};
// 调用String 的构造器即可
String s = new String(charArray);
System.out.println(s); // 123abc-
与 byte[] 之间的转换
1、String 转 byte[] 数组。 实际上字符内部都是以byte存储的。字符串转byte就是编码的过程。
String s1 = "abc123";
// 调用 getBytes 方法
byte[] bytes = s1.getBytes();
for (byte aByte : bytes) {
System.out.print(aByte + "\t");
}
// 输出： 97 98 99 49 50 51getBytes方法有多个重载方法。
可以传入指定的字符编码名称。
String s1 = "中国";
byte[] bytes = s1.getBytes(StandardCharsets.UTF_8);
for (byte aByte : bytes) {
System.out.print(aByte + "\t");
}
// -28 -72 -83 -27 -101 -67
当使用UTF-8编码时，可以看到 一个汉字占用3个字节。中: -28 -72 -83 国： -27 -101 -672、byte[] 数组 转 String， 这个过程也称为解码。
byte[] bytes = new byte[]{-28,-72,-83,-27, -101,-67};
// 还是调用String的构造器，也是可以指定编码
String s = new String(bytes);
System.out.println(s); // 中国// 指定编码
String s = new String(bytes, StandardCharsets.UTF_8);乱码问题一般就是 编解码使用的编码格式不同，统一编码格式都能解决编码问题。
2、StringBuilder 、StringBuffer 类
StringBuilder 和 StringBuffer 非常类似。均表示可变字符序列，而且提供相关功能的方法也一样。
String：不可变的字符序列，底层使用 final char[]
StringBuffer ：可变的字符序列，线程安全的，效率低。底层也是char[] 但不是final
StringBuilder 【JDK5.0新增的】：可变的字符序列，线程不安全，效率高。底层也是char[] 但不是final
源码分析：
//对应String
String str = new String(); // char[] value = new char[0]; 相当于创建了长度为0的char 数组
String str1 = new String("abc"); // char[] value = new char[]{'a','b','c'}
//对于StringBuffer
StringBuffer sb1 = new StringBuffer(); // char[] value = new char[16]; 相当于创建了长度为16的char 数组
System.out.println(str.length()); // 0 这里返回的不是 char[] 数组的长度，而是 append的字符的长度
sb1.append('a'); // value[0] = 'a'
sb1.append('b'); // value[1] = 'b' StringBuffer可以在原来是char数组上添加，而不是新建一个
StringBuffer sb2 = new StringBuffer("abc"); // char[] value = new char["abc".length + 16]; 相当于创建了长度为 你输入的字符串长度加上16 的char 数组问题来了：如果后面添加的数据超过了16呢？
ans：装不了，就扩容。append之前，先计算确保一下能否添加进去。如果不能添加，就new一个新的数组，容量左移1位，扩容2倍，再加上2，把原来的数据拷贝进去。还有一些特殊情况需要考虑。2倍也装不下，左移超出限制等。
因此，如果需要保存长的可变字符串，使用StringBuilder 、StringBuffer类时，new对象的时候指定容量大小，避免扩容。
2.1 常用方法
buffer与builder的常用方法差不多。以buffer为例。
-
append() 添加数据到末尾，如下图，有13个重载的方法。基本涵盖了各种类型。返回值还是一个StringBuffer。
-
delete(int start, int end) 方法：删除 指定索引内的数据。也是左闭右开区间
StringBuffer s1 = new StringBuffer("abc");
s1.append(1);
s1.append("l");
System.out.println(s1); // abc1l
s1.delete(2,4);
System.out.println(s1); // abl-
replace(int start, int end, String str) 方法：替换 start、end也是索引，左闭右开 str 是需要替换的内容
StringBuffer s1 = new StringBuffer("abc");
s1.append(1);
s1.append("l");
s1.replace(2,4, "ddd");
System.out.println(s1); // abdddl-
insert 方法： 有12个重载方法。插入数据。 offset为偏移量，即设置什么时候开始插入，第二个参数是需要插入的内容。
StringBuffer s1 = new StringBuffer("abc");
s1.append(1);
s1.append("l");
s1.insert(2, 'x');
System.out.println(s1); // abxc1l-
reverse() 方法： 反转字符串
StringBuffer s1 = new StringBuffer("abc1l");
s1.reverse();
System.out.println(s1); // l1cba-
indexOf 与 String 类一样
-
substring 与 String 类的也一样，这个方法需要返回值。并不会对当前字符串操作。
-
length 返回字符串长度
-
charAt 与String一样
-
setCharAt() 修改指定索引的字符。
2.2 三者效率
效率其实前面已经讲过。但是要注意使用场景。
StringBuilder > StringBuffer > String
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
