Удаление подписок из ArrayList

Question

Для простоты предположим, что у меня есть ArrayList, индексы которого содержат ровно одно однозначное целое число. Например:

6 4 5 6 0 6 3 4 1 6 1 6 0 6 8 3 

Я хотел бы, чтобы отфильтровать все вхождения подсписке 6 0 6, таким образом, что новый список становится:

6 4 5 3 4 1 6 1 8 3 

Есть ли способ сделать это? Использование ListIterator, похоже, не работает для меня, потому что я должен рассматривать три последовательных элемента вместе, и я честно не знаю, как это сделать.

Вот скелет метода я реализовал:

public static void filterList(ArrayList<Integer> list) { 
    ListIterator<Integer> iterator = list.listIterator(); 
    int elem; 
    while (iterator.hasNext()) { 
     // Remove any sublist of 6 0 6 
    } 
} 

Edit: Опять же, для простоты, давайте предположим, что не будет иметь место случаи, когда мы имеем 60606 или аналогичный.

Answer 1

Вы можете создать решение (нм) эффективное и сжатое O с помощью Collections.indexOfSubList:

public static void removeAllSubList(List<?> list, List<?> subList) { 
    // find first occurrence of the subList in the list, O(nm) 
    int i = Collections.indexOfSubList(list, subList); 
    // if found 
    if (i != -1) { 
     // bulk remove, O(m) 
     list.subList(i, i + subList.size()).clear(); 
     // recurse with the rest of the list 
     removeAllSubList(list.subList(i, list.size()), subList); 
    } 
} 

Ideone Demo

Answer 2

Что я рекомендую - вам нужно поискать ArrayList, прежде чем превращать его в ListIterator.

public static void filterList(ArrayList<Integer> list) { 
    bool firstInstance = false; //Saying we having found our first instance of our sub list 
    for(int i=0;i<list.size();++i) { 
     if(list.get(i) == 6) //Checks to see if our first index is a 6 or it pointless to check the next two numbers i.e. wasting resources 
     if(list.get(i+1) == 0 && list.get(i+2) == 6 && !firstInstance) { //Make sure it a 6 0 6 list 
      list.remove(i); //Removes first one 
      list.remove(i); //Removes second one which now became our current index number 
      list.remove(i); //Removes third one which now became our current index number 
     } else 
      firstInstance = true; //Our first instances has been found and will now remove duplicate ones! 
    } 
    ListIterator<Integer> iterator = list.listIterator(); 
    int elem; 
    while (iterator.hasNext()) { 
     // Remove any sublist of 6 0 6-- Already Done 
    } 
} 

Answer 3

[Отредактировано - лучше, однопроходный подход]

на заказ, расширенный indexOfSublist, начинающийся с offset; поэтому мы не перезапускаем с 0 каждый раз, когда мы удаляем что-то (как это было при использовании Collections.indexOfSublist, см. нижнюю часть этого ответа).

static <T> int indexOfSublist(List<T> haystack, List<T> needle, int offset){ 
    int toRet=-1; 
    int needleLen=needle.size(); 
    if(needleLen>0) { 
    // it makes sense to search 
    int haystackLen=haystack.size(); 
    for(;offset+needleLen<haystackLen && toRet<0; offset++) { 
     int compIx; 
     for(
      compIx=0; 
      (
       compIx<needleLen 
       && false==haystack.get(offset+compIx).equals(needle.get(compIx)) 
     ); 
      compIx++ 
    ); 
     if(compIx==needleLen) { // found 
     toRet=offset; 
     } 
    } 
    } 
    return toRet; 
} 

public static void filterList(List<Integer> haystack, List<Integer> needle) { 
    for(
     int offset=0, ixOfNeedle=indexOfSublist(haystack, needle, offset); 
     ixOfNeedle>=0; 
     ixOfNeedle=indexOfSublist(haystack, needle, offset) 
) { 
    // found one place. We'll continue searching from here next time 
    offset=ixOfNeedle; 
    ////////////////////////////////////////// 
    // for a better removal sequence, see the 
    // 4castle's answer using sublists 
    for(int i=needle.size(); i>0; i--) { 
     haystack.remove(ixOfNeedle); 
    } 
    } 
} 

---

Collections.indexOfSublist является то, что вы после этого.

public static void filterList(ArrayList<Integer> haystack, List<Integer> needle) { 
    for(
     int ixOfNeedle=Collections.indexOfSublist(haystack, needle); 
     ixOfNeedle>=0; 
     ixOfNeedle=Collections.indexOfSublist(haystack, needle) 
    ) { 
     for(int i=needle.size(); i>0; i--) { 
     haystack.remove(ixOfNeedle); 
     } 
    } 
} 

Answer 4

Вы можете использовать комбинацию элементов массива и списка, чтобы найти это решение ниже, надеясь, что это вам поможет.

public void testData() 
    { 
     int tempArray[] = {6, 4, 5, 6, 0, 6, 3, 4, 1, 6, 1, 6, 0, 6, 8, 3}; 
     List<Integer> resultArray = new ArrayList<>(); 

     for(int i = 0; i < tempArray.length; i++) 
     { 
      if(tempArray[i] == 6 && tempArray[i+1] == 0 && tempArray[i + 2] == 6) 
      { 
       i += 2; 
      } 
      else 
      { 
       resultArray.add(tempArray[i]); 
      } 
     } 

     for(int tempInt : resultArray) 
     { 
      System.out.print("\t" + tempInt); 
     } 
    } 

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