黑马程序员——String类与StringBuffer

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

String类

String类适用于描述字符串事物。
那么他就提供了多个方法对字符串进行操作。


常见的操作有哪些？
"abcd"
1，获取。
1.1 字符串中的包含的字符数，也就是字符串的长度。
int length():获取长度。
1.2 根据位置获取位置上的某个字符。
char charAt(int index):
1.3 根据字符获取该字符在字符串中位置。
int indexof(int ch):返回的是ch在字符串中第一次出现的位置。
int indexof(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexof(String str):返回的是str在字符串中第一次出现的位置。
int indexof(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。

2，判断。
2.1 字符串中是否包含某一个子串。
boolean contains(str);
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。
if(str.indexOf("aa")!=-1)
而且该方法即可以判断，又可以获取出现的位置。
2.2 字符串中是否有内容。
boolean isEmpty():原理就是判断长度是否为0.
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.5 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();

3 转换。
3.1 将字符数组转换成字符串。
构造函数：String(char[])
 String(char[],offset,count):将字符数组中的一部分转成字符串。


静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data,int offset,int count)
static String valueOf(char[]):
3.2 将字符串转成字符数组。
char[]toCharArray():
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串
3.4 将字符串转成字节数组。
byte[]  getBytes();
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)

3+""//String.valueOf(3);一样的，+相当于连接符


特殊：字符串和字节数组在转换过程中，是可以指定编码表的。


4 替换
String replace (oldchar,newchar);


5 切割
String[] split(regex);
6 子串  获取字符串的一部分。
String substring(begin);
String substring(begin,end);

7 转换，去除空格，比较。
7.1 将字符串转换成大写或者小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两段的对歌空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);

String s1 = "abc"//s1是一个类类型变量，"abc"是一个对象。
//字符串最大特点：一旦被初始化，就不可以被改变。
String s2 = new String("abc");
//s1和s2有什么区别？

s1在内存中有一个对象。
s2在内存中有两个对象。

System.out.println(s1 == s2);
System.out.println(s1.equals(s2));

String 类复写了object类中的equals方法。
该方法用与判断字符串是否相同。

class StringMethodDemo 
{

	public static void method_7()
	{
		String s = "   Hello Java   ";
		sop(s.toLowerCase());
		sop(s.toUpperCase());
		sop(s.trim());

		String s1 = "acc";
		String s2 = "aaa";
		sop(s1.compareTo(s2));//比较的是阿斯科马值！

	}
	
	public static void method_sub()
	{
		String s = "abcdef";

		sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2,4));//包含头，不包含尾。s.substring(0,s.length());


	}

	public static void method_split()
	{
		String s = "zhangsan,lisi,wangwu";
		String[] arr = s.split(",");

		for (int x = 0;x<arr.length ;x++ )
		{
			sop(arr[x]);
		}

	}

	public static void method_replace()
	{
		String s = "hello java ";
		//String s1 = s.replace('q','n');//如果要替换的字符不存在，返回的还是原串。
		String s1 = s.replace("java","world");
		
		sop("s="+s);
		sop("s1="+s1);
	}


	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		String s = new String(arr,1,3);//从一角标开始，三个，打印结果是bcd

		sop("s="+s);

		String s1 = "zcxvbnm";
		char[] chs = s1.toCharArray();

		for (int x = 0; x < chs.length ;x++ )
		{
			sop("ch="+chs[x]);
		}
	}
	public static void method_is()
	{
		String str = "ArrayDemo.java";

		//判断文件名称是否是Array单词开头。
		sop(str.startsWith("Array"));
		//判断文件名称是否是.java的文件。
		sop(str.endsWith(".java"));
		//判断文件汇总是否包含Demo
		sop(str.contains("Demo"));
	}
	public static void method_get()
	{
		String str = "abcdeakpf";

		//长度
		sop(str.length());

		//根据索引获取字符。
		sop(str.charAt(40));//当访问到字符串中不存在的角标时会发生StringIndesOutOfBoundsException。
		//根据字符获取索引。
		sop(str.indexOf('m',3));//如果没有找到，返回-1；

		//反向索引一个字符出现位置。
		sop(str.lastIndexOf("a"));

	}
	public static void main(String[] args) 
	{

		method_7();
		//method_sub();
		//method_split();
		//method_replace();
		//method_trans();
		//method_is();
		
		//method_get();
		/*
		String s1 = "abc";
		String s2 = new String("abc");
		String s3 = "abc";

		System.out.println(s1 == s2);
		System.out.println(s1 == s3);
		*/
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

String类的练习：

模拟一个trim方法，去除字符串两段的空格。
思路:
1，判断字符串的一个位置是否是空格，如果是继续向下判断，知道不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断不是空格时，就是要获取的字符串。

class StringTest1 
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	public static void main(String[] args) 
	{
		String s = "      ab cd      ";
		sop("("+s+")");
		s = myTrim(s);
		sop("("+s+")");
	}

	//练习一，去除字符串两端空格。
	public static String myTrim(String str)
	{
		int start = 0,end = str.length()-1;

		while(start<=end && str.charAt(start)==' ')
			start++;
		while(start<=end && str.charAt(end)==' ')
			end--;
		return str.substring(start,end+1);//包含头，不包含尾，所以要加以，否则最后一个没有
	}
}

将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
思路：
1，曾经学习过对数组元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将反转的部分的开始和结束位置作为参数传递即可。

class StringTest2 
{
	public static void sop(String str)
	{
		System.out.println(str);
	}


	public static void main(String[] args) 
	{
		String s = "      ab cd      ";
		sop("("+s+")");
		sop("("+reverseString(s,6,7)+")");
	}
	
	//反转指定的字符串
	public static String reverseString(String s,int start,int end )
	{
		//字符串变数组
		char[] chs = s.toCharArray();
		//反转数组
		reverse(chs,start,end);
		//将数组变成字符串
		return new String(chs);
		
	}
	private static void reverse(char[] arr,int x ,int y )
	{
		for(int start = x,end = y-1; start < end;start++,end--)
		{
			swap(arr,start,end);
		}
	}

	/*
	public static String reverseString(String s )
	{
		//字符串变数组
		char[] chs = s.toCharArray();
		//反转数组
		reverse(chs);
		//将数组变成字符串
		return new String(chs);
	}


	private static void reverse(char[] arr)
	{
		for(int start = 0,end = arr.length-1; start < end;start++,end--)
		{
			swap(arr,start,end);
		}
	}
	*/
	private static void swap(char[] arr,int x ,int y )
	{
		char temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;

	}
	
	
}

获取一个字符串在另一个字符串中出现的次数。
“abkkcdkkefkkskk”
思路：
1，定义一个计数器。
2，获取kk第一次出现的位置。
3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
没获取一次就计数一次。
4，当获取不到时，技术完成。

class StringTest3 
{

	public static int getSubCount(String str,String key)
	{	
		int count = 0;
		int index = 0;
		while((index = str.indexOf(key))!=-1)
		{
			sop("str="+str);
			str = str.substring(index + key.length());

			count++;
		}
			return count;
	
	}




	//方式二

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

	}


	public static void sop(String str)
	{
		System.out.println(str);
	}

	public static void main(String[] args) 
	{
		String str = "abkkcdkkefkkskk";
		sop("count="+getSubCount_2(str,"kk"));
	}
}

获取两个字符串中最大相同子串。第一动作：将短的那个串惊醒长度一次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，
如果包含，几经找到。

class StringTest4 
{
	public static String getMacSubString(String s1,String s2)
	{
		String max = "",min = "";
		max = (s1.length()>s2.length())?s1:s2;
		min = (max == s1)?s2:s1;
		//sop("max="+max+"...min="+min);

		for (int x = 0;x <min.length() ;x++ )
		{
			for (int y = 0,z = min.length()-x ;z!=min.length()+1;y++,z++ )
			{
				String temp = min.substring(y,z);

				//sop(temp);
				if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
					return temp;
			}
		}
		return "";
	}


	public static void sop(String str)
	{
		System.out.println(str);
	}

	public static void main(String[] args) 
	{
		String s1 = "abcwerthelloyuiodef";
		String s2 = "cvhellobnm";
		sop(getMacSubString(s1,s2));
	}
}

StringBuffer缓冲区：

StirngBuffer是字符串缓冲区。

是一个容器。
特点：
1，而且长度是可变化的。
2，可以直接操作多个数据类型。
3，最终会用过toString方法变成字符串。


C create U update R read D delete


1，存储。
StringBuffer append():将指定数据作为参数添加到已有数据结尾。
StringBuffer insert(index（角标位）,数据)：可以将数据插入到指定index位置。
2，删除。
StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。
3，获取。
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start,int end)
4，修改。
StringBuffer replace(start,end,string)
void setCharAt(int index,char ch)
5，反转
StringBuffer reverse();
6， 将缓冲区中的指定数据存储到指定字符数组中。
void getChars(int srcBegin,int srcEnd,char[] dst,int detBegin)

JDK1.5版本之后出现了StringBuilder.

StringBuffer是线程同步。
StringBuiler是线程不同步。
以后开发，建议使用StringBuilder
功能一模一样，StringBuffer有锁，单线程是需要判断锁，耗费资源。
StringBuilder没有锁，但是不安全，在多线程中需要自己加锁。

class StringBufferDemo 
{
	public static void main(String[] args) 
	{
		//method_del();
		//method_update();
		StringBuffer sb = new StringBuffer("abcde");
		char[] chs = new char[4];
		sb.getChars(1,4,chs,1);
		for (int x = 0 ;x<chs.length ;x++ )
		{
			sop("chs["+x+"]="+chs[x]+";");
		}

	}

	public static void method_update()
	{
		StringBuffer sb = new StringBuffer("abcde");
		//sb.replace(1,4,"java");
		sb.setCharAt(2,'k');
		sop(sb.toString());
	}
	
	public static void method_del()
	{
		StringBuffer sb = new StringBuffer("abcde");

		//sb.delete(1,3);
		//清空缓冲区。
		//sb.delete(0,sb.length());


		sop(sb.toString());
	}

	public static void method_add()
	{
		StringBuffer sb = new StringBuffer();
		
		sb.append("abc").append(true).append(34);
		sb.insert(1,"qq");
		//StringBuffer sb1 = sb.append(34);
		//sop("sb==sb1:"+(sb==sb1));
		sop(sb.toString());
		//sop(sb1.toString());
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}