Java中字符串的学习（二）String类的小练习

练习

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

思路：

1）判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格，结尾处判断空格也是如此。

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

 分析：

主要代码：

 1 public static String myTrim(String str)
 2 
 3          {
 4 
 5                    int start = 0,end = str.length() - 1;
 6 
 7                    while(start <= end && str.charAt(start) == ' ')
 8 
 9                    start++;
10 
11                    while(start <= end && str.charAt(end) == ' ')
12 
13                    end--;
14 
15                    //这样我们就获取到了中间有效的字符串，并且这个有效的字符串是
16 
17                    //整个字符串的子串，我们就用获取子串的方法来获取
18 
19                    return str.substring(start,end+1);//为什么加1，注意包含头不包含尾。
20 
21          }

 

运行结果：

 

2.将一个字符串进行反转。例：”abcdefg”反转成“abfedcg”.

思路：

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

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

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

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

 

主要代码：

public static String reverseString(String s)

         {

                   //字符串变数组

                   char[] chs = s.toCharArray();

                   //反转数组，创建特有方法

                   reverse(chs);

                   //将数组变成字符串

                   return new String(chs);

         }

         //如果不想吧方法暴露出去（让其他类引用），可以设置方法的修饰符为private

         private static void reverse(char[] arr)

         {

                   //数组反转就是头尾互换

                   for(int start = 0,end = arr.length-1;start)

                   {

                            swap(arr,start,end);

                   }       

         }

         /*实现大功能，尽量细分小功能，便于修改和维护*/

         private static void swap(char[] arr,int x,int y)

         {

                   //这样就剩下一个调换位置这一功能，这个靠第三方变量即可解决

                   char temp = arr[x];

                   arr[x] = arr[y];

                   arr[y] = temp;

         }

 

运行结果:

 

拓展：将字符串中指定部分进行反转。

拓展主要代码：

 1 public static String reverseString(String s,int start,int end)
 2 
 3          {
 4 
 5                             //还是和练习二一致先将字符串变数组
 6 
 7                    char[] chs = s.toCharArray();
 8 
 9                    //反转数组，创建特有方法，但这里反转的是字符串的一部分
10 
11                    reverse(chs,start,end);
12 
13                    //将数组变成字符串
14 
15                    return new String(chs);
16 
17          }
18 
19          private static void reverse(char[] arr,int x,int y)
20 
21          {
22 
23                    //数组反转就是头尾互换
24 
25                    //注意因为在java中，涉及到取从头到尾的部分一般情况下都是包含头不包含尾
26 
27                    //为什么这么写呢，因为官方这样操作取值的方法中参数往往是一个起始点和所要取值的长度，便于取整。
28 
29                    //而长度减一就是最后的脚标。
30 
31                    //所以在这里我们遵照官方（习惯），将尾的脚标减一
32 
33                    for(int start = x,end = y-1;start)
34 
35                    {
36 
37                             swap(arr,start,end);
38 
39                    }       
40 
41          }

 

运行结果：

 

3.获取一个字符串在另一个字符串中出现的次数。”abkkcdkkefkkskk”.

思路：

1）定义一个计数器；

2）获取kk第一次出现的位置；

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

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

分析：

我们要想找这个kk，首先，判断是否存在kk，如果kk都不存在，那么我们也就不用查次数了。如果存在，就获取位置。既判断存在又获取位置，用indexOf方法，不存在返回-1.

本例中，kk是在2脚标的地方首次出现，我们计数一次，下一次我们找就应该从2脚标+kk的长度2=4脚标的地方开始找，找到再加一，（技巧，涉及计数器的地方就会有循环），那循环我们怎样设定呢？是不是当我们找的子串中没有kk了，循环就结束了?这样，代码就有了。

主要代码：

 1 //方法一
 2 
 3          public static int getSubCount(String str,String key)
 4 
 5          {
 6 
 7                    //定义计数器
 8 
 9                    int count = 0;
10 
11                    //定义变量记录位置
12 
13                    int index = 0;
14 
15                    while((index = str.indexOf(key)) != -1)
16 
17                    {
18 
19                             sop("str ="+str);
20 
21                             str = str.substring(index+key.length());
22 
23                             count++;
24 
25                    }
26 
27                    return count;
28 
29          }

 

结果：

 

 1 //练习三，方法二
 2 
 3          //indexOf()方法有个重载方法Int indexOf(String str,int fromIndex)
 4 
 5          //indexOf(String str)方法每一次都是从0脚标位开始查找，为此我们还得获取子串
 6 
 7          public static int getSubCount_2(String str,String key)
 8 
 9          {
10 
11                    //定义计数器
12 
13                    int count = 0;
14 
15                    //定义变量记录位置
16 
17                    int index = 0;
18 
19                    while((index = str.indexOf(key,index)) !=-1 )
20 
21                    {
22 
23                             sop("index=" + index);
24 
25                             index = index + key.length();
26 
27                             count++;
28 
29                    }
30 
31                    return count;
32 
33          }

 

结果：

 

练习三注意：

         针对练习三，有人会想到采用字符串切割的方法. 这里是可行的。

         但我们换另一个字符串

         “kkdwghduwhudkksufbusdhfu”

         如果用切割，并且0脚标开始就是我们要查的字符串，那么第一次切得时候就是两个字符串

         一个是kk前面系统自动“补全”的空字符串

         一个是kk后面的串“dwghduwhudkksufbusdhfu”

         这样，就会平白无故多出来一个串，也就多出了一个数，可能

         结果也不再是我们想要的结果。也就是说，用切割的方法不通用。

         所以，不建议使用切割。

 

4.获取两个字符串中最大相同的子串。第一个动作：将短串进行长度依次递减的子串打印。

“abcwerthellouyiodef”

“cvhellobnm”

思路：

1）将短串按照长度递减的方式获取到。

2）将每获取到的子串去长串中判断是否包含，如果包含，已经找到。

分析：

 

主要代码：

 1 //练习四  获取两个字符串中最大相同的子串
 2 
 3          public static String getMaxSubString(String s1,String s2)
 4 
 5          {
 6 
 7                    //因为传过来的两个字符串不知道谁长谁短
 8 
 9                    //所以先进行判断
10 
11                    String max = "", min = "";
12 
13                    max = (s1.length()>s2.length())?s1:s2;
14 
15                    min = (max ==s1)?s2:s1;
16 
17                    for(int x = 0;x)
18 
19                    {
20 
21                             for(int y=0 ,z= (min.length()) - x;z != min.length()+1;y++,z++)
22 
23                             {
24 
25                             String temp = min.substring(y,z);
26 
27                             //sop(temp);
28 
29                             if(max.contains(temp))//if(s1.indexOf(temp) != -1)
30 
31                                      return temp;
32 
33                             }
34 
35                    }
36 
37                   
38 
39                    return "";
40 
41          }

 

运行结果：

转载于:https://www.cnblogs.com/devtrees/p/4367652.html