------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文档
253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
