Проверка списка строк, полностью содержащихся в другом списке строк

Question

Я написал этот фрагмент кода, чтобы проверить, что список строк полностью содержится в другом, и в этом случае удалить список.

public static void main(String[] args) { 
    LinkedList<String> l1 = new LinkedList<String>(); 
    LinkedList<String> l2 = new LinkedList<String>(); 
    l1.add("Cc"); 
    l1.add("Dd"); 
    l2.add("Cc"); 
    l2.add("Dd"); 
    l2.add("Ee"); 
    LinkedList<LinkedList<String>> l = new LinkedList<LinkedList<String>>(); 
    l.add(l1); 
    l.add(l2); 
    System.out.println("OUTPUT: " + filterSublist(l)); 

} 

static List<LinkedList<String>> filterSublist(LinkedList<LinkedList<String>> l) { 
    List<LinkedList<String>> uniq = new LinkedList<LinkedList<String>>(l); 
    l.forEach(elem -> uniq.removeIf(x -> !x.equals(elem) && elem.contains(x))); 
    return uniq; 
} 

Функция filterSubList должна возвращать список список строк, который не имеет списков, которые полностью содержатся в других списках. В примере мы имеем:

• Список 1: "Cc, Dd"
• Список 2: "Cc, Dd, Ee"

Поскольку список 1 целиком содержится в списке 2, функция должна возвращать список списков, который содержит только список 2. Но когда я запускаю программу, которую я получил вывод, который представляет собой список, который содержит как:

OUTPUT: [[Cc, Dd], [Cc, Dd, Ee]] 

Это неправильно. Есть ли ошибка в функции filterSubList?

Answer 1

Вы проверяете один список (объект), содержащий другой список (объект). Новый список будет отведенное по-разному в памяти всякий раз, когда создается новый объект, вместо проверки на объекты внутри с containsAll:

Попробуйте вместо этого:

static List<LinkedList<String>> filterSublist(LinkedList<LinkedList<String>> l) { 
List<LinkedList<String>> uniq = new LinkedList<LinkedList<String>>(l); 
l.forEach(elem -> uniq.removeIf(x -> !x.equals(elem) && elem.containsAll(x))); 
return uniq; 
} 

В случае Рене поднял некоторые вопросы, имеющие отношение к OP , вот реализация, которая в значительной степени следует за его руководством, по-другому.

static List<LinkedList<String>> filterSublistAlternate(LinkedList<LinkedList<String>> l) { 
boolean[] removed = new boolean[ l.size() ]; 
outer: for(int i=0; i< l.size() ; i++) 
    inner: for(int j=0; j< l.size() ; j++) 
    { 
     if(i != j) 
     if(l.get(j).containsAll(l.get(i))) 
     { 
      System.out.println(i+" and "+j); 
      if(l.get(i).size() == l.get(j).size()) 
       if(removed[i] == removed[j] && !removed[i]) 
        removed[i] = true; 
       else 
        continue outer; 
      else 
      { 
       removed[i] = true; 
       continue outer; 
      } 

     } 
    } 

for(int i=removed.length-1; i>=0 ; i--) 
    if(removed[i]) 
     l.remove(i); 

return l; 
} 

Answer 2

Я предлагаю решение ниже, как это:

• больше памяти эффективной, поскольку она не дублировать первоначальный список
• более правильно, поскольку она действительно проверяет подсписков (а не только один элемент существование)
• более правильный, поскольку это удаляет дубликаты из результата

Код:

static List<LinkedList<String>> filterSublist(LinkedList<LinkedList<String>> l) { 
    return l.stream() 
     .filter(x -> l.stream().noneMatch(elem -> !elem.equals(x) && Collections.indexOfSubList(elem, x) != -1)) 
     .distinct() 
     .collect(Collectors.toList()); 
}