JAVA中String字符串的各种基本操作

[java] view plain copy

1. /* 
2.  String类适用于描述字符串事物。 
3.  那么它就提供了多个方法对字符串进行操作。 
4.   
5.  常用的方法如下： 
6.   
7.  1、获取： 
8.     1.1 字符串中包含的字符数，也就是字符串的长度。 
9.         int length():获取长度。 
10.     1.2 根据位置获取该位置上的某个字符。 
11.         char charAt(int index):返回指定索引处的char值。 
12.     1.3 根据字符获取该字符在字符串的位置。 
13.         int indexOf(String str):返回的是str在字符串中第一次出现的位置。 
14.         int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。 
15.         int lastIndexOf(int ch):反向索引一个字符出现的位置 
16.   
17.  2、判断： 
18.     2.1  字符串中是否包含某一个子串。 
19.         boolean contains(str); 
20.         特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。 
21.                   所以，也可以用于对指定判断是否包含。 
22.                  if(str.indexOf("aa")!=-1)   
23.                   而且该方法既可以判断，又可以获取出现的位置 
24.     2.2 字符中是否有内容。 
25.         boolean isEmpty():原理就是判断长度是否为0. 
26.     2.3 字符串是否是以指定内容开头。 
27.         boolean startsWith(str); 
28.     2.4 字符串是否是以指定内容结尾。 
29.         boolean endsWith(str); 
30.     2.5判断字符串内容是否相同。复写Object类中的equals方法。 
31.         boolean equals(str); 
32.     2.6 判断内容是否相同，并忽略大小写 
33.         boolean equalsIgnoreCase(); 
34.          
35.  3、转换 
36.     3.1 将字符数组转换成字符串。 
37.         构造函数： String(char[]) 
38.                   String(char[],offset,count):将字符数组中的一部分转换成字符串。 
39.         静态方法： 
40.                  static String copyValueOf(char[]); 
41.                  static String copyvalueOf(char[] data, int offset, int count); 
42.     3.2 将字符串转换成字符数组（重点）。 
43.                 char[] toCharArray(); 
44.     3.3 将字节数组转换成字符串。 
45.                  String(byte[]) 
46.                  String(byte[],offset,count):将字节数组中的一部分转换成字符串。 
47.     3.4 将字符串转换成字节数组 
48.     3.5 将基本数据类型转换成字符串。 
49.         String valueOf(int); 
50.         String valueOf(double); 
51.          
52.         特殊：字符串和字节数组在转换过程中是可以指定编码表的。 
53.          
54.  4、替换 
55.         String replace(oldchar,newchar); 
56.  5、切割 
57.         String[] split(regex); 
58.  6、子串            获取字符串中的一部分 
59.         String substring(begin); 
60.         String substring(begin,end); 
61.  7、转换，去除空格，比较 
62.     7.1 将字符串转成大写或者小写。 
63.         String toUpperCase(); 
64.         String toLowerCase(); 
65.     7.2 将字符串两端的多个空格去除。 
66.         String trim(); 
67.     7.3 将两个字符串进行自然顺序的比较。 
68.  */  
69.   
70. public class StringDemo1 {   
71.     //转换，去除空格，比较  
72.     public static void method_7(){  
73.         String s="Hello Java";  
74.         sop("原字符串为："+s);  
75.         sop(s.toUpperCase());  
76.         sop(s.toLowerCase());  
77.         sop(s.trim());  
78.           
79.         String s1="acc";  
80.         String s2="aaa";  
81.         sop(s1.compareTo(s2));  
82.     }  
83.     //子串         获取字符串中的一部分  
84.     public static void method_sub(){  
85.         String s="abcdefghijklmnopqrstuvwxyz";  
86.         sop("原字符串为");  
87.         sop(s);  
88.         String s1=s.substring(9); //从指定位置到结尾。如果角标不存在，则会出现字符串角标越界异常。  
89.         sop("获取的子串s1为：");  
90.         sop(s1);  
91.         String s2=s.substring(7,20); //包含头，不包含尾。 获取整个字符串：s.substring(0,s.length());  
92.         sop("获取的子串s2为：");  
93.         sop(s2);  
94.     }  
95.     //切割  
96.     public static void method_split(){  
97.         String s="zhangsan,lisi,wangwu";  
98.         String[] arr=s.split("a");  
99.         sop("原字符串为：");  
100.         sop(s);  
101.         sop("切割后的字符串为：");  
102.         for(int x=0;x<arr.length;x++)  
103.         {  
104.             System.out.print(arr[x]+" ");  
105.         }  
106.         System.out.println();  
107.     }  
108.     //判断  
109.     public static void method_is(){  
110.         String str="ArrayDemo.java";  
111.         String str1="arraydemo.java";  
112.         //判断文件名称是否以Array开头  
113.         sop(str.startsWith("Array"));  
114.         //判断文件名称是否是以.java结尾  
115.         sop(str.endsWith(".java"));  
116.         //判断文件名称中是否包含Demo  
117.         sop(str.contains("Demo"));  
118.         //判断两个文件名是否相同（区分大小写）  
119.         sop(str.equals(str1));  
120.         //判断两个文件名是否相同（不区分大小写）  
121.         sop(str.equalsIgnoreCase(str1));  
122.     }  
123.     //获取  
124.     public static void method_get(){  
125.         String str="abcdeakpf";  
126.         sop("字符串为："+str);  
127.         //长度  
128.         sop("字符串的长度为："+str.length());  
129.         //根据索引获取字符  
130.         sop("角标为四的位置上的字符为："+str.charAt(4));//当访问到字符串中不存在的角标时，会发生 StringIndexOutOfBoundsException异常  
131.         //根据字符获取索引  
132.         sop("从角标为3的位置开始往后索引 a 出现的位置为："+str.indexOf('a',3));//如果没有找到返回-1  
133.         //反向索引一个字符出现的位置  
134.         sop("从字符串右面开始索引第一个a出现的位置为："+str.lastIndexOf("a"));  
135.     }  
136.     //转换  
137.     public static void method_trans(){  
138.         char[] arr={'a','b','c','d','e','f','g','h'};  
139.         String str="jkasdhavsgjv";  
140.         char[] a=str.toCharArray();  
141.         //字符串操作  
142.         System.out.print("将字符串转换为字符数组为：[");  
143.         for(int x=0;x<a.length;x++)  
144.         {  
145.             if(x<a.length-1)  
146.                 System.out.print(a[x]+",");  
147.             else  
148.                 System.out.print("]");  
149.         }  
150.         System.out.println();  
151.         //字符数组操作  
152.         System.out.print("字符数组为：[");  
153.         for(int x=0;x<arr.length;x++)  
154.         {  
155.             if(x<arr.length-1)  
156.                 System.out.print(arr[x]+",");  
157.             else  
158.                 System.out.print("]");  
159.         }  
160.         System.out.println();  
161.         String s=new String(arr);  
162.         sop("转换成字符串为："+s);  
163.         //获取从角标为1的位置的字符开始三个字符  
164.         String s1=new String(arr,1,3);  
165.         sop("从角标为1的位置的字符开始三个字符组成的字符串为："+s1);  
166.     }  
167.     //替换  
168.     public static void method_replace(){  
169.           
170.         String s="      hello java     ";  
171.           
172.         String s1=s.replace('a', 'n'); //如果要替换的字符不存在，则返回的还是原字符串  
173.           
174.         sop("原来的字符串为："+s);  
175.           
176.         sop("替换字符后的字符串为："+s1);  
177.           
178.     }  
179.     //主函数  
180.     public static void main(String[] args) {  
181.         method_get();  
182.         method_is();  
183.         method_trans();  
184.         method_replace();  
185.         method_split();  
186.         method_sub();  
187.         method_7();  
188.     }  
189.     public static void sop(Object obj){  
190.         System.out.println(obj);  
191.     }  
192. }  

结果图：

心得体会：对字符串的操作有了深一步的认识，一些操作在脑袋里感觉瞬间变得清晰了好多。

=====================================================================================================

字符串查找

String提供了两种查找字符串的方法，即indexOf与lastIndexOf方法。

 1、indexOf（String s） 

    该方法用于返回参数字符串s在指定字符串中首次出现的索引位置，当调用字符串的indexOf()方法时，会从当前字符串的开始位置搜索s的位置；如果没有检索到字符串s，该方法返回-1

1 String str ="We are students";2 int size = str.indexOf("a"); // 变量size的值是3

  2、lastIndexOf(String str)

    该方法用于返回字符串最后一次出现的索引位置。当调用字符串的lastIndexOf()方法时，会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1.

    如果lastIndexOf方法中的参数是空字符串"" ，，则返回的结果与length方法的返回结果相同。

获取指定索引位置的字符

    使用charAt()方法可将指定索引处的字符返回。

1 String str = "hello word";2 char mychar =  str.charAt(5);  // mychar的结果是w

获取子字符串

   通过String类的substring()方法可对字符串进行截取。这些方法的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。在字符串中空格占用一个索引位置。

该子字符串从指定的 beginIndex 处开始，一直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。

1、substring(int beginIndex)

    该方法返回的是从指定的索引位置开始截取知道该字符串结尾的子串。

1 String str = "Hello word";2 String substr = str.substring(3); //获取字符串，此时substr值为lo word

2、substring(int beginIndex,  int endIndex)

    beginIndex : 开始截取子字符串的索引位置

    endIndex：子字符串在整个字符串中的结束位置

1 String str = "Hello word";2 String substr = str.substring(0,3); //substr的值为hel

去除空格

    trim()方法返回字符串的副本，忽略前导空格和尾部空格。

字符串替换

    replace()方法可实现将指定的字符或字符串替换成新的字符或字符串，只替换第一个用replaceFirst()

   oldChar：要替换的字符或字符串

  newChar：用于替换原来字符串的内容

如果要替换的字符oldChar在字符串中重复出现多次，replace()方法会将所有oldChar全部替换成newChar。需要注意的是，要替换的字符oldChar的大小写要与原字符串中字符的大小写保持一致。注意不区分转义字符，如要替换"\\"可直接"\\"若有replaceAll得"\\\"

1 String str= "address";2 String newstr = str.replace("a", "A");// newstr的值为Address

判断字符串的开始与结尾

    startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。

   1、startsWith(String prefix) 

      该方法用于判断当前字符串对象的前缀是否是参数指定的字符串。

   2、endsWith(String suffix) 

     该方法用于判断当前字符串是否以给定的子字符串结束

判断字符串是否相等

    1、equals(String otherstr)

    如果两个字符串具有相同的字符和长度，则使用equals()方法比较时，返回true。同时equals()方法比较时区分大小写。

   2、equalsIgnoreCase(String otherstr)

    equalsIgnoreCase()方法与equals()类型，不过在比较时忽略了大小写。

按字典顺序比较两个字符串

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

1 str.compareTo(String otherstr);

字母大小写转换

    字符串的toLowerCase()方法可将字符串中的所有字符从大写字母改写为小写字母，而tuUpperCase()方法可将字符串中的小写字母改写为大写字母。

1 str.toLowerCase();2 str.toUpperCase();

字符串分割

    使用split()方法可以使字符串按指定的分隔字符或字符串对内容进行分割，并将分割后的结果存放在字符数组中。

1 str.split(String sign);

sign为分割字符串的分割符，也可以使用正则表达式。

没有统一的对字符串进行分割的符号，如果想定义多个分割符，可使用符号“|”。例如，“,|=”表示分割符分别为“，”和“=”。

1 str.split(String sign, in limit)；

该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。

String，StringBuffer，StringBuilder

1.三者在执行速度方面的比较：StringBuilder >  StringBuffer  >  String

String：字符串常量 StringBuffer：字符创变量   StringBuilder：字符创变量

StringBuilder：线程非安全的   StringBuffer：线程安全的

通过.append拼接字符串