0055 String类、StringBuffer类和StringBuilder类

 

 

 

 

 

 

 

 

 

 

 

 

 

 

/*
    String类
    1.String对象用于保存字符串，也就是一组字符序列
    2.字符串常量对象是用""双引号括起的字符序列
    3.字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
    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);
        String s5 = new String(byte[] b)
    5.String类实现了接口Serializable （String可以串行化，可在网络传输）
      String类实现了接口Comparable (String可以比较大小)
    6.String是final类，不能被其他类继承
    7.String有属性private final char value[],用于存放字符串内容
    8.value是final类型，不可以修改（地址）：即value不能指向新地址，但字符内容可以变化

    创建String对象的两种方式
    1.直接赋值  String s = "huang";
        先从常量池查看是否有"huang"数据空间，如果有，直接指向
        如果没有则创建，然后指向，s最终指向常量池的空间地址
    2.调用构造器 String s2 = new String("huang");
        先在堆中创建空间，维护了value属性，指向常量池的huang空间
        如果常量池没有则创建，如果有就直接通过value指向，最终指向堆中的空间地址

    String使用注意：
    string s = "a";//创建了一个字符串
    s += "b";//实际上原来"a"字符串对象已丢弃，又产生了一个字符串"ab"
               若多次执行这样的操作，会导致大量副本字符串对象存留在内存中，降低效率
               如果放到循环中，会极大影响程序的性能
             所以，如果对String做大量修改，不要使用String

 */

/*
    String类的常见方法
    equals                  //区分大小写，判断内容是否相等
    equalsIgnoreCase        //忽略大小写，判断内容是否相等
    length                  //获取字符个数，字符串的长度
    indexOf                 //获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到返回-1
    lastIndexOf             //获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到返回-1
    substring               //截取指定范围的子串 substring(2,3)表示从索引2开始截取，到后面的索引3-1=2位置
    trim                    //去前后空格
    charAt                  //获取某索引处的字符，注意不能使用Str[index]
                            //  即String str = "hello";
                                    str[0]错误
                                    str.charAt(0)正确

    toUpperCase             //转换成大写
    toLowerCase             //转换成小写
    concat                  //拼接字符串
    replace                 //替换字符串中的字符     replace("被替换的内容","替换内容")
    split                   //分割字符串，对于某些分割字符，如果有特殊字符，需要转义 如|,\\等
    compare To              //比较两个字符串的大小
    toCharArray             //转换成字符数组
    format                  //格式字符串
                            //占位符：%d,%s,%.2f,%c
                            %s 表示后面由字符串来替换
                            %d 表示整数替换
                            %.2f 表示使用小数替换，保留2位小数，且进行四舍五入处理
                            %c 使用char类型替换
 */

/*  //判断正误
    String a = "abc";
    String b = "abc";
    System.out.println(a.equals(b));//True
    System.out.println(a == b);//True
    ================================================================================
    String a = "abc";
    String b = new String("abc");
    System.out.println(a.equals(b));//True
    System.out.println(a==b);//False
    System.out.println(a==b.intern());//True
    System.out.println(b==b.intern());//False
    //当调用intern方法时，如果池已经包含一个等于此String对象的字符串（用equals方法确定）
      则返回池中的字符串，否则将此String对象添加到池中，并返回此String对象的引用
    ================================================================================
    Person p1 = new Person();
    p1.name = "huang";
    Person p2 = new Person();
    p2.name = "huang";
    System.out.println(p1.name.equals(p2.name));//True
    System.out.println(p1.name == p2.name);//True,地址都指向huang
    System.out.println(p1.name == "huang");//True
 */
/*
      字符串的特性
    1.String是一个final类，代表不可变的字符序列
    2.字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的

    下列语句创建了几个对象？
    String s1 = "hello";
    s1 = "hi";
            //创建了2个对象

    String s2 = "he" + "llo";
            //创建了1个对象，等价于"hello"

    String s3 = "he";
    String s4 = "llo";
    String s = s3 + s4;  //不等价于 String s = "he" + "llo";
            //s3,s4都指向池，而s指向堆中的对象（String）value[],通过value指向池中的"hello"
            //创建了3个对象
            //重要规则:"a"+"b"常量相加，看池，s1+s2变量相加，看的是堆
    String str1 = "hello";
    String str2 = "he" + "llo"
    System.out.println(str1==s);//False,不是同一个对象
    System.out.println(str1==str2);//True

 */

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

    1.StringBuffer的直接父类是AbstractStringBuilder
    2.StringBuffer实现了Serializable，即StringBuffer对象可以串行化
    3.在父类中有属性char[] value,不是final，即value数组存放的字符串内容放在堆中
    4.StringBuffer是一个final类，不能被继承

    StringBuffer与String
    1.String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率低
    2.StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新无需每次更改地址（空间不够才更新），效率高

    StringBuffer的构造器
    1.StringBuffer（）
        构造一个其中不带字符的字符串缓冲区，初始容量为16个字符
    2.StringBuffer（CharSequence seq）
        构造一个字符串缓冲区，包含与指定的CharSequence相同的字符
    3.StringBuffer（int capacity）
        构造一个不带字符，但具有指定初始容量的字符串缓冲区，即对char[]大小进行指定
    4.StringBuffer（String str）
        构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容

        1.创建一个大小为16的char[]，用于存放字符
        StringBuffer stringBuffer = new StringBuffer();

        2.通过构造器指定char[]大小
        StringBuffer stringBuffer1 = new StringBuffer(100);

        3.通过给一个String创建StringBuffer,char[]大小为str.length() + 16
        StringBuffer hello = new StringBuffer("hello");

    StringBuffer类常用方法
    1.增 append
    2.删 delete（start，end）
    3.改 replace（start，end，string）//将start-end之间的内容替换，不含end
    4.查 indexOf //查找字串第一次出现的索引，找不到返回-1
    5.插 insert
    6.获取长度 length
 */
public class StringBuffer_ {
    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("hello");
        //增
        s.append(',');// "hello,"
        s.append("ja");//"hello,ja"
        s.append("ck").append(100).append(true).append(10.5);//"hello,jack100true10.5"
        System.out.println(s);
        //删
        s.delete(2, 5); //删除2~5的字符,从0开始，[3,5)
        System.out.println(s);//he,jack100true10.5
        //改
        s.replace(3,7,"jhon");
        System.out.println(s);//he,jhon100true10.5
        //查
        System.out.println(s.indexOf("jhon"));//3
        //插
        System.out.println(s.insert(7,","));//he,jhon,100true10.5
        //获取长度
        System.out.println(s.length());//19
    }
}
//  String与StringBuffer相互转换
class String_ {
    public static void main(String[] args) {
        //String转StringBuffer
        String str = "hello tom";
        //方式1 构造器
        StringBuffer stringBuffer1 = new StringBuffer(str);
        //方式2 append
        StringBuffer stringBuffer2 = new StringBuffer();
        stringBuffer2 = stringBuffer2.append(str);

        //StringBuffer转String
        StringBuffer stringBuffer = new StringBuffer("hi jack");
        //方式1 使用StringBuffer的toString方法
        String s1 = stringBuffer.toString();
        //方式2 构造器
        String s2 = new String(stringBuffer);
    }
}

//  练1
public class StringBufferExe {
    public static void main(String[] args) {
        String str = null;
        StringBuffer sb = new StringBuffer();
        sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull
        System.out.println(sb.length());//4
        System.out.println(sb);//null

        StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16);
        System.out.println(sb1);//即null.length()+16，抛出空指针异常
    }
}


//    练2：要求价格的小数点前面三位用逗号隔开
class Exe02{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个小数");
        String price = scanner.next();
        StringBuffer stringBuffer = new StringBuffer(price);
        //找到小数点的索引，在该位置的前三位插入逗号
//        int i = stringBuffer.lastIndexOf(".");
//        stringBuffer.insert(i - 3,",");
        //做成循环
        for(int i = stringBuffer.lastIndexOf(".") - 3;i > 0;i -= 3){
            stringBuffer.insert(i,",");
        }
        System.out.println(stringBuffer);
    }
}

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

    1.StringBuilder继承AbstractStringBuilder类
    2.实现了Serializable，说明StringBuilder对象可以串行化
    3.StringBuilder是final类，不能被继承
    4.StringBuilder对象字符序列仍然存放在其父类char[] value，字符序列在堆中
    5.StringBuilder的方法没有做互斥处理，即没有synchronized关键字，因此在单线程情况下使用

    StringBuilder常用方法
    与StringBuffer方法一致


    String、StringBuffer和StringBuilder的比较
    1.StringBuffer和StringBuilder非常类似，均代表可变的字符序列，方法也一致
    2.String:不可变字符序列，效率低，但复用率高
      StringBuffer:可变字符序列，效率较高，线程安全
      StringBuilder：可变字符序列，效率最高，线程不安全
 */
//  三者的效率测试
public class StringBuilder_ {
    public static void main(String[] args) {
        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 50000; i++) {//StringBuffer 拼接 50000 次
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer 的执行时间：" + (endTime - startTime));

        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 50000; i++) {//StringBuilder 拼接 50000 次
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder 的执行时间：" + (endTime - startTime));

        String text = "";
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 50000; i++) {//String 拼接 50000 次
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String 的执行时间：" + (endTime - startTime));
    }
}