package Test;
public class StringTest3 {
//两个字符串中最大相同的子串。

  public static void main(String[] args) {
   String str = "ahdskjalksdg";
   String str1 = "skjalksdgfsajflskj";
   String string = getSubString(str,str1);
   System.out.println(string);
   
  }
  public static String getSubString(String str, String str1) {
   String max = null,min = null;
   //判断哪个字符串长，哪个短
   max =(str.length()>str1.length())?str:str1;
   min = max.equals(str)?str1:str;
   //遍历字符串
   for(int i=0; i<max.length();i++){
    for (int x=0, y = max.length()-i; y <min.length()+1;x++,y++) {
     String sub = min.substring(x,y);
     //判断获得字符串是包涵与最大字符串中，则返回字符串
     if (max.contains(sub)) {
      return sub;
     }
    }
   }
   /*for(int x=0;x<min.length();x++){
    for(int y=min.length();y>x;y--){
     String sub = min.substring(x,y);
     if (max.contains(sub)) {
      return sub;
     }
    }
     */
     
   
  
   return null;
   }
  }
代码中  for (int x=0, y = max.length()-i; y <min.length()+1;x++,y++)
Y的初始值为什么是max.length()-i，且后面还要y++

Y的初始值为什么是max.length()-i，且后面还要y++
--------------------------------------------------------
先弄明白程序是如何比较的，就是要弄清楚算法，
画了该代码的图并附上代码，供参考：

1. public class StringTest3a
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. String str = "ahdskjalksdgkk";//14个字符
   
6. String str1 = "skjalksdgfsajflskj";//18个字符
   
7. String string = getSubString(str,str1);
   
8. System.out.println(string);
   
9. 
   
10. }
    
11. public static String getSubString(String str,String str1)
    
12. {
    
13. String max = null,min = null;
    
14. 
    
15. //如下的判断语句，当str和str1的长度相等时，max=str1，min=str；
    
16. max = (str.length()>str1.length())?str:str1;
    
17. min = max.equals(str)?str1:str;
    
18. //-----------------------
    
19. for(int i=0;i<max.length();i++)
    
20. {
    
21. System.out.println("第 "+i+" 次循环结果：");
    
22. int innerCount=1;
    
23. for(int x=0,y=max.length()-i;y<min.length()+1;x++,y++)
    
24. {
    
25. System.out.println("开始内循环----"+innerCount);
    
26. String sub = min.substring(x,y);
    
27. if(max.contains(sub))
    
28. {
    
29. System.out.println("此时y等于："+y+" 返回字符串的长度是： "+sub.length());
    
30. return sub;
    
31. }
    
32. innerCount++;
    
33. }
    
34. 
    
35. }
    
36. /*★★★★★---------------
    
37. for(int x=0;x<min.length();x++)
    
38. {
    
39. for(int y=min.length();y>x;y--)
    
40. {
    
41. String sub = min.substring(x,y);
    
42. if(max.contains(sub))
    
43. {
    
44. return sub;
    
45. }
    
46. }
    
47. }
    
48. ★★★★★-------------------*/
    
49. return null;
    
50. }
    
51. 
    
52. }
    
53. /*
    
54. 运行结果：
    
55. D:\>java StringTest3a
    
56. 第 0 次循环结果：
    
57. 第 1 次循环结果：
    
58. 第 2 次循环结果：
    
59. 第 3 次循环结果：
    
60. 第 4 次循环结果：
    
61. 开始内循环----1
    
62. 第 5 次循环结果：
    
63. 开始内循环----1
    
64. 开始内循环----2
    
65. 第 6 次循环结果：
    
66. 开始内循环----1
    
67. 开始内循环----2
    
68. 开始内循环----3
    
69. 第 7 次循环结果：
    
70. 开始内循环----1
    
71. 开始内循环----2
    
72. 开始内循环----3
    
73. 开始内循环----4
    
74. 第 8 次循环结果：
    
75. 开始内循环----1
    
76. 开始内循环----2
    
77. 开始内循环----3
    
78. 开始内循环----4
    
79. 开始内循环----5
    
80. 第 9 次循环结果：
    
81. 开始内循环----1
    
82. 开始内循环----2
    
83. 开始内循环----3
    
84. 开始内循环----4
    
85. 此时y等于：12 返回字符串的长度是： 9
    
86. skjalksdg
    
87. */

复制代码

给你这个例子把里面注释很详细 ，这里给你的的还是一个调试方法，注意看结果，代码中间给你穿插了打印方法
public staticString getSubString(String str, String str1)

           {

              Stringmax = null,min = null;

              max= (str.length() > str1.length()) ? str : str1;//"skjalksdgfsajflskj"

              min= max.equals(str) ? str1 : str;//"ahdskjalksdg"

              for (int i = 0; i <max.length(); i++)

                  {

                     System.out.println("第" + i + "次循环" +"i="+i);

不知道你这是哪里的代码，但是很显然的是，这是你自己构建了一种情况，目的是截取自己想要的特定字符串

问题一：为什么 y = max.length()-i 因为max.length() 是18，而条件min.length()+1是13，y不减去 i 的话嵌套的for里面的语句就执行不到

                     for (int x = 0, y = max.length()- i;    y < min.length() + 1;    x++, y++)

                         {System.out.println("内循环第" + y + "次循环" +"y="+y);

                            Stringsub = min.substring(x, y);

                            if (max.contains(sub))// 判断获得字符串是包涵与最大字符串中，则返回字符串

                                {

                                   return sub;

                                }

                         }

                  }
问题二： 为什么要y++呢，因为y是一个判断的条件，而你这里只有在y小于13的时候才会循环，找到循环的时候y++能够在符合条件的情况下多循环几次
第0次循环i=0
第1次循环i=1
第2次循环i=2
第3次循环i=3
第4次循环i=4
第5次循环i=5
第6次循环i=6
开始内循环第y=12  刚开始是12 y++后 直接跳出
第7次循环i=7
开始内循环第y=11  后来是11，多执行了一次
开始内循环第y=12
第8次循环i=8
开始内循环第y=10  再往下很直接，里面终于出现了，满足你自己设置的条件的字符串
开始内循环第y=11
开始内循环第y=12
第9次循环i=9
开始内循环第y=9
开始内循环第y=10
开始内循环第y=11
开始内循环第y=12
skjalksdg                          你的代码想得到的字符串