——- android培训、java培训、期待与您交流！ ———-
一、类String
类String：是final型的。所以没有子类。只要是" "的都是String类的具体对象。
String s=new String(); //相当于String s=" ";
String s1="abc"; //s1是一个类类型变量，"abc"是一个对象。
s1="kk"; //打印结果为kk，因为s1变了，指向地址变了。
String s2=new String("abc"); 和String s1="abc"; 使用起来是一样的。
字符串最大的特点就是：一旦被初始化就不可以被改变。
例如：
String s1="abc";
String s2=new String("abc");
String s3="abc";
s1==s2; //打印结果为false。因为“==”比的是地址值
s1.equals(s2); //打印结果为true。因为String类复写了Object类中的equals方法，该方法用于判断字符串是否相同，即判断内容是否相同。
s1==s3;////打印结果为true。因为s3进行初始化时，发现abc已经在内存中存在，就不会再独立开辟空间，直接指向abc.
注：s1在内存中有一个对象。
s2在内存中有两个对象。
二、常见操作
String类适用于描述字符串事物，它提供了很多方法对字符串进行操作。
1、获取
a).字符串中包含的字符数，也就是字符串的长度
int length()：获取长度
b).根据位置获取位置上的某个字符
char charAt(int index)：当访问到字符串中不存在的角标时，会发生字符串角标越界的错误。
c).根据字符获取该字符所在字符串中的位置
int indexOf(int ch)：返回的是ch在字符串中第一次出现的位置。传入的是字符对应的ASCII码。如果没有找到，返回-1。
int indexOf(int ch,int fromIndex)：从fromIndex指定位置开始，获取ch在字符串中出现的位置。
int indexOf(String str)：返回的是str在字符串中第一次出现的位置。
int indexOf(String str,int fromIndex)：从fromIndex指定位置开始，获取str在字符串中出现的位置。
int lastIndexOf(int ch)：返回的指定字符在此字符串中的最后一次出现处的索引。
intlastIndexOf(//还有其他情况可查阅API文档)。
2、判断
a).字符串中是否包含某一个子串
boolean contains(String str)
特殊之处：indexOf(str)：可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。所以，indexOf(str)也可以用于对指定判断是否包含字符串。如：if(str.indexOf("aa")!=-1)可判断出字符串str中是否包含aa。indexOf(str)方法既可以用于判断，又可以获取其出现的位置。如果只为判断，可用contains。
b).字符串中是否有内容
boolean isEmpty()：原理就是判断长度是否为0
c).字符串是否是以指定内容开头
boolean startsWith(String str)
d).字符串是否是以指定内容结尾
boolean endsWith(String str)
e).判断字符串内容是否相同，复写了Object类中的equals方法
boolean equals(String str)
f).判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase()
3、转换
a).将字符数组转成字符串
构造函数：String (char[])；
String(char[],offset,count)；//将字符数组中的一部分转成字符串。
静态方法：static String copyValueOf(char[])；
staticString copyValueOf(char[] data,int offset ,int count )；
static String valueOf(char[])；
b).将字符串转成字符数组
char[] toCharArray()
c).将字符串转成字节数组
byte[] getBytes()
d).将字节数组转成字符串
String(byte[])
String(byte[],offset,count)：将字节数组中一部分转成字符串
e).将基本数据类型转成字符串
static String valueOf(int)
static String valueOf(double)
如：3+" "相当于String.valueOf(3)相当于"3"
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4、替换
String raplace(oldChar,newChar)
5、切割
String[] split(regex)
6、子串，获取字符串中的一部分
String substring(begin)
String substring(begin,end)
7、转换，去除空格，比较
a).将字符串转成大写或小写
String toUpperCase()：将小写转换成大写
String toLowerCase()：将大写转换成小写
b).将字符串两端的多个空格去除
String trim()
c).对两个字符串进行自然顺序的比较
int compareTo(String)
示例：
class StringDemo { public static void main(String[] args) { String str="abcabde"; method_get(str); method_is(str); method_trans(str); method_replace(str); method_split(str); method_sub(str); method_change(str); } public static void method_get(String str)//1、获取 { //字符串中包含的字符数，也就是字符串的长度 int s1=str.length(); //根据位置获取位置上的某个字符 char s2=str.charAt(2); //根据字符获取该字符所在字符串中的位置 int s3=str.indexOf('b'); int s4=str.indexOf('a',1); int s5=str.indexOf("ca"); int s6=str.indexOf("ab",2); int s7=str.lastIndexOf('b'); System.out.println("1、获取=="+s1+"::"+s2+"::"+s3+"::"+s4+"::"+s5+"::"+s6+"::"+s7); } public static void method_is(String str)//2、判断 { //字符串中是否包含某一个子串 boolean b1=str.contains("ca"); //字符串中是否有内容 boolean b2=str.isEmpty(); //字符串是否是以指定内容开头 boolean b3=str.startsWith("ab"); //字符串是否是以指定内容结尾 boolean b4=str.endsWith("de"); //判断字符串内容是否相同，复写了Object类中的equals方法 boolean b5=str.equals("abcabde"); //判断内容是否相同，并忽略大小写。 boolean b6=str.equalsIgnoreCase("abCabdE"); System.out.println("2、判断=="+b1+"::"+b2+"::"+b3+"::"+b4+"::"+b5+"::"+b6); } public static void method_trans(String str)//3、转换 { //将字符数组转成字符串 char[] ch={'a','b','c','a','d','f','b'}; String s1=new String(ch); String s2=new String(ch,2,4);//从角标2开始取4个字符 String s3=String.valueOf(ch); String s4=String.copyValueOf(ch); String s5=String.copyValueOf(ch,2,4); System.out.println("3、转换=="+s1+"::"+s2+"::"+s3+"::"+s4+"::"+s5); //将字符串转成字符数组 char ch1[]=str.toCharArray(); for(char c:ch1) { System.out.print(c+" "); } System.out.println(); //将字符串转成字节数组 byte[] bt=str.getBytes(); for(byte b:bt) { System.out.print(b+" "); } System.out.println(); //将字节数组转成字符串 String str1=new String(bt); String str2=new String(bt,1,3); System.out.println(str1+"::"+str2); //将基本数据类型转成字符串 String st1=String.valueOf(3); String st2=String.valueOf(3.14); String st3=3+""; System.out.println(st1+"::"+st2+"::"+st3); } public static void method_replace(String str)//4、替换 { String st=str.replace("b","z");//将字符串中的所有b替换成z System.out.println("4、替换=="+st); } public static void method_split(String str)//5、切割 { //以b为分界线划分字符串 String [] st=str.split("b"); for(String s:st) { System.out.print(s+" "); } System.out.println(); } public static void method_sub(String str)//6、子串 { //获取字符串中的一部分 String st1=str.substring(2);//从角标2开始，到结尾的所有字符 String st2=str.substring(2,4);//包含头，不包含尾 System.out.println("6、子串=="+st1+"::"+st2); } public static void method_change(String str)//7、转换 { //将字符串转成大写或小写 String st1=str.toUpperCase(); String st2=st1.toLowerCase(); //将字符串两端的多个空格去除 String st3=" dsds "; String st4=st3.trim(); //对两个字符串进行自然顺序的比较 int aa=str.compareTo(st3); System.out.println("7、转换=="+st1+"::"+st2+"::"+st4+"::"+aa); } }运行结果为：
练习1：获取一个字符串在另一个字符串中出现的次数
/* 需求：获取一个字符串在另一个字符串中出现的次数 思路：1、定义一计数器 2、获得字符串第一次在另个字符中出现的位置 3、从第一次出现的位置后剩余的字符串中继续获取字符串出现的次数，每出现一次，计数器就加一次 3、当获取不到时候，计数停止 */ class StringTest1 { public static void main(String[] args) { String str="Hello Worlld"; String st="ll"; getCount(str,st); } public static void getCount(String str,String key) { int count=0;//定义一计数器 int index=0;//获得字符串第一次在另个字符中出现的位置 while((index=str.indexOf(key,index))!=-1) { index=key.length()+index; count++; } System.out.println("count="+count); } }运行结果为：
练习2：将一个字符串反转
/*需求：将一个字符串反转 思路：1、将字符串转换为字符数组 2、将数组反转,即第一位和最后一位换位，第二位和倒数第二位换位......依次交换 3、将字符数组转换为字符串 */ class StringTest2 { public static void main(String[] args) { String str="Hello World!"; reserve(str); } public static void reserve(String str) { //将字符串转换为字符数组 char[] ch=str.toCharArray(); //将数组反转,即第一位和最后一位换位，第二位和倒数第二位换位......依次交换 for(int x=0,y=str.length()-1;x<y;x++,y--) { char temp; temp=ch[x]; ch[x]=ch[y]; ch[y]=temp; } //将字符数组转换为字符串 System.out.println(new String(ch)); } }运行结果为：
练习3：获取两个字符串中最大相同子串
/*获取两个字符串中最大相同子串 思路：1、既然取的是最大子串，将短的一个字符串与长的进行比较，先看短的那个字符串是否在长的那个字符串中。 2、如果存在，短的那个字符串就是最大子串。 3、如果没有，则将短串的字串按长度递减的方式获取子串将每次获取的子串，去长串中判断是否包含，包含即找到。 */ class StringTest3 { public static void main(String[] args) { String str="HelloWorld!"; String st="swwrdsHellosdds"; String ss=getMaxSubString(str,st); System.out.println(ss); } public static String getMaxSubString(String str,String st) { String max,min; max=(str.length()>st.length())?str:st; min=(max==str)?st:str; for(int i=0;i<min.length();i++) { for(int x=0,y=min.length()-i;y<min.length()+1;x++,y++) { String temp=min.substring(x,y); if(max.contains(temp)) { return temp; } } } return "没有相同的字符串"; } } <span style="font-size:14px;"> </span>运行结果为：
练习4：对一个字符串中的字符进行自然排序
/*对一个字符串中的字符进行自然排序 思路：1、将字符串转换为字符数组。 2、对字符数组进行选择、冒泡排序 3、将排好序的字符数组转换为字符串 */ class StringTest4 { public static void main(String[] args) { String str="Hello World!"; selectSort(str); } public static void selectSort(String str) { //将字符串转换为字符数组。 char[] ch=str.toCharArray(); //对字符数组进行选择排序 for(int i=0;i<ch.length-1;i++) { for(int j=i+1;j<ch.length;j++) { if(ch[i]>ch[j]) { char temp; temp=ch[i]; ch[i]=ch[j]; ch[j]=temp; } } } //将排好序的字符数组转换为字符串 System.out.println(new String(ch)); } }运行结果为：
三、StringBuffer
StringBuffer：是一个容器，是字符串缓存区。
特点：1.而且长度是可变化的。（数组是固定的）
2.可以直接操作多个数据类型。（数组只能操作一个）
3.最终会通过toString方法变成字符串。
StringBuffer可以对字符串内容进行增删改查等操作。
1、存储
StringBuffer append()：将指定数据作为参数添加到已有数据的结尾处。
StringBuffer insert(intoffset,数据)：可以将数据插入到指定offset位置。
2、删除
StringBufferedelete(start,end)：删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(index)：删除指定位置的字符。
清空缓冲区：对象.delete(0,对象.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 srcEnd,char[] dst,int dstBegin)
示例：
class StringBufferDemo { public static void main(String[] args) { method_add();//增 method_del();//删 method_update();//改 method_sel();//查 StringBuffer sb=new StringBuffer("abcdef");//反转 sop("反转==="+sb.reverse()); char[] chs=new char[4]; sb.getChars(1,4,chs,1); for(int i=0;i<chs.length;i++) { sop("chs["+i+"]="+chs[i]+";"); } } public static void method_add()//增 { StringBuffer sb=new StringBuffer(); sb.append("abc").append("de").append("f"); StringBuffer sb1=new StringBuffer("abcdef"); sop("增==="+(sb==sb1)); sb.insert(1,"qq"); sop(sb.toString()); } public static void method_del()//删 { StringBuffer sb=new StringBuffer("abcdef"); sb.delete(1,3); sop("删==="+sb.toString()); sb.deleteCharAt(1); sop(sb.toString()); sb.delete(0,sb.length()); sop(sb.toString()); } public static void method_update()//改 { StringBuffer sb=new StringBuffer("abcdef"); sb.replace(1,4,"java"); sop("改==="+sb.toString()); sb.setCharAt(2,'K'); sop(sb.toString()); } public static void method_sel()//查 { StringBuffer sb=new StringBuffer("abcdef"); char ch=sb.charAt(2); int sb1=sb.indexOf("cd"); int sb2=sb.lastIndexOf("de"); int sb3=sb.length(); String sb4=sb.substring(1,3); sop("查==="+ch+"::"+sb1+"::"+sb2+"::"+sb3+"::"+sb4); } public static void sop(Object obj) { System.out.println(obj); } }运行结果为：
在JDK1.5版本之后出现了StringBuilder，提高效率。
StringBuffer是线程同步的。有锁。效率低
StringBuilder是线程不同步的。无锁。效率高
以后开发，建议使用StringBuilder。如遇多线程，使用StringBuffer或自己加锁。
升级三因素：
1、提高效率
2、简化书写
3、提高安全性。
四、基本数据类型对象包装类
基本数据类型——>引用数据类型：类
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的最常见作用就是：用于基本数据类型和字符串类型之间的相互转换。
1、基本数据类型转成字符串：
基本数据类型+" "
基本数据类型.toString(基本数据类型值)；
如：Integer.toString(34);//将34整数变成"34"。
2、字符串转成基本数据类型：
静态调用方法： xxx a=Xxx.parseXxx(string);
如：int a=Integer.parseInt("123"); booleanb=Boolean.parseBoolean("true");
对象调用方法：Integer i=new Integer("123");int num=i.intValue();
3、十进制转成其他进制：
toBinaryString();
toHexString();
toOctalString();
4、其他进制转成十进制：
parseInt(String,radix); 如：int a= Intager.parseInt("3c",16);
JDK1.5版本以后出现的新特性：
如：Integer x=4;//自动装箱。相当于new Integer(4),创建对象。
x=x+2;//x+2：x进行自动拆箱(x.intValue())，变成了int类型，和2进行加法运算，再将其进行装箱赋给x。
如：Integer m=128;
Integer n=128;
m==n——>false
Integer a=127;
Integer b=127;
a==b——>true
原因： 因为a和b指向了同一个Integer对象。因为当数值在byte(-128~127)范围内，对于新特性，如果该数组已经存在，则不会再开辟新的空间。
430
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
