下面列出了java.util.ListIterator#set ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Tests the {@link ListIterator#set(Object)} method of the list iterator.
*/
public void testListIteratorSet() {
if (!isSetSupported())
return;
Object[] elements = getFullElements();
resetFull();
ListIterator iter1 = getList().listIterator();
ListIterator iter2 = getConfirmedList().listIterator();
for (int i = 0; i < elements.length; i++) {
iter1.next();
iter2.next();
iter1.set(elements[i]);
iter2.set(elements[i]);
verify();
}
}
/**
* A list shuffle using an iterator.
*
* @param rng Random number generator.
* @param list List.
*/
@SuppressWarnings({"rawtypes", "unchecked"})
private static void shuffleIterator(UniformRandomProvider rng, List<?> list) {
final Object[] array = list.toArray();
// Shuffle array
for (int i = array.length; i > 1; i--) {
swap(array, i - 1, rng.nextInt(i));
}
// Copy back. Use raw types.
final ListIterator it = list.listIterator();
for (final Object value : array) {
it.next();
it.set(value);
}
}
private static List<PluginConfig> buildPluginConfigs(PluginConfig updatedConfig,
String priorVersion, AgentConfig agentConfig) throws OptimisticLockException {
List<PluginConfig> pluginConfigs =
Lists.newArrayList(agentConfig.getPluginConfigList());
ListIterator<PluginConfig> i = pluginConfigs.listIterator();
boolean found = false;
while (i.hasNext()) {
PluginConfig pluginConfig = i.next();
if (pluginConfig.getId().equals(updatedConfig.getId())) {
String existingVersion = Versions.getVersion(pluginConfig);
if (!priorVersion.equals(existingVersion)) {
throw new OptimisticLockException();
}
i.set(buildPluginConfig(pluginConfig, updatedConfig.getPropertyList(), true));
found = true;
break;
}
}
if (found) {
return pluginConfigs;
} else {
throw new IllegalStateException("Plugin config not found: " + updatedConfig.getId());
}
}
public Value put(String key, Value newValue) {
final ListIterator<Item> items = listIterator();
while (items.hasNext()) {
final Item item = items.next();
if (item instanceof Field && item.keyEquals(key)) {
final Field field = (Field) item;
if (field.isMutable()) {
return field.setValue(newValue);
} else {
final Value oldValue = field.toValue();
items.set(field.updatedValue(newValue));
return oldValue;
}
}
}
add(new Slot(Text.from(key), newValue));
return Value.absent();
}
public Value putAttr(Text key, Value newValue) {
final ListIterator<Item> items = listIterator();
while (items.hasNext()) {
final Item item = items.next();
if (item instanceof Field && item.keyEquals(key)) {
if (item instanceof Attr && item.isMutable()) {
return ((Attr) item).setValue(newValue);
} else {
final Value oldValue = item.toValue();
items.set(new Attr(key, newValue));
return oldValue;
}
}
}
add(new Attr(key, newValue));
return Value.absent();
}
@Override
public Record updatedSlot(Value key, Value value) {
final Record record = isMutable() ? this : branch();
final ListIterator<Item> items = record.listIterator();
while (items.hasNext()) {
final Item item = items.next();
if (item.keyEquals(key)) {
if (item instanceof Slot && item.isMutable()) {
((Slot) item).setValue(value);
} else {
items.set(new Slot(key, value));
}
return record;
}
}
record.add(new Slot(key, value));
return record;
}
protected <T extends QueryModelNode> boolean replaceNodeInList(List<T> list, QueryModelNode current,
QueryModelNode replacement) {
ListIterator<T> iter = list.listIterator();
while (iter.hasNext()) {
if (iter.next() == current) {
iter.set((T) replacement);
replacement.setParentNode(this);
return true;
}
}
return false;
}
@Override
public List<ScriptEngineFactory> getEngineFactories() {
List<ScriptEngineFactory> all = new ArrayList<>();
all.addAll(super.getEngineFactories());
all.addAll(extra);
ListIterator<ScriptEngineFactory> it = all.listIterator();
while (it.hasNext()) {
ScriptEngineFactory f = it.next();
if (f.getNames().contains("Graal.js") || isNashornFactory(f)) { // NOI18N
it.set(new GraalJSWrapperFactory(f));
}
}
return all;
}
/**
* Returns a boolean value with the same meaning as the given accumulator.
*
* @requires acc.components in (this.values + this.values.negation +
* BooleanConstant)
* @return v: BooleanValue | [[v]] = [[acc]]
* @ensures v in BooleanFormula - NotGate => this.values' = this.values + v,
* this.values' = this.values
* @throws NullPointerException any of the arguments are null
*/
BooleanValue assemble(BooleanAccumulator acc) {
final int asize = acc.size();
final Operator.Nary op = acc.op;
switch (asize) {
case 0 :
return op.identity();
case 1 :
return acc.iterator().next();
case 2 :
final Iterator<BooleanValue> inputs = acc.iterator();
return assemble(op, inputs.next(), inputs.next());
default :
final List<BooleanValue> vals = new LinkedList<BooleanValue>();
for (BooleanValue v : acc) {
vals.add(v);
}
while (vals.size() > 1) {
final ListIterator<BooleanValue> itr = vals.listIterator();
for (int i = 0, max = vals.size() - 1; i < max; i += 2) {
final BooleanValue v0 = itr.next();
itr.remove();
final BooleanValue v1 = itr.next();
final BooleanValue v0opv1 = assemble(op, v0, v1);
if (v0opv1 == op.shortCircuit())
return op.shortCircuit();
else if (v0opv1 == op.identity())
itr.remove();
else
itr.set(v0opv1);
}
}
return vals.get(0);
}
}
/**
* {@inheritDoc}
*
* <p>If any entries for the specified {@code key} already exist in the
* multimap, their values are changed in-place without affecting the iteration
* order.
*
* <p>The returned list is immutable and implements
* {@link java.util.RandomAccess}.
*/
@CanIgnoreReturnValue
@Override
public List<V> replaceValues(@Nullable K key, Iterable<? extends V> values) {
List<V> oldValues = getCopy(key);
ListIterator<V> keyValues = new ValueForKeyIterator(key);
Iterator<? extends V> newValues = values.iterator();
// Replace existing values, if any.
while (keyValues.hasNext() && newValues.hasNext()) {
keyValues.next();
keyValues.set(newValues.next());
}
// Remove remaining old values, if any.
while (keyValues.hasNext()) {
keyValues.next();
keyValues.remove();
}
// Add remaining new values, if any.
while (newValues.hasNext()) {
keyValues.add(newValues.next());
}
return oldValues;
}
@Test(dataProvider = "modifiable",
expectedExceptions = ConcurrentModificationException.class)
public void testModListIteratorSet(List<Integer> list, int from, int to) {
List<Integer> subList = list.subList(from, to);
ListIterator<Integer> it = subList.listIterator();
it.next();
list.add(42);
it.set(42);
}
@Test(dataProvider = "unsettable",
expectedExceptions = UnsupportedOperationException.class)
public void testUnmodListIteratorSetPrevious(List<Integer> list, int from, int to) {
List<Integer> subList = list.subList(from, to);
ListIterator<Integer> it = subList.listIterator(to - from);
it.previous();
it.set(42);
}
@Override
@SuppressWarnings("unchecked") // Safe casts assuming clone() works correctly
public Object clone() {
try {
ForwardState clonedState = (ForwardState) super.clone();
/* clone checkers, if cloneable */
clonedState.forwardCheckers = (ArrayList<PKIXCertPathChecker>)
forwardCheckers.clone();
ListIterator<PKIXCertPathChecker> li =
clonedState.forwardCheckers.listIterator();
while (li.hasNext()) {
PKIXCertPathChecker checker = li.next();
if (checker instanceof Cloneable) {
li.set((PKIXCertPathChecker)checker.clone());
}
}
/*
* Shallow copy traversed names. There is no need to
* deep copy contents, since the elements of the Set
* are never modified by subsequent calls to updateState().
*/
clonedState.subjectNamesTraversed
= (HashSet<GeneralNameInterface>)subjectNamesTraversed.clone();
return clonedState;
} catch (CloneNotSupportedException e) {
throw new InternalError(e.toString(), e);
}
}
/**
* Only document can be select
* See: https://github.com/code4craft/webmagic/issues/113
*
* @param elementIterator
* @param element
*/
private Element checkElementAndConvert(ListIterator<Element> elementIterator) {
Element element = elementIterator.next();
if (!(element instanceof Document)) {
Document root = new Document(element.ownerDocument().baseUri());
Element clone = element.clone();
root.appendChild(clone);
elementIterator.set(root);
return root;
}
return element;
}
/**
* Handle FALSE items in the immediate children of this
*
* @return true if this composite was replaced by FALSE
*/
private static boolean collapseFalse(CompositeItem composite, ListIterator<Item> parentIterator) {
if ( ! containsFalse(composite)) return false;
if (composite instanceof AndItem) { // AND false is always false
parentIterator.set(new FalseItem());
return true;
}
else if (composite instanceof OrItem) { // OR false is unnecessary
removeFalseIn(composite.getItemIterator());
return false;
}
else if (composite instanceof NotItem || composite instanceof RankItem) { // collapse if first, remove otherwise
ListIterator<Item> i = composite.getItemIterator();
if (i.next() instanceof FalseItem) {
parentIterator.set(new FalseItem());
return true;
}
else {
removeFalseIn(i);
return false;
}
}
else { // other composites not handled
return false;
}
}
public void replaceDirectory(final File oldIndexDir, final File newIndexDir, final boolean destroyOldIndex) {
boolean replaced = false;
synchronized (this) {
for (final Map.Entry<Long, List<IndexLocation>> entry : indexLocationByTimestamp.entrySet()) {
final List<IndexLocation> locations = entry.getValue();
final ListIterator<IndexLocation> itr = locations.listIterator();
while (itr.hasNext()) {
final IndexLocation location = itr.next();
if (location.getIndexDirectory().equals(oldIndexDir)) {
final IndexLocation updatedLocation = new IndexLocation(newIndexDir, location.getIndexStartTimestamp(), location.getPartitionName());
itr.set(updatedLocation);
replaced = true;
logger.debug("Replaced {} with {}", location, updatedLocation);
}
}
}
}
if (!replaced) {
insertIndexDirectory(newIndexDir);
}
if (destroyOldIndex) {
try {
FileUtils.deleteFile(oldIndexDir, true);
} catch (IOException e) {
logger.warn("Failed to delete index directory {}; this directory should be cleaned up manually", oldIndexDir, e);
}
}
removeDirectory(oldIndexDir);
logger.info("Successfully replaced old index directory {} with new index directory {}", oldIndexDir, newIndexDir);
}
@Override
protected boolean doProcess(Record record) {
ListIterator iter = record.get(fieldName).listIterator();
while (iter.hasNext()) {
iter.set(transformFieldValue(iter.next()));
}
return super.doProcess(record);
}
@Override
public TupleFilter transform(TupleFilter tupleFilter) {
TupleFilter translated = null;
if (tupleFilter instanceof CompareTupleFilter) {
//normal case
translated = translateCompareTupleFilter((CompareTupleFilter) tupleFilter);
if (translated != null) {
logger.info("Translated {" + tupleFilter + "}");
}
} else if (tupleFilter instanceof BuiltInFunctionTupleFilter) {
//like case
translated = translateFunctionTupleFilter((BuiltInFunctionTupleFilter) tupleFilter);
if (translated != null) {
logger.info("Translated {" + tupleFilter + "}");
}
} else if (tupleFilter instanceof LogicalTupleFilter) {
@SuppressWarnings("unchecked")
ListIterator<TupleFilter> childIterator = (ListIterator<TupleFilter>) tupleFilter.getChildren()
.listIterator();
while (childIterator.hasNext()) {
TupleFilter transformed = transform(childIterator.next());
if (transformed != null)
childIterator.set(transformed);
}
}
TupleFilter result = translated == null ? tupleFilter : translated;
if (result.getOperator() == TupleFilter.FilterOperatorEnum.NOT
&& !TupleFilter.isEvaluableRecursively(result)) {
TupleFilter.collectColumns(result, unEvaluableColumns);
return ConstantTupleFilter.TRUE;
}
// shortcut for unEvaluatable filter
if (!result.isEvaluable()) {
TupleFilter.collectColumns(result, unEvaluableColumns);
return ConstantTupleFilter.TRUE;
}
return result;
}
@Override
@SuppressWarnings("unchecked") // Safe casts assuming clone() works correctly
public Object clone() {
try {
ReverseState clonedState = (ReverseState) super.clone();
/* clone checkers, if cloneable */
clonedState.userCheckers =
(ArrayList<PKIXCertPathChecker>)userCheckers.clone();
ListIterator<PKIXCertPathChecker> li =
clonedState.userCheckers.listIterator();
while (li.hasNext()) {
PKIXCertPathChecker checker = li.next();
if (checker instanceof Cloneable) {
li.set((PKIXCertPathChecker)checker.clone());
}
}
/* make copy of name constraints */
if (nc != null) {
clonedState.nc = (NameConstraintsExtension) nc.clone();
}
/* make copy of policy tree */
if (rootNode != null) {
clonedState.rootNode = rootNode.copyTree();
}
return clonedState;
} catch (CloneNotSupportedException e) {
throw new InternalError(e.toString(), e);
}
}
private int removeTracksInternal(int first, int last) {
synchronized (this) {
if (last < first) {
return 0;
} else if (first < 0) {
first = 0;
} else if (last >= mPlaylist.size()) {
last = mPlaylist.size() - 1;
}
boolean gotonext = false;
if (first <= mPlayPos && mPlayPos <= last) {
mPlayPos = first;
gotonext = true;
} else if (mPlayPos > last) {
mPlayPos -= last - first + 1;
}
final int numToRemove = last - first + 1;
if (first == 0 && last == mPlaylist.size() - 1) {
mPlayPos = -1;
mNextPlayPos = -1;
mPlaylist.clear();
mHistory.clear();
} else {
for (int i = 0; i < numToRemove; i++) {
mPlaylist.remove(first);
}
ListIterator<Integer> positionIterator = mHistory.listIterator();
while (positionIterator.hasNext()) {
int pos = positionIterator.next();
if (pos >= first && pos <= last) {
positionIterator.remove();
} else if (pos > last) {
positionIterator.set(pos - numToRemove);
}
}
}
if (gotonext) {
if (mPlaylist.size() == 0) {
stop(true);
mPlayPos = -1;
closeCursor();
} else {
if (mShuffleMode != SHUFFLE_NONE) {
mPlayPos = getNextPosition(true);
} else if (mPlayPos >= mPlaylist.size()) {
mPlayPos = 0;
}
final boolean wasPlaying = isPlaying();
stop(false);
openCurrentAndNext();
if (wasPlaying) {
play();
}
}
notifyChange(META_CHANGED);
}
return last - first + 1;
}
}