Finde Untersammlung nicht angrenzend, aber in der gleichen Reihenfolge in Java

Question

Wie kann ich in Java (8) finden, wenn eine Sammlung (Liste oder Menge) Teilmenge einer anderen Sammlung ist, obwohl die Elemente nicht benachbart sind zum Beispiel [1,2, 3,4,5] wie die große Sammlung, und wenn ich nach [2,3,4] suchen will, so ist auch [2,5] wahr, ABER [4,2] aber falsch, obwohl 4 und 2 in der Sammlung, aber sind nicht in der gleichen Reihenfolge

Gibt es ein Dienstprogramm mir helfen, dies zu tun? Oder ein Code, der das richtig macht?

Dank

Answer 1

Diese Funktion gibt true zurück, wenn a enthält b.

Diese Funktion konvertiert die Sammlung in Array, wenn Ihre Sammelklasse .toArray() Funktion nicht implementiert, wird es nicht funktionieren!

public class CollectionUtils { 
    private CollectionUtils() { 
    } 

    /** 
    * @return true if A contains B in order 
    */ 
    public static <T> boolean checkAcontainsB(Collection<T> a, Collection<T> b) { 
     if (a == null || b == null || b.size()>a.size()) { 
      return false; 
     } 
     if (b.isEmpty()) { 
      return true; 
     } 
     final Object[] aElements = a.toArray(); 
     final Object[] bElements = b.toArray(); 

     for (int i = 0; i < aElements.length; i++) { 

      int bIndex = 0; 
      for(int j = i; j< aElements.length; j++) { 
       if(aElements[j] == bElements[bIndex]) { 
        bIndex++; 
        if(bIndex>=bElements.length) { 
         return true; 
        } 
       } 
      } 
     } 
     return false; 
    } 

} 

Sie können es testen:

@Test 
public void test() { 
    Assert.assertFalse(CollectionUtils.contains(Arrays.asList(1,2,3,4), Arrays.asList(2,3,4,5))); 
    Assert.assertTrue(CollectionUtils.contains(Arrays.asList(1,2,3,4), Arrays.asList(2,3,4))); 
    Assert.assertTrue(CollectionUtils.contains(Arrays.asList(1,2,3,4), Arrays.asList(2,4))); 
    Assert.assertTrue(CollectionUtils.contains(Arrays.asList(1,2,3,4,1,2,3,4), Arrays.asList(3,4,2))); 
    Assert.assertFalse(CollectionUtils.contains(Arrays.asList(1,2,3,4), Arrays.asList(2,3,4,5,6))); 
} 

Answer 2

nicht vollständig getestet, aber man kann so etwas wie dies versucht,

int[] x = {1,2,3,4,5}; 
    int[] y = {2,5}; 
    int yIndex = 0; 

    for(int i: x){ 
     if(y[yIndex] == i){ 
      yIndex++; 
      if(yIndex >= y.length){ 
       break; 
      } 
     } 
    } 

    System.out.println(yIndex == y.length ? "Match" : "Not Match"); 

Answer 3

Sie leicht von Sammlungen zur Verfügung gestellt eine Dienstprogramm Methode verwenden können, was Sie nicht genau zu tun beabsichtigen.

Collections.disjoint(c1, c2) 

Die obige Methode gibt "true" zurück, wenn die beiden übergebenen Sammlungen keine Elemente gemeinsam haben und umgekehrt. Genau das, was du willst.

Answer 4

Ich weiß nicht jeder generische Lösung für Ihr Problem, aber unter Ihnen eine maßgeschneiderte Lösung für Ihr Problem finden konnten.

public static boolean containsArray(int[] a, int[] s) { 
    if (a == null || s == null) return false; 
    if (a.length < s.length) return false; 

    int i = -1; 
    for (int current : s) { 
     do { 
      i++; 
      if (i == a.length) { 
       return false; 
      } 
     } while (a[i] != current); 
    } 

    return true; 
}