How to use

listIterator

method

in

java.util.List

 @Override
 public Iterator<T> iterator() {
  final ListIterator<T> listIter = list.listIterator(list.size());
  return new Iterator<T>() {
   @Override
   public boolean hasNext() {
    return listIter.hasPrevious();
   }
   @Override
   public T next() {
    return listIter.previous();
   }
   @Override
   public void remove() {
    listIter.remove();
   }
  };
 }
};

/**
 * Delete removed documents from the internal container.
 */
void refresh()
{
  ListIterator<Document<K>> listIterator = documents_.listIterator();
  while (listIterator.hasNext())
  {
    if (listIterator.next() == null)
      listIterator.remove();
  }
}

public static <E> void fill(List<E> list, E value)
{
  if (list == null) return;
  ListIterator<E> listIterator = list.listIterator();
  while (listIterator.hasNext()) listIterator.set(value);
}

private static DefaultWebFilterChain initChain(List<WebFilter> filters, WebHandler handler) {
  DefaultWebFilterChain chain = new DefaultWebFilterChain(filters, handler, null, null);
  ListIterator<? extends WebFilter> iterator = filters.listIterator(filters.size());
  while (iterator.hasPrevious()) {
    chain = new DefaultWebFilterChain(filters, handler, iterator.previous(), chain);
  }
  return chain;
}

List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size());
for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
  RLock lock = iterator.next();
  boolean lockAcquired;
  try {
    acquiredLocks.add(lock);
  } else {
    if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
      break;
      acquiredLocks.clear();
      while (iterator.hasPrevious()) {
        iterator.previous();
  for (RLock rLock : acquiredLocks) {
    RFuture<Boolean> future = rLock.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);
    futures.add(future);

assertEquals(0, list.size());
assertFalse(list.contains(1));
assertFalse(list.remove((Integer)1));
assertTrue(list.add(1));
assertTrue(list.addAll(Arrays.asList(3, 4, 7)));
list.add(1, 2);
assertTrue(list.addAll(4, Arrays.asList(5, 6)));
assertEquals(7, list.size());
assertEquals(7, list.size());
ListIterator<Integer> lit = list.listIterator(7);
for (int i = 7; i > 0; i--) {
  assertEquals(i, lit.previous().intValue());
assertFalse(list.equals(list3));
list3.add(7);
assertTrue(list3.equals(list));
assertTrue(list.equals(list3));

public void add(Object o) {
  checkMod();
  int i = nextIndex();
  get().add(i, o);
  expected = list;
  iter = get().listIterator(i + 1);
  lastReturnedIndex = -1;
}

ContentGroup(final LottieDrawable lottieDrawable, BaseLayer layer,
       String name, boolean hidden, List<Content> contents, @Nullable AnimatableTransform transform) {
 this.name = name;
 this.lottieDrawable = lottieDrawable;
 this.hidden = hidden;
 this.contents = contents;
 if (transform != null) {
  transformAnimation = transform.createAnimation();
  transformAnimation.addAnimationsToLayer(layer);
  transformAnimation.addListener(this);
 }
 List<GreedyContent> greedyContents = new ArrayList<>();
 for (int i = contents.size() - 1; i >= 0; i--) {
  Content content = contents.get(i);
  if (content instanceof GreedyContent) {
   greedyContents.add((GreedyContent) content);
  }
 }
 for (int i = greedyContents.size() - 1; i >= 0; i--) {
  greedyContents.get(i).absorbContent(contents.listIterator(contents.size()));
 }
}

@Test
public void testNoArguments() throws IOException {
  Tokenizer tokenizer = new Tokenizer(new Context("function myFunc(){}"));
  SyntaxAnalyzer analyzer = new SyntaxAnalyzer(environment, tokenizer);
  Assert.assertTrue(analyzer.getTree().size() == 1);
  Assert.assertTrue(analyzer.getTree().get(0) instanceof FunctionStmtToken);
  FunctionStmtToken func = (FunctionStmtToken)analyzer.getTree().listIterator().next();
  Assert.assertTrue(func.getArguments().size() == 0);
}

  public void testBugCollections447() {
    final List treeList = new TreeList();
    treeList.add("A");
    treeList.add("B");
    treeList.add("C");
    treeList.add("D");
    final ListIterator li = treeList.listIterator();
    assertEquals("A", li.next());
    assertEquals("B", li.next());
    assertEquals("B", li.previous());
    li.remove(); // Deletes "B"
    // previous() after remove() should move to
    // the element before the one just removed
    assertEquals("A", li.previous());
  }    
}

private void replaceValue(List<Entry<K, V>> expected, Entry<K, V> newEntry) {
 for (ListIterator<Entry<K, V>> i = expected.listIterator(); i.hasNext(); ) {
  if (Helpers.equal(i.next().getKey(), newEntry.getKey())) {
   i.set(newEntry);
   return;
  }
 }
 throw new IllegalArgumentException(
   Platform.format("key %s not found in entries %s", newEntry.getKey(), expected));
}

void appendWhereClause(StringBuilder builder, String tablePrefixOrNull, List<Object> values) {
  ListIterator<WhereCondition> iter = whereConditions.listIterator();
  while (iter.hasNext()) {
    if (iter.hasPrevious()) {
      builder.append(" AND ");
    }
    WhereCondition condition = iter.next();
    condition.appendTo(builder, tablePrefixOrNull);
    condition.appendValuesTo(values);
  }
}

/** An implementation of {@link List#indexOf(Object)}. */
static int indexOfImpl(List<?> list, @Nullable Object element) {
 if (list instanceof RandomAccess) {
  return indexOfRandomAccess(list, element);
 } else {
  ListIterator<?> listIterator = list.listIterator();
  while (listIterator.hasNext()) {
   if (Objects.equal(element, listIterator.next())) {
    return listIterator.previousIndex();
   }
  }
  return -1;
 }
}

private static void assertTransformListIterator(List<String> list) {
 ListIterator<String> iterator = list.listIterator(1);
 assertEquals(1, iterator.nextIndex());
 assertEquals("2", iterator.next());
 assertEquals("3", iterator.next());
 assertEquals("4", iterator.next());
 assertEquals(4, iterator.nextIndex());
 try {
 assertEquals("4", iterator.previous());
 assertEquals("3", iterator.previous());
 assertEquals("2", iterator.previous());
 assertTrue(iterator.hasPrevious());
 assertEquals("1", iterator.previous());
 assertFalse(iterator.hasPrevious());
 assertEquals(-1, iterator.previousIndex());
 try {
 } catch (NoSuchElementException expected) {
 iterator.remove();
 assertEquals(asList("2", "3", "4"), list);
 assertFalse(list.isEmpty());

/**
 * Remove a document from this cluster.
 *
 * @param index the index of vector container of documents
 */
void remove_document(int index)
{
  ListIterator<Document<K>> listIterator = documents_.listIterator(index);
  Document<K> document = listIterator.next();
  listIterator.set(null);
  composite_.sub_vector(document.feature());
}

@Override
public int indexOf(Object o) {
 if (!(o instanceof List)) {
  return -1;
 }
 List<?> list = (List<?>) o;
 if (list.size() != axes.size()) {
  return -1;
 }
 ListIterator<?> itr = list.listIterator();
 int computedIndex = 0;
 while (itr.hasNext()) {
  int axisIndex = itr.nextIndex();
  int elemIndex = axes.get(axisIndex).indexOf(itr.next());
  if (elemIndex == -1) {
   return -1;
  }
  computedIndex += elemIndex * axesSizeProduct[axisIndex + 1];
 }
 return computedIndex;
}

/** An implementation of {@link List#lastIndexOf(Object)}. */
static int lastIndexOfImpl(List<?> list, @Nullable Object element) {
 if (list instanceof RandomAccess) {
  return lastIndexOfRandomAccess(list, element);
 } else {
  ListIterator<?> listIterator = list.listIterator(list.size());
  while (listIterator.hasPrevious()) {
   if (Objects.equal(element, listIterator.previous())) {
    return listIterator.nextIndex();
   }
  }
  return -1;
 }
}

List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size());
for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
  RLock lock = iterator.next();
  boolean lockAcquired;
  try {
    acquiredLocks.add(lock);
  } else {
    if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
      break;
      acquiredLocks.clear();
      while (iterator.hasPrevious()) {
        iterator.previous();
  for (RLock rLock : acquiredLocks) {
    RFuture<Boolean> future = rLock.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);
    futures.add(future);

public void add(Object o) {
  checkMod();
  int i = nextIndex();
  get().add(i, o);
  last++;
  expected = list;
  iter = get().listIterator(i + 1);
  lastReturnedIndex = -1;
}

  public Iterator<T> iterator() {
    final ListIterator<T> itr = lst.listIterator(lst.size());
    return new Iterator<T>() {
      public boolean hasNext() {
        return itr.hasPrevious();
      }
      public T next() {
        return itr.previous();
      }
      public void remove() {
        itr.remove();
      }
    };
  }
};