本文主要是介绍探索Java中的String、StringBuilder以及StringBuffer，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 前言
• 一、String 类
• 二、 StringBuffer
• 三、StringBuilder
• 四、常用方法
• • String 常用方法
  • StringBuffer 常用方法
  • StringBuilder 常用方法
• 总结

前言

相信String这个类是Java中使用得最频繁的类之一，并且又是各大公司面试喜欢问到的地方，今天就来和大家一起学习一下String、StringBuilder和StringBuffer这几个类，分析它们的异同点以及了解各个类适用的场景

一、String 类

• String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且大量浪费有限的内存空间。
• 部分源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
......

• 从上面可以看出几点：

• String类是final类，也即意味着String类不能被继承，并且它的成员方法都默认为final方法。在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法。在确定不想让该方法被覆盖时，才将方法设置为final。

• 部分方法源码

    public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

    public String concat(String str) {
        int otherLen = str.length();
        if (otherLen == 0) {
            return this;
        }
        int len = value.length;
        char buf[] = Arrays.copyOf(value, len + otherLen);
        str.getChars(buf, len);
        return new String(buf, true);
    }

    public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

• 从上面的三个方法可以看出，无论是substring操作、concat还是replace操作都不是在原有的字符串上进行的，而是重新生成了一个新的字符串对象。也就是说进行这些操作后，最原始的字符串并没有被改变。
• 再次强调对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象。

二、 StringBuffer

• StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。
• 每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。

StringBuffer buf=new StringBuffer(); //分配长16字节的字符缓冲区
StringBuffer buf=new StringBuffer(512); //分配长512字节的字符缓冲区
StringBuffer buf=new StringBuffer("this is a test")//在缓冲区中存放了字符串，并在后面预留了16字节的空缓冲区

• 部分源码：

public StringBuffer() {
        super(16);
    }

   public StringBuffer(int capacity) {
        super(capacity);
    }
       public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }

• 部分方法源码

    public synchronized String substring(int start) {
        return substring(start, count);
    }

    public synchronized StringBuffer replace(int start, int end, String str) {
        toStringCache = null;
        super.replace(start, end, str);
        return this;
    }
    public synchronized String substring(int start, int end) {
        return super.substring(start, end);
    }

• 从上面的方法可以看出，无论是substring 操作还是replace操作都是在原有的字符串上进行的，且都有synchronized 是线程安全的，但也因没有synchronized 导致性能比StringBuffer高。

三、StringBuilder

• StringBuilder是可变类，线程不安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。
• 每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量。

StringBuilder buf=new StringBuilder(); //分配长16字节的字符缓冲区
StringBuilder buf=new StringBuilder(512); //分配长512字节的字符缓冲区
StringBuilder buf=new StringBuilder("this is a test")//在缓冲区中存放了字符串，并在后面预留了16字节的空缓冲区

• 部分源码：

  public StringBuilder() {
        super(16);
    }
    public StringBuilder(int capacity) {
        super(capacity);
    }

    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

• 部分方法源码

    public StringBuilder replace(int start, int end, String str) {
        super.replace(start, end, str);
        return this;
    }
    

• 从上面的方法可以看出，replace操作都是在原有的字符串上进行的，且没有synchronized 是线程不安全的，但也因没有synchronized 导致性能比。

四、常用方法

String 常用方法

//length（）字符串的长度
String a = "Hello Word!";
System.out.println(a.length);
//输出的结果是字符串长度10。 

// charAt（）截取一个字符
String a = "Hello Word";
System.out.println(a.charAt(1));
//输出的结果是字符串a的下标为1的字符e。

// getchars（）截取多个字符并由其他字符串接收
String a = "Hello Word";
char[] b = new char[10];
a.getChars(0, 5, b, 0);
System.out.println(b);
//输出的结果为Hello，其中第一个参数0是要截取的字符串的初始下标（int sourceStart），
//第二个参数5是要截取的字符串的结束后的下一个下标（int sourceEnd）也就是实际截取到的下标是int sourceEnd-1，
//第三个参数是接收的字符串（char target[]），最后一个参数是接收的字符串开始接收的位置。

//getBytes()将字符串变成一个byte数组
String a = "Hello Word";
byte b[] = a.getBytes();
System.out.println(new String(b));
//输出的结果为Hello Word的byte数组。 

// toCharArray()将字符串变成一个字符数组
String a = "Hello Word";
char[]b = a.toCharArray();
System.out.println(b);  
//输出的结果为Hello Word字符数组。

// equals()和equalsIgnoreCase()比较两个字符串是否相等，前者区分大小写，后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.equals(b));
System.out.println(a.equalsIgnoreCase(b));  
//输出的结果为第一条为false，第二条为true。

// startsWith()和endsWith()判断字符串是不是以特定的字符开头或结束
String a = "Hello Word";
System.out.println(a.startsWith("ee"));  
System.out.println(a.endsWith("rd"));
//输出的结果第一条为false，第二条为true。

// toUpperCase()和toLowerCase()将字符串转换为大写或小写
String a = "Hello Word";
System.out.println(a.toUpperCase());
System.out.println(a.toLowerCase());
//输出的结果第一条为“HELLO WORD”，第二条为“hello word”。

// concat() 连接两个字符串
String a = "Hello Word";
String b = "你好";
System.out.println(b.concat(a));
//输出的结果为“你好Hello Word”。

// trim()去掉起始和结束的空格
String a = "    Hello Word   ";
System.out.println(a.trim());
//输出的结果为“Hello Word”。

//substring（）截取字符串
String a = "Hello Word";
System.out.println(a.substring(0, 5));
System.out.println(a.substring(6));
//输出的结果第一条为“Hello”,第一个参数0（beginIndex）是开始截取的位置，
//第二个参数5（endIndex）是截取结束的位置，输出的结果第二条是“Word”，参数6（beginIndex）是开始截取的位置。

//indexOf()和lastIndexOf()前者是查找字符或字符串第一次出现的地方，后者是查找字符或字符串最后一次出现的地方
String a = "Hello Word";
System.out.println(a.indexOf("o"));
System.out.println(a.lastIndexOf("o"));
//输出的结果第一条是4，是o第一次出现的下标，第二条是7，是o最后一次出现的下标。

//compareTo()和compareToIgnoreCase(）按字典顺序比较两个字符串的大小，前者区分大小写，后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.compareTo(b));
System.out.println(a.compareToIgnoreCase(b)); 
//输出的结果第一条为-32，第二条为0，两个字符串在字典顺序中大小相同，返回0。

// replace() 替换
String a = "Hello Word";
String b = "你好";
System.out.println(a.replace(a, b));
System.out.println(a.replace(a, "HELLO WORD"));
System.out.println(b.replace("你", "大家"));
//输出的结果第一条为“你好”，第二条为“HELLO WORD”，第三条为“大家好”。

StringBuffer 常用方法

StringBuffer tmp = new StringBuffer("cba");

//append(String s)：将指定的字符串追加到此字符序列。
System.out.println("append():\t" + tmp.append("|append(a)"));

//Reverse()：将此字符序列用其反转形式取代。
System.out.println("reverse():\t" + tmp.reverse());

//delete(int start, int end)：移除此序列的子字符串中的字符。
System.out.println("delete():\t" + tmp.delete(0, 3));

//insert(int offset, int i)：将 int 参数的字符串表示形式插入此序列中。
System.out.println("insert():\t" + tmp.insert(0, "|insert|"));

//replace(int start, int end, String str)：使用给定 String 中的字符替换此序列的子字符串中的字符。
System.out.println("replace():\t" + tmp.replace(0, 2, "(a)")); 

StringBuilder 常用方法

• 与StringBuffer类似

总结

• 一般情况下,速度从快到慢:StringBuilder>StringBuffer>String,这种比较是相对的，不是绝对的。
• 如果要操作少量的数据用 String
• 单线程操作字符串缓冲区 下操作大量数据 StringBuilder
• 多线程操作字符串缓冲区 下操作大量数据 StringBuffer

这篇关于探索Java中的String、StringBuilder以及StringBuffer的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！