黑马程序员——Java基础---String与StringBuilder

 1 /*
 2 1.模拟一个trim，去掉字符串两端的kongge
 3     思路：1        判断字符串两端是否为空，获取两端首先不为空的角标
 4           2        使用subString(start,end)方法 
 5 
 6 
 7 2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
 8     思路：
 9     1，曾经学习过对数组的元素进行反转。
10     2，将字符串变成数组，对数组反转。
11     3，将反转后的数组变成字符串。
12     4，只要将或反转的部分的开始和结束位置作为参数传递即可。*/
13 class Test
14 {
15     public static void main(String[] args)
16     {
17         String s="   Hello  world   ";
18         String s1=MyTrim(s);
19         System.out.println(s1);
20         String s2="abcdefg";
21         String s3=reverseString(s2,2,5);
22         System.out.println(s3);
23     }
24     public static String MyTrim(String str)//去除空格
25     {
26         int start=0,end=str.length()-1;//定义字符串变成字节数组后，起始位置，以及末尾位置
27         while(start<=end&&str.charAt(start)==‘ ‘)//获取字节数组中非空格的起始角标
28             start++;
29         while(start<=end&&str.charAt(end)==‘ ‘)//获取字节数组中末尾非空格的角标
30                 end--;
31         String s=str.substring(start,end+1);//截取原字符串部分
32         return s;
33     }
34     public static String reverseString(String str,int begin,int end)//自定义，反转字符串顺序
35     {
36         char ch[]=str.toCharArray();//将字符串转成字节数组，通过字节数组的角标互换，实现反转
37         while(begin<end)
38         {
39             swap(ch,begin,end);
40             begin++;
41             end--;
42         }
43         String s2=new String(ch);
44         return s2;
45     }
46     public static void swap(char arr[],int begin,int end)//数组中，交换元素的值
47     {
48         char temp=arr[begin];
49         arr[begin]=arr[end];
50         arr[end]=temp;
51     }
52 }

 1 /*
 2 3，获取一个字符串在另一个字符串中出现的次数。
 3     "abkkcdkkefkkskk"
 4 
 5 
 6     思路：
 7     1，定义个计数器。
 8     2，获取kk第一次出现的位置。contains
 9     3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
10         每获取一次就计数一次。
11     4，当获取不到时，计数完成。
12 
13 
14 
15 */
16 class Test3
17 {
18     
19     public static void main(String[] args)
20     {
21         String s="abkkcdkkefkkskk";
22         String s1="kk";
23         
24             System.out.print(myIndexOf(s,s1));
25     
26 
27         
28     }
29     public static int myIndexOf(String str,String key)
30     {    
31         int count = 0;//定义计数器
32         int index = 0;//定义位置角标
33 
34         while((index= str.indexOf(key,index))!=-1)//获取key在Str中从index位置开始首次的位置，如果index=-1，则跳出循环
35         {
36             System.out.println("index="+index);//打印key出现的位置
37             index = index + key.length();//index出现后，在此遍历的位置则是index原有的位置加上key的字符串长度
38 
39             count++;     //计数器加1
40         }
41         return count;//返回计数器
42     }
43 
44     public static int getSubCount(String str,String key)
45     {
46         int count = 0;//定义计数器
47         int index = 0;//定义位置角标
48 
49         while((index=str.indexOf(key))!=-1)//获取key在Str中从index位置开始首次的位置，如果index=-1，则跳出循环
50         {
51             sop("str="+str);
52             str = str.substring(index+key.length());// 将字符串  从得到的位置加上key的长度，截取后面的字符串
53                                                     //每次遍历寻找的字符串  都是 截取后的字符串
54             count++;    
55         }
56         return count;
57     }
58     public static void sop(String str)//打印字符串
59     {
60         System.out.println(str);
61     }
62 
63 }

 1 /*
 2 
 3 4    获取两个字符串中最大相同子串。
 4         第一个动作：将短的哪个串进行长度一次递减的子串打印。
 5         "abcwerthelloyuiodef"
 6         "cvhellobnm"
 7         思路：
 8             1    将短的那个子串按照长度递减的方式获取到
 9             2    将每获取到的子串去长串中判断是否包含
10                 如果包含，已经找到
11 */
12 
13 class  Test4
14 {
15     /*
16     练习四。
17     */
18     public static String getMaxSubString(String s1,String s2)
19     {
20 
21         String max = "",min = "";
22 
23         max = (s1.length()>s2.length())?s1: s2;//判断s1与s2哪个字符串更大，将大的存入max
24 
25         min = (max==s1)?s2: s1;
26         
27     //sop("max="+max+"...min="+min);
28         for(int x=0; x<min.length(); x++)//控制循环次数，外循环最多为小的字符串的长度，目的使每次循环小字符串的子串长度减1
29         {
30             for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)//定义y到z的长度，限定小字符串子串长度，然后通过双方都递增的情况遍历
31             {
32                 String temp = min.substring(y,z);//取出小字符串的长度
33                 
34                 sop(temp);
35                 if(max.contains(temp))//判断大字符串是否包含小字符串的子串
36                 //if(s1.indexOf(temp)!=-1)
37                     return temp;//包含则返回子串，即最大公有子串
38             }
39         }
40         return "";
41     }
42 
43 
44     public static void main(String[] args) 
45     {
46         String s1 = "abcwerthelloyuiodef";//创建两个字符串
47         String s2 = "cvhellobnm";
48         sop(getMaxSubString(s2,s1));//调用自定义获取最大公有子串方法，将两字符串传入
49     }
50 
51     public static void sop(String str)
52     {
53         System.out.println(str);
54     }
55 }

 1 class StringBuilderDemo
 2 {
 3     public static void main(String[] args)
 4     {
 5         //method_update();
 6         /*StringBuilder sb=new StringBuilder("abcdef");
 7         char[] chs=new char[6];
 8         sb.getChars(1,4,chs,1);//将数组sb中1~4位置的内容传入chs中，是从1位置开始传入。
 9         
10         for(int x=0;x<chs.length;x++)//将数组中的元素全部打印出来
11         {
12             sop("chs["+x+"]="+chs[x]+";");
13             
14         }*/
15         method_update();
16         //method_del();
17         //method_add();
18         //draw(3,6);
19         //draw(3,6);
20 
21     }
22     public static void method_del()
23     {
24         StringBuilder sb= new StringBuilder("abcdeff");
25         //sb.delete(1,3);//清空1~3的数据
26         sop(sb.toString());
27         sb.delete(0,sb.length());//清空容器sb中的数据
28         sb.append(‘1‘).append("abv");
29         sop(sb.toString());
30         //sb.deleteCharAt(2);//单独删除2位置上的数据
31         //sop(sb.toString());
32     }
33 
34     public static void method_add()
35     {
36 
37         StringBuilder sb= new StringBuilder();
38         //sb.append("dafg ").append("dfas");//在容器中添加元素通过append（）
39         StringBuilder sb1 = sb.append(34);
40         sop("sb==sb1"+(sb==sb1));//输出结果为正确，容器为固定，只是同时两个名字指向它
41         sop(sb.toString());
42         sb.insert(1,"qq");//在1位置中插入qq，其他的按顺序顺延
43         sop(sb.toString());//将容器变为字符串打印出来
44 
45     }
46     public static void method_update()
47     {
48         StringBuilder sb=new StringBuilder("abcde");
49         sop(sb.toString());
50         sb.replace(1,4,"java");//容器sb中1~4位置中的元素用“java”替代
51         sop(sb.toString());
52         sb.setCharAt(2,‘d‘);
53         sop(sb.toString());
54         
55     }
56     public static void draw(int row,int col)//将row行，col列的*存储在容器中，并打印出来
57     {
58         StringBuilder sb=new StringBuilder();
59         for(int x=0;x<row;x++)
60         {
61             for(int y=0;y<col;y++)
62             {
63                 sb.append("*");
64             }
65             sb.append("\r\n");
66         }
67         sop(sb.toString());
68     }
69 
70 
71     public static void sop(String str)
72     {
73         System.out.println(str);
74     }
75     
76 }