黑马程序员——String类常见的操作方法

　——- android培训、java培训、期待与您交流！ ———-
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在字符串中出现的位置。

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 endWith（str）;
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同。并忽略大小写。
boolean equalsTgnoreCase();

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

静态方法：
static String copyValueof(char[]);
static String copyValueOf(char[] data,int offest,int count)
3.2将字符串转成字符数组。**重点
char[] toCharArray()
3.3将字节数组转成字符串。
String(byte[])
String(byte[],offect,count);
3.4将字符串转成字节数组。
byte[] getBytes();
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
3.5将基本数据类型转成字符串。
String valueOf(int)
String valueOf(double)

4.替换
String replasce(oldchar,newchar);
5.切割
String split(regex);
6.获取子串。
String substring(begin);
String substring(begin,end);
7.特殊转换。（去除空格，两者比较）
7.1 将字符串转换成大写或者小写
String toUperCase();
String ToLowerCase();
7.2将字符串两端多余空格去除。
String trim();
7.3将两字符串进行既然顺序的比较。
int compareTo(string);
示例1：

class String1 
{
public static void method_get()
    {
        String str="abcdeakpf";
//长度
//System.out.println(str.length);
//获取某个位置的字符
//System.out.println(str());
        sop(str.length());  //长度

//根据索引获取字符
        sop(str.charAt(4));//

//根据字符获取索引
        sop(str.indexOf('a'));//第一次的位置
        sop(str.indexOf('a',3));//3位置后第一次出现的位置
    }
public static void main(String[] args) 
    {
        method_get();
        String s1="abc";
        String s2=new String("abc");
        String s3="abc";
        String s4=new String("abc");
        System.out.println(s1==s2);  //false
        System.out.println(s1==s3);  //true
        System.out.println(s4==s2);  //false
        System.out.println(s1==s2);
    }

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

---

//示例2
class test1
{

public static void main(String[] args) 
    {
        String str=" a, d ";
        testn1(str);
        System.out.println("<"+str+">");//没有去两头空字符
    }
public static void testn1(String str)
    {
int start =0;
int end =str.length()-1;//和数组异常str角标从零开始，长度从1开始
while(start<=end&&str.charAt(start)==' ')
            start++;
while(start<=end&&str.charAt(end)==' ')
            end--;
        System.out.println("内<"+str.substring(start,end+1)+">");
    }
}

编译如下：

---

/**
将字符串反转
*/
class test2 
{
public static void sop(String arr)//封装输出语句
    {
        System.out.println("<"+arr+">");
    }
public static void main(String[] args) //定义主函数
    {

        String s=" ab,cd,ef ";
        sop(s);                 
        sop(reverseString(s));

    }
public static String reverseString(String s)//
    {
char[] arr=s.toCharArray();//转换为数组进行操作A
        reverse(arr);           //反转操A
return new String(arr); //返回一个数组并转换成字符串
    }

public static void reverse(char[] arr)//A1
    {       
for(int x=0,y=arr.length-1;x<y;x++,y--)
        {swap(arr,x,y);}

    }
public static void swap(char[] arr,int x,int y)//A2
    {
char temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;

    }

}

编译如下：

---

/**
将部分字符串a--c反转
*/
class test3 
{
public static void sop(String arr)//封装输出语句
    {
        System.out.println("<"+arr+">");
    }
public static void main(String[] args) //定义主函数
    {       
        String s=" ab,cd,ef ";
        sop(s);                 
        sop(reverseString(s,5,8));      
    }
public static String reverseString(String s,int a,int b)
    {
char[] arr=s.toCharArray();//转换为数组进行操作A
        reverse(arr,a,b);           //反转操A
return new String(arr); //返回一个数组并转换成字符串 
    }
public static void reverse(char[] arr,int a,int b)//A1
    {       
for(int x=a,y=b-1;x<y;x++,y--)
        {swap(arr,x,y);}        
    }
public static void swap(char[] arr,int x,int y)//A2
    {
char temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;        
    }   
}

编译如下：

---

/**
获取字串的位置”abkkcdkkefkkskk“
利用split切割方法
*/
class test4 
{
public static void main(String[] args) 
    {
        String str="kkabkkcdkkefkks";
        sop("count=------"+str.split("kk").length);//不建议使用
        sop("count="+ getSubCount(str, "kk"));//改变了字符串
        sop("count="+ getSubCount_1(str, "kk"));//不改变字符串
    }
public static void sop(String str)
    {
        System.out.println(str);
    }
public static int getSubCount_1(String str,String key)
    {
int count=0;//Key出现的次数
int index=0;//字串位置
while((index=str.indexOf(key,index))!=-1)//indexOf(String str, int fromIndex)
        {                               //返回从指定的位置开始搜索返回子字符串第一次出现的位置
            sop("str= "+str);
            sop("index= "+index);
index+=key.length();
count++;
        }
return count;
    }
public static int getSubCount(String str,String key)
    {
int count=0;//key出现的次数
int index=0;//字串位置
while((index=str.indexOf(key))!=-1)//index的位置设定为每次key字符的位置
        {
            sop("str= "+str);
str=str.substring(index+key.length());//每循环一次都会取key后面子字符串
count++;
        }
return count;
    }
}

---

/**
获取两个字符串最大相同的子串
s1="abcwerthelloyuiodef"
s2="cvhellobnm"
思路;
1,将短的字符串按照长度递减的方式获取到
2，将每获取到的子串去长串判断是否包含。
如果包含，已经找到。
*/
class test5 
{
public static void main(String[] args) 
    {
        String s2="abcwerthelloyuiodef";
        String s1="cvhellobnm";
//getmin(s1,s2);
        sop(getMaxSubstring(s1,s2));
    }
public static void getmin(String s1,String s2 )
    {
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
         min=(max==s1)?s2:s1;
        sop("max="+max);
        sop("min="+min);
        sop(getMaxSubstring(max,min));
    }
public static void sop(String temp)
    {
        System.out.println(temp);
    }
public static String getMaxSubstring(String s1,String s2)
    {
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
         min=(max==s1)?s2:s1;
         sop("max="+max);
        sop("min="+min);
for(int x=0;x<min.length();x++)
        {
for (int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)//y；每一层开始地址。z:每一层结束位地址
            {                                   //遍历每一层都是y和z分别加1,最后判断z到最后一位就是字符串的末位所以是(s.length+1)
                String temp= min.substring(y,z);        
                sop("min.substring(y,z) "+temp);
if(max.contains(temp))//if(max.indexOf(temp)!=-1)
return temp;
            }
        }
return "";
    }
}

编译如下：

---

StringBuffer是字符缓冲区

是一个容器C create U update R read D delete
1.长度是可变化的，数组是一个容器，长度是固定的
2.可以直接操作多个数据类型
3.最终会通过toString方法变成字符串。
4.当数据类型不确定，数据个数不确定，最终变成字符串时候用。

1.存储。
StringBuffer append();将知道数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,数据)：可以将数据插入到指定index位置。
2.删除。
delete(statrt,end),删除头不删除尾
delete(0,str.length()) 清空缓冲区
deleteCharAt(n)清空n位置的字符。
3.获取
int charAt(int index)
int indexOf(String str)
String substring(int start,int end)
4.修改
replace(int start,int end,String str1)//换头不换尾
setCharAt(2,k);替换字符
5.反转
StringBuffer reverse()
6. 定义一个新数组，将缓冲区指定位置字符串存储到该字符数组指定位置（不包含尾）
void getChars(int strBegin,int sreEnd,char[] dst, int dstBegin)
原来头, 原来尾, dst的字符数组,数组存储开始位

**升级三个因素：
1.提高效率。
2.提高安全性。
3.简化书写。**

class test6 
{
public static void main(String[] args) 
    {
        StringBuffer sb=new StringBuffer();
//StringBuilder sb=new StringBuilder();//方法一样
        sb.append("abc").append("true").append(38);//"abctrue38"
        sb.insert(1,"qq");//1位置插入数据
        sop(sb.toString());
        char [] str=new char [6];//定义新数组长度为6
        sb.getChars(1, 4,str,1) ;//将sb字符串中数据从1位置到3位置存储到str数组1位置后。
            sop(new String(str));
for(int x=0;x<str.length;x++)
            {
                sop("str["+x+"]= "+str[x]);
            }
        /*sb.replace(1,4,"java");//**替换1--4，不包含4
            sop(sb.toString());
        sb.delete(1,5);//**删除1--5，不包含5
            sop(sb.toString());
        sb.deleteCharAt(3);//删除3
            sop(sb.toString());
            sb.setCharAt(3,'k');//替换2
            sop(sb.toString());
            sb.delete(0,(sb.length()));//清空缓冲区
            sop("<"+sb.toString()+">");
//sop(sb1.toString());
//sop(sb2.toString());
//sop("sb1==sb: "+(sb1==sb));*/
    }
public static void sop(String str)
    {
        System.out.println(str+">");
    }
}

编译如下：