字符串操作

String的创建

String的创建方式有一下集中：
1. 直接使用“”创建
2. 直接使用new String()创建
3. 使用new String("sth")创建以及其他的一些重载的函数创建
4. 使用重载的字符串连接符"+"进行创建。

其中，方式1

String s = "hello";

JVM首先会根据内容”hello”查找对象，如果没有找到，则在heap上创建新对象，并将其赋予s1,否则使用已经存在的对象。
方式2

String s = new String(“hello”);

JVM直接咋heap上创建新的对象，所以在heap中会出现内容相同而地址不同的String对象。
并且，这种方式会创建出两个对象出来。

方式4

String str ="a" + "b" + "c" + "d";

上面的代码只会创建出一个对象，”a”、“b”等由于都是常亮，因此他们存在与常量池中，不会去创建新的对象，因此就只会创建出最后的对象"acbd".

String对象的比较

==是比较地址，equals是比较内容。

public static void main(String[] args) {        String s1 ="hello";        String s2 = "hello";        String s3 = new String("hello");        System.out.println(s1==s2);//true        System.out.println(s1==s3);//false        System.out.println(s1.equals(s2));//true        System.out.println(s1.equals(s3));//true    }

intern()方法

查找相同内容(equals())的字符串，举例如下：

    public static void main(String[] args) {        String s1 = "hello";        String s2 = new String("hello");        System.out.println(s1 == s2);//true        System.out.println(s1.equals(s2));//true        s2 = s2.intern();//找到内容相同的对象，此时只有s1，因此将s1赋给s2        System.out.println(s1 == s2);//true    }

程序的执行结果如下：

String和StringBuffer

例子1：

public static void main(String[] args) {        long start  = System.nanoTime();        for(int i=0;i<100000;i++){            StringBuffer result2 = new StringBuffer().append("hello").append("world");        }        System.out.println(System.nanoTime()-start);        start  = System.nanoTime();        for(int i=0;i<100000;i++){            String result1 = "hello" + "world";        }        System.out.println(System.nanoTime()-start);    }

程序的运行时间如下
可以发现：
使用”+”的形式，效率会更好，因为JVM会进行如下处理：

• 将result1字符串进行“hello” + “world”处理，然后才赋值给result。只开辟了一次内存段。
• 编译StringBuffer后还要进行append处理，花的时间要长一些。

另外String 、StringBuffer、StringBuilder三者的效率对比如下：

实例2：

public static void main(String[] args) {        STRClass strTest = new STRClass();        long start  = System.nanoTime();        for(int i=0;i<10000;i++){            strTest.getString1("hello","world");        }        System.out.println(System.nanoTime()-start);        start  = System.nanoTime();        for(int i=0;i<10000;i++){            strTest.getString1("hello","world");        }        System.out.println(System.nanoTime()-start);    }    public String getString1(String s1, String s2) {        return s1+s2;    }    public String getString2(String s1, String s2) {        return String.valueOf(new StringBuffer().append(s1).append(s2));    }

程序的执行结果是：

从上面的运行结果可以看到，两者的效率基本上是差不多

StringBuffer常见的问题:
（1）不要认为.append()操作的效率优于”+”
（2）不要使用new 创建String
（3）注意.intern()的使用
（4）在编译期间能够确定字符串值的情况下，使用"+"效率最高。
（5）避免使用”+=”来构造字符串。
（6）在声明StringBuffer对象的时候，制定合适的capacity，不要使用默认的值。
（7）注意以下二者的区别，后者开辟了两个内存段。

 String s = "a"  +  "b"; String s = "a";           s += "b";

示例3：

package com.company;/** * Created by shugen on 17-3-4. */public class HowManyClassWillCreate {    public static void main(String[] args) {        String A, B, C;        A = "a";//将会创建一个对象“a”,A是一个引用变量        B = "b";//同A一样        A= A + B;//此处床架了一个新的对象，由A重新引用        StringBuffer D = new StringBuffer("abc");//这里将会创建两个变量"abc"和D（D是new出来的）        D.append("def");//"def"又是一个对象    }}

上面的程序将会创建5个对象。

有一下几个需要说明的问题：

引用变量和对象的区别。

A a;

上面的语句创建的是一个引用变量，而对象的创建是通过new关键字来进行创建的，示例如下：

A a = new A();

Java中的字符串文字的说明

java中的所有的字符串文字都是一个String的对象。
因此，下面的代码先是创建了一个引用变量A，再创建了一个字符串对象"a"

String A;A = "a";

Java字符串对象的创建。

由于字符串对象的大量使用，Java为了节省内存空间和运行时间，再编译阶段就把所有的字符串文字放到了poll of literal strings中，也就是常量池的一部分。字符串池的好处就是池中的所有相同的字符串常量将会被何必，从而只占用一个空间。