如何检查列表是否包含Java中给定顺序的子列表

Question

I read in groovy how to check if a list contains a sublist - stackoverflow .

I am interested if there is a way of checking whether list contains sublist, but in a given order. For example, this code will give true ,

    List<String> list = Arrays.asList("PRP", "VBP", "VBN", "NN", "NNS", "MD", "VB");
    List<String> sublist = Arrays.asList("MD", "VB", "VBN");
    System.out.println(list.containsAll(sublist));

But I want to get false back.

Answer 1

You can use method Collections.indexOfSubList .

Returns the starting position of the first occurrence of the specified target list within the specified source list, or -1 if there is no such occurrence. More formally, returns the lowest index i such that source.subList(i, i+target.size()).equals(target) , or -1 if there is no such index. (Returns -1 if target.size() > source.size() .)

int index=Collections.indexOfSubList(list , sublist);

SHORT:
If Collections.indexOfSubList(list , sublist) =! -1 Collections.indexOfSubList(list , sublist) =! -1 you will have a match

Answer 2

Cheap but ugly solution:

String listStr = list.toString().replace("[", "").replace("]", "");
String sublistStr = sublist.toString().replace("[", "").replace("]", "");

System.out.println(listStr.contains(sublistStr));

Answer 3

Not entirely clear from your question: If the sublist can be contained in the list in order, but with other elements in between, you can use something like this:

public static <T> boolean containsInOrder(List<T> list, List<T> sublist) {
    Iterator<T> listIter = list.iterator();
    for (T item : sublist) {
        if (! listIter.hasNext()) {
            // still elements in sublist, but none in list
            return false;
        }
        while (listIter.hasNext() && ! listIter.next().equals(item)) {
            // do nothing, just consume the list until item is found
        }
    }
    // entire sublist found in list
    return true;
}

With list = ["PRP", "VBP", "VBN", "NN", "NNS", "MD", "VB"] , this returns false for sublist = ["MD", "VB", "VBN"] , and true for sublist = ["PRP", "VBN", "VB"] .

Answer 4

I found it necessary to comment that @JordiCastilla solution is not correct in the sense that it is complete. It can be correct if item type has correct equals, because in case of Collections.indexOfSubList you invoke list element type equals .

/**
 * Compares the specified object with this list for equality.  Returns
 * <tt>true</tt> if and only if the specified object is also a list, both
 * lists have the same size, and all corresponding pairs of elements in
 * the two lists are <i>equal</i>.  (Two elements <tt>e1</tt> and
 * <tt>e2</tt> are <i>equal</i> if <tt>(e1==null ? e2==null :
 * e1.equals(e2))</tt>.)  In other words, two lists are defined to be
 * equal if they contain the same elements in the same order.  This
 * definition ensures that the equals method works properly across
 * different implementations of the <tt>List</tt> interface.
 *
 * @param o the object to be compared for equality with this list
 * @return <tt>true</tt> if the specified object is equal to this list
 */
boolean equals(Object o);

This however is trivially culture dependent and in case of type String is incorrect. Consider for example the case:

String a = "ss";
String b = "ß";                  //german "ss" character
Assert.IsTrue(a.equals(b));      //in java, this will return false even in DE locale

I think reasoning behind it is that character count does not match - in any case it is not correct. You would think that "at least they got the basics down right" - and you would be wrong :

"You should be aware that internationalization and localization issues of full Unicode strings are not addressed with [String] methods. For example, when you're comparing two strings to determine which is 'greater', characters in strings are compared numerically by their Unicode values, not by their localized notion of order."

In Unicode however same string can have multiple representations and they would not equate. Type String is an example but you could have any custom data type.

Long story short : make sure your item type equals has the correct implementation.

---

Another example how this can trivially be wrong is following:

List arrlistsrc = new ArrayList();
List arrlisttarget = new ArrayList();

arrlistsrc.add("A");
arrlistsrc.add("B");
arrlistsrc.add("C");

arrlisttarget.add("A");
arrlisttarget.add("C");

int index = Collections.indexOfSubList(arrlistsrc, arrlisttarget); // this will be -1

First list contains second one and they have the same order, but in between elements target elements source contains other elements.

To find that you can use something in the lines :

boolean ContainsOrderedSublist<T>(IList<T> arrlistsrc, IList<T> arrlisttarget){
    int slider = 0;
    for (String val: arrlisttarget ) {
        slider = arrlistsrc.indexOf(val, slider);// or use culture independent version
        if(slider < 0) break;
    }
    return slider < 0;    
}

(NB : code examples not tested and written from head)