【设计模式】JAVA Design Patterns——Combinator（功能模式）

// 用于查找文本中的行的功能界面。
public interface Finder {
 
  // 在文本中查找行的函数。
  List<String> find(String text);
 
  // 函数{@link #find(String)}的简单实现。
  static Finder contains(String word) {
        return txt -> Stream.of(txt.split("\n"))
            .filter(line -> line.toLowerCase().contains(word.toLowerCase()))
            .collect(Collectors.toList());
    }
 
  // 组合器：not。
  default Finder not(Finder notFinder) {
        return txt -> {
            List<String> res = this.find(txt);
            res.removeAll(notFinder.find(txt));
            return res;
          };
    }
 
  // 组合器：or。
  default Finder or(Finder orFinder) {
        return txt -> {
            List<String> res = this.find(txt);
            res.addAll(orFinder.find(txt));
            return res;
          };
  }
 
  // 组合器：and。
  default Finder and(Finder andFinder) {
        return
          txt -> this
                .find(txt)
                .stream()
                .flatMap(line -> andFinder.find(line).stream())
                .collect(Collectors.toList());
    }
  ...
}

// 由简单取景器组成的复杂取景器。
public class Finders {
 
  private Finders() {
    }
 
  // Finder 用于查找复杂的查询。
  public static Finder advancedFinder(String query, String orQuery, String notQuery) {
        return
            Finder.contains(query)
                  .or(Finder.contains(orQuery))
                  .not(Finder.contains(notQuery));
  }
 
  // 过滤查找器也会查找包含排除查询的查询。
  public static Finder filteredFinder(String query, String... excludeQueries) {
    var finder = Finder.contains(query);
 
        for (String q : excludeQueries) {
            finder = finder.not(Finder.contains(q));
        }
        return finder;
  }
 
  // 专门查询。 每个下一个查询都会在上一个结果中查找。
  public static Finder specializedFinder(String... queries) {
        var finder = identMult();
 
    for (String query : queries) {
            finder = finder.and(Finder.contains(query));
        }
        return finder;
    }
 
  // 扩展查询。 寻找替代品。
  public static Finder expandedFinder(String... queries) {
        var finder = identSum();
 
        for (String query : queries) {
            finder = finder.or(Finder.contains(query));
        }
      return finder;
    }
  ...
}

var queriesOr = new String[]{"many", "Annabel"};
var finder = Finders.expandedFinder(queriesOr);
var res = finder.find(text());
LOGGER.info("the result of expanded(or) query[{}] is {}", queriesOr, res);
 
var queriesAnd = new String[]{"Annabel", "my"};
finder = Finders.specializedFinder(queriesAnd);
res = finder.find(text());
LOGGER.info("the result of specialized(and) query[{}] is {}", queriesAnd, res);
 
finder = Finders.advancedFinder("it was", "kingdom", "sea");
res = finder.find(text());
LOGGER.info("the result of advanced query is {}", res);
 
res = Finders.filteredFinder(" was ", "many", "child").find(text());
LOGGER.info("the result of filtered query is {}", res);
 
private static String text() {
    return
        "It was many and many a year ago,\n"
            + "In a kingdom by the sea,\n"
            + "That a maiden there lived whom you may know\n"
            + "By the name of ANNABEL LEE;\n"
            + "And this maiden she lived with no other thought\n"
            + "Than to love and be loved by me.\n"
            + "I was a child and she was a child,\n"
            + "In this kingdom by the sea;\n"
            + "But we loved with a love that was more than love-\n"
            + "I and my Annabel Lee;\n"
            + "With a love that the winged seraphs of heaven\n"
            + "Coveted her and me.";
  }

the result of expanded(or) query[[many, Annabel]] is [It was many and many a year ago,, By the name of ANNABEL LEE;, I and my Annabel Lee;]
the result of specialized(and) query[[Annabel, my]] is [I and my Annabel Lee;]
the result of advanced query is [It was many and many a year ago,]
the result of filtered query is [But we loved with a love that was more than love-]