——- 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)范围内,对于新特性,如果该数组已经存在,则不会再开辟新的空间。