13、String类
1、字符串是一种特殊的对象
2、字符串一旦初始化就不可以改变
3、String str="abc" str是一种类类型变量， abc是一种对象
4、String str1=new String("abc");字符串最大的特点是一旦被初始化，就不可以被改变
5、String类复写了Object类中的equals方法，该方法用于判断字符串是否相同
练习代码：
package days6;
public class Equals1
{
public static void main(String []args)
{
String s1="abc";
String s2=new String("abc");
String s3="abc";
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//true
System.out.println(s1==s2);//false
System.out.println(s1==s3);//true
}
}
String类是描述字符串事物的，那么它就提供了多个方法对字符串进行控制
1、获取
（1）字符串包含的字符数也就是字符串长度。int length（）获取长度。
（2）根据位置获取位置上的某个字符 char charAt(int index)
（3）根据字符获取该字符在字符串中的位置 int indexof（int ch）返回的是ch在字符串中第一次出现的位置
Int indexof （int ch， int fromIndex）从fronIndex指定位置开始，获取ch在字符串中出现的位置
2、判断
（1）字符串中是否包含某一个字符 boolean contanins（str）
（2）字符串中是否有内容 boolean isEmpty（）//原理是判断长度是否为空
（3）字符串是否以指定内容开头 boolean startWith（str）；
（4）字符是否以指定内容结尾boolean endWith（str）
（5）判断字符串内容是否相同 boolean equals（str）//复写了Object类中的equals方法
（6）判断内容是否相同并忽略大小写boolean equalsIgnore case（）；
练习代码：
package days6;
public class StringMethod
{
public static void main(String[]args)
{
String str="abcdef";
sop(str.length());
sop(str.charAt(1));
sop(str.indexOf('a'));
sop(str.indexOf('a', 3));
String str1="abc.java";
sop(str1.startsWith("ab"));
sop(str1.endsWith("java"));
sop(str1.contains("bcc"));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
特殊之处：indexOf（str）；可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中出现，所以也可以对指定字符串判断是否包含
例如：if（str.indexof（“aa”）！=-1）表示有，而且该方法既可以获取出现的位置又可以判断。
转换
（1）将字符数组转换成字符串：
构造函数：String（char[ ]） String（char[ ]，offset，count）将字符数组中一部分转换成字符串
静态方法：static String copyValueof（char[ ]）； static copyValueof（char[ ]data, intoffset,int count） static String Valueof(char[ ]);
（2）将字符串转换成字符数组：char[] toCharArray():
（3）将字符串转换成字符数组String (byte[ ]),String (byte[ ],offset,count)
（4）将字符串转成字节数组byte[] getBytes():
（5） 将基本数据类型转成字符串。static String valueOf(int)，static String valueOf(double)
字符串和字符数组在转换过程中是可以指定编码表的
package days6;
public class StringMethod2
{
public static void main(String[]args)
{
char[]arr={'a','b','c','d','e'};
String s=new String(arr,1,3);
sop("s="+s);
String str="abcdef";
char[]ch=str.toCharArray();
for(int x=0;x<ch.length;x++)
{
sop("ch"+"["+x+"]="+ch[x]);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
替换
String replace（old char，new char）
切割
String[ ]split（regex）
子串：获取子串的一部分
String substring(begin);//从指定位置开始到结尾，如果角标不存在，会出现字符串角标越界 异常
String substring（begin，end）//包含头不包含尾
package days6;
public class StringMethod3
{
public static void main(String[]args)
{
method_replace();
method_split();
method_sub();
}
public static void method_replace()
{
String s="hello";
String s1=s.replace('e', 'a');
sop("s="+s);
sop("s1="+s);
String s2=s.replaceAll("he", "hee");
sop("s2="+s2);
}
public static void method_sub()
{
String s="abcdd";
sop(s.substring(1));
sop(s.substring(1, 3));
}
public static void method_split()
{
String s="java,C++,C#";
String[]arr=s.split(",");
for(int x=0;x<arr.length;x++)
{
sop("arr"+"["+x+"]="+arr[x]);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
转换大小写
String toUppercase（）； String toLowerCase（）；
去除两端多个空格
String trim（）；
对两个字符串进行自然顺序比较
Int compareTo（str）；
package days6;
public class StringMethod4
{
public static void main(String[]args)
{
String s=" Hello java ";
sop(s.toLowerCase());
sop(s.toUpperCase());
sop(s.trim());
sop(s);
String s1="abc";
String s2="def";
sop(s1.compareTo(s2));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
练习代码：
1，模拟一个trim方法，去除字符串两端的空格。
思路：1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
结尾处判断空格也是如此。
2，当开始和结尾都判断到不是空格时，就是要获取的字符串。
package days6;
public class StringTest
{
public static void main(String[]args)
{
String str=" abc ";
sop(MyTrim(str));
}
public static String MyTrim(String str)
{
int start=0; int end=str.length()-1;
sop(end);
while(start<=end&&str.charAt(start)==' ')
{
start++;
}
while(start<=end&&str.charAt(end)==' ')
{
end--;
}
String str2=str.substring(start, end+1);
return str2;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
思路：
1，曾经学习过对数组的元素进行反转。
2，将字符串变成数组，对数组反转。
3，将反转后的数组变成字符串。
4，只要将或反转的部分的开始和结束位置作为参数传递即可。
package days6;
public class StringTest2
{
public static void main(String[]args)
{
String str="abcdefg";
sop(str);
sop(reverse(str));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static String reverse(String str)
{
char[]ch=str.toCharArray();
swap(ch);
String str2=new String(ch);
return str2;
}
public static void swap(char[]ch)
{
for(int i=0,j=ch.length-1;i<j;i++,j--)
{
char temp=ch[i];
ch[i]=ch[j];
ch[j]=temp;
}
}
}
获取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
"abcwerthelloyuiodef""cvhellobnm"
思路：
1，将短的那个子串按照长度递减的方式获取到。
2将每获取到的子串去长串中判断是否包含，如果包含，已经找到！。
package days6;
public class StringTest3
{
public static void main(String[]args)
{
String str1="ade";
String str2="abcde";
sop(MySubstring(str1,str2));
}
public static String MySubstring(String str1,String str2)
{
String max=(str1.length()>=str2.length())?str1:str2;
String min=(max==str1)?str2:str1;
String m = null;
String n = null;
for(int i=min.length()-1;i>0;i--)
{
m=min.substring(0, i);
if(max.indexOf(m)==0)
{
n=m;
break;
}
}
return n;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
获取一个字符串在另一个字符串中出现的次数“abkkcdkkefkkskk”
思路：
1、定义一个计数器
2、获取kk第一次出现的位置
3、当第一次出现位置后剩余的字符串中继续获取kk出现的位置
4、每获取一次，就计数一次
5、当获取不到时，计数完成
package days6;
public class StringTest4
{
public static void main(String[]args)
{
String s1="abkkcdkkefkkskk";
String s2="kk";
sop("一共出现了"+getCount(s1,s2)+"次");
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static int getCount(String s1,String s2)
{
String m=null;
int count = 0;
for(int i=0;i<s1.length()-1;i++)
{
m=s1.substring(i);
//sop(m);
if(m.indexOf(s2)==0)
{
sop("s2在s1中出现在第"+i+"号位置");
count++;
}
}
return count;
}
}
14、StringBuffer类
概述
1、字符串的组成原理就是通过该类实现的
2、StringBuffer可以对字符串内容进行删改
3、StringBuffer是一个容器
4、很多方法与String相同
5、StringBuffer是可变长度的
StringBuffer是一个容器，而且长度是可变化的，可以直接操作多个数据类型，最终会通过String方法变成字符串
存储
StringBuffer append（）；//将指定数据作为参数添加到已有数据的结尾处
StringBuffer insert（index，数据）可以将数据插入到指定index位置
package days6;
public class StringBuffer1
{
public static void main(String []args)
{
StringBuffer sb = new StringBuffer();
sb.append(39);
sb.insert(1, 99);
sb.append("abc").append(true).append(34);
StringBuffer sb1=sb.append(34);
String s1=new String(sb);
String s2=new String(sb1);
sop(s1);
sop(s2);
}
public static void sop(String sb)
{
System.out.println(sb);
}
}
删除
StringBuffer delete（start，end）删除缓冲区中的数据（包含start，不包含end）
StringBuffer deletecharAT（index）删除指定位置的字符
package days6;
public class StringBuffer2
{
public static void main(String[]args)
{
delete();
}
public static void sop(String str)
{
System.out.println(str);
}
public static void delete()
{
StringBuffer st=new StringBuffer("abcde");
st.delete(1, 3);
sop(st.toString());
st=new StringBuffer();
sop(st.toString());
;
}
}
获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String substring(int start, int end)
修改。
StringBuffer replace(start,end,string);
void setCharAt(int index, char ch) ;
反转。
StringBuffer reverse();
将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
package days6;
public class StringBuffer4
{
public static void main(String[]args)
{
update();
chars();
}
public static void update()
{
StringBuffer st=new StringBuffer("abcda");
st.replace(1, 4, "str");
sop(st.toString());
st.setCharAt(2, 'k');
sop(st.toString());
}
public static void chars()
{
StringBuffer st=new StringBuffer("abcda");
char[] chs=new char[6];
st.getChars(1, 4,chs,1);
for(int x=0;x<chs.length;x++)
{
sop("chs["+x+"]="+chs[x]);
}
}
public static void sop(String str)
{
System.out.println(str);
}
}
15、StringBuilder类
Jdk1.5版本之后出现了StringBuilder
StringBuffer：线程同步
StringBuilder：线程不同步
开发建议使用StringBuilder
升级三个因素：
1、提高效率
2、简化书写
3、提高安全性
16、基本数据类型对象包装类
基本数据类型对象包装类。
Byte——Byte
Short——short
Int——Integer
Long——Long
boolean ——Boolean
Float——Float
Double——Double
Char——Character
基本数据类型对象包装类的最常见作用，
就是用于基本数据类型和字符串类型之间做转换
基本数据类型转成字符串。
基本数据类型.toString(基本数据类型值);
如： Integer.toString(34);//将34整数变成"34";
字符串转成基本数据类型。
xxx a = Xxx.parseXxx(String);
int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
Integer i = new Integer("123");
int num = i.intValue();
十进制转成其他进制。
toBinaryString();
toHexString();
toOctalString();
其他进制转成十进制。
parseInt(string,radix);
练习代码：
package days6;
public class Inte
{
public static void main(String[]args)
{
Ints();
}
public static void sop(int m)
{
System.out.println(m);
}
public static void Ints()
{
int m=Integer.parseInt("123");
sop(m);
}
}