------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
一、字符串的特点
String是一个特殊的对象,之所以是对象,这是为了方便对字符串进行各种操作。同时String类具有final属性,所以String类不能被继承,其方法也不能被覆写。将字符串赋值给标识符时,是把字符串对象的地址赋给了引用变量。
字符串一旦被初始化成功,就是一个常量,不能被改变,若对字符串进行修改操作,实际上是建立了新字符串对象。
形如:String s = new String("abc");
看似只建立了一个字符串对象,其实是两个,"abc"是一个,将其作为参数传入构造函数得到的新字符串又是一个,因此这种新建字符串的方法不太好,直接这样就可以了:
String s = "abc";
String类复写了Object中的equals方法,用于比较两字符串是否相同。
s1 = "abc";s2 = "abc";
s1.equals(s2);//结果为true
另一种比较:
boolean a = (s1 == s2);//结果为true在常量池中已经存在的字符串不会再新建对象,因此s1与s2指向同一个对象。
1.获取
获取字符串长度
int length();
根据位置获取某个字符
char charAt(int index);
获取该字符在字符串中的位置,接收的是该字符的ASC码
int indexOf(int ch);//返回该字符在字符串中第一次出现的位置
int indexOf(int ch,int fromIndex);//从fromIndex指定位置开始,返回ch在字符串中出现的位置
int indexOf(String str);//返回给定字符串在字符串中第一次出现的位置
int indexOf(String str,int fromIndex);//从fromIndex指定位置开始,返回给定字符串在字符串中出现的位置
以上四种获取位置的方法,如果没有找到,则返回-1
相反的,如果获取反向索引,即字符或字符串最后一次出现的位置,则使用lastIndexOf方法,参数同上面四个函数
int lastindexOf(int ch);//返回该字符在字符串中最后一次出现的位置
int lastindexOf(int ch,int fromIndex);//从fromIndex指定位置开始,返回ch在字符串中最后一次出现的位置
int lastindexOf(String str);//返回给定字符串在字符串中最后一次出现的位置
int lastindexOf(String str,int fromIndex);//从fromIndex指定位置开始,返回给定字符串在字符串中最后一次出现的位置
2.判断
字符串中是否包含有指定子串
boolean contains(String str);
需要说明的是,indexOf函数也能判断是否包含有子串,因为若没有找到子串,该函数返回-1,到底用哪个方法视情况而定。
字符串中是否有内容
boolean isEmpty();//实际上函数内部判断length()是否返回0,若返回0,则isEmpty()返回true,否则返回false字符串是否以指定内容开头
boolean starsWith(String str);
字符串是否以指定内容结尾
boolean endesWith(String str);
判断字符串是否相同
boolean equals(String str);
boolean equalsIgnoreCase(String str);//忽视大小写,判断字符串是否相同
3.转换
将字符数组转成字符串
构造函数
String(char[]):初始化时就转化
String(char[],offset,count):将字符数组中的一部分转换成字符串静态方法
static String copyValueOf(char[] ch);
static String copyValueOf(char[] data,int offset,int count)static String valueOf(char[] ch);
将字符串转成字符数组
char[] toCharArray();
将字节数组转成字符串
String(byte[]):初始化时就转化
String(byte[],offset,count):将字节数组中的一部分转换成字符串
将字符串转成字节数组byte[] getBytes()
将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)
字符串和字节数组在转换过程中,是可以指定编码表的。
4.替换
将旧字符替换为新字符
String replace(oldchar,newchar);
注意,由于字符串的不可变性,返回的是一个新字符串对象,如果找不到要替换的字符,则返回原串用到正则表达式的方法:
replaceAll(String regex, String replacement) :使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
replaceFirst(String regex, String replacement) :使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
5.切割
String[] split(regex reg); 按指定的正则表达式作为分隔符切割字符串
注意:切割的时候,末尾的末尾的空字符串会全部略去获取子串(如果角标不存在,会出现角标越界异常)
String substring(int begin);按起点获取
String substring(int begin,int end);按起点-终点获取,注意:包含头不包含尾巴,即参数2,4指的是角标2-3的子串
6.转换大小写,去除空格,比较
(1)将字符串转换成大写或者小写String toUpperCase();
String toUpperCase();
(2)将字符串两端的多个空格去掉
String trim();(3)对两个字符串进行自然顺序的比较,注意:自然顺序指的是字符Unicode码的数值大小
int compareTo(String);
如果字符串等于参数字符串,则返回值0,如果小于参数字符串则返回负数,如果大于参数字符串则返回正数,具体的返回值为第一个不相等的字符的unicode码的差值。
三、字符串练习
1,模拟一个trim方法,去除字符串两端的空格。
思路:
(1),判断字符串第一个位置是否是空格,如果是继续向下判断,直到不是空格为止。结尾处判断空格也是如此。
(2),当开始和结尾都判断到不是空格时,就是要获取的字符串。
2,将一个字符串进行反转。将字符串中指定部分进行反转,"abcdefg";abfedcg
思路:
(1),曾经学习过对数组的元素进行反转。(2),将字符串变成数组,对数组反转。
(3),将反转后的数组变成字符串。
(4),只要将或反转的部分的开始和结束位置作为参数传递即可。
<span style="font-family:Microsoft YaHei;">class StringTest
{
public static void sop(String str)
{
System.out.println(str);
}
public static void main(String[] args)
{
String s = " ab cd ";
sop("("+s+")");
// s = myTrim(s);
// sop("("+s+")");
sop("("+reverseString(s)+")");
}
//练习二:将字符串反转。
/*
思路:
1,将字符串变成数组。
2,对数组反转。
3,将数组变成字符串。
*/
public static String reverseString(String s,int start,int end)
{
//字符串变数组。
char[] chs = s.toCharArray();
//反转数组。
reverse(chs,start,end);
//将数组变成字符串。
return new String(chs);
}
public static String reverseString(String s)
{
return reverseString(s,0,s.length());
}
private static void reverse(char[] arr,int x,int y)
{
for(int start=x,end=y-1; start<end ; start++,end--)
{
swap(arr,start,end);
}
}
private static void swap(char[] arr,int x,int y)
{
char temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
//练习一,去除字符串两端空格。
public static String myTrim(String str)
{
int start = 0,end = str.length()-1;
while(start<=end && str.charAt(start)==' ')
start++;
while(start<=end && str.charAt(end)==' ')
end--;
return str.substring(start,end+1);
}
}</span>
3,获取一个字符串在另一个字符串中出现的次数。
"abkkcdkkefkkskk"思路:
(1),定义个计数器。
(2),获取kk第一次出现的位置。
(3),从第一次出现位置后剩余的字符串中继续获取kk出现的位置。每获取一次就计数一次。
(4),当获取不到时,计数完成。
<span style="font-family:Microsoft YaHei;">class StringTest2
{
/*
练习三。
*/
public static int getSubCount(String str,String key)
{
int count = 0;
int index = 0;
while((index=str.indexOf(key))!=-1)
{
sop("str="+str);
str = str.substring(index+key.length());
count++;
}
return count;
}
/*
练习三,方式二。
*/
public static int getSubCount_2(String str,String key)
{
int count = 0;
int index = 0;
while((index= str.indexOf(key,index))!=-1)
{
sop("index="+index);
index = index + key.length();
count++;
}
return count;
}
public static void main(String[] args)
{
String str = "kkabkkcdkkefkks";
///sop("count====="+str.split("kk").length);不建议使用。
sop("count="+getSubCount_2(str,"kk"));
}
public static void sop(String str)
{
System.out.println(str);
}
}</span>
4,获取两个字符串中最大相同子串。第一个动作:将短的那个串进行长度一次递减的子串打印。
"abcwerthelloyuiodef"
"cvhellobnm"
思路:
(1),将短的那个子串按照长度递减的方式获取到。
(2),将每获取到的子串去长串中判断是否包含,如果包含,打印-----已经找到!。
<span style="font-family:Microsoft YaHei;">class StringTest3
{
/*
练习四。
*/
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+"...min="+min);
for(int x=0; x<min.length(); x++)
{
for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)
{
String temp = min.substring(y,z);
sop(temp);
if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
return temp;
}
}
return "";
}
public static void main(String[] args)
{
String s1 = "ab";
String s2 = "cvhellobnm";
sop(getMaxSubString(s2,s1));
}
public static void sop(String str)
{
System.out.println(str);
}
}</span>
StringBuffer类是字符串缓冲区,是一个容器。
缓冲区的特点:
(1).长度是可变化的(2).可以字节操作多个数据类型
(3).最终会通过toString方法变成字符窜
(4).修改后返回同一个对象,并不新建对象
什么时候用缓冲区:当数据类型不确定,数据个数也不确定,最后要得到字符串的时候,用缓冲区,比数组方便。
五、StringBuffer的方法
构造函数:
StringBuffer()初始容量为16字符
StringBuffer(int capacity)指定初始容量
StringBuffer(String str)初始化内容
方法:
1.存储
StringBuffer append()函数:支持基本数据类型的添加(除了byte和short),将指定数据作为 添加到已有数据的结尾处
如下形式是可行的
StringBuffer sb = new StringBuffer();
sb.append("abc").append(true).append(34);//方法调用链
插入方法
StringBuffer insert(index,数据)将数据插入到指定位置,可以传入多种数据类型
2.删除
StringBuffer delete(int start,int end):删除缓冲区中的数据,包含start,不包含end
StringBuffer deleteCharAt():删除指定位置字符
清空缓冲区
sb.delete(0,sb.length());
3.获取
char charAt(int index)获取指定位置的字符
int indexOf(String str)获取子串的位置
int lastIndexOf(String str)获取子串最后一次出现的位置
int length()获取缓冲区长度
String substring(int start, int end)截取子串
4.修改
StringBuffer replace(int start,int end,String str)将指定子串替换掉
void setCharAt(int index,char ch)替换指定位置的字符,无返回值
5.反转
StringBuffer reverse();
6.转存到数组
void getChars(int srcBegin,int scEnd,char[] dst,int dstBegin)
获取缓冲区的指定数据并按字符存入指定数组的指定位置,这类方法都要注意角标越界异常
六、StringBuilder类
StringBuilder类:JDK1.5增加内容 新缓冲区类与StringBuffer的区别:StringBuffer是线程同步,StringBuildr是线程不同步,由于简化同步操作,后者效率更高,开发建议使用后者
七、基本数据类型对象包装类
1.基本数据类型和它们对应的包装类如下:byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
将基本数据类型包装后能提供更多的方法,实现更强大的功能。最常见的作用:用于基本数据类型和字符串类型之间做转换。
基本数据类型转换成字符串:
基本数据类型+""基本数据类型.toString(基本数据类型值)
字符串转成基本数据类型:
X a = X.parseX(String):X代表基本数据类型的包装类
若字符串书写格式不是基本数据,会报数据格式异常
2.重要的方法
十进制转换
Integer.toBinaryString();转换成二进制
Integer.toHexString();转换成十六进制
Integer.toOctalString();转换成八进制
其他进制转换成十进制
parseInt(String s,int radix)接收指定进制的数字字符串,转换成十进制Integer构造方法
Integer(String s)接收数字字符串
基本数据包装类转换成基本数据类型
Integer.intValue();
3. 1.5版本新特性 基本数据类型自动装箱
Integer x=4;数值自动装箱变成对象
x=x+2;这个语句先进行自动拆箱,变成int类型,加法运算后,再自动装箱
注意:若x=null,会抛空指针异常
下面代码:Integer a=128;
Integer b=128;
System.out.println(a==b);//打印结果为false
Integer a=127;
Integer b=127;
System.out.println(a==b);//打印结果为true
之所以这样,原因是当数值在byte范围内时,对于新特性,不会开辟新的空间
更多常用方法可参考API文档