我的算法还可以改进一下，等下会把改好的发上来

改进后的代码，之前遍历耗时83秒，改进后耗时53秒，可见性能提升还是很明显的

1.         /**
   
2.          * 这个接口用于定义规则的，用户可以在这个接口的实现类中自定义规则，如果一个item符合这个规则返回真，否则返回假
   
3.          */
   
4.         interface ItemFilter {
   
5.                 boolean accept(String item);// 用于检测符合的情况
   
6. 
   
7.                 boolean exclude(String item);// 用于检测不符合的情况，以避免无谓的遍历
   
8.         }
   
9. 
   
10.         public static void main(String[] args) throws Exception {
    
11.                 String[] values = { "H", "E", "L", "L", "O", "H", "E", "I", "M", "A", "!" };
    
12.                 TreeSet<String> result = new TreeSet<>();
    
13.                 BufferedWriter out = new BufferedWriter(new FileWriter(new File("D:\\LResult.txt")));
    
14.                 // 这里我自定义的规则是:L后面跟A，H后面跟I，E和M相隔两个字符,O和!不相邻，不能有连续两个相同的字符(如LL
    
15.                 // 或HH),O在I前面(不是I前面跟O而是O的位置在I前面，可以相邻可以不相邻)
    
16.                 ItemFilter filter = new ItemFilter() {
    
17.                         private Pattern pattern1 = Pattern.compile("(E.{2}M)|(M.{2}E)");// 匹配E和M相隔两个字符
    
18.                         private Pattern pattern2 = Pattern.compile("(.)\\1");// 匹配不能有连续两个相同的字符(如LL或HH)
    
19.                         private Pattern pattern3 = Pattern.compile("O.*I");// 匹配O在I前面(不是I前面跟O而是O的位置在I前面，可以相邻可以不相邻)
    
20.                         private Pattern pattern4 = Pattern.compile("O!|!O");// 匹配O和!不相邻
    
21.                         private Pattern pattern5 = Pattern.compile("LA");// 匹配L后面跟A
    
22.                         private Pattern pattern6 = Pattern.compile("HI");// 匹配H后面跟I
    
23. 
    
24.                         @Override
    
25.                         public boolean accept(String item) {
    
26.                                 boolean rule1 = pattern1.matcher(item).find();
    
27.                                 boolean rule3 = pattern3.matcher(item).find();
    
28.                                 boolean rule5 = pattern5.matcher(item).find();
    
29.                                 boolean rule6 = pattern6.matcher(item).find();
    
30.                                 // boolean rule2 = !pattern2.matcher(item).find();//
    
31.                                 // 这个要匹配失败才表示没有连续两个相同的字符
    
32.                                 //boolean rule4 = !pattern4.matcher(item).find();//
    
33.                                 // 这个要匹配失败才表示O和!不相邻
    
34.                                 return rule1 && rule3 && rule5 && rule6 ;//&&rule2&&rule4;
    
35.                         }
    
36. 
    
37.                         @Override
    
38.                         public boolean exclude(String item) {
    
39.                                 // 这里面的pattern任意一个匹配成功则以此head开始的组合都是不符合规则的，所以没必要继续递归下去了
    
40.                                 boolean rule2 = pattern2.matcher(item).find();// 这个匹配成功表示有连续两个相同的字符
    
41.                                 boolean rule4 = pattern4.matcher(item).find();// 这个匹配成功表示O和!相邻
    
42.                                 return rule2 || rule4;
    
43.                         }
    
44.                 };
    
45.                 long start = System.currentTimeMillis();
    
46.                 listAvailableItems(values, "", result, filter);
    
47.                 out.write("共有" + result.size() + "组\r\n");
    
48.                 for (String item : result) {
    
49.                         out.write(item + "\r\n");
    
50.                 }
    
51.                 out.flush();
    
52.                 out.close();
    
53.                 long end = System.currentTimeMillis();
    
54.                 System.out.println("共耗时:" + (end - start) / 1000 + "秒");
    
55.         }
    
56. 
    
57.         public static void listAvailableItems(final String[] values, final String head, TreeSet<String> result,
    
58.                         ItemFilter filter) {
    
59.                 for (int i = 0; i < values.length; i++) {
    
60.                         String[] localV = Arrays.copyOf(values, values.length);
    
61.                         String localH = new String(head);
    
62.                         if (localV[i] == null) {// 这里过滤掉null元素，
    
63.                                 continue;
    
64.                         }
    
65. 
    
66.                         localH += localV[i];// 到这里说明找到一个可用元素，则把该元素追加到已排列组合的尾部
    
67.                         localV[i] = null;// 将已取走的元素从values中去除
    
68. 
    
69.                         if (filter.exclude(localH)) {//这里避免不必要的遍历
    
70.                                 continue;
    
71.                         }
    
72.                         if (localH.toCharArray().length == values.length) {// 这是递归结束的条件，即一个组合已排列出来，未必是符合规则的组合
    
73.                                 if (filter.accept(localH)) {// 这里判断这个组合是否符合规则
    
74.                                         result.add(localH);
    
75.                                 }
    
76.                                 return;
    
77.                         }
    
78.                         listAvailableItems(localV, localH, result, filter);// 到这里说明还没有排列完成一个组合，则继续递归
    
79.                 }
    
80.         }

复制代码

看一看,多多学习

膜拜大神，完全看不懂