黑马程序员_Java基础_String类

一、String(概述)

[java]  view plain copy

1. /* 
2. String概述： 
3. */  
4. class StringDemo   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         String s1="abc";/*s1是一个类类型变量，"abc"是一个对象。 
9.                         字符串最大特点：一旦被初始化就不可改变。 
10.                         "abc"存在常量池中。 
11.                         */  
12.   
13.         String s2=new String("abc");  
14.         /* 
15.         s1和s2的区别： 
16.         s1在内存中有一个对象。 
17.         s2在内存中有两个对象。 
18.         */  
19.   
20.         System.out.println(s1==s2);  
21.         System.out.println(s1.equals(s2));/*String类复写了Object类的equals方法。 
22.                                             该方法用于判断字符串是否相同。 
23.                                             */  
24.   
25.     }  
26. }  

二、String(常见功能-获取和判断)

String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。

常见的操作有哪些？

"abcd"

1.获取：

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

int length():获取长度。

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

char charAt(int index):

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

int indexOf(int ch) :返回的是ch在字符串中第一次出现的位置。

int indexOf(int ch,int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中第一次出现的位置。

int indexOf(String str) :返回的是str在字符串中第一次出现的位置。

int lastIndexOf(int ch):反向索引一个字符出现的位置。

2.判断：

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

boolean contains(CharSequence s):当且仅当此字符串包含指定的 char 值序列时，返回 true。 

特殊之处：int indexOf(String str) :返回的是str在字符串中第一次出现的位置，不存在返回-1。

所以也可以用于对指定判断是否包含。例如：if(str.indexOf("aa")!=-1)

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

2.2字符串中是否有内容

boolean isEmpty() :当且仅当 length() 为 0 时返回 true。

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

boolean startsWith(String prefix) :测试此字符串是否以指定的前缀开始。

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

boolean endsWith(String suffix) :测试此字符串是否以指定的后缀结束。

2.5判断字符串的内容是否相同（复写了Object类的equals方法）

boolean equals(Object anObject):将此字符串与指定的对象比较。当且仅当该参数不为 null， 并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。

2.6判断字符串的内容是否相同

boolean equalsIgnoreCase(String anotherString):将此 String 与另一个 String 比较，不考虑大小写。如果两个字符串的长度相同，并且其中的相应字符都相等（忽略大小写），则认为这 两个字符串是相等的。

3.转换：

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

构造函数：

String(char[] value):分配一个新的 String，使其表示字符数组参数中当前包含的字符序 列。 该字符数组的内容已被复制；后续对字符数组的修改不会影响新创建的字符串。

String(char[] value,int offset,int count):分配一个新的 String，它包含取自字符数组参数一个子数组的字符。offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。该子 数组的内容已被复制；后续对字符数组的修改不会影响新创建的字符串。

静态方法：

static String copyValueOf(char[] data):返回指定数组中表示该字符序列的 String。

static String copyValueOf(char[] data,int offset,int count):返回指定数组中表示该字符序列的  String。 data - 字符数组。offset - 子数组的初始偏移量。count - 子数组的长度。

static String valueOf(char c):返回 char 参数的字符串表示形式。

3.2将字符串转换成字符数组 *

char[] toCharArray():将此字符串转换为一个新的字符数组。

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

String(byte[] bytes):通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的  String。新 String 的长度是字符集的函数，因此可能不等于 byte 数组的长度。

String(byte[] bytes,int offset,int length):通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。新 String 的长度是字符集的函数，因此可能不等于该子数组的长度。

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

byte[] getBytes():使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一 个新的 byte 数组中。

byte[] getBytes(Charset charset):使用给定的 charset 将此 String 编码到 byte 序列，并将结 果存储到新的 byte 数组。 

3.5将基本数据类型转换为字符串

static String valueOf(char c):返回 char 参数的字符串表示形式。

static String valueOf(char[] data,int offset,int count):返回 char 数组参数的特定子数组的字符 串表示形式。 offset 参数是子数组的第一个字符的索引。count 参数指定子数组的长度。 字符数组的内容已被复制，后续修改不会影响新创建的字符串。

static String valueOf(double d):返回 double 参数的字符串表示形式。 该表示形式恰好是单参数的 Double.toString 方法返回的结果。

static String valueOf(int i):返回 int 参数的字符串表示形式。 该表示形式恰好是单参数的 Integer.toString 方法返回的结果。 

例如：

3+"";  //String.valueOf(3);

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

4.替换：

String replace(char oldChar,char newChar):返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 

String replace(CharSequence target,CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。该替换从字符串的开头朝末尾执行，例 如，用 "b" 替换字符串 "aaa" 中的 "aa" 将生成 "ba" 而不是 "ab"。

5.切割：

String[] split(String regex):根据给定正则表达式的匹配拆分此字符串。 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾 空字符串。

String[] split(String regex,int limit):根据匹配给定的正则表达式来拆分此字符串。 此方法返回 的数组包含此字符串的子字符串，每个子字符串都由另一个匹配给定表达式的子字符串终 止，或者由此字符串末尾终止。数组中的子字符串按它们在此字符串中出现的顺序排列。 如果表达式不匹配输入的任何部分，那么所得数组只具有一个元素，即此字符串。

6.获取字串：

String substring(int beginIndex,int endIndex):返回一个新字符串，它是此字符串的一个子字符 串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该 子字符串的长度为 endIndex-beginIndex。

String substring(int beginIndex):返回一个新的字符串，它是此字符串的一个子字符串。该子 字符串从指定索引处的字符开始，直到此字符串末尾。

7.转换，去除空格，比较：

7.1将字符串转换成大写或者小写

String toUpperCase():使用默认语言环境的规则将此 String 中的所有字符都转换为大写。此方法等效于 toUpperCase(Locale.getDefault())。 

String toLowerCase():使用默认语言环境的规则将此 String 中的所有字符都转换为小写。这等效于调用 toLowerCase(Locale.getDefault())。 

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

String trim():返回字符串的副本，忽略前导空白和尾部空白。 

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

int compareTo(String anotherString):按字典顺序比较两个字符串。该比较基于字符串中各个字 符的 Unicode 值。按字典顺序将此 String 对象表示的字符序列与参数字符串所表示的字符 序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负 整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如 果这两个字符串相等，则结果为 0；compareTo 只在方法 equals(Object) 返回 true 时才返 回 0。 

[java]  view plain copy

1. /* 
2. 测试： 
3. 常见功能 
4. */  
5. class StringMethodDemo   
6. {  
7.     public static void method_7()  
8.     {  
9.         String s="   Hello Java     ";  
10.         sop(s.toLowerCase());  
11.         sop(s.toUpperCase());  
12.   
13.         sop(s.trim());  
14.   
15.         String s1="abc";  
16.         String s2="aaa";  
17.         sop(s1.compareTo(s2));  
18.     }  
19.     public static void method_sub()  
20.     {  
21.         String s="abcdefg";  
22.         sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。  
23.         sop(s.substring(2,4));//包含头，不包含尾。获取全部：s.substring(0,s.length());  
24.     }  
25.     public static void method_split()  
26.     {  
27.         String s="zhangsan,lisi,wangwu";  
28.         String[] arr= s.split(",");  
29.         for(int i=0;i<arr.length;i++)  
30.         {  
31.             sop(arr[i]);  
32.         }  
33.     }  
34.     public static void method_replace()  
35.     {  
36.         String s="hello java";  
37.         String s1=s.replace('a','n');//如果要替换的字符不存在，返回的还是原字符串  
38.         sop("s="+s);  
39.         sop("s1="+s1);  
40.     }  
41.     public static void method_trans()  
42.     {  
43.         char[] arr={'a','b','c','d','e','f'};  
44.         String s=new String(arr,1,3);  
45.         sop("s="+s);  
46.   
47.         String s1="yangcheng";  
48.         char[] chs=s1.toCharArray();  
49.         for(int i=0;i<chs.length;i++)  
50.         {  
51.             sop("ch["+i+"]="+chs[i]);  
52.         }  
53.     }  
54.     public static void method_is()  
55.     {  
56.         String str="ArrayDemo.java";  
57.       
58.         sop(str.startsWith("Array"));//判断文件名是否是Array单词开头。  
59.         sop(str.endsWith(".java"));//判断文件名称是否是.java  
60.         sop(str.contains("Demo"));//判断文件中是否包含Demo  
61.     }  
62.     public static void method_get()  
63.     {  
64.         String str="abcdefasgpireeqfrf";  
65.   
66.         sop(str.length());//长度  
67.         sop(str.charAt(2));/*根据索引获取字符。注意：当访问字符串中不存在的角标时， 
68.                             会发生StringIndexOutOfBoundsException异常。 
69.                             */  
70.         sop(str.indexOf('a'));//根据字符获取索引，如果没有找到该字符，返回-1  
71.         sop(str.lastIndexOf("r"));//返回指定字符在此字符串中最后一次出现处的索引。  
72.     }  
73.     public static void main(String[] args)   
74.     {  
75.           
76.         String s1="abc";  
77.         String s2=new String("abc");  
78.         String s3="abc";//常量池中已经有"abc",不再分配内存存储"abc"  
79.   
80.         System.out.println(s1==s2);  
81.         System.out.println(s1==s3);  
82.   
83.           
84.         method_get();  
85.         method_is();  
86.         method_trans();  
87.         method_replace();  
88.         method_split();  
89.         method_sub();  
90.         method_7();  
91.     }  
92.     public static void sop(Object obj)  
93.     {  
94.         System.out.println(obj);  
95.     }  
96. }  

三、String(字符串练习)

[java]  view plain copy

1. /* 
2. 项目1： 
3. 模拟一个trim方法，取出字符串两端的空格。 
4. 思路： 
5. 1.判断字符串第一个位置是否是空格，如果是，继续向下判断，直到不是空格为止。 
6. 结尾处判断空格也是这样的。 
7. 2.当开始和结尾都判断不是空格时，就要是获取的字符串。 
8. */  
9.   
10. class  StringTest1  
11. {  
12.     public static void sop(String str)  
13.     {  
14.         System.out.println(str);  
15.     }  
16.     public static String myTrim(String str)  
17.     {  
18.         int start=0,end=str.length()-1;  
19.   
20.         while(start<=end && str.charAt(start)==' ')  
21.             start++;  
22.         while(start<end && str.charAt(end)==' ')  
23.             end--;  
24.   
25.         return str.substring(start,end+1);  
26.     }  
27.     public static void main(String[] args)   
28.     {  
29.         String s="    How are you     ";  
30.         sop("s="+s);  
31.         sop("s="+myTrim(s));  
32.     }  
33.       
34. }  

[java]  view plain copy

1. /* 
2. 项目2： 
3. 将一个字符串进行反转，将字符串中指定部分进行反转。 
4. 思路： 
5. 1.曾经学习过对数组元素进行反转。 
6. 2.将字符串编程数组，对数组反转。 
7. 3.将反转后的数组变成字符串。 
8. 4.只要将或反转的部分的开始和结束位置最为参数传递即可。 
9. */  
10. class StringTest2   
11. {  
12.     public static void sop(String str)  
13.     {  
14.         System.out.println(str);  
15.     }  
16.     public static String reverseString(String s)  
17.     {  
18.         return reverseString(s,0,s.length()-1);//将数组变成字符串  
19.     }  
20.     public static String reverseString(String s,int start,int end)  
21.     {  
22.         char[] chs=s.toCharArray();//字符串变数组  
23.         reverse(chs,start,end);//反转数组  
24.         return new String(chs);//将数组变成字符串  
25.   
26.     }  
27.     private static void reverse(char[] arr,int x,int y)  
28.     {  
29.         for(int start=x,end=y-1;start<end;start++,end--)  
30.         {  
31.             swap(arr,start,end);  
32.         }  
33.     }  
34.     private static void swap(char[] arr,int x,int y)  
35.     {  
36.         char temp=arr[x];  
37.         arr[x]=arr[y];  
38.         arr[y]=temp;  
39.     }  
40.   
41.     public static void main(String[] args)   
42.     {  
43.         String s="   ab   cd      ";  
44.         sop("s="+s);  
45.         sop("s="+reverseString(s));  
46.         sop("s="+reverseString(s,3,5));//包含头，不包含尾  
47.     }  
48. }  

[java]  view plain copy

1. /* 
2. 项目3： 
3. 获取一个字符串在另一个字符串中出现的次数。 
4. "askkdfsdssddkkwerkk"; 
5. 思路： 
6. 1.定义一个计数器 
7. 2.获取kk第一次出现的位置 
8. 3.从第一次出现位置后剩余的字符串中继续获取kk出现的位置。每获取一次计数一次。 
9. 4.当获取不到时，计数完成。 
10. */  
11. class StringTest3   
12. {  
13.     public static void sop(String str)  
14.     {  
15.         System.out.println(str);  
16.     }  
17.     public static int getSubCount(String str,String key)//方法1  
18.     {  
19.         int count=0;  
20.         int index=0;  
21.   
22.         while((index=str.indexOf(key))!=-1)  
23.         {  
24.             str=str.substring(index+key.length());  
25.             count++;  
26.         }  
27.         return count;  
28.     }  
29.     public static int getSubCount_2(String str,String key)//方法2  
30.     {  
31.         int count=0;  
32.         int index=0;  
33.   
34.         while((index=str.indexOf(key,index))!=-1)  
35.         {  
36.             index=index+key.length();  
37.   
38.             count++;  
39.         }  
40.         return count;  
41.   
42.     }  
43.     public static void main(String[] args)   
44.     {  
45.         String str1="askkdfsdssddkkwer";  
46.         String str2="kk";  
47.         sop("s="+str1);  
48.         sop("子串："+str2);  
49.         sop("count="+getSubCount(str1,"kk"));  
50.         sop("count="+getSubCount_2(str1,"kk"));  
51.         //sop("count="+str1.split(str2).length);//不建议使用  
52.     }  
53. }  

[java]  view plain copy

1. /* 
2. 项目4: 
3. 获取两个字符串中最大相同字串。第一动作：将短的那个串进行长度依次递减的字串打印。 
4. "abcsfwgtrhello6frgerhq" 
5. "sdhellovb" 
6. 思路： 
7. 1.将短的那个字串按照长度递减的方式获取到。 
8. 2.将每获取到的字串去长串中判断是否包含。如果包含，就找到了。 
9. */  
10. class StringTest4   
11. {  
12.     public static void sop(String str)  
13.     {  
14.         System.out.println(str);  
15.     }  
16.     public static String getMaxSubString(String s1,String s2)  
17.     {  
18.         String max="",min="";  
19.         max=s1.length()>s2.length()?s1:s2;//长串  
20.         min=(max==s1)?s2:s1;//短串  
21.   
22.   
23.         for(int i=0;i<min.length();i++)  
24.         {  
25.             for(int j=0,k=min.length()-i;k!=min.length()+1;j++,k++)  
26.             {  
27.                 String temp=min.substring(j,k);  
28.                 if(max.contains(temp))  
29.                     return temp;  
30.             }  
31.               
32.         }  
33.         return "";  
34.     }  
35.     public static void main(String[] args)   
36.     {  
37.         String s1="abcsfwgtrhello6frgerhq";  
38.         String s2="sdhellovb";  
39.         sop("s1="+s1);  
40.         sop("s2="+s2);  
41.         sop(getMaxSubString(s1,s2));  
42.         sop(getMaxSubString(s2,s1));  
43.     }  
44. }  

四、StringBuffer(常见功能-添加)

StringBuffer是一个字符串缓冲区，是一个容器。

特点：

1.长度可以变化。

2.可以操作多个数据类型。

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

1.存储

StringBuffer append():将指定的数据作为参数添加到已有数据的结尾处。

StringBuffer insert(intdex,数据):可以将数据插入到指定index位置。

2.删除

StringBuffer delete(start,end):删除缓冲区中的数据。包含start不包含end。

StringBuffer deleteCharAt(index):删除指定位置的字符。

3.获取

char charAt(int index):获取index位置的字符。

int indexOf(String str) :返回第一次出现的指定子字符串在该字符串中的索引。

int lastIndexOf(String str) :返回最右边出现的指定子字符串在此字符串中的索引。

int length() :返回长度（字符数）。

String substring(int start, int end) :返回一个新的 String，它包含此序列当前所包含的字符子序列。

4.修改

StringBuffer replace(start,end,string):使用给定 String 中的字符替换此序列的子字符串中的字符。

void setCharAt(int index,char ch): 将给定索引处的字符设置为 ch。

5.反转

StringBuffer reverse() :将此字符序列用其反转形式取代。

6.将缓冲区中指定数据存储到指定数组中

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：将字符从此序列复制到目标字符数组 dst。 

[java]  view plain copy

1. /* 
2. StringBuffer常见功能操作： 
3. */  
4. class StringBufferDemo   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         method_add();//添加  
9.         method_del();//删除  
10.         method_update();//修改  
11.         method_select();//获取  
12.     }  
13.     public static void method_add()  
14.     {  
15.         sop("添加：");  
16.         StringBuffer sb=new StringBuffer();  
17.         sb.append(23).append(true).append(78);  
18.   
19.         sb.insert(1,"qq");  
20.         sop(sb.toString());  
21.     }  
22.     public static void method_del()  
23.     {  
24.         sop("删除：");  
25.         StringBuffer sb=new StringBuffer("abcdefg");  
26.         sb.delete(1,3);  
27.         sop(sb.toString());  
28.   
29.         //sb.delete(0,sb.length());//清空缓冲区  
30.         sb.deleteCharAt(2);  
31.         sop(sb.toString());  
32.     }  
33.     public static void method_update()  
34.     {  
35.         sop("修改：");  
36.         StringBuffer sb=new StringBuffer("abcdefg");  
37.         sb.replace(1,4,"java");  
38.         sop(sb.toString());  
39.         sb.setCharAt(2,'x');  
40.     }  
41.     public static void method_select()  
42.     {  
43.         sop("获取");  
44.         StringBuffer sb=new StringBuffer("abcdefg");  
45.         sop(sb.substring(2,4));  
46.     }  
47.     public static void sop(String str)  
48.     {  
49.         System.out.println(str);  
50.     }  
51. }  

五、StringBuilder

JDK1.5版本以后出现了StringBuilder

StringBuffer:线程同步。

StringBuilder:线程不同步。

以后开发建议使用StringBuilder。

六、基本数据类型对象包装类

byte Byte 

short Short

int Integer

long Long

boolean Boolean

float Float

double Double

char Character

基本数据类型对象包装类的最常见作用：

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

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

基本数据类型+""

基本数据类型.toString(基本数据类型值);

如：Integer.toString(32);//将32整数变成"32"

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

xxx a= Xxx.parseXxx(String);

例如：

int a=Integer.parseInt("123");

double d= double.parseDouble("12.23");

boolean b=Boolean.pareseBoolean("true");

char c=Character.toLowerCase('A');

也可以封装Integer 对象。

Integer num=new Integer("123");

int n=num.intValue();

十进制转换为其它进制：

toBinaryString();

toHexString();

toOctalString();

其它进制转换为十进制：

parseInt(string,radix):    radix:   2代表二进制。8代表八进制。16代表十六进制。

七、基本数据类型对象包装类新特性

[java]  view plain copy

1. /* 
2. JDK1.5版本以后出现的新特性： 
3.  
4. */  
5. class IntegerDemo1   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         //Integer x=new Integer(4);  
10.         Integer x=4;//自动装箱 new Integer(4)   
11.         sop("x="+x);  
12.         x=x+2;/*x=2 x进行自动拆箱，变成了int 类型和2进行加法运算，再将 
13.                     和进行装箱赋值给x 
14.                      
15.                     x=x.intValue()+2 
16.  
17.                     如果x=null; 
18.                     x.intValue()时会抛出Runtime异常。 
19.                      
20.                */  
21.         sop("x+2="+x);  
22.   
23.         Integer m=128;  
24.         Integer n=128;  
25.         sop("m==n:"+(m==n));  
26.   
27.         Integer a=127;  
28.         Integer b=127;  
29.         sop("a==b:"+(a==b));/*结果为true。因为a和b指向了同一个Integer对象。 
30.                             当数值在byte范围内时，对于新特性，如果数值已经存在 
31.                             则不会再开辟新的空间。 
32.  
33.  
34.                             */  
35.         method();  
36.   
37.     }  
38.     public static void method()   
39.     {  
40.         Integer x=new Integer("123");  
41.         Integer y=new Integer(123);  
42.   
43.         sop("x==y:"+(x==y));  
44.         sop("x.equals(y):"+x.equals(y));  
45.     }  
46.     public static void sop(String str)  
47.     {  
48.         System.out.println(str);  
49.     }  
50. }