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

字符串就是一连串的字符序列，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 {
    //......
}