String StringBuffer StringBuilder

package com.atguigu.java;

import org.junit.Test;

public class StringBufferBuilderTest {
	
	@Test
	public void test4(){
		String str = null;
		StringBuffer sb = new StringBuffer();
		sb.append(str);

		System.out.println(sb.length());//4

		System.out.println(sb);//"null"
		
		StringBuffer sb1 = new StringBuffer(str);//报异常
		System.out.println(sb1);
		
	}
	
	/*
	 *  StringBuffer append(String s),   StringBuffer append(int n) ,  
		StringBuffer append(Object o) ,  StringBuffer append(char n),
		StringBuffer append(long n),  StringBuffer append(boolean n),
		StringBuffer insert(int index, String str) 
		public StringBuffer reverse() :反转
		StringBuffer delete(int startIndex, int endIndex) 
		public char charAt(int n )
		public void setCharAt(int n ,char ch)
		StringBuffer replace( int startIndex ,int endIndex, String str) 
		public int indexOf(String str)
		public String substring(int start,int end)
		public int length()
		
		总结：
			增加：append()
			删除：delete(int startIndex, int endIndex)
			修改：setCharAt(int n ,char ch) / replace( int startIndex ,int endIndex, String str) 
			查询：charAt(int n )
			插入：insert(int index, String str)
			长度：length();
		
	 */
	@Test
	public void test3(){
		StringBuffer sb1 = new StringBuffer("abc");//new char[19]
		sb1.append("123").append("hello");//方法链的调用
		System.out.println(sb1.length());
		System.out.println(sb1);
		StringBuffer sb2 = sb1.delete(1, 3);
		System.out.println(sb1);
		System.out.println(sb2);
	}
	
	/*
	 * 测试String/StringBuffer/StringBuilder三者的效率。
	 * 操作数据的效率从高到低：StringBuilder > StringBuffer > String
	 */
	@Test
	public void test2(){
		String text = "";
		StringBuffer buffer = new StringBuffer("");
		StringBuilder builder = new StringBuilder("");
		
		long startTime = 0L;
		long endTime = 0L;
		
		
		startTime = System.currentTimeMillis();
		
		for(int i = 0;i<20000;i++){
			buffer.append(String.valueOf(i));
		}
		endTime = System.currentTimeMillis();
		
		System.out.println("StringBuffer的执行时间："+(endTime-startTime));
		
		
		startTime = System.currentTimeMillis();
		for(int i = 0;i<20000;i++){
			builder.append(String.valueOf(i));
		}
		endTime = System.currentTimeMillis();
		System.out.println("StringBuilder的执行时间："+(endTime-startTime));
		
		
		startTime = System.currentTimeMillis();
		for(int i = 0;i<20000;i++){
			text = text + i;
		}
		endTime = System.currentTimeMillis();
		System.out.println("String的执行时间："+(endTime-startTime));

	}
	
	/*
	 * 面试题：
	 * String:不可变的字符序列；使用char[]存储
	 * StringBuffer:可变的字符序列；线程安全的，效率低；使用char[]存储
	 * StringBuilder:可变的字符序列；线程不安全的，效率高；（jdk 5.0）使用char[]存储
	 * 
	 * 
	 * 
	 * new ArrayList();//new Object[10];
	 * new StringBuffer();//new char[16];// abfedc
	 * 
	 * 建议：new StringBuffer(int size);//new char[size];
	 * 
	 */
	@Test
	public void test1(){
		
	}
}

     面试题：
      String:不可变的字符序列；使用char[]存储
      StringBuffer:可变的字符序列；线程安全的，效率低；使用char[]存储
      StringBuilder:可变的字符序列；线程不安全的，效率高；（jdk 5.0）使用char[]存储

package com.atguigu.java;

import org.junit.Test;

public class StringTest {
	
	/*
	 * String中常用的方法？
	 * length();equals();charAt();comparaTo();substring();
	 * contains();....
	 * 
	 * 
	 * String与包装类、基本数据类型的转换：
	 * String--->包装类、基本数据类型:调用包装类的parseXxx();
	 * 包装类、基本数据类型--->String:调用String类的valueOf(Xxx xxx)
	 * 
	 * String与字节数组间的转换：
	 * String---->字节数组:getBytes();
	 * 字节数组---->String:new String(byte[] buf)
	 * 
	 * String与字符数组间的转换：
	 * String---->字符数组:toCharArray();
	 * 字符数组---->String:new String(char[] cuf)
	 * 
	 */
	
	/*
	 *  public String substring(int startpoint):获取从startpoint开始的子串
		public String substring(int start,int end)：获取从start开始，到end结束左闭右开区间的子串
		pubic String replace(char oldChar,char newChar)
		public String replaceAll(String old,String new)
		public String trim()：去除当前字符串中左右两端的空格。
		public String concat(String str):连接两个字符串
		public boolean contains(CharSequence s)：当前字符串是否包含s
		public String[] split(String regex)

	 */
	@Test
	public void test5(){
		String s1 = "   h  e   llo   ";
		String s2 = s1.trim();
		System.out.println("----" + s1 + "----");
		System.out.println("----" + s2 + "----");
		
		
		
		String[] fakeFileData = {
		          "justin\t64/5/26\t0939002302\t5433343",
		          "momor\t68/7/23\t0939100391\t5432343" }; 
        for(String data : fakeFileData) {
            String[] tokens = data.split("\t");
             //\t为字符串的分割符号。          
            for(String token : tokens) {
                System.out.print(token + "\t| ");}
            System.out.println(); 
        }
	}
	
	/*
	 *  public int length():求长度
		public char charAt(int index)：获取指定索引位置的字符
		public boolean equals(Object anObject)：比较两个对象是否相等
		public int compareTo(String anotherString)：比较两个字符串的大小
		public int indexOf(String s)：获取当前字符串中s字符串首次出现的位置。如果不存在，返回-1
		public int indexOf(String s ,int startpoint):
		public int lastIndexOf(String s):获取当前字符串中s字符串末次出现的位置。如果不存在，返回-1
		public int lastIndexOf(String s ,int startpoint)
		public boolean startsWith(String prefix)：当前字符串是否以prefix开头
		public boolean endsWith(String suffix):当前字符串是否以suffix结尾
		public boolean regionMatches(int firstStart,String other,int otherStart ,int length)
	 * 
	 * 
	 */
	@Test
	public void test4(){
		String s1 = "helwoloworld";
		String s2 = "wo";
		System.out.println(s1.indexOf(s2));//3
		System.out.println(s1.indexOf(s2,4));//7
		
		System.out.println(s1.startsWith("hel"));
		
		String s3 = "hooworld";
		System.out.println(s1.regionMatches(7, s3, 3, 5));//true
	}
	
	/*
	 * 
	 * 举例：s5,s6,s7所赋的值中，都出现了变量。只要出现变量，都理解为在堆空间中声明的值。
	 * 
	 */
	@Test
	public void test3(){
		String s1 = "hello";
		String s2 = "world";
		
		String s3 = "helloworld";
		String s4 = "hello" + "world";
		String s5 = s1 + s2;
		String s6 = s1 + "world";
		String s7 = "hello" + s2;
		//intern()：表示在字符串常量池中声明。如果在常量池中已经存在，则复用。否则，声明一个新的字符串
		String s8 = (s1 + s2).intern();
		
		
		System.out.println(s3 == s4);
		System.out.println(s3 == s5);
		System.out.println(s3 == s6);
		System.out.println(s3 == s7);
		System.out.println(s5 == s6);
		System.out.println(s5 == s7);
		
		System.out.println(s3 == s8);//true
		
		
	}
	
	/*
	 * String:不可变的字符序列。（String的不可变性）
	 * ①给现有的字符串赋新的值 ②向现有的字符串后面添加新的字符串 ③修改现有的字符串中的某个字符
	 * 以上三种情况都算修改，都必须创建新的字符串才可。
	 */
	@Test
	public void test2(){
		String s1 = "java";
		String s2 = "java";
		s1 = "bigdata";
		
		System.out.println(s1);//bigdata
		System.out.println(s2);//java
		
		System.out.println("********************");
		String s3 = "hello";
		String s4 = "hello";
		s3 += "world";
		System.out.println(s4);//hello
		
		System.out.println("********************");
		
		String s5 = "helloworld";
		String s6 = "helloworld";
		String s7 = s5.replace('h', 'm');
		System.out.println(s7);//melloworld
		System.out.println(s5);//helloworld
		System.out.println(s6);//helloworld
		
	}
	
	/*
	 * String:
	 * 1.final的 
	 * 2. 实现了Serializable：可序列化，字符串可以直接在不同的进程间，前端与后台
	 * 之间的通信。 
	 * 3. 实现了Comparable接口，可比较大小 
	 * 4.实现了CharSequence：String内部提供了一个char[] ，用于存储数据
	 *  
	 *  String在内存中的存储结构。
	 *  本质上，声明的字符串存储在字符串常量池中。
	 *  
	 *  面试题：String s3 = new String("hello");在内存中创建了几个对象？
	 *        在堆空间和常量池中会分别创建对象。
	 */
	@Test
	public void test1(){
		String s1 = "hello";//int num = 10; 
		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
		
		System.out.println("****************");
		Person p1 = new Person("Tom",12);
		Person p2 = new Person("Tom",14);
		System.out.println(p1.name == p2.name);
		
		p1.name = "jerry";
		System.out.println(p2.name);//Tom
		
		
	}
	
}

class Person{
	String name;
	int age;
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
}

容易出错的题型

	@Test
	public void test4(){
		String str = null;
		 
		StringBuffer sb = new StringBuffer();
		sb.append(str);

		System.out.println(sb.length());//4

		System.out.println(sb);//"null"
		
		StringBuffer sb1 = new StringBuffer(str);//报异常 空指针异常
		System.out.println(sb1);
		
	}