字符串就是一连串的字符序列，Java提供了String和StringBuffer两个类来封装字符串，并提供了一系列方法来操作字符串对象。

String类是不可变类，即一个String对象被创建后，包含在这个对象汇总的字符序列是不可改变的，直至这个对象被销毁。

StringBuffer对象则代表一个字符序列可变的字符串。一旦通过StringBuffer生成了最终想要的字符串，就可以调用他的toString()方法将其转换成一个String对象。

JDK1.5版本之后又新增了一个StringBuilder类。与StringBuffer类相似，区别是StringBuilder是非线程安全的，但是性能略高一点。因此通常情况下，如果需要创建一个内容可变的字符串对象，优先考虑使用StringBuilder类。

String

1.存在哪儿

java.lang包

没有任何继承关系实现三个接口Serializable, CharSequence, Comparable<String>

2.如何构建对象

String str = "abc"; //直接将字符串常量赋值给str (字符串常量池)

String str = new String();//无参数构造方法创建空的对象

String str = new String("abc");//带string参数的构造方法创建对象

String str = new String(byte[] )//将数组中的每一个元素转化成对应的char 组合成String

String str = new String(char[] )//将数组中的每一个char元素拼接成最终的String

String str =new String(byte[] bytes,Charset charset);//按照指定的字符集将指定byte[]数组解码成一个新的String字符串

String str = new String(StringBuilder builder)/new String(StringBuffer buffer);//通过StringBuilder和StringBuffer对象来创建字符串。

3.String的特性

（1）不可变特性

String类中包含一个private final char[] value;这个char数组就是用来存值的。也就是说String的底层实际上是数组。

体现在两个地方长度及内容

长度不可变是由于: 数组的长度是固定的，不能改变

内容不可变是由于: 用final修饰数组(引用地址不能改变)

（2）String对象赋值之后就会在常量池中缓存，如果下次创建会判定常量池是否已经有缓存对象，如果有的话直接返回该引用给创建者。

String  s1 = "laowang";//内存中会有这个字符串缓存
String  s2 =s1;//将s1的引用直接传给s2
String  s3 = "laownag";//这里是将s1创建的字符串地址赋给了s3,所以s1和s3指向的是同一个地址
String  s4 =new String(s1);

System.out.println(s1==s2);//true
System.out.println(s1==s3);//true
System.out.println(s1==s4);//false

这是因为S3在使用new String()时一定会在堆内存中创建一个内存区，而s2、s3则会直接使用s1的引用。

4.JVM对字符串的优化

根据以前学的知识我们知道，对于String的任何操作其实是创建了一个新对象，然后再把引用地址返回给该对象，但是JVM会对String进行特殊处理，以此来提高程序的运行效率。

例如：

String str = "hi,"+"lao"+"wang";

经过JVM优化后的代码是这样的：

String str = "hi,laowang"

验证代码如下：

5.常用的方法

boolean = equals(Object obj);

//继承自Object类，在String类中重写了比较两个字串中的字面值是否相等

int = hashCode();

//继承自Object ，重写了，将当前字符串的每一个char元素拆开乘以31求和

int = compareTo(String str);

//实现自Comparable接口按照字典(Unicode编码)索引的顺序比较

按照两个字符串的长度较小的那个(次数)来进行循环

若每次的字符不一致则直接返回code之差

若比较之后都一致则直接返回长度之差

有忽略大小写的equals和compareTo方法compareToIgnoreCase()和equalsIgnoreCase();

String = toString();

//继承自Object 重写不再输出类名@hashCode 字符串中的字面值

char = charAt(int index);//"abc" 0-->a

//返回给定index对应位置的那个char值

int = codePointAt(int index);//"abc" 0-->97

//返回给定index对应位置的那个char所对应的code码

int = length();

返回字符串的长度 (其实就是底层char[] value属性的长度)

注意: 区别数组length是属性 String的length()方法集合size()方法

//返回字符串的长度

String = concat(String);
//将给定的字符串拼接在当前字符串之后

// 注意: 方法执行完毕需要接受返回值 String的不可变特性

//concat方法与 +拼接的性能问题,开发中若遇到频繁的拼接字符串--->通常使用StringBuilder/StringBuffer

//自己回去查看API文档
boolean = contains() : 字符串中是否存在元素
boolean = startsWith(String pefix):判断字符串是否以pefix开头
boolean = endsWith(String suffix)： 判断字符串是否以suffix结尾
byte[] = getBytes() 将该String对象转换成byte数组
char[] = toCharArray() :将字符串转化成char数组
indexOf() 找寻给定的元素在字符串中第一次出现的位置参数四种：int ；String str ，int fromINdex；int fromIndex;String str;
lastIndexOf()：找寻给定元素在字符串中最后一次出现的位置。如果不存在则返回-1
isEmpty(): 判断字符串是否是空串；如果String str = null; 则不能调用该方法。
String = replace() 但是实际上也能将字符串中所有相同的字符换掉。和repaceAll()方法效果一样
replaceAll(char oldChar,char newChar)
replaceFirst(char oldChar,char newChar):替换第一个出现的。
String[] value = str.split(String regex) regex 是正则表达式(拆分标志符)
split(String regex,int limit)按照给定的表达式将原来的字符串拆分开。Limit是限制拆成几段。
String = substring(int beginIndex,int endIndex)：截取给定的字符串其中的一部分
String = toUpperCase();将全部字符串转换成大写
String = toLowerCase();将全部字符串转换成小写
String = str.trim() :去掉字符串前后多于的空格，注意字符串中间的空格去不掉
boolean = matches(String regex) 判断字符串是否符合给定的正则表达式

字符串格式化：

字符串格式化可以让代码更简洁更直观，比如，“我叫老王，今年 30 岁，喜欢读书”在这条信息中：姓名、年龄、兴趣都是要动态改变的，如果使用“+”号拼接的话很容易出错，这个时候字符串格式化方法 String.format() 就派上用场了，代码如下：

String str = String.format("我叫%s，今年%d岁，喜欢%s", "老王", 30, "读书");
转换符说明列表：

转换符      说明
%s        字符串类型
%d 整数类型（十进制）
%c       字符类型
%b     布尔类型
%x       整数类型（十六进制）
%o       整数类型（八进制）
%f      浮点类型
%a       浮点类型（十六进制）
%e       指数类型
%%      百分比类型
%n     换行符

StringBuffer和StringBuilder

1.所属的包

java.lang包

2.继承关系

继承AbstractStringBuilder 间接继承 Object

实现接口Serializable,CharSequence,Appendable

StringBuffer/StringBuilder没有compareTo方法

StringBuffer/StringBuilder含有一个String没有的方法 append();拼接

3.特性:

可变字符串 char[] value; 动态扩容,没有用final修饰，因此可以改变数组的地址。

4.对象的构建

//无参数构造方法构建一个默认长度16个空间的对象 char[]

StringBuilder builder = new StringBuilder();

//利用给定的参数构建一个自定义长度空间的对象 char[]

StringBuilder builder = new StringBuilder(20);

//利用带String参数的构造方法默认数组长度字符串长度+16个

StringBuilder builder = new StringBuilder("abc");

5.StringBuilder/StringBuffer中常用的方法

最主要的方法 append() 频繁的拼接字符串的时候使用此方法提高性能

可以拼接几乎任何类型

并且在拼接内容的速度上非常的快。下图是“+”、concat()、append()三种方式拼接字符串的性能对比

ensureCapacity(int minimumCapacity) 确保底层数组容量够用
builder.capacity();//字符串底层char[]的容量
builder.length();//字符串有效元素个数(长度)
setLength();//设置字符串的有效元素个数
char = charAt(int index); 根据给定的索引号返回对应位置上的String内容
int = codePointAt(int index);
String = substring(int start [,int end]);

注意需要接受返回值看见截取出来的新字符串效果

StringBuilder = delete(int start [,int end]);

StringBuilder类中独有的方法String类没有

将start到end之间的字符串删掉不用接受返回值就看到效果

StringBuilder = deleteCharAt(int index)：将指定位置的某一个字符删除掉，也是String类中没有的方法
int = indexOf(String str [,int fromIndex])：找寻给定的元素在字符串中第一次出现的位置
int = lastIndexOf(String str [,int fromIndex])：找寻给定的str在字符串中第一次出现的索引位置带重载则从某一个位置开始找
insert(int index,value)：将给定的value插入在index位置之上
replace(int start,int end,String str)：将start和end之间的部分替换成str

builder.replace(2,5,"zzt");

setCharAt(int index,char value)：将index位置的字符改成给定的value
toString() ：重写过，可以用来将StringBuilder对象构建成一个string对象返回
trimToSize()：将数组中无用的容量去掉变成length长度的数组
reverse() :字符串反转

6.StringBuffer和StringBuilder的不同

StringBuffer早期版本1.0

StringBuilder后来的版本1.5

方法使用几乎一致

早期版本线程同步安全性比较高执行效率相对较低

后期版本线程非同步安全性比较低执行效率相对较高

7、相关面试题

1. String 属于基础数据类型吗？
答：String 不是基础数据类型，它是从堆上分配来的。基础数据类型有 8 个，分别为：boolean、byte、short、int、long、float、double、char。

2. 以下可以正确获取字符串长度的是？
A：str.length
B：str.size
C：str.length()
D：str.size()

答：C

题目解析：字符串没有 length 属性，只有 length() 方法。

3. "==" 和 equals 的区别是什么？
答："==" 对基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重写了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

① "==" 解读

对于基本类型和引用类型 == 的作用效果是不同的，如下所示：

基本类型：比较的是值是否相同；
引用类型：比较的是引用是否相同。
代码示例：

String x = "string";
String y = "string";
String z = new String("string");
System.out.println(x==y); // true
System.out.println(x==z); // false
System.out.println(x.equals(y)); // true
System.out.println(x.equals(z)); // true
代码说明：因为 x 和 y 指向的是同一个引用，所以 == 也是 true，而 new String() 方法则重写开辟了内存空间，所以 == 结果为 false，而 equals 比较的一直是值，所以结果都为 true。

② equals 解读

equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。看下面的代码就明白了。

首先来看默认情况下 equals 比较一个有相同值的对象，代码如下：

class Cat {
    public Cat(String name) {
        this.name = name;
    }
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
Cat c1 = new Cat("王磊");
Cat c2 = new Cat("王磊");
System.out.println(c1.equals(c2)); // false
输出结果出乎我们的意料，竟然是 false？！

这是怎么回事，看了 equals 源码就知道了，源码如下：

public boolean equals(Object obj) {
    return (this == obj);
}
原来 equals 本质上就是 ==。

那问题来了，两个相同值的 String 对象，为什么返回的是 true？代码如下：

String s1 = new String("老王");
String s2 = new String("老王");
System.out.println(s1.equals(s2)); // true
同样的，当我们进入 String 的 equals 方法，找到了答案，代码如下：

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}
原来是 String 重写了 Object 的 equals 方法，把引用比较改成了值比较。

总结来说，"==" 对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重写了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。

4. 以下代码输出的结果是？
String str = "laowang";
str.substring(0,1);
System.out.println(str);
A：l
B：a
C：la
D：laowang

答：D

题目解析：因为 String 的 substring() 方法不会修改原字符串内容，所以结果还是 laowang。

5. 以下字符串对比的结果是什么？
String s1 = "hi," + "lao" + "wang";
String s2 = "hi,";
s2 += "lao";
s2 += "wang";
String s3 = "hi,laowang";
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s2 == s3);
答：false true false

题目解析：String s1 = "hi," + "lao" + "wang" 代码会被 JVM 优化为：String s1 = "hi,laowang"，这样就和 s3 完全相同，s1 创建的时候会把字符"hi,laowang"放入常量池，s3 创建的时候，常量池中已经存在对应的缓存，会直接把引用返回给 s3，所以 s1==s3 就为 true，而 s2 使用了 += 其引用地址就和其他两个不同。

6. 以下 String 传值修改后执行的结果是什么？
public static void main(String[] args) {
  String str = new String("laowang");
  change(str);
  System.out.println(str);
}
public static void change(String str) {
    str = "xiaowang";
}
答：laowang

7. 以下 StringBuffer 传值修改后的执行结果是什么？
public static void main(String[] args) {
  StringBuffer sf = new StringBuffer("hi,");
  changeSf(sf);
  System.out.println(sf);
}
public static void changeSf(StringBuffer sf){
    sf.append("laowang");
}
答：hi,laowang

题目解析：String 为不可变类型，在方法内对 String 修改的时候，相当修改传递过来的是一个 String 副本，所以 String 本身的值是不会被修改的，而 StringBuffer 为可变类型，参数传递过来的是对象的引用，对其修改它本身就会发生改变。

8. 以下使用 substring 执行的结果什么？
String str = "abcdef";
System.out.println(str.substring(3, 3));
答：""(空)。

9. 判定字符串是否为空，有几种方式？
答：常用的方式有以下两种。

str.equals("")
str.length()==0
10. String、StringBuffer、StringBuilder 的区别？
答：以下是 String、StringBuffer、StringBuilder 的区别：

可变性：String 为字符串常量是不可变对象，StringBuffer 与 StringBuilder 为字符串变量是可变对象；
性能：String 每次修改相当于生成一个新对象，因此性能最低；StringBuffer 使用 synchronized 来保证线程安全，性能优于 String，但不如 StringBuilder；
线程安全：StringBuilder 为非线程安全类，StringBuffer 为线程安全类。
11. String 对象的 intern() 有什么作用？
答：intern() 方法用于查找常量池中是否存在该字符值，如果常量池中不存在则先在常量池中创建，如果已经存在则直接返回。

示例代码：

String s = "laowang";
String s2 = s.intern();
System.out.println(s == s2); // 返回 true
12. String s=new String("laowang") 创建了几个对象？
答：总共创建了两个对象，一个是字符串 “laowang”，另一个是指向字符串的变量 s。new String() 不管常量池有没有相同的字符串，都会在内存（非字符串常量池）中创建一个新的对象。

13. 什么是字符串常量池？
字符串常量池是存储在 Java 堆内存中的字符串池，是为防止每次新建字符串带的时间和空间消耗的一种解决方案。在创建字符串时 JVM 会首先检查字符串常量池，如果字符串已经存在池中，就返回池中的实例引用，如果字符串不在池中，就会实例化一个字符串放到池中并把当前引用指向该字符串。

14. String 不可变性都有哪些好处？
答：不可变的好处如下。

只有当字符串是不可变的，字符串常量池才能实现，字符串池的实现可以在运行时节约很多堆空间，因为不同的字符串变量都指向池中的同一个字符串；
可以避免一些安全漏洞，比如在 Socket 编程中，主机名和端口都是以字符串的形式传入，因为字符串是不可变的，所以它的值是不可改变的，否则黑客们可以钻到空子，改变字符串指向的对象的值，造成安全漏洞；
多线程安全，因为字符串是不可变的，所以同一个字符串实例可以被多个线程共享，保证了多线程的安全性；
适合做缓存的 key，因为字符串是不可变的，所以在它创建的时候哈希值就被缓存了，不需要重新计算速度更快，所以字符串很适合作缓存的中的 key。

15. String 是否可以被继承？为什么？
答：String 不能被继承。因为 String 被声明为 final（最终类），所以不能被继承，源码如下（JDK 8）。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    //......
}

monologuezjp

发布了47 篇原创文章 · 获赞 10 · 访问量 1万+

私信关注

Java基础类库（三）————String类、StringBuffer类、StringBuilder类