String、StrngBuffer、StringBulider

一、Sting类是对字符串事物的描述，该类定义了专门用于操作字符串的方法。它是一个final类，不能被继承。

String s1="java";  Strings2="java" String类在java中采用了享元设计模式，s1和s2两个引用变量指向了同一个内存地址。s1==s2 为true.String s=new String("java") ;创建了两个对象，"java"是一个匿名对象，new关键字在对内存又创建一个对象。

二、String类常用方法列举

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在字符串中出现的位置。
int lastIndexOf(int ch) ：从字符串后面开始获取字符第一次出现的位置。

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.6 判断内容是否相同，并忽略大小写。
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);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
构造函数public String(byte[] bytes,Charset charset)，通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。

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);

三 、练习

public class StringTest1
{

	/**
	 * 1.仿照trim()方法的功能，去掉字符串两端的空格
	 * 2.自写一个字符串反转的功能
	 */
	public static void main(String[] args)
	{
		System.out.println(myTrim("   dsds dsd dsok  kp   "));
		System.out.println(reverseString("java hello world"));
		System.out.println(getSubCount("fjfdfffjkkjkfffkjkkjkjff", "ff"));

	}
    
	public static String myTrim(String s)//头尾去空
	{
		/*
		 * 思路：1.从头开始判断，直到找到非空字符出现的位置a 
		 *      2.从尾开始判断，直到找到非空字符出现的位置b
		 *      3.截取a到b位置的子字符串
		 *      */
		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);
	}
	/*
	 * 字符串反转思路：
	 * 1.将字符串转换成字符数组
	 * 2.定义两个变量分别指向字符数组的头尾位置
	 * 3.指向头变量向后移动，同时指向尾的变量向前移动，依次交换
	 * 4.将反转后的字符数组转变成字符串
	 * 
	 * */
	
	public static String reverseString(String s,int x,int y)//反转字符串
	{
		char ch[]=s.toCharArray();
		for (int start = 0,end=s.length()-1; start <end; start++,end--)
		{
			swap(ch,start,end);
		}
		return new String(ch);
	}
	
	public static void swap(char[] ch,int a,int b)//交换位置
	{
		char temp=ch[a];
		ch[a]=ch[b];
		ch[b]=temp;
	}
	
	
	public static String reverseString(String s)//反转字符串方法重载
	{
		return reverseString(s,0,s.length()-1);
	}
	
	
	//获取一个字符串在另一个字符串中出现的次数。
	public static int getSubCount(String s,String key)
	{
		int count=0,index=0;
		while((index=s.indexOf(key, index))!=-1)
		{
			index=index+key.length();
			count++;
		}
		return count;
	}
	//获取一个字符串在另一个字符串中出现的次数。
	public static int getSubCount_1(String s,String key)
	{
		int count=0,index=0;
		while((index=s.indexOf(key))!=-1)
		{
			s=s.substring(index+key.length());
			count++;
		}
		return count;
	}
}

/*
获取两个字符串最大相同子串？
思路：
1.比较两个字符串的长度
2.选择长度短的字符串并获取其按长度逐步
减小的子字符串,
从最大字符串开始减，比如字符串 ：abcde
长度5  ---  1个  abcde
长度4  ---  2个 abcd  bcde
长度3  ---  3个 abc bcd cde
长度2  ---  4个  ab bc cd de
长度1  ---  5个  a b c d e 
3.循环判断长度大的字符串是否包含获取的字符串
*/

class StringTest3 
{
	public static void main(String[] args) 
	{   
		String s1="ohello";
		String s2="cfdkhel lkhellokiohello";
		//System.out.println(getMaxSubString(s1,s2));
		getString("abcde");
	}

	public static String getMaxSubString(String s1,String s2)
	{
		String max=s1.length()>s2.length()?s1:s2;
		String min=s1.length()<s2.length()?s1:s2;

		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);//substring不取z位置的字符，所以注意上面的参数取值
                if(max.contains(temp))
				{
					return temp;
				}
			}
			
		}
		return "";
	}

	//获取字符串按长度递增的子串
	public static void getString(String s)
	{
		for (int x=0;x<s.length() ;x++ )
		{
			for (int y=0,z=x+1;z<=s.length() ;y++,z++ )
			{
				System.out.println(s.substring(y,z));
			}
		}
	}
}