class MaxSubstring  // 在Java中  有一个习惯 就是顾头不顾尾  
{
        public String maxString(String s1, String s2)
        {
                for (int x=0; x<s2.length();x++ )
                {
                        for (int y=0,z=s2.length()-x-1 ;z!=s2.length() ; y++,z++)
                        {
                                String temp=s2.substring(y,z); /
                                if (s1.contains(temp))
                                {
                                   return temp;
                                }
                        }
                }
                return "";

        }
}


class  MaxSubstringTest
{
        public static void main(String[] args)
        {


                MaxSubstring d= new MaxSubstring();
                String str1="abcwertyuiodefhello";
                String str2="cvbnmhello";   //  如果我这样写的话  输出的结果就是hell了  这是为什么？

               
                System.out.println(d.maxString(str1,str2));
        }
}

红色部分是我的问题和我以为出错误的地方  我不明白的是明明字符串是从0开始算起   这样str.length()来指示字符串不是已经越界了吗？

你这种程序实现的就是str2和str1最大公共子集，也就是数学当中最大公约数的概念！
for (int x=0; x<s2.length();x++ )
{
        for (int y=0,z=s2.length()-x-1 ;z!=s2.length() ; y++,z++) //当x=0的时，y=0，z=s2.length()-1也就是拿整个s2去和s1比较，看s1包不包含s2
        {                                                                                //而z!=s2.length(),就是为了防止角标越界，因为z的初始值永远比s2.length小
                                                                                      //所以每次增加后都要判断，一但相等，就超过了s2的长度。其实这里改为z<s2.length()是一样的效果！
         String temp=s2.substring(y,z);                              //内循环每循环一次，就是起始角标和结束角标同时向后移，
                  if (s1.contains(temp))                     //外循环每循环一次，就是把起始角标和结束角标之间的距离缩小1
                  {
                      return temp;
                    }
         }
  }

数组中有一个公共的实例变量是length.ta 他是指数组的长度的。。。。

楼主 你好 这是我帮你 debug 而且还只能  step over  如果用step into 会出现错误

首先请看你的两个 String
  String str1="abcwertyuiodefhello";
                String str2="cvbnmhello";


而在 API 中  
substringpublic String substring(int beginIndex,                        int endIndex)返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符

所以 你最后截取到的字符串中 不会包含  字母‘o’ 这也是 最后你只能得到 “hell” 的原因
本来 你的两个 String 中 都有 “hello” 但是 substring()不会得到 字母’o‘ 的

上面是我帮你运行的 debug 截图 你仔细看看
在外层循环里面 (外层循环):
每次 结束的时候 比如第一次  temp="cvbnmhell";
                                第二次  temp="vbnmhell";
                                第二次  temp="vbnmhell";
第二次  temp="vbnmhell";
第二次  temp="vbnmhell";
第二次  temp="vbnmhell";

李元峰 发表于 2012-6-16 16:43
楼主 你好 这是我帮你 debug 而且还只能  step over  如果用step into 会出现错误

首先请看你的 ...

刚才不晓得 按错了键 提交了 我补充下 在外层循环里面 (外层循环):
每次 结束的时候 比如第一次  temp="cvbnmhell";（x=0）
                                第二次  temp="vbnmhell";(x=1)
                                第三次  temp="bnmhell";(x=2)
第四次  temp="nmhell";(x=3)
第五次  temp="mhell";(x=4)
第六次  temp="hell";(x=5)
最后外层循环 return的时候  就是 "hell“ 了

for (int y=0,z=s2.length()-x-1 ;z!=s2.length() ; y++,z++)
修改一下成：
for (int y=0,z=s2.length()-x-1 ;z<=s2.length() ; y++,z++)
运行就正常了。

api文档中的substring是这样写的：
public String substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。
z=s2.length() 的时候，你才能获取到最后那个字符。

其实是因为你的z!=s2.length() ;
假如你的相同字符是最后一个字符的话
就会因为z不能=s2.length();
所以他才会少取一个o
不是最后一个的话 就没问题了
所以就像上面说的

1. class MaxSubstring  // 在Java中  有一个习惯 就是顾头不顾尾  
   
2. {
   
3.         public String maxString(String s1, String s2)
   
4.         {
   
5.                 for (int x=0; x<s2.length();x++ )
   
6.                 {
   
7.                         for (int y=0,z=s2.length()-x-1 ;z<=s2.length() ; z++,y++)
   
8.                         {
   
9.                                 String temp=s2.substring(y,z);
   
10.                                                                                 System.out.println(temp);
    
11.                                                                                 System.out.println(x);
    
12.                                                                         System.out.println(y);
    
13.                                                                         System.out.println(z);
    
14. 
    
15.                                 if (s1.contains(temp))
    
16.                                 {
    
17.                                                                         System.out.println(x);
    
18.                                                                         System.out.println(y);
    
19.                                                                         System.out.println(z);
    
20.                                    return temp;
    
21.                                 }
    
22.                         }
    
23.                 }
    
24.                 return "";
    
25. 
    
26.         }
    
27. }
    
28. class  MaxSubstringTest
    
29. {
    
30.         public static void main(String[] args)
    
31.         {
    
32. 
    
33. 
    
34.                 MaxSubstring d= new MaxSubstring();
    
35.                 String str1="abdefhellqqqqoj";
    
36.                 String str2="cndhellqqqqo";   //  如果我这样写的话  输出的结果就是hell了  这是为什么？
    
37. 
    
38.                
    
39.                 System.out.println(d.maxString(str1,str2));
    
40.                                 
    
41.         }
    
42. }
    

复制代码

这样就没问题 上面的同学给的方法
但是我觉得 他们分析错了
有不同意见的 欢迎回复讨论下...