Java ListIterator.remove方法代码示例

import java.util.ListIterator; //导入方法依赖的package包/类
public synchronized void put (String pkey, AuthCacheValue value) {
    LinkedList<AuthCacheValue> list = hashtable.get (pkey);
    String skey = value.getPath();
    if (list == null) {
        list = new LinkedList<AuthCacheValue>();
        hashtable.put(pkey, list);
    }
    // Check if the path already exists or a super-set of it exists
    ListIterator<AuthCacheValue> iter = list.listIterator();
    while (iter.hasNext()) {
        AuthenticationInfo inf = (AuthenticationInfo)iter.next();
        if (inf.path == null || inf.path.startsWith (skey)) {
            iter.remove ();
        }
    }
    iter.add(value);
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Returns an iterator for the specified glyphs, sorted either ascending or descending.
 * 
 * @param glyphs The glyphs to return if present
 * @return An iterator of the sorted list of glyphs
 */
private Iterator getIterator(List glyphs) {
	if (orderAscending) return glyphs.iterator();
	final ListIterator iter = glyphs.listIterator(glyphs.size());
	return new Iterator() {
		public boolean hasNext () {
			return iter.hasPrevious();
		}

		public Object next () {
			return iter.previous();
		}

		public void remove () {
			iter.remove();
		}
	};
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public ListIterator<T> update() {
	ListIterator<T> ia = add.listIterator();
	ListIterator<T> ir = add.listIterator();
	
	while (ia.hasNext()) {
		values.add(ia.next());
		ia.remove();
	}
	
	while (ir.hasNext()) {
		values.remove(ir.next());
		ir.remove();
	}
	
	return values.listIterator();
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
synchronized void removeFromExpiryList(HttpConnection c) {
    if (c == null) {
        return;
    }
    ListIterator<ExpiryEntry> li = expiryList.listIterator();
    while (li.hasNext()) {
        ExpiryEntry e = li.next();
        if (e.connection.equals(c)) {
            li.remove();
            return;
        }
    }
    CacheCleaner cleaner = this.cleanerRef.get();
    if (expiryList.isEmpty() && cleaner != null) {
        this.cleanerRef.compareAndSet(cleaner, null);
        cleaner.stopCleaner();
        cleaner.interrupt();
    }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
private void match(ListIterator<Match<T>> lit) {
	Match<T> m = lit.next();
	State<T> state = m.getState();
	m.setMatched(false);
	match(lit, m, state);
	if (skipSearch) {
		if (m.isMatched())
			lit.add(m.spawn(state));
		else if (state == trie.getRoot())
			lit.remove();
	}
	else {
		if (!m.isMatched())
			lit.remove();
	}
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public synchronized void threadSafeRemove(@NonNull final IThreadSafeConditions<T> conditions) {

        if (conditions == null) {
            throw new IllegalArgumentException("conditions cannot be null");
        }

        /*
         * Remove everything except PivotsRV
         *
         * Use iterator to avoid ConcurrentModificationException
         */
        ListIterator<T> iterator = getList().listIterator();
        final Stack<Integer> positions = new Stack<>();
        int position;
        T item;
        while (iterator.hasNext()) {
            position = iterator.nextIndex();
            item = iterator.next();
            if (conditions.removeIf(item)) {
                iterator.remove();
                positions.push(position);
            }
        }
        conditions.onItemsRemoved(positions);
    }
 

import java.util.ListIterator; //导入方法依赖的package包/类
private Packet findSendablePacket(LinkedList<Packet> outgoingQueue,
                                  boolean clientTunneledAuthenticationInProgress) {
    synchronized (outgoingQueue) {
        if (outgoingQueue.isEmpty()) {
            return null;
        }
        if (outgoingQueue.getFirst().bb != null // If we've already starting sending the first packet, we better finish
            || !clientTunneledAuthenticationInProgress) {
            return outgoingQueue.getFirst();
        }

        // Since client's authentication with server is in progress,
        // send only the null-header packet queued by primeConnection().
        // This packet must be sent so that the SASL authentication process
        // can proceed, but all other packets should wait until
        // SASL authentication completes.
        ListIterator<Packet> iter = outgoingQueue.listIterator();
        while (iter.hasNext()) {
            Packet p = iter.next();
            if (p.requestHeader == null) {
                // We've found the priming-packet. Move it to the beginning of the queue.
                iter.remove();
                outgoingQueue.add(0, p);
                return p;
            } else {
                // Non-priming packet: defer it until later, leaving it in the queue
                // until authentication completes.
                if (LOG.isDebugEnabled()) {
                    LOG.debug("deferring non-priming packet: " + p +
                            "until SASL authentication completes.");
                }
            }
        }
        // no sendable packet found.
        return null;
    }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public PeakList removeMultiplePeaks() {
    // TODO (LS) :
    ListIterator<Peak> peakListIterator = this.pList.listIterator();

    while (peakListIterator.hasNext()) {
        int index = peakListIterator.nextIndex();
        Peak currentPeak = peakListIterator.next();
        for (int j = 0; j < index; ++j) {
            if (currentPeak.equalsPeak(this.pList.get(j))) {
                peakListIterator.remove();
                break; // TODO why break ?
            }
        }
    }

    return this;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Returns a recycled connection to {@code address}, or null if no such connection exists.
 */
synchronized Connection get(Endpoint endpoint) {

    /*
    * Iterate the connections in reverse order
    * and take the first connection having the same endpoint.
    * */
    ListIterator<Connection> iterator = connections.listIterator(connections.size());
    while (iterator.hasPrevious()) {
        Connection connection = iterator.previous();
        if (connection.endpoint().equals(endpoint)) {
            iterator.remove();
            return connection;
        }
    }

    return null;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Try to remove extraneous items from the set of sampled items. This checks
 * if an item is unnecessary based on the desired error bounds, and merges it
 * with the adjacent item if it is.
 */
private void compress() {
  if (samples.size() < 2) {
    return;
  }

  ListIterator<SampleItem> it = samples.listIterator();
  SampleItem prev = null;
  SampleItem next = it.next();

  while (it.hasNext()) {
    prev = next;
    next = it.next();
    if (prev.g + next.g + next.delta <= allowableError(it.previousIndex())) {
      next.g += prev.g;
      // Remove prev. it.remove() kills the last thing returned.
      it.previous();
      it.previous();
      it.remove();
      // it.next() is now equal to next, skip it back forward again
      it.next();
    }
  }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * App started in VA may be removed in OverView screen, then AMS.removeTask
 * will be invoked, all data struct about the task in AMS are released,
 * while the client's process is still alive. So remove related data in VA
 * as well. A new TaskRecord will be recreated in `onActivityCreated`
 */
private void optimizeTasksLocked() {
    // noinspection deprecation
    ArrayList<ActivityManager.RecentTaskInfo> recentTask = new ArrayList<>(mAM.getRecentTasks(Integer.MAX_VALUE,
            ActivityManager.RECENT_WITH_EXCLUDED | ActivityManager.RECENT_IGNORE_UNAVAILABLE));
    int N = mHistory.size();
    while (N-- > 0) {
        TaskRecord task = mHistory.valueAt(N);
        ListIterator<ActivityManager.RecentTaskInfo> iterator = recentTask.listIterator();
        boolean taskAlive = false;
        while (iterator.hasNext()) {
            ActivityManager.RecentTaskInfo info = iterator.next();
            if (info.id == task.taskId) {
                taskAlive = true;
                iterator.remove();
                break;
            }
        }
        if (!taskAlive) {
            mHistory.removeAt(N);
        }
    }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
/**
 * Releases for normal dispatching to the current focus owner all
 * KeyEvents which were enqueued because of a call to
 * {@code enqueueKeyEvents} with the same timestamp and Component.
 * If the given timestamp is less than zero, the outstanding enqueue
 * request for the given Component with the <b>oldest</b> timestamp (if
 * any) should be cancelled.
 *
 * @param after the timestamp specified in the call to
 *        {@code enqueueKeyEvents}, or any value &lt; 0
 * @param untilFocused the Component specified in the call to
 *        {@code enqueueKeyEvents}
 * @see #enqueueKeyEvents
 * @see #discardKeyEvents
 */
protected synchronized void dequeueKeyEvents(long after,
                                             Component untilFocused) {
    if (untilFocused == null) {
        return;
    }

    if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
        focusLog.finer("Dequeue at {0} for {1}",
                   after, untilFocused);
    }

    TypeAheadMarker marker;
    ListIterator<TypeAheadMarker> iter = typeAheadMarkers.listIterator
        ((after >= 0) ? typeAheadMarkers.size() : 0);

    if (after < 0) {
        while (iter.hasNext()) {
            marker = iter.next();
            if (marker.untilFocused == untilFocused)
            {
                iter.remove();
                return;
            }
        }
    } else {
        while (iter.hasPrevious()) {
            marker = iter.previous();
            if (marker.untilFocused == untilFocused &&
                marker.after == after)
            {
                iter.remove();
                return;
            }
        }
    }
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
public boolean resetOffset(long offset) {
    MappedFile mappedFileLast = getLastMappedFile();

    if (mappedFileLast != null) {
        long lastOffset = mappedFileLast.getFileFromOffset() +
            mappedFileLast.getWrotePosition();
        long diff = lastOffset - offset;

        final int maxDiff = this.mappedFileSize * 2;
        if (diff > maxDiff)
            return false;
    }

    ListIterator<MappedFile> iterator = this.mappedFiles.listIterator();

    while (iterator.hasPrevious()) {
        mappedFileLast = iterator.previous();
        if (offset >= mappedFileLast.getFileFromOffset()) {
            int where = (int) (offset % mappedFileLast.getFileSize());
            mappedFileLast.setFlushedPosition(where);
            mappedFileLast.setWrotePosition(where);
            mappedFileLast.setCommittedPosition(where);
            break;
        } else {
            iterator.remove();
        }
    }
    return true;
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
@Test
public void listIterator_remove_nonRealmList_throwUnsupported() {
    if (skipTest(CollectionClass.MANAGED_REALMLIST, CollectionClass.UNMANAGED_REALMLIST)) {
       return;
    }
    ListIterator<AllJavaTypes> it = collection.listIterator();
    AllJavaTypes obj = it.next();
    assertEquals("test data 0", obj.getFieldString());
    realm.beginTransaction();
    thrown.expect(UnsupportedOperationException.class);
    it.remove();
}
 

import java.util.ListIterator; //导入方法依赖的package包/类
@Test
public void removeBeforeNext() {
  IRCode code = simpleCode();

  ListIterator<BasicBlock> blocks = code.listIterator();
  ListIterator<Instruction> instructions = blocks.next().listIterator();
  thrown.expect(IllegalStateException.class);
  instructions.remove();
}