String是一个特殊的对象，在计算机里是很重要的角色，很多都是以String的形式存储在计算机里。
对字符串基本的操作有：
1、获取：
A、获取长度：int length(）；
B、根据角标获取元素：char charAt(int index)；
C、根据元素获取角标：
int indexOf(char ch);
int indexOf(char ch,int fromIndex);
int lastIndexOf(char ch)
int indexOf(String str)；
int indexOf(String str,int fromIndex);
2、判断：
A、字符串是否包含某一子串：boolean contains(CharSequence s);
B、是否有内容：boolean isEmpty();
C、是否以某字符串开头：boolean startsWith(String str);
D、是否以某字符串结尾：boolean endsWith(String str);
E、判断两个字符串的内容是否相同：boolean equals(String str);
F、忽略大小写比较：hboolean equalsIgnoreCase(String str) ；
3、转换：
A、字符串转换成字符数组：char[] toCharArray();
B、字符数组转换字符串：new String(char[] chs); static String copyValueOf(char[] chs); 可以只转部分，需要提供角标和位数。
C、字符串转换字节数组：byte[] getBytes(Charset charset);
D、字节数组转字符串：new String(byte[] bts,Charset charset);
注：charset参数可以省略，省略是按照每人编码表。
4、替换：
String replace(char oldChar,char newChar) ,若要替换的字符不存在，则返回原串。
5、切割：
String[] split(String regex); 如：string[] str = s.split(“,”);
6、获取子串：
String substring(int beginIndex);String substring(int beginIndex,int endIndex);
7、转换、去除空格、比较：
A、将字符串转换成大写或小写：String toUpperCase();String toLowerCase()；
B、将字符串两端的多个空格去除：String trim();
C、将字符串进行自然顺序的比较，不区分大小写：int compareTo(String str);
StringBuffer：字符串缓冲区，是一个容器，长度可变，可直接操作多个数据类型(不支持byte和short)，最终会通过toString的方法变成字符串。数组也是一个容器，长度固定的，操作的数据类型是在定义数组的时候就确定的。StringBuffer的基本操作（增、删、改、查）：
1、存储：
A、StringBuffer append(数据类型 变量)；数据类型不能为byte和short；
B、StringBuffer insert(int offset,数据类型 变量);
2、删除：
StringBuffer delete(int start,int end)
3、修改：
A、StringBuffer replace(int start,int end,String str)
B、StringBuffer setCharAt(int index,char ch);将指定角标处的字符更改为ch；
4、获取：
A、char charAt(int index)：获取指定角标处的字符；
B、int indexOf(String str)：获取第一次出现指定字符串的位置；
int lastIndexOf(String str)：获取最后一次出现指定字符的位置；
C、int indexOf(String str,int fromIndex)：从指定角标开始，返回第一次出现指定字符串的角标；
D、int length()：获取StringBuffer的长度；
E、String subString(int start,int end)：获取子串。
5、反转：
StringBuffer reverse();
6、将StringBuffer中指定的数据复制到字符数组中：
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Jdk1.5之后出现了StringBuilder，两者的区别是StringBuffer是同步的，StringBuilder是不同步的。StringBuilder的效率高于StringBuffer，在多线程中StringBuilder的安全性低。
字符串的相应练习代码：
/*
1、去除字符串两端的空格；
2、将字符串进行反转；
3、获取一个字符串在另一个字符串中出现的次数；"kk"
4、获取两个字符串中最大相同子串。
" abkkcwkkerkkthellokkykkuiokkdefkkkk "
"cvhellobnm"
"kk"
分析：1、去除前端空格的方法：先判断第一位是否为空，若是，从第二位开始取子串，再判断，
再取子串，直至第一位不空为止；去除后端空格的方法：先判断最后一位是否为空，
如是，去子串：第一位到倒数第二位，再判断，再取子串，直至倒数第一位不为空
为止；
2、StringBuffer有反转输出的功能，String没有，当然也可以先把字符串存储到StringBuffer
中，再将其反转输出。这里我用的方法是：通过char[] toCharArray()将字符串转变为
字符数组，字符数组反转之后，通过new String(char[] chs)方法将字符数组转换为字符串
输出。
3、获取一个字符串(s1)在另一个字符串(s2)出现的次数：先判断s2中是否包含s1，如果包含，
从s1在s2中出现的第一角标加上s1的长度的位置开始取子串，并且计数器加1，再判断，再
取子串，直至s2不包含s1为止。
4、获取两个字符串最大的相同子串。先判断长的字符串是否包含短的字符串，如果不包含，
将短的字符串去掉一位，再判断长的字符串是否包含短的字符串，如果不包含，将短的
字符串去掉两位，再判断，依次类推，如果短的字符串的长度为0，还是长的字符串还是
不包含短的字符串，那说明这两个字符串没有共同的元素。
*/
class StringTest
{
public static void main(String[] args)
{
String s1 = " abkkcwkkerkkthellokkykkuiokkdefkkkk ";
String s2 = "cvhellobnm";
//去除字符串两端空格的方法
System.out.println("练习1：---------------------------------------------------------");
String s = myTrim(s1);
//将字符串反转输出
System.out.println("练习2：---------------------------------------------------------");
myReverse(s);
//获取一个字符串在另一个字符串中出现的次数
System.out.println("练习3：---------------------------------------------------------");
int count = myCount(s,"kk");
System.out.println("字符串“kk”在字符串s中出现的次数为："+count);
//获取两个字符串的最大相同子串
System.out.println("练习4：---------------------------------------------------------");
mySubstring(s,s2);
}
//去除字符串两端空格
public static String myTrim(String s)
{
System.out.println("原来的字符串："+s);
System.out.println("原来字符串长度："+s.length());
//去除前端空格
for(int i=0;i<s.length();i++)
{
//如果字符串的第一位为空格，则取子串，继续循环判断子串中的第一位是否为空
if(s.charAt(i) == ' ')
s = s.substring(i+1,s.length());
//如果第一位不为空，则循环结束
else
break;
}
System.out.println("去除前端的空格后的字符串："+s);
System.out.println("去除字符串前端空格后的字符串长度："+s.length());
//去除后端空格
for(int i=s.length()-1;i>0;i--)
{
//如果字符串的最后一位为空，则取子串，继续循环判断字符串中的最后一位是否为空
if(s.charAt(i) == ' ')
s = s.substring(0,i);
//如果字符串的最后一位不为空，则退出循环
else
break;
}
System.out.println("去除字符串后端空格的字符串："+s);
System.out.println("去除字符串后端空格的字符串长度："+s.length());
return s;
}
//将字符串反转输出
public static void myReverse(String s)
{
System.out.println("原来的字符串："+s);
//定义一个中间变量，便于交换字符位置
char temp = ' ';
//将字符串转换成字符数组
char[] chs = s.toCharArray();
//将字符数组反转
for(int i=0;i<s.length()/2;i++)
{
temp = chs[i];
chs[i] = chs[s.length()-1-i];
chs[s.length()-1-i] = temp;
}
//将反转后的字符数组转换成字符串并打印
System.out.println("反转后的字符串："+new String(chs));
}
//获取一个字符串在另一个字符串中出现的次数
public static int myCount(String s,String key)
{
//定义一个计数器
int count = 0;
while(true)
{
//如果字符串中包含字符串key，计数器加1，,取子串，继续判断
if(s.contains(key))
{
count++;
s = s.substring(s.indexOf(key)+key.length(),s.length());
}
//如果不包含，则计数结束，退出循环
else
break;
}
return count;
}
//获取两个字符串的最大相同子串
public static void mySubstring(String s1,String s2)
{
//定义两个变量分别存放大、小字符串
String max = "";
String min = "";
//判断两个字符串的长短并赋值给相应的变量
max = s1.length() > s2.length()?s1:s2;
min = s1.length() < max.length()?s1:s2;
//System.out.println(max+"::"+min);
//定义一个变量来存储两个字符串的最大子串
String submax = "";
/*获取最大子串：外循环控制最短字符串的最少子串数；内循环控制最短字符串的所有子串；
取子串所需的角标跟外循环无关。
*/
for(int i=0;i<min.length();i++)
{
for(int j=min.length()-i,k=0;j>k && j<min.length()+1;j++,k++)
{
String temp = min.substring(k,j);
//System.out.println(temp);
//如果长字符串包含短字符串的子串，则结束循环，并将该子串赋值为submax
if(max.contains(temp))
{
submax = temp;
break;
}
}
//如果submax不为空，说明已找到最大相同子串，结束外循环
if(!submax.isEmpty())
break;
}
//根据submax是否为空，来判断是否找到最大相同子串
if(!submax.isEmpty())
System.out.println("这两字符串的最大相同子串为："+submax);
else
System.out.println("这两个字符串没有相同的字符！");
}
}
