package com.test;

import java.util.Date;

/***
*
*
// 输出的结果是：
// 来一个测试
// 来一个测试如果只输出这句就证明了String是不可变的
// 上边的代码证明了String是不可变的，因此像concat这样操作执行的结果是值存储在了新的对象中。
* @author Administrator
*
*/
public class StringTest {
public static void main(String[] args) {


/* 通俗易懂的说法：
String、StringBuffer和StringBuilder之间最大的区别是String是不可变的对象，而StringBuffer和StringBuilder是可变对象。不可变的意思是【不可变的机制和好处】存储在对象中的值是不变的，下一个问题是：“如果对象是不可变的那么当我想改变对象的内容的时候怎么去更改呢？”准确的说更改后的String对象和更改前的String对象并不是同一个对象。
假设你声明了下边一个String对象：
[java] view plaincopy
String myString = "hello";
下一步你想在同一个String对象里添加“Guest”，你怎么做呢
[java] view plaincopy
myString = myString + ” Guest”;

当你打印myString的内容的时候输出的是“Hello Guest”.尽管我们使用的是同一个对象（mySting），在内部却是创建了新的对象，所以，如果对String做类似的操作，比如append、trim等修改String对象的，你实际就是创建了String的新对象。
现在的问题是，这样会导致性能问题吗，答案是肯定的。那么如何使String操作更有效率呢，那就是通过使用StringBuffer和StringBuilder。
因为StringBuffer和StringBuilder对象是可变的，我们可以对存储在对象中的一些值做些改变。这里的有效的意思是和String相比使用StringBuffer和StringBuilder在一些像append等操作上会更有效。
那么StringBuffer和StringBuilder之间又有什么区别呢？
StringBuffer和StringBuilder有着相同的方法，但是StringBuffer是同步的而StringBuilder不是同步的，所以如果你不想使用线程那么使用StringBuilder会更有效（因为这少了同步的开支）。
怎么使用StringBuilder：
*/
String s = "来一个测试";
s.concat("如果是同一个对象，这句话要输出！");
System.out.println(s);
s = s.concat("如果只输出这句就证明了String是不可变的");
System.out.println(s);

System.out.println("========================");

StringBuilder sb = new StringBuilder("Hello");
sb.append("Hello");
System.out.println("sb == :"+sb);
System.out.println("========================");

String ss = "Hello";
ss = ss + "Hello";
System.out.println("ss == :"+ss);
System.out.println("========================");

// 那么StringBuffer和StringBuilder之间又有什么区别呢？
// StringBuffer和StringBuilder有着相同的方法，
// 但是StringBuffer是同步的而StringBuilder不是同步的，
// 所以如果你不想使用线程那么使用StringBuilder会更有效（因为这少了同步的开支）

StringBuilder sbf2 = new StringBuilder();
Date beginTime2 = new Date();
System.out.println("开始时间："+beginTime2);
for(int i=0;i<100000;i++)
{
sbf2.append(i);
}
Date endTime2 = new Date();
System.out.println("结束时间："+endTime2);
System.out.println("花费时间为 ： "+ (endTime2.getTime()-beginTime2.getTime()));

System.out.println("================StringBuilder ========================");

// 接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。
StringBuffer sbf = new StringBuffer();
Date beginTime = new Date();
System.out.println("开始时间："+beginTime);
for(int i=0;i<100000;i++)
{
sbf.append(i);
}
Date endTime = new Date();
System.out.println("结束时间："+endTime);
System.out.println("花费时间为 ： "+ (endTime.getTime()-beginTime.getTime()));

System.out.println("================StringBuffer ========================");

// 上面代码的效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。

String str = new String();
Date beginTime1 = new Date();
System.out.println("开始时间："+beginTime1);
for(int i=0;i<100000;i++)
{
str = str + i;
}
Date endTime1 = new Date();
System.out.println("结束时间："+endTime1);
System.out.println("花费时间为 ： "+ (endTime1.getTime()-beginTime1.getTime()));
System.out.println("================String ========================");

// 在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，



// String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，

// StringBuilder与StringBuffer的区别
// 1. 在执行速度方面的比较：StringBuilder > StringBuffer
// 2. StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，
// 实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快了。
// 3. StringBuilder：线程非安全的
// 　 StringBuffer：线程安全的
// 当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。
// 当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。
//
// 对于三者使用的总结：1.如果要操作少量的数据用 = String
// 　　　　　　 2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
// 　　　　　　 3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
// StringBuffer与StringBuilder的区别主要是前者是线程安全的，就是说它是同步的；后者不安全，不是同步的，其它的区别不大。当你的程序不需要线程同步，一般都用StringBuilder.

/* 1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String

　　2.String <（StringBuffer，StringBuilder）的原因

　　　　String：字符串常量

　　　　StringBuffer：字符创变量

　　　　StringBuilder：字符创变量

　　　　从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问 ，比如这段代码：

1 String s = "abcd";
2 s = s+1;
3 System.out.print(s);// result : abcd1

　　　 我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来　　　　执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

　　　 而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

　　3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

　　

　　　　你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：

　　　　String str = “This is only a” + “ simple” + “test”;

　　　　其实就是：

　　　　String str = “This is only a simple test”;

　　　　所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：

　　　　String str2 = “This is only a”;

　　　　String str3 = “ simple”;

　　　　String str4 = “ test”;

　　　　String str1 = str2 +str3 + str4;

　　　　这时候JVM会规规矩矩的按照原来的方式去做。

　　4.StringBuilder与 StringBuffer

　　　　StringBuilder：线程非安全的

　　　　StringBuffer：线程安全的

　　　　当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

对于三者使用的总结： 1.如果要操作少量的数据用 = String

　　　　　　　　　　 2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

　　　　　　　　　　 3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
*/

　　　　　　　　　　

}
}