（8）String、StringBuffer、StringBuilder

1.String s1="abc";

String s2=new String ("abc");
String s3="abc";

s1==s2;   //flase
s1==s3;   //true
区别：S1在内存中有1个对象，S2在内存中有2个对象
常量是在方法区中的常量池里的，当String s1="abc"时，常量池中已经有了abc对象，执行String s3="abc"时，虚拟机就不会再开辟空间创建abc对象，所以s1和s3指向的是同一对象。而s2包含两个对象。
2.String 类重写了Object类中的equals方法（本类是比较两个对象的地址值），比较的是字符串的值。
3.字符串的常见操作
获取：
（1）获取字符串的长度： 
int length()
（2）获取指定索引在字符串中的字符：
char chatAt(int index)
（3）获取指定字符第一次出现的索引：
int indexOf(int ch)
        从指定索引处开始获取指定字符的索引
int indexOf(int ch,int fromIndex)
（4）获取指定字符串的索引：
int indexOf(String str)
        从指定索引处开始获取指定字符串的索引
int indexOf(String str,int fromIndex)
（5）反向索引
获取指定字符最后一次出现的索引：
int lastIndexOf(int ch)
从指定位置开始，从后往前获取指定字符第一次出现的索引：
int lastIndexOf(int ch,int fromIndex)
获取指定字符串最后一次出现的索引：
int lastIndexOf(String str)
从指定位置开始，从后往前获取指定字符串第一次出现的索引：
int lastIndexOf(String str,int fromIndex)
判断：
（1）判断字符串是否包含指定的字符序列
boolean contains(CharSequence cs)
（2）判断字符串是否为空
boolean isEmpty()
（3）判断字符串是否以指定的字符串开头
boolean startsWith()
（4）判断字符串是否以指定的字符串结尾
boolean endsWith()
（5）比较字符串内容是否相同
boolean equals(Object obj)
（6）比较字符串是否相同，且忽略大小写
boolean equalsIgnoreCase(String str)
转换：
（1）将字符数组转换为字符串：
构造方法：String(char[] ch)
静态方法：static String copyValueOf(char[] ch)
                static String copyValueOf(char[] ch,int offset,int count)
                static String valueOf(char[])
（2）将字符串转换为字符数组：
char[] toCharArray()
（3）将字节数组转换为字符串：
构造方法：String(byte[] by)
（4）将字符串转换为字节数组：
getBytes()
（5）将基本数据类型转换为字符串：
static String valueOf(int/double/float……)
切割：
String[] split(String regex)
子串：
String substring(int beginIndex)
String substring(int beginIndex,int endIndex)
替换：
    替换单个字符
String replace(char oldChar,char newChar)
    替换字符串
String replace(charSequence target,charSequence replacement)
大小写转换
String toUpperCase()
String toLowerCase()
去除两端空格
String trim()
按字典顺序比较字符串
int compareTo(String anotherString)
int compareToIgnoreCase(String str)

4.模拟一个trim方法，去掉字符串两端的空格
//思路：先分别获取字符串前面和后面连续空格的角标，取子串
public class Test1
{
    public static void main(String []args)
    {
        String str="  dff  dfd   ";
        System.out.println("("+str+")");
        System.out.println("("+myTrim(str)+")");
    }
public static String myTrim(String str)
{
    String sub="";
    int start=0,end=str.length()-1;
        while ( start<end && str.charAt(start)==' ')
            start++;
        while( start<end && str.charAt(end)==' ')
            end--;
     sub=str.substring(start,end+1);
     return sub;
}
}

5.将一个字符串进行反转，将字符串指定的部分进行反转
//思路：1.将字符串转换为字符数组
//      2.将字符数组反转
//      3.将字符数组转换为字符串

public class Test2
{ 
    public static void main(String [] args)
    {
        String str="asdf  skfk fjk  ";
        System.out.println("("+str+")");
        
        //System.out.println("("+reverseTest(str)+")");
        System.out.println("("+reverseTest(str,2,3)+")");
    }

    //将一个字符串进行反转
    public static String reverseTest(String str)
    {
        char [] arr=str.toCharArray();
        reverse(arr);
        return new String(arr);
    }
    //反转数组
    public static void reverse(char [] arr)
    {
        for (int start=0,end=arr.length-1;start<end ;start++,end-- )
        {
            swap(arr,start,end);
        }
    }
    public static void swap(char [] arr,int start,int end)
    {
        char temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
    }
    //指定字符串的位置进行反转
    //overload----------------------------------
        public static String reverseTest(String str,int i,int j)
    {
        char [] arr=str.toCharArray();
        reverse(arr,i,j);
        return new String(arr);
    }
    //反转数组
    public static void reverse(char [] arr,int i,int j)
    {
        for (int start=i,end=j;start<end ;start++,end-- )
        {
            swap(arr,i,j);
        }
    }

}

6.获取一个字符串在另一个字符串中出现的次数
//思路：计数器，int index=indexOf(sub)，每次循环后indexOf(sub,index+sub.length())

public class Test3
{
    public static void main (String [] args)
    {
        String s="weaddherddelloddorddse";
        System.out.println(getCount(s,"dd"));
    }
    /*
    public static int getCount(String s,String key)
    {
        int count=0;
        int index=0;
        while((index=s.indexOf(key))!=-1)
        {
            s=s.substring(index+key.length());
            count++;
        }
        return count;
    }
    */
    //方法二
    public static int getCount(String s,String key)
    {
        int count=0;
        int index=0;
        while((index=s.indexOf(key,index))!=-1)
        {
            index=index+key.length();
            count++;
        }
        return count;
    }
}

7.获取两个字符串中最大相同字串
//思路：拿短的字符串去和长的字符串比较，看是否包含
//      如果不包含，则取出短字符串长度减1后的字串再和长字符串比较，依次循环
public class Test4
{
    public static void main(String []args)
    {
        String s1="programmerhellojava";
        String s2="okmybabyjava";
        String sub=getMaxSubstring(s1,s2);
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(sub);
    }
    public static String getMaxSubstring(String s1,String s2)
    {
        String sub="";
        //把两个字符串中长的放在max中，短的放在min中
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
        min=(max==s1)?s2:s1;
        for (int i=0;i<min.length() ;i++ )
        {
            for (int j=0,z=min.length()-i;z!=min.length()+1 ;j++,z++ ) //注意写法
            {
                sub=min.substring(j,z);
                System.out.println(sub);
                if(max.contains(sub))
                    return sub;
            }
        }
        return sub;
    }
}

8.StringBuffer字符串缓冲区，是一个容器，特点：
长度可变
可以操作多种数据类型
最终通过toString方法转换为字符串
9.常见方法
CRUD
增加、插入：
StringBuffer append(各种数据类型)
StringBufer insert(int offset,各种数据类型)
删除
StringBuffer delete(int start,int end)  清空StringBuffer delete(0,sb.length())
StringBuffer deleteCharAt(int index)
查索引、查字符
int indexOf(String str)
int indexOf(String str,int fromIndex)
char charAt(int index)
修改、替换、复制
void setChatAt(int index,char ch)
StringBuffer replace(int start,int end,String str)
void getChars（int srcBegin,int srcEnd,char[] dst,int dstBegin)
获取长度、字串
int length();
String substring(int start)
String substring(int start,int end )
反转
StringBuffer reverse()
10.StringBuffer是线程同步的
StringBuilder是线程不同步的
StringBuilder是jdk1.5以后才出现的，虽然StringBuilder是线程不安全的，但可以提高效率
java升级的原因：
提高效率、简化代码、提高安全性