71字符串.docx

71字符串.docx

《71字符串.docx》由会员分享，可在线阅读，更多相关《71字符串.docx（17页珍藏版）》请在冰豆网上搜索。

71字符串

1.字符串是一个特殊的对象。

字符串一旦初始化就不可以被改变。

2.Strings1=“abc”；

Strings2=newString（“abc”）;//new是一个，”abc”是一个

Stringstr2=“abc”;//因为字符串对象”abc”已经在内存中存在了，str2发现它应经在内存中存在，就不再开辟空间了，为了节约内存嘛

System.out.println（s1==s2）;false

System.out.println（s1.equals（s2））;true

System.out.println（s1==s2）;true

s1和s2有什么区别？

s1在内存中有一个对象。

s2在内存中有两个对象。

3.publicstaticvoidsop（objectobj）{System.out.println（obj）};//什么都能打印

4.1，获取。

1.1字符串中的包含的字符数，也就是字符串的长度。

intlength（）:

获取长度。

//注意一下数组的长度不加括号

1.2根据位置获取位置上某个字符。

charcharAt（intindex）:

//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。

1.3根据字符获取该字符在字符串中位置。

intindexOf（intch）:

返回的是ch在字符串中第一次出现的位置。

intindexOf（intch,intfromIndex）:

从fromIndex指定位置开始，获取ch在字符串中出现的位置。

intindexOf（Stringstr）:

返回的是str在字符串中第一次出现的位置。

intindexOf（Stringstr,intfromIndex）:

从fromIndex指定位置开始，获取str在字符串中出现的位置。

intlastIndexOf（intch）：

5.2，判断。

2.1字符串中是否包含某一个子串。

booleancontains（str）:

特殊之处：

indexOf（str）:

可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。

所以，也可以用于对指定判断是否包含。

if（str.indexOf（"aa"）!

=-1）

而且该方法即可以判断，有可以获取出现的位置。

2.2字符中是否有内容。

booleanisEmpty（）:

原理就是判断长度是否为0.

2.3字符串是否是以指定内容开头。

booleanstartsWith（str）;

2.4字符串是否是以指定内容结尾。

booleanendsWith（str）;

2.5判断字符串内容是否相同。

复写了Object类中的equals方法。

booleanequals（str）;

2.6判断内容是否相同，并忽略大小写。

booleanequalsIgnoreCase（）;

6.3，转换。

3.1将字符数组转成字符串。

构造函数：

String（char[]）

String（char[],offset,count）:

将字符数组中的一部分转成字符串。

静态方法：

staticStringcopyValueOf（char[]）;

staticStringcopyValueOf（char[]data,intoffset,intcount）

staticStringvalueOf（char[]）:

3.2将字符串转成字符数组。

**

char[]toCharArray（）:

3.3将字节数组转成字符串。

String（byte[]）

String（byte[],offset,count）:

将字节数组中的一部分转成字符串。

3.4将字符串转成字节数组。

byte[]getBytes（）:

3.5将基本数据类型转成字符串。

staticStringvalueOf（int）

staticStringvalueOf（double）

//3+"";//String.valueOf（3）;这两一样

特殊：

字符串和字节数组在转换过程中，是可以指定编码表的。

7.4，替换

Stringreplace（oldchar,newchar）;//如果要替换的字符不存在，返回的还是原串。

5，切割

String[]split（regex）;

6，子串。

获取字符串中的一部分。

Stringsubstring（begin）;

Stringsubstring（begin,end）;

7，转换，去除空格，比较。

7.1将字符串转成大写或则小写。

StringtoUpperCase（）;

StringtoLowerCase（）;

7.2将字符串两端的多个空格去除。

Stringtrim（）;

7.3对两个字符串进行自然顺序的比较。

//整数，负数，零

intcompareTo（string）;

8.publicstaticStringreverseString（Strings,intstart,intend）

{

//字符串变数组。

char[]chs=s.toCharArray（）;

//反转数组。

reverse（chs,start,end）;

//将数组变成字符串。

returnnewString（chs）;

}

9.1，模拟一个trim方法，去除字符串两端的空格。

思路：

1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。

结尾处判断空格也是如此。

2，当开始和结尾都判断到不是空格时，就是要获取的字符串。

2，将一个字符串进行反转。

将字符串中指定部分进行反转，"abcdefg";abfedcg

思路：

1，曾经学习过对数组的元素进行反转。

2，将字符串变成数组，对数组反转。

3，将反转后的数组变成字符串。

4，只要将或反转的部分的开始和结束位置作为参数传递即可。

classStringTest

{

publicstaticvoidsop（Stringstr）

{

System.out.println（str）;

}

publicstaticvoidmain（String[]args）

{

Strings="abcd";

sop（"（"+s+"）"）;

//s=myTrim（s）;

//sop（"（"+s+"）"）;

sop（"（"+reverseString（s）+"）"）;

}

//练习二：

将字符串反转。

思路：

1，将字符串变成数组。

2，对数组反转。

3，将数组变成字符串。

publicstaticStringreverseString（Strings,intstart,intend）

{

//字符串变数组。

char[]chs=s.toCharArray（）;

//反转数组。

reverse（chs,start,end）;

//将数组变成字符串。

returnnewString（chs）;

}

publicstaticStringreverseString（Strings）

{

returnreverseString（s,0,s.length（））;

}

privatestaticvoidreverse（char[]arr,intx,inty）

{

for（intstart=x,end=y-1;start

{

swap（arr,start,end）;

}

}

privatestaticvoidswap（char[]arr,intx,inty）

{

chartemp=arr[x];

arr[x]=arr[y];

arr[y]=temp;

}

//练习一，去除字符串两端空格。

publicstaticStringmyTrim（Stringstr）

{

intstart=0,end=str.length（）-1;

while（start<=end&&str.charAt（start）==''）

start++;

while（start<=end&&str.charAt（end）==''）

end--;

returnstr.substring（start,end+1）;

}

}

10.3，获取一个字符串在另一个字符串中出现的次数。

"abkkcdkkefkkskk"

思路：

1，定义个计数器。

2，获取kk第一次出现的位置。

3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。

每获取一次就计数一次。

4，当获取不到时，计数完成。

classStringTest2

{

publicstaticintgetSubCount（Stringstr,Stringkey）

{

intcount=0;

intindex=0;

while（（index=str.indexOf（key））!

=-1）

{

sop（"str="+str）;

str=str.substring（index+key.length（））;

count++;

}

returncount;

}

publicstaticintgetSubCount_2（Stringstr,Stringkey）

{

intcount=0;

intindex=0;

while（（index=str.indexOf（key,index））!

=-1）

{

sop（"index="+index）;

index=index+key.length（）;

count++;

}

returncount;

}

publicstaticvoidmain（String[]args）

{

Stringstr="kkabkkcdkkefkks";

///sop（"count====="+str.split（"kk"）.length）;不建议使用。

sop（"count="+getSubCount_2（str,"kk"））;

}

publicstaticvoidsop（Stringstr）

{

System.out.println（str）;

}

}

11.4，获取两个字符串中最大相同子串。

第一个动作：

将短的那个串进行长度一次递减的子串打印。

"abcwerthelloyuiodef"

"cvhellobnm"

思路：

1，将短的那个子串按照长度递减的方式获取到。

2，将每获取到的子串去长串中判断是否包含，

如果包含，已经找到！

。

classStringTest3

{

publicstaticStringgetMaxSubString（Strings1,Strings2）

{

Stringmax="",min="";

max=（s1.length（）>s2.length（））?

s1:

s2;

min=（max==s1）?

s2:

s1;

//sop（"max="+max+"...min="+min）;

for（intx=0;x

{

for（inty=0,z=min.length（）-x;z!

=min.length（）+1;y++,z++）

{

Stringtemp=min.substring（y,z）;

sop（temp）;

if（max.contains（temp））//if（s1.indexOf（temp）!

=-1）

returntemp;

}

}

return"";

}

publicstaticvoidmain（String[]args）

{

Strings1="ab";

Strings2="cvhellobnm";

sop（getMaxSubString（s2,s1））;

}

publicstaticvoidsop（Stringstr）

{

System.out.println（str）;

}

}

12.StringBuffer是字符串缓冲区。

是一个容器。

特点：

1，长度是可变化的。

2，可以字节操作多个数据类型。

3，最终会通过toString方法变成字符串。

CcreateUupdateRreadDdelete

1，存储。

StringBufferappend（）:

将指定数据作为参数添加到已有数据结尾处。

StringBufferinsert（index,数据）:

可以将数据插入到指定index位置。

2，删除。

StringBufferdelete（start,end）:

删除缓冲区中的数据，包含start，不包含end。

StringBufferdeleteCharAt（index）:

删除指定位置的字符。

3，获取。

charcharAt（intindex）

intindexOf（Stringstr）

intlastIndexOf（Stringstr）

intlength（）

Stringsubstring（intstart,intend）

4，修改。

StringBufferreplace（start,end,string）;

voidsetCharAt（intindex,charch）;

5，反转。

StringBufferreverse（）;

6，

将缓冲区中指定数据存储到指定字符数组中。

voidgetChars（intsrcBegin,intsrcEnd,char[]dst,intdstBegin）

JDK1.5版本之后出现了StringBuilder.

StringBuffer是线程同步。

StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

将StringBuider的实例用于多个线程是不安全的。

如果需要这样同步，则建议使用StringBuffer

升级三个因素：

1，提高效率。

2，简化书写。

3，提高安全性。

13.classStringBufferDemo

{

publicstaticvoidmain（String[]args）

{

//method_update（）;

StringBuildersb=newStringBuilder（"abcdef"）;

char[]chs=newchar[6];

sb.getChars（1,4,chs,1）;//将

for（intx=0;x

{

sop（"chs["+x+"]="+chs[x]+";"）;

}

draw（3,6）;

draw（8,9）;

//StringBuildersb1=newStringBuilder（）;

//sb1.append（newDemo（））.append（newDemo（））;

//sop（"sb1="+sb1）;

}

publicstaticvoidmethod_update（）

{

StringBuffersb=newStringBuffer（"abcde"）;

//sb.replace（1,4,"java"）;

sb.setCharAt（2,'k'）;

sop（sb.toString（））;

}

publicstaticvoidmethod_del（）

{

StringBuffersb=newStringBuffer（"abcde"）;

//sb.delete（1,3）;

//清空缓冲区。

sb=newStringBuffer（）;//别用这个连盆都去了

//sb.delete（0,sb.length（））;

//sb.delete（2,3）;//从几到几sb.delete（2,2）什么都没删

sb.deleteCharAt

（2）;

sop（sb.toString（））;//对象转为字符串

}

publicstaticvoidmethod_add（）

{

StringBuffersb=newStringBuffer（）;

//sb.append（"abc"）.append（true）.append（34）;

//StringBuffersb1=sb.append（34）;

//sop（"sb==sb1:

"+（sb==sb1））;

sb.insert（1,"qq"）;

sop（sb.toString（））;//abctrue34

//sop（sb1.toString（））;

}

publicstaticvoidsop（Stringstr）

{

System.out.println（str）;

}

publicstaticvoiddraw（introw,intcol）

{

StringBuildersb=newStringBuilder（）;

for（intx=0;x

{

for（inty=0;y

{

sb.append（"*"）;

}

sb.append（"\r\n"）;

}

sop（sb.toString（））;

}

}

14.将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

常用的操作之一：

用于基本数据类型与字符串之间的转换。

基本数据类型转成字符串。

基本数据类型+""

基本数据类型.toString（基本数据类型值）;

如：

Integer.toString（34）;//将34整数变成"34";

字符串转成基本数据类型。

xxxa=Xxx.parseXxx（String）;

inta=Integer.parseInt（"123"）;//”s123”会出现NumberFormatException

doubleb=Double.parseDouble（"12.23"）;

booleanb=Boolean.parseBoolean（"true"）;

Integeri=newInteger（"123"）;

intnum=i.intValue（）;//非静态的，上面是静态的

15.十进制转成其他进制。

toBinaryString（）;

toHexString（）;

toOctalString（）;

其他进制转成十进制。

parseInt（string,radix）;

classIntegerDemo

{

publicstaticvoidsop（Stringstr）

{

System.out.println（str）;

}

publicstaticvoidmain（String[]args）

{

//整数类型的最大值。

//sop（"intmax:

"+Integer.MAX_VALUE）;

//将一个字符串转成整数。

intnum=Integer.parseInt（"123"）;//必须传入数字格式的字符串。

//longx=Long.parseLong（"123"）;

//sop（"num="+（num+4））;

//sop（Integer.toBinaryString（-6））;

//sop（Integer.toHexString（60））;

intx=Integer.parseInt（"3c",16）;//进制表现形式和进制，转为十进制

sop（"x="+x）;

}

}

16.JDK1.5版本以后出现的新特性。

classIntegerDemo1

{

publicstaticvoidmain（String[]args）

{

//Integerx=newInteger（4）;

Integerx=4;//自动装箱。

//newInteger（4）//注意这的x可能为null，若为null会抛出异常

x=x/*x.intValue（）拆箱原理*/+2;//x+2:

x进行自动拆箱。

变成成了int类型。

和2进行加法运算。

//再将和进行装箱赋给x。

Integerm=128;

Integern=128;

sop（"m==n:

"+（m==n））;//false

Integera=127;

Integerb=127;

sop（"a==b:

"+（a==b））;//结果为true。

因为a和b指向了同一个Integer对象。

//因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。

}

publicstaticvoidmethod（）

{

Integerx=newInteger（"123"）;

Integery=newInteger（123）;

sop（"x==y:

"+（x==y））;//false

sop（"x.equals（y）:

"+x.equals（y））;//true之比较数值

}

publicstaticvoidsop（Stringstr）

{

System.out.println（str）;

}

}