下面列出了怎么用java.util.AbstractSequentialList的API类实例代码及写法，或者点击链接到github查看源代码。
/**
* {@inheritDoc}
*
* <p>If the multimap is modified while an iteration over the list is in
* progress (except through the iterator's own {@code add}, {@code set} or
* {@code remove} operations) the results of the iteration are undefined.
*
* <p>The returned list is not serializable and does not have random access.
*/
@Override
public List<V> get(final @Nullable K key) {
return new AbstractSequentialList<V>() {
@Override
public int size() {
KeyList<K, V> keyList = keyToKeyList.get(key);
return (keyList == null) ? 0 : keyList.count;
}
@Override
public ListIterator<V> listIterator(int index) {
return new ValueForKeyIterator(key, index);
}
};
}
@Override
List<Entry<K, V>> createEntries() {
@WeakOuter
class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<Entry<K, V>> listIterator(int index) {
return new NodeIterator(index);
}
}
return new EntriesImpl();
}
/**
* {@inheritDoc}
*
* <p>If the multimap is modified while an iteration over the list is in
* progress (except through the iterator's own {@code add}, {@code set} or
* {@code remove} operations) the results of the iteration are undefined.
*
* <p>The returned list is not serializable and does not have random access.
*/
@Override
public List<V> get(final @Nullable K key) {
return new AbstractSequentialList<V>() {
@Override
public int size() {
KeyList<K, V> keyList = keyToKeyList.get(key);
return (keyList == null) ? 0 : keyList.count;
}
@Override
public ListIterator<V> listIterator(int index) {
return new ValueForKeyIterator(key, index);
}
};
}
@Override
List<Entry<K, V>> createEntries() {
@WeakOuter
class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<Entry<K, V>> listIterator(int index) {
return new NodeIterator(index);
}
}
return new EntriesImpl();
}
/**
* {@inheritDoc}
*
* <p>If the multimap is modified while an iteration over the list is in
* progress (except through the iterator's own {@code add}, {@code set} or
* {@code remove} operations) the results of the iteration are undefined.
*
* <p>The returned list is not serializable and does not have random access.
*/
@Override
public List<V> get(final @Nullable K key) {
return new AbstractSequentialList<V>() {
@Override
public int size() {
KeyList<K, V> keyList = keyToKeyList.get(key);
return (keyList == null) ? 0 : keyList.count;
}
@Override
public ListIterator<V> listIterator(int index) {
return new ValueForKeyIterator(key, index);
}
};
}
@Override
List<Entry<K, V>> createEntries() {
@WeakOuter
class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<Entry<K, V>> listIterator(int index) {
return new NodeIterator(index);
}
}
return new EntriesImpl();
}
/**
* {@inheritDoc}
*
* <p>If the multimap is modified while an iteration over the list is in
* progress (except through the iterator's own {@code add}, {@code set} or
* {@code remove} operations) the results of the iteration are undefined.
*
* <p>The returned list is not serializable and does not have random access.
*/
@Override
public List<V> get(final @Nullable K key) {
return new AbstractSequentialList<V>() {
@Override
public int size() {
KeyList<K, V> keyList = keyToKeyList.get(key);
return (keyList == null) ? 0 : keyList.count;
}
@Override
public ListIterator<V> listIterator(int index) {
return new ValueForKeyIterator(key, index);
}
};
}
@Override
List<Entry<K, V>> createEntries() {
@WeakOuter
class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<Entry<K, V>> listIterator(int index) {
return new NodeIterator(index);
}
}
return new EntriesImpl();
}
/**
* {@inheritDoc}
*
* <p>If the multimap is modified while an iteration over the list is in
* progress (except through the iterator's own {@code add}, {@code set} or
* {@code remove} operations) the results of the iteration are undefined.
*
* <p>The returned list is not serializable and does not have random access.
*/
@Override
public List<V> get(final @Nullable K key) {
return new AbstractSequentialList<V>() {
@Override
public int size() {
KeyList<K, V> keyList = keyToKeyList.get(key);
return (keyList == null) ? 0 : keyList.count;
}
@Override
public ListIterator<V> listIterator(int index) {
return new ValueForKeyIterator(key, index);
}
};
}
@Override
List<Entry<K, V>> createEntries() {
@WeakOuter
class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<Entry<K, V>> listIterator(int index) {
return new NodeIterator(index);
}
}
return new EntriesImpl();
}
public FramedGraph load() {
Graph graph = TinkerGraph.open();
final FramedGraph framedGraph = new DelegatingFramedGraph(graph, true, JAVA_TYPE_TYPES);
// Interfaces
Vertex collection = makeInterface(graph, Collection.class);
Vertex list = makeInterface(graph, List.class);
// Classes
Vertex obj = makeClass(graph, null, Object.class);
Vertex abstrCollection = makeClass(graph, obj, AbstractCollection.class, collection);
Vertex abstrList = makeClass(graph, abstrCollection, AbstractList.class, list);
Vertex abstrSeqList = makeClass(graph, abstrList, AbstractSequentialList.class, list);
makeClass(graph, abstrList, ArrayList.class, list);
makeClass(graph, abstrSeqList, LinkedList.class, list, collection);
return framedGraph;
}
@Override
List<V> createValues() {
@WeakOuter
class ValuesImpl extends AbstractSequentialList<V> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<V> listIterator(int index) {
final NodeIterator nodeItr = new NodeIterator(index);
return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
@Override
V transform(Entry<K, V> entry) {
return entry.getValue();
}
@Override
public void set(V value) {
nodeItr.setValue(value);
}
};
}
}
return new ValuesImpl();
}
@Override
List<V> createValues() {
@WeakOuter
class ValuesImpl extends AbstractSequentialList<V> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<V> listIterator(int index) {
final NodeIterator nodeItr = new NodeIterator(index);
return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
@Override
V transform(Entry<K, V> entry) {
return entry.getValue();
}
@Override
public void set(V value) {
nodeItr.setValue(value);
}
};
}
}
return new ValuesImpl();
}
@Override
List<V> createValues() {
@WeakOuter
class ValuesImpl extends AbstractSequentialList<V> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<V> listIterator(int index) {
final NodeIterator nodeItr = new NodeIterator(index);
return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
@Override
V transform(Entry<K, V> entry) {
return entry.getValue();
}
@Override
public void set(V value) {
nodeItr.setValue(value);
}
};
}
}
return new ValuesImpl();
}
@Override
List<V> createValues() {
@WeakOuter
class ValuesImpl extends AbstractSequentialList<V> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<V> listIterator(int index) {
final NodeIterator nodeItr = new NodeIterator(index);
return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
@Override
V transform(Entry<K, V> entry) {
return entry.getValue();
}
@Override
public void set(V value) {
nodeItr.setValue(value);
}
};
}
}
return new ValuesImpl();
}
@Override
List<V> createValues() {
@WeakOuter
class ValuesImpl extends AbstractSequentialList<V> {
@Override
public int size() {
return size;
}
@Override
public ListIterator<V> listIterator(int index) {
final NodeIterator nodeItr = new NodeIterator(index);
return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
@Override
V transform(Entry<K, V> entry) {
return entry.getValue();
}
@Override
public void set(V value) {
nodeItr.setValue(value);
}
};
}
}
return new ValuesImpl();
}
@SuppressWarnings("FeatureEnvy")
@Test
public void testResultsCountGoesDownAfterAddingConcept() {
final ListView results = searchAndWait("loathing");
final int resultsCountNoConcept = results.getTotalResultsNum();
assumeThat("Initial query returned no results", resultsCountNoConcept, greaterThan(0));
final AbstractSequentialList<Integer> resultCountList = new LinkedList<>();
resultCountList.add(resultsCountNoConcept);
final int numberOfRepeats = 2;
for (int i = 0; i < numberOfRepeats; ++i) {
final TopicMapView topicMap = goToTopicMap();
topicMap.clickNthClusterHeading(0);
Waits.loadOrFadeWait();
findPage.goToListView();
results.waitForResultsToLoad();
resultCountList.add(results.getTotalResultsNum());
}
for (int i = 0; i < resultCountList.size() - 1; ++i) {
LOGGER.info("Search no. " + (i + 1) + " yielded " + resultCountList.get(i) + " results.");
assertThat("Adding a concept does not increase the result count",
resultCountList.get(i),
greaterThanOrEqualTo(resultCountList.get(i + 1)));
}
}
/**
* {@link java.util.AbstractSequentialList#addAll(int, java.util.Collection)}
*/
public void test_addAll_ILCollection() {
AbstractSequentialList<String> al = new ASLT<String>();
String[] someList = { "Aardvark" ,
"Bear" ,
"Chimpanzee",
"Duck" };
Collection<String> c = Arrays.asList(someList);
al.addAll(c);
assertTrue("Should return true", al.addAll(2, c));
}
private Map<String, String> getAbstrListBothDirectionsExtEdges() {
Map<String, String> edges = new HashMap<>();
edges.put(AbstractList.class.getName(), AbstractCollection.class.getName());
edges.put(ArrayList.class.getName(), AbstractList.class.getName());
edges.put(AbstractSequentialList.class.getName(), AbstractList.class.getName());
return edges;
}
/** {@inheritDoc} */
@Override
protected AbstractSequentialList<T> newCollection() {
return new LinkedList<T>();
}
@Test
public void testGetPrettyClassName()
{
assertEquals( "Array List", TextUtils.getPrettyClassName( ArrayList.class ) );
assertEquals( "Abstract Sequential List", TextUtils.getPrettyClassName( AbstractSequentialList.class ) );
}
@Override
protected Class<? extends Collection> getExpectedTypeClass() {
return AbstractSequentialList.class;
}
@Override
protected AbstractSequentialList<T> newCollection() {
return new LinkedList<T>();
}