Example usage for java.util AbstractCollection subclass-usage

Introduction

In this page you can find the example usage for java.util AbstractCollection subclass-usage.

Usage

/**
 *
 * @author thorm
 */
public class OneItemSet<E> extends AbstractCollection<E> implements Serializable {

From source file edu.uci.ics.jung.utils.MapBinaryHeap.java

/**
 * An array-based binary heap implementation of a priority queue, 
 * which also provides
 * efficient <code>update()</code> and <code>contains</code> operations.
 * It contains extra infrastructure (a hash table) to keep track of the 
 * position of each element in the array; thus, if the key value of an element

From source file CircularQueue.java

public final class CircularQueue extends AbstractCollection {

    // This is the largest capacity allowed by this implementation
    private static final int MAX_CAPACITY = 1 << 30;
    private static final int DEFAULT_CAPACITY = 1 << 8;

From source file de.dhke.projects.cutil.collections.ExtractorCollection.java

/**
 * Wrapper collection that supports transformed reading from
 * another collection.
 * <p/>
 * Can bee seen as as the "reader" variant of {@link TransformedCollection},
 * which transforms items <em>ADDED</em> to a collection.

From source file com.nesscomputing.service.discovery.client.internal.ConsistentRingGroup.java

/** A group of servers, partitioned into rings by their service type, which provide a particular service.
 *
 * @author christopher
 *
 */
public class ConsistentRingGroup extends AbstractCollection<ConsistentHashRing> {

From source file edu.uci.ics.jung.algorithms.util.MapBinaryHeap.java

/**
 * An array-based binary heap implementation of a priority queue, 
 * which also provides
 * efficient <code>update()</code> and <code>contains</code> operations.
 * It contains extra infrastructure (a hash table) to keep track of the 
 * position of each element in the array; thus, if the key value of an element

From source file MinMaxHeap.java

/**
 * A <code>MinMaxHeap</code> provides a heap-like data structure that
 * provides fast access to both the minimum and maximum elements of
 * the heap.  Each min-max heap is of a fixed maximum size.  A min-max
 * heap holds elements implementing the {@link Scored} interface, with
 * scores being used for sorting.

From source file arrow.framework.util.collections.AbstractMultiset.java

/**
 * This class provides a skeletal implementation of the {@link Multiset} interface. A new multiset implementation can be
 * created easily by extending this class and implementing the {@link Multiset#entrySet()} method, plus optionally
 * overriding {@link #add(Object, int)} and {@link #remove(Object, int)} to enable modifications to the multiset.<br />
 * The {@link #contains}, {@link #containsAll}, {@link #count}, and {@link #size} implementations all iterate across the
 * set returned by {@link Multiset#entrySet()}, as do many methods acting on the set returned by {@link #elementSet()}.

From source file UnifyHash.java

public class UnifyHash extends AbstractCollection {
    /** 
     * the default capacity
     */
    private static final int DEFAULT_CAPACITY = 11;

From source file uniol.apt.util.EquivalenceRelation.java

/**
 * Instances of this class represent an equivalence relation over an unknown set. Initially, all elements are only
 * equivalent to themselves, but the equivalence classes of two elements can be joined.
 * @param <E> The type of elements in the equivalence relation.
 * @author Uli Schlachter
 */