1. /*
   
2. 练习四：获取一个字符串在另一个字符串中出现的次数。
   
3. */
   
4. class StringTest4
   
5. {
   
6.         public static String getMax(String s1,String s2)
   
7.         {
   
8.                 String max="";
   
9.                 if(s1.length()<s2.length())
   
10.                 {
    
11.                         max=s2;
    
12.                 }
    
13.                 else
    
14.                         max=s1;
    
15.                 return max;
    
16.         }
    
17.         public static String getMin(String s1,String s2)
    
18.         {
    
19.                 String min="";
    
20.                 if(s1.length()<s2.length())
    
21.                 {
    
22.                         min=s1;
    
23.                 }
    
24.                 else
    
25.                         min=s2;
    
26.                 return min;
    
27.         }
    
28.         public static String getMaxSubString(String s1,String s2)
    
29.         {
    
30.                 String max=getMax(s1,s2);
    
31.                 String min=getMin(s1,s2);
    
32.                 //String max="",min="";
    
33.                 //max=(s1.length()>s2.length())?s1:s2;
    
34.                 //min=(max==s1)?s2:s1;
    
35.                 for(int x=0;x<min.length();x++)
    
36.                 {
    
37.                         for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
    
38.                         {
    
39.                                 String temp=min.substring(y,z);
    
40.                                 sop(temp);
    
41.                                 if(max.contains(temp))
    
42.                                         return temp;
    
43.                         }
    
44.                 }
    
45.                 return "";
    
46.         }
    
47.         public static void main(String[] args)
    
48.         {
    
49.                 String s2="abcwerthelloyuiodef";
    
50.                 String s1="cvhellobnm";
    
51.                 sop(getMaxSubString(s1,s2));
    
52.         }
    
53.         public static void sop(String str)
    
54.         {
    
55.                 System.out.println(str);
    
56.         }
    
57. }
    

复制代码

1、我想问一下在getMaxSubString（）里最后的return "";是什么？应该是返回temp吧，为什么有两个return？
2、在获取较大和较小的字符串时，能不能用一个方法代替？能不能用一个方法交换两个字符串？视频里老师没有用能交换两个字符串的方法，而是直接在getMaxSubString（）里用max=(s1.length()>s2.length())?s1:s2; min=(max==s1)?s2:s1;取得较大较小值，

1.由于temp是循环代码块内部定义的变量，对于外部是没有办法直接引用的，也可以理解为如果循环一直都没有执行到return的返回语句，那么这个方法就没有了结束标记，所以在外部定义一个return ""用来表示当循环内没有执行到return时，结束循环后，由外部返回结果。
2.楼主要通过一个方法同时或得到最大和最小值，而一个方法只能有一个返回值，那么可以用返回一个数组的形式来实现，并默认的0角标为max，1角标为min。这样也可以实现

注：在我当时学到这里的时候有一个小疑问，也就是说如果量个字符串中有两个或多个等长的子串都重复了，那么用这个代码就不能实现。所以我进行了改写。附上我的代码，和楼主要求的代码，供楼主参考。

1. package test;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class test3
   
7. {
   
8.                 //按照楼主要求：用一个方法直接返回两个字符串中的最大和最小值
   
9.                 //由于返回是两个值，那就可以通过返回一个字符数组的形式来存储
   
10.                 //并默认0角位为max，1角标位为min
    
11.                 //这个只是为了给楼主举例，在下列的方法中并没有调用进行验证。不过理论上应该可行，不知是否符合楼主要求
    
12.                 public static String[] gets(String s1,String s2)
    
13.                 {
    
14.                         String[] strs = new String[2];
    
15.                        
    
16.                         if(s1.length() > s2.length())
    
17.                         {
    
18.                                 strs[0] = s1;
    
19.                                 strs[1] = s2;
    
20.                         }
    
21.                         else
    
22.                         {
    
23.                                 strs[1] = s1;
    
24.                                 strs[0] = s2;
    
25.                         }
    
26.                         return null;
    
27.                 }
    
28.                
    
29.                
    
30.                 //以下是我当初的代码体现，供楼主参考
    
31.                
    
32.                
    
33.         //由于存在特殊情况，就是两个字符串中出现了两个等长的重复子串
    
34.         //所以，使用一个集合来作为子串容器。
    
35.         public static List<String> getMaxSubString(String s1,String s2)
    
36.         {
    
37. 
    
38.                 List<String> strs = new ArrayList<String>();//存取子串元素
    
39.                 List<String> strs1 = new ArrayList<String>();//取出长度最大的子串元素
    
40.                
    
41.                 String max=(s1.length()>s2.length())?s1:s2;
    
42.                 String min=(max==s1)?s2:s1;
    
43. 
    
44.                 for(int x=0;x<min.length();x++)
    
45.                 {
    
46.                         for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
    
47.                         {
    
48.                                 String temp=min.substring(y,z);
    
49.                                 //sop(temp);
    
50.                                 if(max.contains(temp))//如果是大字符串中包含的子串，则存入子串集合中
    
51.                                 {
    
52.                                         strs.add(temp);
    
53.                                 }
    
54.                         }
    
55.                 }
    
56.                
    
57.                 if(strs.size() == 0)//当子串集合中没有元素，说明两个字符串没有重复元素，则返回null
    
58.                 {
    
59.                         return null;
    
60.                 }
    
61.                
    
62.                 int len = strs.get(0).length();
    
63.                
    
64.                 for(String str : strs)//遍历子串以后，过滤出长度最大的子串
    
65.                 {
    
66.                         if(str.length() == len)
    
67.                         {
    
68.                                 strs1.add(str);//将过滤出来的子串存入到过滤后的子串集合中
    
69.                         }
    
70.                 }
    
71.                 return strs1;
    
72.         }
    
73.         public static void main(String[] args)
    
74.         {
    
75.                 String s2="abcwerthellovabcdef";
    
76.                 String s1="cvhelloabcde";
    
77. 
    
78.                 sop(getMaxSubString(s1,s2));
    
79.         }
    
80.         public static void sop(Object obj)
    
81.         {
    
82.                 System.out.println(obj);
    
83.         }
    
84. }
    

复制代码

1. package wenti;
   
2. /*
   
3. * 哥们，我很佩服你能把取最大值最小值方法写成这样。开个玩笑。。。
   
4. * 你知道  其实他return "";是他循环完之后没有返回值才给默认返回值。这就表示他没
   
5. * 有找到匹配的的字符串。   如果你把最后一句改成return "没有找到匹配字符串";是不是
   
6. * 会豁然开朗。
   
7. */
   
8. 
   
9. public class wenti6  {
   
10. 
    
11. public static void compare(String s1, String s2){//其实写一个很简单的比较方法就行了，然后你默认的时候取s1是最大值，如果s1<s2的话就替换
    
12.         if(s1.length()<s2.length()){
    
13.                 String str=s1;
    
14.                 s1 = s2;
    
15.                 s2 = str;
    
16.         }
    
17. }
    
18. public static String getMaxSubString(String s1,String s2)
    
19. {
    
20.                 compare(s1,s2);
    
21.         String max=s1;
    
22.         String min=s2;
    
23. 
    
24.         for(int x=0;x<min.length();x++)
    
25.         {
    
26.                 for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
    
27.                 {
    
28.                         String temp=min.substring(y,z);
    
29. //                        System.out.println(temp);
    
30.                         if(max.contains(temp))
    
31.                                 return temp;
    
32.                 }
    
33.         }
    
34.         return "没有找到匹配字符串";
    
35. }
    
36. public static void main(String[] args)
    
37. {
    
38.         String s2="abcwerthelloyuiodef";
    
39.         String s1="cvhellobnm";
    
40.         System.out.println(getMaxSubString(s1,s2));
    
41.         String s3="asdfghjk";
    
42.         String s4="cxv";
    
43.         System.out.println(getMaxSubString(s3,s4));
    
44. }
    
45. }

复制代码

Mr_Free 发表于 2013-7-29 10:12

我知道我写的那个麻烦啦，只是那个替换s1和s2的方法我也试过，对于String类型的好像是不管用，貌似String类型一建立时就不能修改了，因此调用了这个compare方法，也不能把较大值给s1，把较小值给s2，好像是这样。。。。。所以不知道怎么弄了

王磊 发表于 2013-7-28 15:09
1.由于temp是循环代码块内部定义的变量，对于外部是没有办法直接引用的，也可以理解为如果循环一直都没有执 ...

你这个太猛啦。。哈哈。。厉害

1. package wenti;
   
2. 
   
3. public class wenti6  {
   
4. 
   
5. public static String getMaxSubString(String s1,String s2)
   
6. {               
   
7.                 if(s1.length()<s2.length()){
   
8.                         String s3;
   
9.                         s3=s1;
   
10.                         s1=s2;
    
11.                         s2=s3;
    
12.                 }
    
13.                 String max=s1;
    
14.                 String min=s2;
    
15.         
    
16.                
    
17.                 System.out.println("S1:"+s1);
    
18.         
    
19. 
    
20.         for(int x=0;x<min.length();x++)
    
21.         {
    
22.                 for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)
    
23.                 {
    
24.                         String temp=min.substring(y,z);
    
25. //                        System.out.println(temp);
    
26.                         if(max.contains(temp))
    
27.                                 return temp;
    
28.                 }
    
29.         }
    
30.         return "没有找到匹配字符串";
    
31. }
    
32. public static void main(String[] args)
    
33. {
    
34.         String s2="abcwerthelloyuiodef";
    
35.         String s1="cvhellobnm";
    
36.         System.out.println(getMaxSubString(s1,s2));
    
37.         String s3="asdfghjk";
    
38.         String s4="cxv";
    
39. //        System.out.println(getMaxSubString(s3,s4));
    
40. }
    
41. }

复制代码

/*我真不好意思，我自己写的代码没有验证，现在我该了一下，验证过了。希望对你有帮助*/

iBadboy 发表于 2013-7-29 22:18
你这个太猛啦。。哈哈。。厉害

这。。。猛在哪里。。。

王磊 发表于 2013-7-29 22:37
这。。。猛在哪里。。。

我都没想那个会出现多个相同最大长度子串的问题。。。。哈哈

Mr_Free 发表于 2013-7-29 22:37
/*我真不好意思，我自己写的代码没有验证，现在我该了一下，验证过了。希望对你有帮助*/  ...

没事了，真的多谢耐心解答，不过还是不知道能不能把交换s1和s2那个封装成一个方法？

iBadboy 发表于 2013-7-29 22:42
我都没想那个会出现多个相同最大长度子串的问题。。。。哈哈

额。。。我也是那时候做测试想到的。。。就试着解决了一下而已。。