1. // 找一個字串的最大子串
2.     publicstaticvoid main(String[] args) {  
3.         String s1 = ”qwerabcdtyuiop”;  
4.         String s2 = ”xcabcdvbn”;  
5.         String stringMax = stringMax(s1, s2);  
6.         System.out.println(”最大的相同子字串是：” + stringMax);  
7.     }  
8.     /** 
9.      * 找出兩個字串中最大的相同子字串 
10.      * 
     
11.      * @param s1 
12.      * @param s2 
13.      * @return 
14.      */
15.     privatestatic String stringMax(String s1, String s2) {  
16.         // 記錄相同子字串
17.         String sameString = null;  
18.         // 比較兩個字條串的長度，這裡是設定S1的長度大於S2的長度
19.         if (s1.length() < s2.length()) {  
20.             // 如果s2的長度大，那麼就將兩個字串進行替換
21.             String temp = s1;  
22.             s1 = s2;  
23.             s2 = temp;  
24.         }  
25.         // 如果s2就被包含在s1中，那麼這兩個字串最大的子串就是s2
26.         boolean isContains = s1.contains(s2);  
27.         if (isContains) {  
28.             return s2;  
29.         } else {  
30.             boolean b1 = false;  
31.             // 如果s2不是兩個字串最大的子類，那麼再進行迴圈查詢
32.             for (int
     i = 0; i < s2.length(); i++) {  
33.                 for (int j = 0; j <= i; j++) {  
34.                     // 獲取每次進行比較的子字條串
35.                     String str = s2.substring(j, s2.length() - i + j);  
36.                     System.out.println(”第” + i + “次比較：” + str);  
37.                     if (s1.contains(str)) {  
38.                         sameString = str;  
39.                         b1 = true;  
40.                         break;  
41.                     }  
42.                 }  
43.                 // 如果比較到s2中最小的為2的時候還沒有相同的字串，我們就預設沒相同的子字串
44.                 if (s2.substring(0, s2.length() - i).length() == 2) {  
45.                     System.out.println(”沒有相同的子字串”);  
46.                     b1 = true;  
47.                     break;  
48.                 }  
49.                 if (b1 == true)  
50.                     break;  
51.             }  
52.         }  
53.         return sameString;  
54.     }  

// 找一個字串的最大子串
    public static void main(String[] args) {

        String s1 = "qwerabcdtyuiop";
        String s2 = "xcabcdvbn";
        String stringMax = stringMax(s1, s2);
        System.out.println("最大的相同子字串是：" + stringMax);
    }

    /**
     * 找出兩個字串中最大的相同子字串
     * 
     * @param s1
     * @param s2
     * @return
     */
    private static String stringMax(String s1, String s2) {
        // 記錄相同子字串
        String sameString = null;
        // 比較兩個字條串的長度，這裡是設定S1的長度大於S2的長度
        if (s1.length() < s2.length()) {
            // 如果s2的長度大，那麼就將兩個字串進行替換
            String temp = s1;
            s1 = s2;
            s2 = temp;
        }
        // 如果s2就被包含在s1中，那麼這兩個字串最大的子串就是s2
        boolean isContains = s1.contains(s2);

        if (isContains) {
            return s2;
        } else {
            boolean b1 = false;
            // 如果s2不是兩個字串最大的子類，那麼再進行迴圈查詢
            for (int i = 0; i < s2.length(); i++) {
                for (int j = 0; j <= i; j++) {
                    // 獲取每次進行比較的子字條串
                    String str = s2.substring(j, s2.length() - i + j);
                    System.out.println("第" + i + "次比較：" + str);
                    if (s1.contains(str)) {
                        sameString = str;
                        b1 = true;
                        break;
                    }

                }
                // 如果比較到s2中最小的為2的時候還沒有相同的字串，我們就預設沒相同的子字串
                if (s2.substring(0, s2.length() - i).length() == 2) {
                    System.out.println("沒有相同的子字串");
                    b1 = true;
                    break;

                }
                if (b1 == true)
                    break;
            }
        }
        return sameString;
    }

編譯執行：

分析原理圖：