1. /*
   
2. 获取两个字符串中最大相同的子串，第一个动作，将短的那个串进行长度一次递减的子串打印。
   
3. “asdfjhellolkjl”
   
4. “adhellowl”
   
5. 思路：
   
6. 将短的那个子串去长串中判断是否包含，如果包含，已经找到了
   
7. */
   
8. class StringTest4
   
9. {
   
10. public static void main(String[] args)
    
11. {
    
12. String s1="asdfjhellolkjl";
    
13. String s2="adhellowl";
    
14. sop(getMaxSubString(s1,s2));
    
15. }
    
16. public static String getMaxSubString(String s1,String s2)
    
17. {
    
18. for(int x=0;x<s2.length();x++)
    
19. {
    
20. for(int y=0,z=s2.length()-x;z!=s2.length()+1;y++,z++)
    
21. {
    
22. String temp=s2.substring(y,z);
    
23. //if(s1.contains(temp));
    
24. if(s1.indexOf(temp)!=-1)
    
25. return temp;
    
26. 
    
27. 
    
28. }
    
29. }
    
30. return "";
    
31. }
    
32. public static void sop(String str)
    
33. {
    
34. System.out.println(str);
    
35. }
    
36. }

复制代码

在第二个循环里面为什么用//if(s1.contains(temp));就打印不出最长子串而是打印出所有的子串。而用if(s1.indexOf(temp)!=-1)就成功。

public class StringTest2 {
       
        /* 获取一个字符串中指定子串出的次数。比如说“hanbasdnbafllgnbahjnbakqqqqlnbaxi” 在这个字符串中，多有个nba？
         *
         * 分析：
         *                 A:定义两个字符串，一个大串，一个小串。
         *                 B:定义一个统计变量。
         *                
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                String maxString = "niniabcjnhooabcerabcabcijnoabcnjinnabcnnoabc";
                String minString = "abc";
                int count = 0;
               
                char []maxch = maxString.toCharArray();
                char []minch = minString.toCharArray();


               
               
               
                for (int i = 0; i < maxch.length; i++) {
                       
                        if( (maxch[i] == minch[0]) && (maxch[i+1] == minch[1])&&(maxch[i+2] == minch[2])){
                               
                                count++;
                        }
                }
                System.out.println(count);
        }

}

主要是两个String类方法的不同：
contains方法：返回值boolean 。s1.contains(temp)比较的是temp表示的字符串是否是s1字符串的子串，如果是，返回true，否则，返回false。
indexOf方法：返回值int。s1.indexOf(temp)!=-1，判断temp在s1中第一次出现的位置，如果存在，返回这个位置，否则返回-1.
没有判断条件，打印的是s2的所有子串。

contains方法和indexOf方法只是比较的方式和返回值不同，但不会影响你判断的结果，所以你用这两种方法都应该能得到最长的字串。
我看你的代码，应该是因为你的if(s1.contains(temp))后面多写一个；的原因。代表你的if语句作用的范围已经结束，你return temp这个语句不再属于if，所以不管你的判断结果如何，它都会返回temp。因此，在你做第一次循环判断的时候，这个temp就返回了，循环就结束了。打印的结果是所有的字符串，而不是最长字串。

我去，这代码看的我想死 你就不能把代码格式改一下？？？？

很简单。。。。。。你多加了一个“；”代码里面标记了

1. package it.cast;
   
2. 
   
3. 
   
4. 
   
5. /*
   
6. 获取两个字符串中最大相同的子串，第一个动作，将短的那个串进行长度一次递减的子串打印。
   
7. “asdfjhellolkjl”
   
8. “adhellowl”
   
9. 思路：
   
10. 将短的那个子串去长串中判断是否包含，如果包含，已经找到了
    
11. */
    
12. class Test1
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 String s1="asdfjhellolkjl";
    
17.                 String s2="adhellowl";
    
18.                 sop(getMaxSubString(s1,s2));
    
19.         }
    
20.         public static String getMaxSubString(String s1,String s2)
    
21.         {
    
22.                 for(int x=0;x<s2.length();x++)
    
23.                         {
    
24.                                 for(int y=0,z=s2.length()-x;z!=s2.length()+1;y++,z++)
    
25.                                         {
    
26.                                                 String temp=s2.substring(y,z);
    
27.                                                 if(s1.contains(temp));//原因很简单因为你这里有一个“；”
    
28.                                                 //if(s1.indexOf(temp)!=-1)
    
29.                                                 return temp;
    
30.                                         }
    
31.                         }
    
32.                         return "";
    
33.         }
    
34.         public static void sop(String str)
    
35.         {
    
36.                         System.out.println(str);
    
37.         }
    
38. }
    

复制代码

wconho 发表于 2014-4-18 19:06
主要是两个String类方法的不同：
contains方法：返回值boolean 。s1.contains(temp)比较的是temp表示的字符 ...

你真逗！！