How to use

lastIndexOf

method

in

java.util.ArrayList

@Override
public int lastIndexOf(Object o) {
  return list.lastIndexOf(o);
}

@Override
public int lastIndexOf(Object o) {
  return list.lastIndexOf(o);
}

/**
 * Search for the last occurrence of the given argument, testing
 * for equality using the <code>equals()</code> method, and return
 * the corresponding index, or -1 if the object is not found.
 *
 * @param element The element to search for
 */
public int lastIndexOf(Object element) {
  if (fast) {
    return (list.lastIndexOf(element));
  } else {
    synchronized (list) {
      return (list.lastIndexOf(element));
    }
  }
}

public int lastIndexOf(Object o) {
  return list.lastIndexOf(o);
}

public int lastIndexOf(Object o) {
  return list.lastIndexOf(o);
}

/**
 * Search for the last occurrence of the given argument, testing
 * for equality using the <code>equals()</code> method, and return
 * the corresponding index, or -1 if the object is not found.
 *
 * @param element The element to search for
 */
public int lastIndexOf(Object element) {
  if (fast) {
    return (list.lastIndexOf(element));
  } else {
    synchronized (list) {
      return (list.lastIndexOf(element));
    }
  }
}

public void test3NoBugs(ArrayList<? extends CharSequence> list) {
  list.lastIndexOf(new StringBuffer("Key"));
}

public void test3Bugs(ArrayList<? extends CharSequence> list) {
  list.lastIndexOf(Integer.valueOf(3));
}

void insertOnStackAfter(Element after, Element in) {
  int i = stack.lastIndexOf(after);
  Validate.isTrue(i != -1);
  stack.add(i+1, in);
}

private void replaceInQueue(ArrayList<Element> queue, Element out, Element in) {
  int i = queue.lastIndexOf(out);
  Validate.isTrue(i != -1);
  queue.set(i, in);
}

public int lastIndexOf(String text) {
  return super.lastIndexOf(new KeyboardButton(text));
}

/**
 * Calculates the coaccessible states of an fst
 */
private static void calcCoAccessible(Fst fst, State state,
    ArrayList<ArrayList<State>> paths, HashSet<State> coaccessible) {
  // hold the coaccessible added in this loop
  ArrayList<State> newCoAccessibles = new ArrayList<State>();
  for (ArrayList<State> path : paths) {
    int index = path.lastIndexOf(state);
    if (index != -1) {
      if (state.getFinalWeight() != fst.getSemiring().zero()
          || coaccessible.contains(state)) {
        for (int j = index; j > -1; j--) {
          if (!coaccessible.contains(path.get(j))) {
            newCoAccessibles.add(path.get(j));
            coaccessible.add(path.get(j));
          }
        }
      }
    }
  }
  // run again for the new coaccessibles
  for (State s : newCoAccessibles) {
    calcCoAccessible(fst, s, paths, coaccessible);
  }
}

/**
 * Returns the index of the last occurrence of the specified element in this list, or -1 if
 * none.
 */
@Override
public int lastIndexOf(Object o) {
  synchronized (getLock()) {
    return super.lastIndexOf(o);
  }
}

/**
 *
 * @param compound
 * @return
 */
@Override
public int getLastIndexOf(C compound) {
  return this.parsedCompounds.lastIndexOf(compound) + 1;
}

/**
 * Remove a style change listener.
 * 
 * @param listener
 *            The listener to remove.
 */
public void removeListener(StyleGroupListener listener) {
  int index = listeners.lastIndexOf(listener);
  if (index >= 0) {
    listeners.remove(index);
  }
}

/**
 * Remove an event from the set.
 * 
 * @param event
 *            The event to remove.
 */
public void popEvent(String event) {
  int index = eventSet.lastIndexOf(event);
  if (index >= 0)
    eventSet.remove(index);
  events = eventSet.toArray(events);
}

void remove(Context context) {
  if (context == top_) {
    pop();
    return;
  }
  stack_.remove(stack_.lastIndexOf(context)); 
}
Context top() { 

void insertOnStackAfter(Element after, Element in) {
  int i = stack.lastIndexOf(after);
  Validate.isTrue(i != -1);
  stack.add(i+1, in);
}

private void replaceInQueue(ArrayList<Element> queue, Element out, Element in) {
  int i = queue.lastIndexOf(out);
  Validate.isTrue(i != -1);
  queue.set(i, in);
}

public int lastIndexOf(Object o) {
  if (fullyLoaded) {
    return objectList.lastIndexOf(o);
  }
  return super.lastIndexOf(o);
}