就是说    两个字符串的最大相同子串。
比如:
"sadabcdfghjkl"
"werabcdtyu"

package com.itcast.string;
/*
需求：两个字符串的最大相同子串。
分析：
在长串里面直接查找短串，如果查到了，那么短串就是这两个串的最大子串。
如果没查到，怎么办呢？
接下来，把短串截取，然后再在长串里面查，如果有就是最大子串。
假如用户不知道哪个是长串，哪个是短串，怎么办？
*/
public class StringTest {

        /**
         * @param args
         */
        public static void main(String[] args) {
                String maxString = "sadabcdfghjkl";
                String minString = "werabcdtyu";
                System.out.println(getMaxSubString(maxString, minString));
        }

        public static String getMaxSubString(String maxString, String minString) {
                for (int x = 0; x < minString.length(); x++) {
                        for (int start = 0, end = minString.length() - x; end <= minString
                                        .length(); start++, end++) {
                                // 小串的变换
                                String temp = minString.substring(start, end);
                                if (maxString.contains(temp)) {
                                        return temp;
                                }
                        }
                }
                return null;
        }
}

public class StringDemo2 {
    public static void main(String[] args){
        String str1 = "avdkfahellosjks";
        String str2 = "ewavdrhellotte";
        System.out.println(commonMaxSubstring(str1, str2));
    }
    public static String commonMaxSubstring(String str1,String str2){
        int len = str1.length();
        String str3 = null;
        outer:
            //i为子串的长度
            for(int i = len;i>0;i--){
                //j为子串的脚标
                for(int j=0;j<len-i+1;j++){
                    str3=str1.substring(j,j+i);
                    if(str2.contains(str3))
                        break outer;
                    
                }
            }
        return str3;
    }
}
{:soso_e100:}

论坛有很多类似帖,最好先搜索一下
这种方法缺点是只从左到右比较, 取得第一次遇到的最大相同字符串

1. 
   
2. public class test {
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 System.out.println(getMaxSubString(s1,s2));
   
6.         }
   
7.         public static String getMaxSubString(String s1, String s2) {
   
8.                 String max, min;
   
9.                 max = s1.length() > s2.length() ? s1 : s2;
   
10.                 min = s1.length() <= s2.length() ? s1 : s2;//这个min 跟max 是为了判断获取的2个字符串 把长的赋值给max短的赋值给min 减少比较次数
    
11.                 for(int x=0; x<min.length(); x++){
    
12.                         for(int y=0,z=min.length()-x; z<=min.length(); y++,z++){//先比较整个的min字符 也就是0角标到min.length()角标
    
13.                                 String temp = min.substring(y,z);          //第二次是min.length-1个字符来比较 也就是werabcdty erabcdtyu
    
14.                                 if(max.contains(temp)){                    //第三次是min.length-2个字符来比较 也就是werabcdt erabcdty rabcdtyu 以此类推的...
    
15.                                         return temp;
    
16.                                 }
    
17.                         }
    
18.                 }
    
19.                 return null;
    
20.         }
    
21. }

复制代码

下面这段代码提供了,可计最大相同子串出现次数,同样也有如有两个不同子串长度最大且相等的时候,输出结果取决于entrySet()取出的映射

1. import java.util.HashMap;
   
2. import java.util.Map;
   
3. 
   
4. public class test {
   
5.         public static void main(String[] args) {
   
6.                 Map<String, Integer> map = new HashMap<String, Integer>();
   
7.                 String s1 = "cdefsadabcdfghjcdefkl";
   
8.                 String s2 = "cdefghjwerabcdtyucdef";
   
9.                 for (int i = 0; i < s2.length(); i++) {
   
10.                         for (int j = i + 1; j <= s2.length(); j++) {
    
11.                                 String key = s2.substring(i, j);                               
    
12.                                 if (s1.contains(key)) {                               
    
13.                                         if (map.containsKey(key)) {                                               
    
14.                                                 map.put(key, map.get(key) + 1);
    
15.                                         } else {                                                       
    
16.                                                 map.put(key, 1);
    
17.                                         }
    
18.                                 }
    
19.                         }
    
20.                 }
    
21.                 int maxValue = 0;
    
22.                 String maxKey = "";
    
23.                 for (Map.Entry<String, Integer> m : map.entrySet()) {               
    
24.                         if (m.getKey().length()> maxKey.length()) {
    
25.                                 maxValue = m.getValue();
    
26.                                 maxKey = m.getKey();
    
27.                         }
    
28.                 }
    
29.                 System.out.println("最大的重复子串为："+maxKey+" 出现次数为："+maxValue);
    
30.         }
    
31. }

复制代码

兄弟你 看视频了么？ 老毕讲的有啊，不会是刷分的吧