Java中的str.contains

我有两张名单

allWords [book, pen, pencil] 
subsetString [book  pen  , book  pencil  , pen  pencil  ]

我希望我的输出为

book  pen => pencil
book  pencil => pen
pen  pencil => book

对于子字符串中的每个元素，我将使用allwords进行检查。 一旦未找到匹配项，则allwords中的字符串将添加到输出的RHS中

但我的问题是 现在我只得到2个输出，而不是3个

allWords [book, pen, pencil]
subsetString [book  pen  , book  pencil  , pen  pencil  ]
pen  pencil   => book
book  pen   => pencil

原因是当进入

book pencil

时，它会被

allWords[book，pen，pencil]

一旦涉及到pen包含

书本铅笔

，它就会感到满意（因为

铅笔

包含子字符串

笔

）

代码

public void getStrongRules2(ArrayList<String> allWords,String delim) {
        ArrayList<ArrayList<String>> subsets = BTSum(allWords);
        ArrayList<String> subsetString = new ArrayList<String>();

        for (int j = 0; j < subsets.size(); j++) {
            String substring = "";
            for (int k = 0; k < subsets.get(j).size(); k++) {

                substring += subsets.get(j).get(k) + "  ";
            }
            subsetString.add(substring);
        }
        System.out.println("allWords "+allWords);
        System.out.println("subsetString "+subsetString);

        for(String a : allWords){
            for (int j = 0; j < subsetString.size(); j++) {
                if (!(subsetString.get(j).contains(a))) {
                    System.out.println(subsetString.get(j)+" => "+a);
                }
            }
        }
    }
    public static ArrayList<ArrayList<String>> BTSum(ArrayList<String> numbers) {

        int n = numbers.size();
        ArrayList<ArrayList<String>> powerSet = new ArrayList<ArrayList<String>>();

        for (long i = 0; i < (1 << n); i++) {
            ArrayList<String> element = new ArrayList<String>();
            for (int j = 0; j < n; j++)
                if ((i >> j) % 2 == 1) {
                    element.add(numbers.get(j));
                }
            if (element.size() > 1 && element.size() < n) {
                powerSet.add(element);
            }
        }
        return powerSet;
    }

}

public void getStrongRules2（ArrayList allWords，String delim）{
ArrayList子集=BTSum（所有字）；
ArrayList subsetString=新的ArrayList（）；
对于（int j=0；j”+a）；
}
}
}
}
公共静态ArrayList BTSum（ArrayList编号）{
int n=numbers.size（）；
ArrayList powerSet=新的ArrayList（）；
对于（长i=0；i<（1>j）%2==1）{
元素.add（number.get（j））；
}
if（element.size（）>1&&element.size（）

但这不应该发生在我身上

如何纠正这一点

---

请建议

只需按长度desc对子字符串进行排序，然后查找它们。 使用自定义压缩机，如：

public class MyComparator implements java.util.Comparator<String> {

    private int referenceLength;

    public MyComparator(String reference) {
        super();
        this.referenceLength = reference.length();
    }

    public int compare(String s1, String s2) {
        int dist1 = Math.abs(s1.length() - referenceLength);
        int dist2 = Math.abs(s2.length() - referenceLength);

        return dist1 - dist2;
    }
}

---

这是因为（subsetString.get（j）.contains（a））->“pen pencil.contains（'pen'）是真的。因此，它不会进入if循环内部打印结果。

问题是

书本铅笔
'pen'cil包含
pen
，因此使用
contains（）
无法获得正确的结果

所以你可以试试下面的方法

 ArrayList<String> allWords = new ArrayList<String>() {{
        add("book");
        add("pen");
        add("pencil");
    }};
 ArrayList<String> subsetString = new ArrayList<String>() {{
        add("book  pen");
        add("book  pencil");
        add("pen  pencil");
    }};

 for (String i : subsetString) {
      List<String> stringList = Arrays.asList(i.split(" "));
        for (String j : allWords) {
            if(!stringList.contains(j)) {
               System.out.println(i + " => " + j);
            }
        }
  }  

ArrayList allWords=new ArrayList（）{{
添加（“账簿”）；
添加（“笔”）；
加上（“铅笔”）；
}};
ArrayList subsetString=新的ArrayList（）{{
添加（“书笔”）；
添加（“书本铅笔”）；
添加（“钢笔”）；
}};
用于（字符串i：子字符串）{
List stringList=Arrays.asList（i.split（“”）；
for（字符串j:allWords）{
如果（！stringList.contains（j））{
系统输出println（i+“=>”+j）；
}
}
}  
您不需要所有这些代码。只需使用以下工具即可完成所有重物搬运：

List<String> allWords = Arrays.asList("book", "pen", "pencil");
List<List<String>> subsetString = Arrays.asList(
    Arrays.asList("book", "pen"), 
    Arrays.asList("book", "pencil"),
    Arrays.asList("pen", "pencil"));

for (List<String> subset : subsetString) {
    ArrayList<String> strings = new ArrayList<String>(allWords);
    strings.removeAll(subset);
    System.out.println(subset + " => " + strings);
}

您可以这样做：

    List<String> allWords = new ArrayList<String>();
    allWords.add("book");
    allWords.add("pen");
    allWords.add("pencil");

    List<String> subsetStrring = new ArrayList<String>();
    subsetStrring.add("book pen");
    subsetStrring.add("book pencil");
    subsetStrring.add("pen pencil");

    for (String string : subsetStrring) {
        List<String> subsetStr = Arrays.asList(string.split(" "));
        for (String word : allWords) {
            if(!subsetStr.contains(word)) {
                System.out.println(string + " => " + word);
                break;
            }
        }
    }

List allWords=new ArrayList（）；
所有词语。添加（“书籍”）；
所有文字。添加（“笔”）；
添加（“铅笔”）；
List subsettrring=new ArrayList（）；
子条款添加（“书笔”）；
子条款添加（“书笔”）；
子条款添加（“钢笔”）；
用于（字符串：子字符串）{
List subsettr=Arrays.asList（string.split（“”））；
for（字符串字：allWords）{
如果（！subsettr.包含（word））{
System.out.println（字符串+“=>”+字）；
打破
}
}
}
考虑

     List<String> allWords = new ArrayList<>();
     allWords.add("Book"); allWords.add("Pen"); allWords.add("Pencil") ; 

您可以不做循环而遵循此操作

     Set<String> results1 = new HashSet<String>(allWords);
     results1.removeAll(list1);
     System.out.println("result1 : "+ list1 +" ===> "+ results1);

     Set<String> results2 = new HashSet<String>(allWords);
     results2.removeAll(list2);
     System.out.println("result2 : "+ list2 +" ===> "+ results2);

     Set<String> results3 = new HashSet<String>(allWords);
     results3.removeAll(list3);
     System.out.println("result3 : "+ list3 +" ===> "+ results3);

希望这有帮助
我认为使用等于匹配字符串可以避免子字符串问题

for(String a : allWords)
{
    for (int j = 0; j < subsets.size(); j++) 
    {
        boolean isMatch = false;
        String subSetString = "";
        for(int k = 0 ; k < subsets.get(j).size() ; k++)
        {
            if(subsets.get(j).get(k).equals(a))
            {
                isMatch = true;
                break;
            }
            subSetString += subsets.get(j).get(k) + " ";
        }
        if(!isMatch) 
        {
            System.out.println(subSetString + " => " + a);
        }
    }
}

for（字符串a:allWords）
{
对于（int j=0；j”+a）；
}
}
}
< /代码>发布一些可运行代码供我们调试。请显示您的代码，以便我们可以帮助您。也许您应该搜索“钢笔”的“钢笔”？考虑提供一个演示您的问题。这将减少混乱和更好的响应。是否使用字符串包含？为什么不简单地使用列表包含？
     List<String> allWords = new ArrayList<>();
     allWords.add("Book"); allWords.add("Pen"); allWords.add("Pencil") ; 

     list1 [Book,Pen] 
     list2 [Book,Pencil]
     list3 [Pen,Pencil]

     Set<String> results1 = new HashSet<String>(allWords);
     results1.removeAll(list1);
     System.out.println("result1 : "+ list1 +" ===> "+ results1);

     Set<String> results2 = new HashSet<String>(allWords);
     results2.removeAll(list2);
     System.out.println("result2 : "+ list2 +" ===> "+ results2);

     Set<String> results3 = new HashSet<String>(allWords);
     results3.removeAll(list3);
     System.out.println("result3 : "+ list3 +" ===> "+ results3);

result1 : [Book, Pen] ===> [Pencil]
result2 : [Book, Pencil] ===> [Pen]
result3 : [Pen, Pencil] ===> [Book]

for(String a : allWords)
{
    for (int j = 0; j < subsets.size(); j++) 
    {
        boolean isMatch = false;
        String subSetString = "";
        for(int k = 0 ; k < subsets.get(j).size() ; k++)
        {
            if(subsets.get(j).get(k).equals(a))
            {
                isMatch = true;
                break;
            }
            subSetString += subsets.get(j).get(k) + " ";
        }
        if(!isMatch) 
        {
            System.out.println(subSetString + " => " + a);
        }
    }
}