String、StringBuffer和StringBuilder

String类：

字符串是一个特殊的对象

字符串一旦初始化就不可以被改变

String str = ''abc";

String str1 = new String("abc");

有什么区别？

package cn.itcast.p1.string.demo;

public class StringDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/*
		 * String类的特点：
		 * 字符串对象一旦被初始化就不会被改变。
		 * 
		 */
		stringDemo2();
	}

	public static void stringDemo2() {
		// TODO Auto-generated method stub
		
		String s = "abc";//创建一个字符串对象在常量池中。		
		String s1 = new String("abc");//创建两个对象一个new一个字符串对象在堆内存中。
		
		System.out.println(s==s1);//false ，比较的仅仅是地址值
		
		System.out.println(s.equals(s1));
		//string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。
		//其实就是比较字符串内容。
		
		
//		System.out.println("s="+s);
//		System.out.println("s1="+s1);
		
	}

	/**
	 * 演示字符串定义的第一种方式，并明确字符串常量池的特点.
	 * 池中没有就建立，池中有，直接用。
	 */
	private static void stringDemo1() {
		String s = "abc";//"abc"存储在字符串常量池中。
//		s = "nba";
		String s1 = "abc";		
		System.out.println(s==s1);//true?
//		System.out.println("s="+s);
	}

}

String类的构造函数：

package cn.itcast.p1.string.demo;

public class StringConstructorDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/*
		 * 将字节数组或者字符数组转成字符串可以通过String类的构造函数完成。
		 */
		
		stringConstructorDemo2();
	}

	private static void stringConstructorDemo2() {
		char[] arr = {'w','a','p','q','x'};
		String s = new String(arr,1,3);
		
		System.out.println("s="+s);
	}

	public static void stringConstructorDemo() {
		String s = new String();//等效于String s = "";  不等效String s = null;
		
		byte[] arr = {97,66,67,68};
		
		String s1 = new String(arr);
		System.out.println("s1="+s1);
		
	}


}

 String类的常见功能：

package cn.itcast.p1.string.demo;

public class StringMethodDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		/*
		 * 按照面向对象的思想对字符串进行功能分类。
		 * "abcd"
		 * 
		 * 1,获取：
		 * 1.1 获取字符串中字符的个数(长度).
		 * 		int length();
		 * 1.2 根据位置获取字符。
		 * 		char charAt(int index);
		 * 1.3 根据字符获取在字符串中的第一次出现的位置.
		 * 		int indexOf(int ch)
		 * 		int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置 
		 * 		int indexOf(String str);
		 * 		int indexOf(String str,int fromIndex);
		 * 		 根据字符串获取在字符串中的第一次出现的位置.
		 * 		int lastIndexOf(int ch)
		 * 		int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置 
		 * 		int lastIndexOf(String str);
		 * 		int lastIndexOf(String str,int fromIndex);
		 * 1.4 获取字符串中一部分字符串。也叫子串.
		 * 		String substring(int beginIndex, int endIndex)//包含begin 不包含end 。
		 * 		String substring(int beginIndex);
		 * 		
		 * 
		 * 
		 * 2，转换。
		 * 		2.1 将字符串变成字符串数组(字符串的切割)
		 * 			String[]  split(String regex):涉及到正则表达式.
		 * 		2.2 将字符串变成字符数组。
		 * 			char[] toCharArray();
		 * 		2.3 将字符串变成字节数组。
		 * 			byte[] getBytes();
		 * 		2.4 将字符串中的字母转成大小写。
		 * 			String toUpperCase():大写
		 * 			String toLowerCase():小写
		 *		2.5  将字符串中的内容进行替换
		 *			String replace(char oldch,char newch);
		 * 			String replace(String s1,String s2);
		 * 		2.6 将字符串两端的空格去除。
		 * 			String trim();
		 * 		2.7 将字符串进行连接 。
		 * 			String concat(string);
		 * 
		 * 3，判断
		 * 		3.1 两个字符串内容是否相同啊？
		 * 			boolean equals(Object obj);
		 * 			boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。
		 * 		3.2 字符串中是否包含指定字符串？
		 * 			boolean contains(string str);
		 * 		3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
		 * 			boolean startsWith(string);
		 * 			boolean endsWith(string);
		 * 		
		 * 4，比较。
		 * 		
		 */
		stringMethodDemo_4();
		
//		System.out.println("abc".concat("kk"));
//		System.out.println("abc"+"kk");
		
//		System.out.println(String.valueOf(4)+1);
//		System.out.println(""+4+1);
		
	}

	private static void stringMethodDemo_4() {
		
		System.out.println("abc".compareTo("aqz")); //字符串对象相互比较
	}

	private static void stringMethodDemo_3() {
		String s = "abc";
		System.out.println(s.equals("ABC".toLowerCase()));
		System.out.println(s.equalsIgnoreCase("ABC"));
		
		System.out.println(s.contains("cc"));
		
		String str  = "ArrayDemo.java";
		
		System.out.println(str.startsWith("Array"));
		System.out.println(str.endsWith(".java"));
		System.out.println(str.contains("Demo"));
	}

	private static void stringMethodDemo_2() {
		
		String  s = "张三,李四,王五";
		String[] arr = s.split(",");
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		char[] chs = s.toCharArray();
		
		for (int i = 0; i < chs.length; i++) {
			System.out.println(chs[i]);
		}
		s = "ab你";
		byte[] bytes = s.getBytes();
		for (int i = 0; i < bytes.length; i++) {
			System.out.println(bytes[i]);
		}
		
		System.out.println("Abc".toUpperCase());
		
		
		String s1 = "java";
		String s2 = s1.replace('q', 'z');
		System.out.println(s1==s2);//true
		
		System.out.println("-"+"    ab  c    ".trim()+"-");
		
	}

	private static void stringMethodDemo_1() {
		
		String  s = "abcdae";
		
		System.out.println("length:"+s.length());//6
		System.out.println("char:"+s.charAt(2));//c//StringIndexOutOfBoundsException
		System.out.println("index:"+s.indexOf('k'));//0//-1 我们可以根据-1，来判断该字符或者字符串是否存在。
		System.out.println("lastIndex:"+s.lastIndexOf('a'));//4
		
		
		System.out.println("substring:"+s.substring(2,4));
	}

}

String类的intern方法：

package cn.itcast.p1.string.demo;

public class StringObjectDemo {


	/**
	 * @param args
	 */
	public static void main(String[] args) {

//		String s1 = "abc";
//		String s2 = "abc";
		
		//intern():对字符串池进行操作的 
		
		String s1 = new String("abc");
		String s2 = s1.intern();
		
		System.out.println(s1==s2);
		
		
		
	}

}

package cn.itcast.p1.string.test;

/*
 * 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
 * {"nba","abc","cba","zz","qq","haha"}
 * 
 * 思路：
 * 1,对数组排序。可以用选择，冒泡都行。
 * 2,for嵌套和比较以及换位。
 * 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。
 *   字符串对象怎么比较呢？爽了，对象中提供了用于字符串对象比较的功能。
 * 
 * 
 */
public class StringTest_1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };

		printArray(arr);

		sortString(arr);

		printArray(arr);

	}

	public static void sortString(String[] arr) {

		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {

				if(arr[i].compareTo(arr[j])>0)//字符串比较用compareTo方法
					swap(arr,i,j);
			}
		}
	}

	private static void swap(String[] arr, int i, int j) {
		String temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	public static void printArray(String[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i != arr.length - 1)
				System.out.print(arr[i] + ", ");
			else
				System.out.println(arr[i] + "]");
		}
	}

}

package cn.itcast.p1.string.test;

/*
 * 2，一个子串在整串中出现的次数。
 * "nbaernbatynbauinbaopnba"
 * 思路：
 * 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。
 * 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，
 * 而剩余字符串的起始位是出现位置+子串的长度.
 * 3,以此类推，通过循环完成查找，如果找不到就是-1，并对 每次找到用计数器记录。 
 * 
 */



public class StringTest_2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String str = "nbaernbatnbaynbauinbaopnba";
		String key = "nba";
		
		int count = getKeyStringCount_2(str,key);
		System.out.println("count="+count);
				
	}

	public static int getKeyStringCount_2(String str, String key) {
		
		int count = 0;
		int index = 0;
		
		while((index = str.indexOf(key,index))!=-1){
			
			index = index + key.length();
			count++;
			
		}
		
		return count;
	}

	/**
	 * 获取子串在整串中出现的次数。
	 * @param str
	 * @param key
	 * @return
	 */
	public static int getKeyStringCount(String str, String key) {
		
		//1,定义计数器。 
		int count = 0;
		
		//2，定义变量记录key出现的位置。
		int index = 0;
		
		while((index = str.indexOf(key))!=-1){
			
			str = str.substring(index+key.length());
			count++;
		}
		return count;
	}
	
	

}

package cn.itcast.p1.string.test;

/*
 * 3，两个字符串中最大相同的子串。
 * "qwerabcdtyuiop"
 * "xcabcdvbn"
 * 
 * 思路：
 * 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。
 * 如果存在，短的那个字符串就是最大子串。
 * 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。
 * 如果存在就已找到，就不用在找了。
 * 
 * 
 */
public class StringTest_3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String s1 = "qwerabcdtyuiop";
		String s2 = "xcabcdvbn";

		String s = getMaxSubstring(s2, s1);
		System.out.println("s=" + s);
	}

	/**
	 * 获取最大子串
	 * 
	 * @param s1
	 * @param s2
	 * @return
	 */
	public static String getMaxSubstring(String s1, String s2) {
		
		String max = null,min = null;
		max = (s1.length()>s2.length())?s1:s2;
		
		min = max.equals(s1)?s2:s1;
		
		System.out.println("max="+max);
		System.out.println("min="+min);
		
		
		
		for (int i = 0; i < min.length(); i++) {
			
			for(int a = 0,b = min.length()-i; b != min.length()+1; a++,b++){
				
				String sub = min.substring(a, b);
//				System.out.println(sub);
				if(max.contains(sub))
					return sub;
			}
		}
		
		return null;
	}
}

package cn.itcast.p1.string.test;

/*
 * 4，模拟一个trim功能一致的方法。去除字符串两端的空白 
 * 思路：
 * 1，定义两个变量。
 * 一个变量作为从头开始判断字符串空格的角标。不断++。
 * 一个变量作为从尾开始判断字符串空格的角标。不断--。
 * 2,判断到不是空格为止，取头尾之间的字符串即可。
 */
public class StringTest_4 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String s = "    ab   c     ";

		s = myTrim(s);
		System.out.println("-" + s + "-");
	}

	public static String myTrim(String s) {

		int start = 0, end = s.length() - 1;

		while (start <= end && s.charAt(start) == ' ') {
			start++;
		}
		while (start <= end && s.charAt(end) == ' ') {
			end--;
		}
		return s.substring(start, end + 1);
	}

}

package cn.itcast.p2.stringbuffer.demo;

public class StringBufferDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		/*
		 * StringBuffer:就是字符串缓冲区。
		 * 用于存储数据的容器。
		 * 特点：
		 * 1，长度的可变的。 
		 * 2，可以存储不同类型数据。
		 * 3，最终要转成字符串进行使用。
		 * 4，可以对字符串进行修改。
		 * 
		 * 
		 * 既然是一个容器对象。应该具备什么功能呢？
		 * 1，添加：
		 * 		StringBuffer append(data);
		 * 		StringBuffer insert(index,data);
		 * 2，删除：
		 * 		StringBuffer delete(start,end):包含头，不包含尾。
		 * 		StringBuffer deleteCharAt(int index):删除指定位置的元素 
		 * 3，查找：
		 * 		char charAt(index);
		 * 		int indexOf(string);
		 * 		int lastIndexOf(string);
		 * 4，修改：
		 * 		StringBuffer replace(start,end,string);
		 * 		void setCharAt(index,char);
		 * 
		 * 增删改查  C(create)U(update)R(read)D(delete) 
		 * 
		 * 
		 * 
		 */
		bufferMethodDemo_2();
	}
	
	private static void bufferMethodDemo_2() {
		StringBuffer sb = new StringBuffer("abce");
		
//		sb.delete(1, 3);//ae
		
		//清空缓冲区。
//		sb.delete(0,sb.length());
//		sb = new StringBuffer();
		
//		sb.replace(1, 3, "nba");
//		sb.setCharAt(2, 'q');
		
//		sb.setLength(10);
		
//		System.out.println("sb:"+sb);
//		System.out.println("len:"+sb.length());
		
		System.out.println(sb.reverse());
		
		
	}

	private static void bufferMethodDemo_1() {
		StringBuffer sb = new StringBuffer("abce");
		
//		sb.append("xixi");
		sb.insert(2, "qq");
		
		System.out.println(sb.toString());
	}

	public static void bufferMethodDemo(){
		//创建缓冲区对象。
		StringBuffer sb = new StringBuffer();
		
		sb.append(4).append(false);//.append("haha");
		sb.insert(1, "haha");
//		sb.append(true);
		
		System.out.println(sb);
		
	}
	
	

}

package cn.itcast.p2.stringbuffer.demo;

public class StringBuilderDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		
		/*
		 * jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder
		 * 
		 * 不同的是：
		 * StringBuffer是线程同步的。通常用于多线程。
		 * StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。
		 * 
		 * jdk升级：
		 * 1，简化书写。
		 * 2，提高效率。
		 * 3，增加安全性。
		 */
		
		
	}

}
/*

class StringBuffer jdk1.0
{
	object lock;
	public   StirngBuffer append(int x)
	{
		synchronized(lock)
		{
		}
	}
	
	
	public synchronized StringBuffer delete(int start,int end)
	{
		synchronized(lock)
		{
		}
	}
}



*/

package cn.itcast.p2.stringbuffer.test;

public class StringBuilderTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		int[] arr = {3,1,5,3,8};
		String s = arrayToString_2(arr);
		
		System.out.println(s);
	}
	public static String arrayToString_2(int[] arr){
		
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < arr.length; i++) {
			if(i!=arr.length-1)
				sb.append(arr[i]+", ");
			else
				sb.append(arr[i]+"]");
		}
		return sb.toString();
	}
	
	/**
	 * 将一个int数组变成字符串。
	 */
	public static String arrayToString(int[] arr){
		
		String str = "[";
		for (int i = 0; i < arr.length; i++) {
			if(i!=arr.length-1)
				str+=arr[i]+", ";
			else
				str+=arr[i]+"]";
		}
		
		return str;
	}

}