String、StringBuffer 和StringBuilder

String类

String类的理解和创建对象

1. String对象用于保存字符串，也就是一组字符序列
2. 字符串常量对象是用双引号括起的字符序列。例如: “你好”、“12.97”、"boy"等
3. 字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节 char
4. String类较常用构造方法(其它看手册):
   String s1 = new String();
   String s2 = new String(String original);
   String s3 = new String(char[] a);
   String s4 = new String(char[] a,int startIndex,int count)

package www.xz.string_;

/**
 * @author 许正
 * @version 1.0
 */
public class String01 {
    public static void main(String[] args) {
        //1.String 对象用于保存字符串，也就是组字符序列
        //2. "jack" 字符串常量，双引号括起的字符序列
        //3.字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
        //4. String 类有很多构造器，构造器的重载
        //   常用的有String s1 = new String(); //
        //   string s2 = new String(String original);
        //   String s3 =new String(char[] a);
        //   Strings4 = new String(char[] a, int startIndex, int count)
        //   String s5 = new String(byte[] b)
        //5. String 类实现了接口Serializable [String 可以串行化:可以在网络传输]
        //                 接口Comparable [String 对象可以比较大小]
        //6. String 是final 类，不能被其他的类继承
        //7. String 有属性private final char value[]; 用于存放字符串内容
        //8.一定要注意: value 是一个final类型， 不可以修改:即value不能指向
        //  新的地址，但是单个字符内容是可以变化
        new String().intern();
    }
}

创建String对象的两种方式

1. 方式一:直接赋值String s = “xz”;

2. 方式二:调用构造器String S = new String(“xz”);

3. 方式一:先从常量池查看是否有"xz"数据空间，如果有，直接指向;如果
   没有则重新创建，然后指向。s最终指向的是常量池的空间地址

4. 方式二:先在堆中创建空间，里面维护了value属性，指向常量池的xz空间。

   如果常量池没有"xz",重新创建，如果有，直接通过value指向。

   最终指向的是堆中的空间地址。

5. 画出两种方式的内存分布图

字符串的特性

1. String是一个final类， 代表不可变的字符序列
2. 字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的.

Exercise（两个）

package www.xz.string_;

/**
 * @author 许正
 * @version 1.0
 */
public class Exercise {
    public static void main(String[] args) {
        String a = "hello"; //创建a对象
        String b = "abc";//创建b对象
        //1. 先创建一个StringBuilder sb = StringBuilder()
        //2. 执行sb.append("hello");
        //3. sb.append("abc");
        //4. String c = sb.toString()
        //最后其实是C指向堆中的对象(String) value[] ->池中"helloabc"
        String c = a + b;
        String d = "helloabc";
        System.out.println(c == d);//真还是假? 是false
        String e = "hello" + "abc";
        System.out.println(d == e);//true
    }
}

String类的常见方法

说明

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因
此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，
并提高效率。[后面我们还会详细介绍StringBuilder 和StringBuffer]

String类的常见方法一览

• equals
• equalslgnoreCase
• length
• indexOf
• lastIndexOf
• substring
• trim
• charAt:获取某索引处的字符
• toUpperCase
• toLowerCase
• concat
• compare To
• toCharArray
• format

StringBuffer类

基本介绍

• java.lang.StringBuffer代表可变的字符序列， 可以对字符串内容进行增删。
• 很多方法与String相同，但StringBuffer是可变长度的。
• StringBuffer是一 个容器。

package www.xz.stringbuffer_;

/**
 * @author 许正
 * @version 1.0
 */
public class StringBuffer01 {
    public static void main(String[] args) {
        //1. StringBuffer 的直接父类是AbstractStringBuilder
        //2. StringBuffer 实现了Serializable, 即StringBuffer的对象可以串行化
        //3. 在父类中  AbstractStringBuilder有属性char[] vaLue ,不是final
        //   该 value 数组存放字符串内容，因此存放在堆中的
        //4. StringBuffer 是一个final类，不能被继承
        //5. 因为StringBuffer 字符内容是存在char[] value, 所以在变化(增加/删除)
        //   不用每次都更换地址(即不是每次创建新对象)，所以效率高于 String
        StringBuffer stringBuffer = new StringBuffer();
    }
}

package www.xz.stringbuffer_;

/**
 * @author 许正
 * @version 1.0
 */
public class StringBuffer02 {
    public static void main(String[] args) {
        //构造器的使用
        //1.创建一个大小为16的 char[] ,用于存放字符内容
        //默认为16
        StringBuffer stringBuffer = new StringBuffer();
        //2.通过构造器指定char[] 大小
        //指定为100
        StringBuffer stringBuffer1 = new StringBuffer(100);
        //3.通过给一个String 创建StringBuffer, char[] 大小就是str.length + 16
        StringBuffer hello = new StringBuffer("hello");

    }
}

String和StringBuffer相互转换

在开发中，我们经常需要将String和StringBuffer进行转换

package www.xz.stringbuffer_;

/**
 * @author 许正
 * @version 1.0
 */
public class StringAndStringBuffer {
    public static void main(String[] args) {
        //String-->StringBuffer
        String str = "hello xz";
        //方式1  使用构造器
        //注意:  返回的才是 StringBuffer 对象，对 str 本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);

        //方式2  使用 append 方法
        StringBuffer stringBuffer1 = new StringBuffer();
        StringBuffer append = stringBuffer1.append(str);//可以得到一个append对象
        //或者直接返回给 stringBuffer1
//        stringBuffer1 = stringBuffer1.append(str);


        //StringBuffer-->String
        StringBuffer stringBuffer3 = new StringBuffer("许正学习java");
        //方式1使用StringBuffer提供的toString方法
        String s = stringBuffer3.toString();
        //方式2:使用构造器来搞定
        String s1 = new String(stringBuffer3);
    }
}

StringBuffer类常见方法

1. 增append
2. 删delete(start,end)
3. 改replace(start,end,string)//将star—end间的内容替换掉，不含end
4. 查indexOf //查找子串在字符串第1次出现的索引，如果找不到返回-1
5. 插 insert
6. 获取长度 length

StringBufferExercise

package www.xz.stringbuffer_;

import java.util.Scanner;

/**
 * @author 许正
 * @version 1.0
 */
public class StringBufferExercise {
    public static void main(String[] args) {
        /*
        输入商品名称和商品价格，要求打印效果示例，使用前面学习的方法完成:
        商品名
        商品价格
        手机123, 564.59 //比如价格3, 456, 789.88
        要求:价格的小数点前面每三位用逗号隔开，再输出。
        思路分析：
        1.定义一个Scanner 对象，接收用户输入的价格(String)
        2.希望使用到StringBuffer的 insert ，需要将String 转成StringBuffer
        3.然后使用相关方法进行字符串的处理
        代码实现
        */

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个想要格式化的数值：");
        String str = scanner.next();
        StringBuffer stringBuffer = new StringBuffer(str);
        //找到"."的位置并向前三位插入","
//        int i = stringBuffer.indexOf(".");
//        stringBuffer = stringBuffer.insert(i - 3, ",");
        for (int i = stringBuffer.indexOf(".") - 3; i > 0; i -= 3) {
            stringBuffer.insert(i, ",");
        }


        System.out.println(stringBuffer);
    }
}

StringBuilder类

基本介绍

1. 一个可变的字符序列。此类提供一个与 StringBuffer兼容的API,但不保证同
   步。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个
   线程使用的时候。如果可能，建议优先采用该类，因为在大多数实现中，它比
   StringBuffer要快。
2. 在StringBuilder上的主要操作是append和insert方法，可重载这些方法，
   以接受任意类型的数据。

StringBuilder类常见方法与StringBuffer是一样的

package www.xz.stringbuilder_;

/**
 * @author 许正
 * @version 1.0
 */
public class StringBuilder01 {
    public static void main(String[] args) {
        //1. StringBuilder 继承AbstractStringBuilder 类
        //2. 实现了Serializable , 说明StringBuilder对象是可以串行化(对象可以网络传输，可以保存到文件)
        //3. StringBuilder 是final类，不能被继承
        //4. StringBuilder 对象字符序列仍然是存放在其父类AbstractStringBuilder的 char[] value;
        //    因此，字符序列是放在堆中的
        //5. StringBuilder 的方法，没有做互斥的处理,即没有synchronized关键字，
        //    因此在单线程的情况下使用StringBuilder
        StringBuilder stringBuilder = new StringBuilder();
    }
}

String. StringBuffer 和StringBuilder的比较

1. StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
2. String:不可变字符序列，效率低,但是复用率高。
3. StringBuffer:可变字符序列、效率较高(增删)、线程安全
4. StringBuilder:可变字符序列、效率最高、线程不安全
5. String使用注意说明:
   string s=“a”; //创建了一个字符串
   S += “b”; //实际上原来的" a"字符串对象已经丢弃了，现在又产生了-一个字符
   串s+“b” (也就是" ab").如果多次执行这些改变串内容的操作，会导致大量副
   本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大
   影响程序的性能=>结论:如果我们对String做大量修改，不要使用String

String、StringBuffer 和StringBuilder的选择

使用的原则

1. 如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder

2. 如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder

3. 如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer

4. 如果我们字符串很少修改，被多个对象引用，使用String, 比如配置信息等

   StringBuilder的方法使用和StringBuffer一样