Java之String、StringBuffer和StringBuilder相关方法和比较

String类

理解和创建对象

1.String对象用于保存字符串，也就是一组字符序列
2.字符串常量对象是用双引号括起的字符序列
3.字符串的字符使用Unicode编码，一个字符（不管字符还是汉字）占两个字节

public class String01 {
    public static void main(String[] args) {
        //1.String 类有很多构造器，构造器的重载
        // 常用的有 String  s1 = new String();
        //String s2 = new String(String original);
        //String s3 = new String(char[] a);
        //String s4 = new String(byte[] b);
        //2.String 类实现类接口 Serializable[String 可以串行化：可以在网络传输]
        //              接口 Comparable [String 对象可以比较大小]
        //3.String 是final 类，不能被其它的类继承
        //4.String 有属性 private final char value[]; 用于存放字符串内容
        //5.一定要注意：value 是一个final类型，不可以修改(即value不能指向新的地址，但是单该字符的内容是可以变化的)
        String name = "jack";
        name = "tom";
        final char[] value = {'a', 'b', 'c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';
        //不可以修改value的地址
        //value = v2;
    }
}

创建String对象的两种方式

方式一:直接赋值 String s = "hspedu";
方式二：调用构造器 String s = new String("hspedu");
1.方式一：先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有则程序创建，然后指向。s最终指向的是常量池的空间地址
2.方法二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

String题目

字符串的特性

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

上图：2个对象

上图：1个对象
分析
1.编译器不傻，做一个优化，判断创建的常量池对象，是否有引用指向
2.String a = “hello”+“abc”; => String a = “helloabc”;

难：

常用方法

说明：String类是保存字符串常量的，名称更新都需要重新开辟新的空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，并提高效率
1.equal：区分大小写，判断内容是否相等
2.equalslgnoreCase：忽略大小写的判断内容是否相等
3.length：获取字符的个数，字符串的长度
4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
5.lastIndexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
6.substring 截取指定访问的子串
7.charAt() 方法返回给定索引号处的字符

public class StringMethod01 {
    public static void main(String[] args) {
        //1.equals
        String str1 = "hello";
        String str2 = "Hello";
        System.out.println(str1.equals(str2));
        //2.equalsIgnoreCase 忽略大小写的判断内容是否相等
        String username = "johN";
        if("john".equalsIgnoreCase(username)){
            System.out.println("Success!");
        }else{
            System.out.println("Failure!");
        }
        //3.length 获取字符的个数，字符串的长度
        System.out.println("韩顺平".length());
        //4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
        String s1 = "wer@terwe@g";
        int index = s1.indexOf('@');
        System.out.println(index);
        System.out.println("we的位置=" + s1.indexOf("we"));
        //5.lastIndexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1
        s1 = "wer@terwe@g";
        index = s1.lastIndexOf('@');
        System.out.println(index);
        System.out.println("ter的位置=" + s1.lastIndexOf("ter"));
        //6.substring 截取指定访问的子串
        String name = "hello,张三";
        //下面name.substring(6)表示从索引6开始截取后面所有的内容
        System.out.println(name.substring(6));
        //name.substring(0,5)表示从索引0开始，截取到索引5-1=4的位置(左闭右开)
        System.out.println(name.substring(2,5));
        //7.Java 中String 类的 charAt() 方法返回给定索引号处的 char 值。 索引号从 0 开始到 n-1，其中 n 是字符串的长度。
        //如果给定的索引号大于或等于此字符串长度或负数，则返回 StringIndexOutOfBoundsException。
        String str = "Welcome";
        System.out.println("Character at 0 index is: "+ str.charAt(0));
    }
}

8.toUpperCase 转换大小写,小变大
9.toLowerCase转换大小写,大变小
10.concat 拼接字符串
11.replace 替换字符串中的字符
12.split 分割字符串
13.toCharArray 转换成字符数组
14.compareTo 比较两个字符串的大小
15.format 格式化字符串(类似c语言printf)

public class StringMethod02 {
    public static void main(String[] args) {
        //1.toUpperCase 转换大小写,小变大
        String s = "hello";
        System.out.println(s.toUpperCase());
        //2.toLowerCase转换大小写,大变小
        System.out.println(s.toLowerCase());
        //3.concat 拼接字符串
        String s1 = "宝玉";
        s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together");
        System.out.println(s1);//宝玉林黛玉薛宝钗together
        //4.replace 替换字符串中的字符
        s1 = "宝玉 and 林黛玉 薛宝钗 薛宝钗";
        //在s1中，将 所有的 林黛玉 替换成 薛宝钗
        //s1.replace() 方法执行后，返回的结果才是替换过的
        //注意对s1没有任何影响，除非s1 = s1.replace()
        s1 = s1.replace("林黛玉","薛宝钗");
        System.out.println(s1);
        //5.split 分割字符串，对于某些分割字符，需要 转义比如 ｜ \\等
        String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        //以 ， 为标准对poem进行分割，返回一个数组
        String [] split = poem.split(",");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        poem = "E:\\aaa\\bbb";
        split = poem.split("\\\\");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
        //6.toCharArray 转换成字符数组
        s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }
        //7.compareTo 比较两个字符串的大小，如果前者大，
        //则返回正数，后者大，则返回负数，如果相等，返回0；
        //(1)如果长度相同，并且每个字符都相同，则返回0
        //(2)如果长度相同或者不相同，但是在进行比较时，可以区分大小
        //    就返回 if(c1 != c2){
        //              return c1 - c2;
        //          }
        //(3)如果前面都部分源码相同，就返回 str1.len - str2.len
        String a = "jcck";
        String b = "jack";
        System.out.println(a.compareTo(b));
        //8.format 格式化字符串(类似c语言printf)
        //1. %s,%d,%.2f,%c 称为占位符
        //2.这些占位符由后面变量来替换
        String name = "john";
        int age = 10;
        double score = 98.3/3;
        char gender = '男';
        //将所有都信息都拼接在一个字符串
        String info2 = String.format("为都姓名是%s 年龄是%d,成绩是%.2f 性别是%c.希望大家喜欢我",name,age,score,gender);
        System.out.println("info=" + info2);
    }
}

StringBuffer类

基本介绍

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

String VS StringBuffer

1.string保存的是字符串常量，类名的值不能更改，名称string类的更新实际上说更改地址，效率较低//private final char value[]
2.StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用每次更新地址，效率较高//这个放在堆

StringBuffer转换

注：不同的jdk版本有所不同

public class StringBuffer02 {
    public static void main(String[] args) {

        //构造器的使用
        StringBuffer stringBuffer = new StringBuffer();
        //通过构造器指定大小
        StringBuffer stringBuffer1 = new StringBuffer(100);
        //3.提供给一个String创建StringBuffer
        StringBuffer hello = new StringBuffer("hello");
    }
}

两者相互转换

public class StringAndStringBuffer {
    public static void main(String[] args) {

        //String->StringBuffer
        String str = "hello tom";
        //方法1 使用构造器
        //注意：返回的才是StringBuffer对象，对str本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);

        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);

        //StringBuffer->String
        StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
        //方式1 使用StringBuffer提供对 toString方法
        String s = stringBuffer3.toString();
        //方式2 使用构造器来搞定
        String s1 = new String(stringBuffer3);

    }
}

常用方法

1.append增
2.delete删(左闭右开)
3.改(左闭右开)
4.index查：查找指定的子串在字符串第一次1出现的索引，如果找不到返回-1
5.insert插
6.length长度

public class StringBufferMethod {
    public static void main(String[] args) {

        StringBuffer s = new StringBuffer("hello");
        //增
        s.append(',');
        s.append("张三丰");
        s.append("赵敏").append(100).append(true).append(10.5);
        System.out.println(s);//hello,张三丰赵敏100true10.5

        //删(左闭右开)
        s.delete(11,14);
        System.out.println(s);//hello,张三丰赵敏true10.5

        //改(左闭右开)
        //使用周芷若替换索引9-11的字符
        s.replace(9,11,"周芷若");
        System.out.println(s);//hello,张三丰周芷若true10.5

        //查找指定的子串在字符串第一次1出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);//6

        //插
        //在索引为9的位置插入"赵敏"，原来索引为9的内容自动后移
        s.insert(9,"赵敏");
        System.out.println(s);//hello,张三丰赵敏周芷若true10.5

        //长度
        System.out.println(s.length());//22
        System.out.println(s);
    }
}

�StringBuilder类

基本介绍

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

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();
    }
}

三者对比

比较

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

效率测试

效率：StringBuilder>StringBuffer>String

使用选择

1.如果字符串存在大量的修改操作
(1)在单线程的情况：StringBuilder
(2)在多线程的情况：StringBuffer
2.字符串很少修改，被多个对象引用，使用String，比如配置信息等

注：StringBuilder的方法使用和StringBuffer一样