——- 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+">");
}
}编译如下：
