String基础

Java String 类

字符串广泛应用在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

创建字符串

创建字符串最简单的方式如下:

String greeting = "菜鸟教程";

在代码中遇到字符串常量时，这里的值是 "菜鸟教程""，编译器会使用该值创建一个 String 对象。

和其它对象一样，可以使用关键字和构造方法来创建 String 对象。

String 类有 11 种构造方法，这些方法提供不同的参数来初始化字符串，比如提供一个字符数组参数:

StringDemo.java 文件代码：

public class StringDemo{    
    public static void main(String args[]){       
        char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};       
        String helloString = new String(helloArray);         
        System.out.println( helloString );    
    } 
}

以上实例编译运行结果如下：

runoob复制代码

注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了（详看笔记部分解析）。

如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

String基本用法

创建String对象的常用方法

（1） String s1 = "mpptest"

(2) String s2 = new String();

(3) String s3 = new String("mpptest")

String中常用的方法，用法如图所示，具体问度娘

三个方法的使用： lenth() substring() charAt()

package com.mpp.string; 
public class StringDemo1 { 
    public static void main(String[] args) { 
        //定义一个字符串"晚来天欲雪 能饮一杯无"
        String str = "晚来天欲雪 能饮一杯无";
        System.out.println("字符串的长度是："+str.length()); 
        //字符串的雪字打印输出  charAt(int index)
        System.out.println(str.charAt(4)); 
        //取出子串  天欲
        System.out.println(str.substring(2));   
        //取出从index2开始直到最后的子串，包含2
        System.out.println(str.substring(2,4));  
        //取出index从2到4的子串，包含2不包含4  顾头不顾尾
    }
}

两个方法的使用,求字符或子串第一次/最后一次在字符串中出现的位置： indexOf() lastIndexOf()

package com.mpp.string; 
public class StringDemo2 { 
    public static void main(String[] args) {
        String str = new String("赵客缦胡缨 吴钩胡缨霜雪明"); 
        //查找胡在字符串中第一次出现的位置
        System.out.println(""胡"在字符串中第一次出现的位置："+str.indexOf("胡")); 
        //查找子串"胡缨"在字符串中第一次出现的位置
        System.out.println(""胡缨"在字符串中第一次出现的位置"+str.indexOf("胡缨")); 
        //查找胡在字符串中最后一次次出现的位置
        System.out.println(str.lastIndexOf("胡")); 
        //查找子串"胡缨"在字符串中最后一次出现的位置
        System.out.println(str.lastIndexOf("胡缨")); 
        //从indexof为5的位置，找第一次出现的"吴"
        System.out.println(str.indexOf("吴",5));
    }
}

字符串与byte数组间的相互转换

package com.mpp.string; 
import java.io.UnsupportedEncodingException; 
public class StringDemo3 { 
    public static void main(String[] args) throws UnsupportedEncodingException { 
        //字符串和byte数组之间的相互转换
        String str = new String("hhhabc银鞍照白马 飒沓如流星"); 
        //将字符串转换为byte数组，并打印输出
        byte[] arrs = str.getBytes("GBK"); 
        for(int i=0;i){
            System.out.print(arrs[i]);
        } 
        //将byte数组转换成字符串
        System.out.println();
        String str1 = new String(arrs,"GBK");  
        //保持字符集的一致，否则会出现乱码
        System.out.println(str1);
    }
}

==运算符和equals之间的区别：

引用指向的内容和引用指向的地址

package com.mpp.string; public class StringDemo5 { public static void main(String[] args) {String str1 = "mpp";String str2 = "mpp";String str3 = new String("mpp");
    System.out.println(str1.equals(str2)); //true  内容相同
    System.out.println(str1.equals(str3));   //true  内容相同
    System.out.println(str1==str2);   //true   地址相同
    System.out.println(str1==str3);   //false  地址不同复制代码

}}

字符串的不可变性

String的对象一旦被创建，则不能修改，是不可变的

所谓的修改其实是创建了新的对象，所指向的内存空间不变

上图中，s1不再指向imooc所在的内存空间，而是指向了hello,imooc

String的连接

@Test
public void contact () {
    //1连接方式
    String s1 = "a";
    String s2 = "a";
    String s3 = "a" + s2;
    String s4 = "a" + "a";
    String s5 = s1 + s2;
    //表达式只有常量时，编译期完成计算
    //表达式有变量时，运行期才计算，所以地址不一样
    System.out.println(s3 == s4); //f
    System.out.println(s3 == s5); //f
    System.out.println(s4 == "aa"); //t

}复制代码

String、String builder和String buffer的区别

String是Java中基础且重要的类，并且String也是Immutable类的典型实现，被声明为final class，除了hash这个属性其它属性都声明为final,因为它的不可变性，所以例如拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。

StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append和add方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上了synchronized。但是保证了线程安全是需要性能的代价的。

在很多情况下我们的字符串拼接操作不需要线程安全，这时候StringBuilder登场了，StringBuilder是JDK1.5发布的，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。

StringBuffer 和 StringBuilder 二者都继承了 AbstractStringBuilder ，底层都是利用可修改的char数组(JDK 9 以后是 byte数组)。

所以如果我们有大量的字符串拼接，如果能预知大小的话最好在new StringBuffer 或者StringBuilder 的时候设置好capacity，避免多次扩容的开销。扩容要抛弃原有数组，还要进行数组拷贝创建新的数组。

我们平日开发通常情况下少量的字符串拼接其实没太必要担心，例如

String str = "aa"+"bb"+"cc";

像这种没有变量的字符串，编译阶段就直接合成"aabbcc"了，然后看字符串常量池（下面会说到常量池）里有没有，有也直接引用，没有就在常量池中生成，返回引用。

如果是带变量的，其实影响也不大，JVM会帮我们优化了。

1、在字符串不经常发生变化的业务场景优先使用String(代码更清晰简洁)。如常量的声明，少量的字符串操作(拼接，删除等)。

2、在单线程情况下，如有大量的字符串操作情况，应该使用StringBuilder来操作字符串。不能使用String"+"来拼接而是使用，避免产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。如JSON的封装等。

3、在多线程情况下，如有大量的字符串操作情况，应该使用StringBuffer。如HTTP参数解析和封装等。

String类的源码分析

String类型的intern

public void intern () {
    //2：string的intern使用
    //s1是基本类型，比较值。s2是string实例，比较实例地址
    //字符串类型用equals方法比较时只会比较值
    String s1 = "a";
    String s2 = new String("a");
    //调用intern时,如果s2中的字符不在常量池，则加入常量池并返回常量的引用
    String s3 = s2.intern();
    System.out.println(s1 == s2); //false
    System.out.println(s1 == s3);  //true
}复制代码

String类型的equals

//字符串的equals方法
//    public boolean equals(Object anObject) {
//            if (this == anObject) {
//                return true;
//            }
//            if (anObject instanceof String) {
//                String anotherString = (String)anObject;
//                int n = value.length;
//                if (n == anotherString.value.length) {
//                    char v1[] = value;
//                    char v2[] = anotherString.value;
//                    int i = 0;
//                    while (n-- != 0) {
//                        if (v1[i] != v2[i])
//                            return false;
//                        i++;
//                    }
//                    return true;
//                }
//            }
//            return false;
//        }复制代码

StringBuffer和Stringbuilder

底层是继承父类的可变字符数组value

/**

- The value is used for character storage.
  */
  char[] value;
  初始化容量为16

/**

- Constructs a string builder with no characters in it and an
- initial capacity of 16 characters.
  */
  public StringBuilder() {
  super(16);
  }
  这两个类的append方法都是来自父类AbstractStringBuilder的方法

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}
@Override
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}复制代码

append方法

Stringbuffer在大部分涉及字符串修改的操作上加了synchronized关键字来保证线程安全，效率较低。

String类型在使用 + 运算符例如

String a = "a"

a = a + a;时，实际上先把a封装成stringbuilder，调用append方法后再用tostring返回，所以当大量使用字符串加法时，会大量地生成stringbuilder实例，这是十分浪费的，这种时候应该用stringbuilder来代替string。

扩容

注意在append方法中调用到了一个函数

ensureCapacityInternal(count + len);该方法是计算append之后的空间是否足够，不足的话需要进行扩容

public void ensureCapacity(int minimumCapacity) {
    if (minimumCapacity > 0)
        ensureCapacityInternal(minimumCapacity);
}
private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
                newCapacity(minimumCapacity));
    }
}复制代码

如果新字符串长度大于value数组长度则进行扩容

扩容后的长度一般为原来的两倍 + 2；

假如扩容后的长度超过了jvm支持的最大数组长度MAX

ARRAY

SIZE。

考虑两种情况

如果新的字符串长度超过int最大值，则抛出异常，否则直接使用数组最大长度作为新数组的长度。

private int hugeCapacity(int minCapacity) {
    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
        throw new OutOfMemoryError();
    }
    return (minCapacity > MAX_ARRAY_SIZE)
        ? minCapacity : MAX_ARRAY_SIZE;
}
复制代码

删除

这两个类型的删除操作：

都是调用父类的delete方法进行删除

public AbstractStringBuilder delete(int start, int end) {
    if (start < 0)
        throw new StringIndexOutOfBoundsException(start);
    if (end > count)
        end = count;
    if (start > end)
        throw new StringIndexOutOfBoundsException();
    int len = end - start;
    if (len > 0) {
        System.arraycopy(value, start+len, value, start, count-end);
        count -= len;
    }
    return this;
}
复制代码

事实上是将剩余的字符重新拷贝到字符数组value。

这里用到了system.arraycopy来拷贝数组，速度是比较快的

system.arraycopy方法

转自知乎：

在主流高性能的JVM上（HotSpot VM系、IBM J9 VM系、JRockit系等等），可以认为System.arraycopy()在拷贝数组时是可靠高效的——如果发现不够高效的情况，请报告performance bug，肯定很快就会得到改进。

java.lang.System.arraycopy()方法在Java代码里声明为一个native方法。所以最naïve的实现方式就是通过JNI调用JVM里的native代码来实现。

String的不可变性

关于String的不可变性，这里转一个不错的回答

什么是不可变？

String不可变很简单，如下图，给一个已有字符串"abcd"第二次赋值成"abcedl"，不是在原内存地址上修改数据，而是重新指向一个新对象，新地址。

String和JVM的关系

下面我们了解下Java栈、Java堆、方法区和常量池：

Java栈（线程私有数据区）：

    每个Java虚拟机线程都有自己的Java虚拟机栈，Java虚拟机栈用来存放栈帧，每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。
复制代码

Java堆（线程共享数据区）：

   在虚拟机启动时创建，此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配。
复制代码

方法区（线程共享数据区）：

   方法区在虚拟机启动的时候被创建，它存储了每一个类的结构信息，例如运行时常量池、字段和方法数据、构造函数和普通方法的字节码内容、还包括在类、实例、接口初始化时用到的特殊方法。在JDK8之前永久代是方法区的一种实现，而JDK8元空间替代了永久代，永久代被移除，也可以理解为元空间是方法区的一种实现。
复制代码

常量池（线程共享数据区）：

    常量池常被分为两大类：静态常量池和运行时常量池。

    静态常量池也就是Class文件中的常量池，存在于Class文件中。

    运行时常量池（Runtime Constant Pool）是方法区的一部分，存放一些运行时常量数据。
复制代码

下面重点了解的是字符串常量池：

    字符串常量池存在运行时常量池之中（在JDK7之前存在运行时常量池之中，在JDK7已经将其转移到堆中）。

    字符串常量池的存在使JVM提高了性能和减少了内存开销。

    使用字符串常量池，每当我们使用字面量（String s=”1”;）创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就将此字符串对象的地址赋值给引用s（引用s在Java栈中）。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，并将此字符串对象的地址赋值给引用s（引用s在Java栈中）。
复制代码

    使用字符串常量池，每当我们使用关键字new（String s=new String(”1”);）创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么不再在字符串常量池创建该字符串对象，而直接堆中复制该对象的副本，然后将堆中对象的地址赋值给引用s，如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中，然后在堆中复制该对象的副本，然后将堆中对象的地址赋值给引用s。
复制代码

Java基础4-一文搞懂String常见面试题，从基础到实战，更有原理分析和源码解析！（二）：https://developer.aliyun.com/article/1535632

Java基础4-一文搞懂String常见面试题，从基础到实战，更有原理分析和源码解析！（一）