黑马程序员——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+">");
}
}

编译如下：