字符串String，StringBuffer，StringBuilder修炼大法

绝地灬酷狼 2023-02-26 08:29 62阅读 0赞

### 目录 ###

*   *   *  String
         *   *  字符串常量不可变
             *  null，" "的区别
             *  数组转成字符串（String的构造）
             *  ==与equals()的比较字符串是否相等
             *  字符串的拼接
             *  字符串操作常用方法
             *  转换功能
             *  字符串的比较和替换
             *  编码与解码
         *  StringBuilder
         *   *  StringBuilder构造
             *  StringBuilder成员方法
         *  StringBuffer
         *   *  常见的String，StringBuffer,StringBuilder的面试题
             *  String，StringBuffer,StringBuilder的区别？
             *  如何使用三者？

栈：存放基础的数据类型变量以及对象的引用

堆：存放new出来的对象以及数组

常量池：字符串常量

tips:栈与常量池中的对象是共享的，堆里面的对象不共享

### String ###

#### 字符串常量不可变 ####

Java底层源码中使用final修饰 char\[\] value来存储字符串的值（Java9以后使用byte\[\]存储字符串的）。字符串常量是存在`常量池`中，一旦声明，就不可以改变,同时常量池中不会存储相同内容的字符串，即s1与s2是相等的。

String s1 = "aaa";
        s1 = "bbb";
        System.out.println(s1);
        String s2 = "123";
    	String s3 = y"123";
    	System.out.println(s2==s3);

输出的s1的值是bbb，不是改变了么？其实表面上是这样的，内存中并不是这样的情况！  
这里的s1是引用对象，首先会在栈内存中开辟一个s1引用对象的空间，而`aaa`这个字符串常量是存在方法区常量池中，通过s1这个对象引用指向`aaa`,如果没有`aaa`则会在常量池中开辟一个空间将其放入，然后s1再指向它，现在只是将引用指向了`bbb`,而 `aaa`并没有从池中消失，所以字符串常量是不可变的，且在常量池中的字符串是不可重复的，也就是说明了s2与s3相等。

**注意：JDK1.7之前，常量池在方法区中，JDK1.7及以后常量池放在了堆里面，我们通常指的的是1.7之前的常量池**

除此之外，String还实现了`Serializable`接口，表示字符串可以被序列化，还实现了`Comparable`接口表示字符串可以比较大小

#### null，" "的区别 ####

String s1 = null
        String s2 = ""

*  null代表的是`空对象`，并不是字符串，可以赋给任何对象,字符串中表示只是一个引用，还没有内存空间的分配
 *  “ ”表示引用已经指向了 一块内存空间了，是一个实际的东西，可以进行操作了，表示一个长度为0的字符串

#### 数组转成字符串（String的构造） ####

*  String():构造一个空的字符串
 *  String(byte\[\] arr): 将字节数组变为一个字符串
 *  String(byte\[\] arr, int offset, int lengh): 将字节数组部分变为字符串
 *  String(char\[\] arr): 将char字节数组变为字符串
 *  String(char\[\] arr, int offset, int length): 将char字节数组部分变为字符串
 *  String(String original): 字符串常量构建字符串
 *

**byte\[\]===>String**

*  全部转换:转换所有byte数据

byte[] b = { 97,98,99,100};	
        String str = new String(b);
        System.out.println(str);//abcd

*  部分转换: 截取转换，超出索引,报出`StringIndexOutOfBoundsException`异常，通常Java中数组索引区间左开右闭的

byte[] b = { 97,98,99,100};	
        String str = new String(b,1,3);
        System.out.println(str);//bc

char\[\]转String等等一些数组转String的方式都和上述大同小异，这些都是对String方法使得构造

#### ==与equals()的比较字符串是否相等 ####

*  == 比较的地址和内容都相等才相等
 *  equals()内容相等即是相等

理解上面两句：

String s1 = "123";①
        String s2 = "123";②
        String s3 = new String("123");③
        System.out.println(s1==s2);//正确
        System.out.println(s1==s3);//错误

只要明白了内存分布，判断不成问题。对于①，②来说，上面已经解释过了s1,s2都在栈内存中，对于③来说，会先在栈中开辟一个内存空间存放引用对象s3,然后会在堆内存中重新开辟空间存放`new String("123")`中的String匿名对象的值`123`所以s1==s3是错误的！！！对于equals()就不一样了比较的是内容是否相等，三者内容都是相等的，所以equals是`true`。

练习一：

String s1 = new String("hello");
    String s2 = new String("hello");
    System.out.println(s1==s2);
    System.out.println(s1.equals(s2));
    String s3 = new String("hello");
    String s4 = "hello";
    System.out.println(s3==s4);
    System.out.println(s3.equals(s4));
    String s5 = "hello";
    String s6 = "hello";
    System.out.println(s5==s6);
    System.out.println(s5.equals(s6));

答案：F T F T T T

#### 字符串的拼接 ####

*  常量与常量的拼接还在常量池中
 *  常量池不可有相同的常量
 *  拼接的时候，只要存在变量都会存到堆中
 *  调用intern()方法返回常量池里面的常量

String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3==(s1+s2));//F 变量的连接存在堆中不相等
        System.out.println(s3==(s1+s2).intern());//T 获取的是值相等
        System.out.println(s3.equals(s1+s2));//T 获取内容相等
        System.out.println(s3=="hello" + "world");//T 常量与常量连接还在常量池中
        System.out.println(s3.equals("hello"+"world"));//T 内容相等

#### 字符串操作常用方法 ####

**字符串的判断：**

*  equals方法比较两个字符串内容是否相等
 *  equalsIgnorecase忽略大小写比较两个对象是否相等
 *  contains是否包含字符串
 *  startsWith()是否以指定的字符串开头
 *  endsWIth()是否以指定的字符串结尾
 *  isEmpty()是否为空

String s1 = "abcde";
        String s2 = "AbCde";
        String s3 = "abcde";
        //equals
        System.out.println(s1.equals(s2));//t
        System.out.println(s1.equals(s3));//f
        //equalsIgnorecase
        System.out.println(s1.equalsIgnoreCase(s2));//t
        System.out.println(s1.equalsIgnoreCase(s3));//t
        //是否包含指定字符串
        System.out.println(s1.contains("bd"));//f
        //是否以指定字符串开头
        System.out.println(s1.startsWith("ab"));//t
        System.out.println(s1.startsWith("cde",2));//t 字符串是否在索引2开始截取
        //是否以字符串结尾
        System.out.println(s1.endsWith(s3));//t
        //是否为空 
        System.out.println(s1.isEmpty());//false

**字符串的获取**

*  length():字符串的长度
 *  charAt(inx index):返回某个字符在字符串中的索引
 *  indexOf(int ch)：获取指定的字符在字符串第一次出现的位置,可以写对应的ASCALL码值
 *  indexOf(int ch, int fromIndex)：从指定的索引开始，字符出现的位置
 *  indexOf(String str)：获取指定的字符串在原字符串的位置
 *  indexOf(String str, int fromIndex)：从指定的索引开始，获取字符串第一次出现的位置
 *  lastIndexOf(int ch)：获取指定字符最后一次出现的索引值
 *  lastIndexOf(String str,int fromIndex)获取指定字符串最后出现的索引值
 *  subString(int start)：从指定位置开始截取字符串
 *  subString(int start, int end)从指定位置到指定位置截取字符串

**注意:如果没有找到都会返回-1**

**练习：**

String str = "abcdeababcdacaeca";
        //长度
        System.out.println(str.length());//17
        //获取第二个元素
        System.out.println(str.charAt(1));//b
        //获取最后一个元素值
        System.out.println(str.charAt(str.length() - 1));//a
        //获取'a'第一次的索引值
        System.out.println(str.indexOf('a'));//0
        System.out.println(str.indexOf(97));//0
        //从第二个索引值开始，'a'第一次出现的位置
        System.out.println(str.indexOf('a', 2));//5
        //获取"bc"第一次出现的索引值
        System.out.println(str.indexOf("bc"));//1
        //从2索引开始"ad"第一次出现的索引值
        System.out.println(str.indexOf("ad", 2));//-1
        //获取'a'最后一次存储的索引值
        System.out.println(str.lastIndexOf('a'));//16
        //获取'bc'最后一次出现的索引值
        System.out.println(str.lastIndexOf("bc"));//8
        //从7索引结束前获取'a'最后一次索引值
        System.out.println(str.lastIndexOf('a', 7));//7
        System.out.println(str.lastIndexOf('c', 6));//2
        //从索引5截取到末尾
        String s1 = str.substring(5);
        System.out.println(s1);//ababcdacaeca
        //"abcdeabca" ===> "deab"
        String s2 = str.substring(3, 7);
        System.out.println(s2);

#### 转换功能 ####

*  byte\[\] getBytes():将字符串转换为字节数组
 *  byte\[\] getBytes(String charset):通过指定的字符集，将字符串转成字节数组
 *  char\[\] toCharArray():将字符串转成字符数组
 *  static valueOf(char\[\] chs):将字符数组转成字符串
 *  static valueOf(int num):将int数据转成字符串
 *  static valueOf(Object obj):将任意的引用数据转成字符串
 *  toLowerCase():转成小写
 *  toUpperCase():转成大写
 *  concat(String str):字符串连接
 *  trim():去除两边空格

**tips：不同编码方式汉字占用的字节不同，GBK编码，一个汉字字符占用2个字节，UTF-8编码中一个字符占用3个字节**

String s = "Ab三上悠亚";
        //String转为byte[]
        byte[] bys =s.getBytes();
        //[65, 98, -28, -72, -119, -28, -72, -118, -26, -126, -96, -28, -70, -102]
        System.out.println(Arrays.toString(bys));
        //String转为char[]
        char[] c = s.toCharArray();
        //[A, b, 三, 上, 悠, 亚]
        System.out.println(Arrays.toString(c));
        //其它大部分类型转String
        System.out.println(String.valueOf(100));//100
        System.out.println(String.valueOf(false));//false
        System.out.println(String.valueOf('a'));//a
        System.out.println(String.valueOf(3.23f));//3.23
        System.out.println(String.valueOf(c,0,3));//Ab三 从0索引开始截取三个字符
        char[] data = { 'A','B','c'};
        System.out.println(String.valueOf(data));//ABc
    	System.out.println(s.toLowerCase());//ab三上悠亚
    	System.out.println(s.toUpperCase());//AB三上悠亚

#### 字符串的比较和替换 ####

*  replace(char old, char new):新的字符替换新的字符
 *  replace(String old, Stringnew):新的字符串替换新的字符串
 *  String replace(CharSequence target, CharSequence replacement)：替换指定的字符序列
 *  int compareTo(String str):字典比较字符串
 *  int compareToIgnoreCase(String str):忽略大小写比较

**字符串的替换：**

String s = "abc三上悠亚abc";
        //b替换B 字符替换
        String s1 = s.replace('b', 'B');
        System.out.println(s1);//aBc三上悠亚aBc
        //三上悠亚替换为JAPAN字符串替换
        String s2 = s.replace("三上悠亚", "JAPAN");
        System.out.println(s2);//abcJAPANabc
        //替换指定的字符序列
        String s4 = "abc";
        String s5 = "abcd";
        String s6 = s.replace(s4, s5);
        System.out.println(s6);//abcd三上悠亚abcd

**字典比较**

**字符串是英文并且长度不一样**

*  长度长的包含长度短的（这个包含表示从第一个字符开始匹配）直接是长度相减
    
        String str1 = "abcde";
            String str2 = "abc";
            System.out.println(str1.compareTo(str2));//2
    
    相当于`s1.length() - s2.length()`
 *  长度不一样，且从第一个字符开始找，没有匹配，则是两个字符ASCALL的差值
    
        String str1 = "abcde";
            String str2 = "cabc";
            System.out.println(str1.compareTo(str2));//-2
    
    相当于a-c=-2
 *  长度一样且不匹配，单个字符ascall值相减即可，多个字符不一样从第一个字符找，如果第一个字符一样比较第二个字符，依次类推…直到不一样时，ASCALL码值相减即可。
    
        String str1 = "cdea";
            String str2 = "cdeb ";
            System.out.println(str1.compareTo(str2));//-1
    
    中文与英文类似！！！
    
    #### 编码与解码 ####
    
    编码：将看懂的变为看不懂的
    
    解码：将看不懂的变为看懂的
    
        String s1 = "我爱china";
            byte[] c = s1.getBytes();
            //默认为UTF-8，占用3个字节
            //[-26, -120, -111, -25, -120, -79, 99, 104, 105, 110, 97]
            System.out.println(Arrays.toString(c));
            byte[] bys = s1.getBytes("GBK");
            //指定用GBK进行编码
            //[-50, -46, -80, -82, 99, 104, 105, 110, 97]
            System.out.println(Arrays.toString(bys));
            //对c进行解码
            String s = new String(c);
            System.out.println(s);
            //对bys进行解码
            String s2 = new String(bys,"gbk");
            System.out.println(s2);
            //解码错误出现乱码 
            String s3 = new String(bys,"utf-8");
            System.out.println(s3);
    
    运行图：  
    ![在这里插入图片描述][20200715212758160.JPG_pic_center]

### StringBuilder ###

#### StringBuilder构造 ####

*  StringBuilder():空的构造，底层默认创建容量为16的字符缓冲区对象
 *  StringBuilder(int capacity):可以指定容量创建StringBuilder对象
 *  StringBuilder(String str):创建指定字符串的StringBuilder对象

StringBuilder是线程不安全的！！！

使用这些构造：

StringBuilder sb = new StringBuilder();
        System.out.println(sb);//空
        System.out.println(sb.length());//0
        System.out.println(sb.capacity());//16
    
        StringBuilder sb1 = new StringBuilder(100);
        System.out.println(sb1);//空
        System.out.println(sb1.length());//0
        System.out.println(sb1.capacity());//100
    
        StringBuilder sb3 = new StringBuilder("java");
        System.out.println(sb3);//java
        System.out.println(sb3.length());//4
        System.out.println(sb3.capacity());//20

#### StringBuilder成员方法 ####

*  增加功能：
    
     *  String append(Object obj) 括号中可以是任意类型
     *  insert(int offset, String str)任意地方添加指定类型
 *  删除功能：
    
     *  deleteCharAt(int index) 指定位置删除对应的元素
     *  delete(int index, int end)删除\[index，end-1\]之间的元素
 *  修改功能:
    
     *  setCharAt(int n, char ch):
     *  replace(int start,int end,String str):
 *  查询功能
    
     *  charAt(int n):
     *  int Capacity():
     *  int length():
 *  反转功能
    
     *  reverse() 反转功能
 *  截取功能
    
     *  String substring(int start)：截取指定位置一直到末尾
     *  String substring(int start,int end)：截取\[start,end-1\]范围

**使用这些方法：**

StringBuilder sb = new StringBuilder();
    		//添加
    		sb.append('j').append("av").append(false).append(100);//javfalse100
    		sb.insert(1, false);//jfalseavfalse100
    		//删除
    		sb.deleteCharAt(0);//删除第一个字符 falseavfals100
    		sb.delete(0, 3);//删除[0-2]的字符 seavfals100
    		//修改
    		sb.setCharAt(3, 't');//seatfalse100
    		sb.replace(3,7,"true");//seatruelse100
    		//查询元素
    		System.out.println(sb.charAt(6));//e
    		System.out.println(sb.length());//12
    		System.out.println(sb.capacity());//初始容量16
    		//截取功能
    		System.out.println(sb.substring(3));//truelse100
    		System.out.println(sb.substring(4, 7));//rue 截取[4,6]

### StringBuffer ###

StringBuffer与StringBuilder的用法是一模一样的，这里不再赘述相关方法，主要对比他们两有什么区别。

#### 常见的String，StringBuffer,StringBuilder的面试题 ####

#### String，StringBuffer,StringBuilder的区别？ ####

*  **可变性**
    
     *  String用final修饰，不可变
     *  StringBuffer与StringBuilder都是继承AbstratBuilder类，存储的char\[\]并未用final修饰，是可变的
 *  **线程安全性**
    
     *  String对象不可变，可以视为线程安全
     *  StringBuffer加了同步锁，线程安全
     *  StringBuilder方法未加同步锁，线程不安全
 *  **性能**
    
     *  每次对String进行赋值时都会产生新对象，然后将指针指向新的对象
     *  StringBuffer每次都会对对象的本身进行操作，而不是产生新的对象去引用它，相同情况下，使用StringBuilder的性能会提高，但是会有线程不安全的风险

代码比较StringBuilder与StringBuffer的性能：

private static void demo02() { 
    		StringBuilder sb = new StringBuilder("abc");
            //当前时间
    		long l1  = System.currentTimeMillis();
    		for(int i=0; i<100000;i++) { 
    			sb.append("hello");
    		}
            //跑完循环
    		long l2  = System.currentTimeMillis();
    		System.out.println("String连接耗时："+ (l2 -l1));
    	}
    private static void demo01() { 
    		String s = "abc";
    		//当堆空间溢出会发生OutOfMemoryError
            //当前时间
    		long l1  = System.currentTimeMillis();
    		for(int i=0; i<100000;i++) { 
    			s += "hello";
    		}
            //跑完循环
    		long l2  = System.currentTimeMillis();
    		System.out.println("String连接耗时："+ (l2 -l1));
    	}

#### 如何使用三者？ ####

*  操作少量的数据：String
 *  单线程操作大量数据：StringBuilder
 *  多线程操作大量数据：StringBuffer

[20200715212758160.JPG_pic_center]: /images/20230209/d42c87f28fed4a68a5830f4261f674f7.png