parent
0177e7588e
commit
4a73b69ab3
|
@ -28,7 +28,7 @@ import java.util.EmptyStackException;
|
|||
* <p>
|
||||
* The removal order of an {@code ArrayStack} is based on insertion
|
||||
* order: The most recently added element is removed first. The iteration
|
||||
* order is <i>not</i> the same as the removal order. The iterator returns
|
||||
* order is <em>not</em> the same as the removal order. The iterator returns
|
||||
* elements from the bottom up.
|
||||
* </p>
|
||||
* <p>
|
||||
|
|
|
@ -29,8 +29,8 @@ import java.util.Set;
|
|||
* calling {@link #uniqueSet()} would return {@code {a, b, c}}.
|
||||
* </p>
|
||||
* <p>
|
||||
* <i>NOTE: This interface violates the {@link Collection} contract.</i>
|
||||
* The behavior specified in many of these methods is <i>not</i> the same
|
||||
* <em>NOTE: This interface violates the {@link Collection} contract.</em>
|
||||
* The behavior specified in many of these methods is <em>not</em> the same
|
||||
* as the behavior specified by {@code Collection}.
|
||||
* The non-compliant methods are clearly marked with "(Violation)".
|
||||
* Exercise caution when using a bag as a {@code Collection}.
|
||||
|
@ -47,7 +47,7 @@ import java.util.Set;
|
|||
public interface Bag<E> extends Collection<E> {
|
||||
|
||||
/**
|
||||
* <i>(Violation)</i>
|
||||
* <em>(Violation)</em>
|
||||
* Adds one copy of the specified object to the Bag.
|
||||
* <p>
|
||||
* If the object is already in the {@link #uniqueSet()} then increment its
|
||||
|
@ -82,7 +82,7 @@ public interface Bag<E> extends Collection<E> {
|
|||
boolean add(E object, int nCopies);
|
||||
|
||||
/**
|
||||
* <i>(Violation)</i>
|
||||
* <em>(Violation)</em>
|
||||
* Returns {@code true} if the bag contains all elements in
|
||||
* the given collection, respecting cardinality. That is, if the
|
||||
* given collection {@code coll} contains {@code n} copies
|
||||
|
@ -91,7 +91,7 @@ public interface Bag<E> extends Collection<E> {
|
|||
*
|
||||
* <p>
|
||||
* The {@link Collection#containsAll(Collection)} method specifies
|
||||
* that cardinality should <i>not</i> be respected; this method should
|
||||
* that cardinality should <em>not</em> be respected; this method should
|
||||
* return true if the bag contains at least one of every object contained
|
||||
* in the given collection.
|
||||
* </p>
|
||||
|
@ -123,15 +123,15 @@ public interface Bag<E> extends Collection<E> {
|
|||
Iterator<E> iterator();
|
||||
|
||||
/**
|
||||
* <i>(Violation)</i>
|
||||
* <em>(Violation)</em>
|
||||
* Removes all occurrences of the given object from the bag.
|
||||
* <p>
|
||||
* This will also remove the object from the {@link #uniqueSet()}.
|
||||
* </p>
|
||||
* <p>
|
||||
* According to the {@link Collection#remove(Object)} method,
|
||||
* this method should only remove the <i>first</i> occurrence of the
|
||||
* given object, not <i>all</i> occurrences.
|
||||
* this method should only remove the <em>first</em> occurrence of the
|
||||
* given object, not <em>all</em> occurrences.
|
||||
* </p>
|
||||
*
|
||||
* @param object the object to remove
|
||||
|
@ -154,7 +154,7 @@ public interface Bag<E> extends Collection<E> {
|
|||
boolean remove(Object object, int nCopies);
|
||||
|
||||
/**
|
||||
* <i>(Violation)</i>
|
||||
* <em>(Violation)</em>
|
||||
* Remove all elements represented in the given collection,
|
||||
* respecting cardinality. That is, if the given collection
|
||||
* {@code coll} contains {@code n} copies of a given object,
|
||||
|
@ -163,8 +163,8 @@ public interface Bag<E> extends Collection<E> {
|
|||
*
|
||||
* <p>
|
||||
* The {@link Collection#removeAll(Collection)} method specifies
|
||||
* that cardinality should <i>not</i> be respected; this method should
|
||||
* remove <i>all</i> occurrences of every object contained in the
|
||||
* that cardinality should <em>not</em> be respected; this method should
|
||||
* remove <em>all</em> occurrences of every object contained in the
|
||||
* given collection.
|
||||
* </p>
|
||||
*
|
||||
|
@ -175,7 +175,7 @@ public interface Bag<E> extends Collection<E> {
|
|||
boolean removeAll(Collection<?> coll);
|
||||
|
||||
/**
|
||||
* <i>(Violation)</i>
|
||||
* <em>(Violation)</em>
|
||||
* Remove any members of the bag that are not in the given
|
||||
* collection, respecting cardinality. That is, if the given
|
||||
* collection {@code coll} contains {@code n} copies of a
|
||||
|
@ -187,8 +187,8 @@ public interface Bag<E> extends Collection<E> {
|
|||
*
|
||||
* <p>
|
||||
* The {@link Collection#retainAll(Collection)} method specifies
|
||||
* that cardinality should <i>not</i> be respected; this method should
|
||||
* keep <i>all</i> occurrences of every object contained in the
|
||||
* that cardinality should <em>not</em> be respected; this method should
|
||||
* keep <em>all</em> occurrences of every object contained in the
|
||||
* given collection.
|
||||
* </p>
|
||||
*
|
||||
|
|
|
@ -350,7 +350,7 @@ public class CollectionUtils {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns the number of occurrences of <i>obj</i> in <i>coll</i>.
|
||||
* Returns the number of occurrences of <em>obj</em> in <em>coll</em>.
|
||||
*
|
||||
* @param obj the object to find the cardinality of
|
||||
* @param collection the {@link Iterable} to search
|
||||
|
@ -591,7 +591,7 @@ public class CollectionUtils {
|
|||
* which is the same behavior as {@link Collection#containsAll(Collection)}.
|
||||
* <p>
|
||||
* In other words, this method returns {@code true} iff the
|
||||
* {@link #intersection} of <i>coll1</i> and <i>coll2</i> has the same cardinality as
|
||||
* {@link #intersection} of <em>coll1</em> and <em>coll2</em> has the same cardinality as
|
||||
* the set of unique values from {@code coll2}. In case {@code coll2} is empty, {@code true}
|
||||
* will be returned.
|
||||
* </p>
|
||||
|
@ -642,7 +642,7 @@ public class CollectionUtils {
|
|||
* Returns {@code true} iff at least one element is in both collections.
|
||||
* <p>
|
||||
* In other words, this method returns {@code true} iff the
|
||||
* {@link #intersection} of <i>coll1</i> and <i>coll2</i> is not empty.
|
||||
* {@link #intersection} of <em>coll1</em> and <em>coll2</em> is not empty.
|
||||
* </p>
|
||||
*
|
||||
* @param coll1 the first collection, must not be null
|
||||
|
@ -675,7 +675,7 @@ public class CollectionUtils {
|
|||
* Returns {@code true} iff at least one element is in both collections.
|
||||
* <p>
|
||||
* In other words, this method returns {@code true} iff the
|
||||
* {@link #intersection} of <i>coll1</i> and <i>coll2</i> is not empty.
|
||||
* {@link #intersection} of <em>coll1</em> and <em>coll2</em> is not empty.
|
||||
* </p>
|
||||
*
|
||||
* @param <T> the type of object to lookup in {@code coll1}.
|
||||
|
@ -727,10 +727,10 @@ public class CollectionUtils {
|
|||
* Returns a {@link Collection} containing the exclusive disjunction
|
||||
* (symmetric difference) of the given {@link Iterable}s.
|
||||
* <p>
|
||||
* The cardinality of each element <i>e</i> in the returned
|
||||
* The cardinality of each element <em>e</em> in the returned
|
||||
* {@link Collection} will be equal to
|
||||
* <code>max(cardinality(<i>e</i>,<i>a</i>),cardinality(<i>e</i>,<i>b</i>)) - min(cardinality(<i>e</i>,<i>a</i>),
|
||||
* cardinality(<i>e</i>,<i>b</i>))</code>.
|
||||
* <code>max(cardinality(<em>e</em>,<em>a</em>),cardinality(<em>e</em>,<em>b</em>)) - min(cardinality(<em>e</em>,<em>a</em>),
|
||||
* cardinality(<em>e</em>,<em>b</em>))</code>.
|
||||
* </p>
|
||||
* <p>
|
||||
* This is equivalent to
|
||||
|
@ -1189,9 +1189,9 @@ public class CollectionUtils {
|
|||
* Returns {@code true} iff the given {@link Collection}s contain
|
||||
* exactly the same elements with exactly the same cardinalities.
|
||||
* <p>
|
||||
* That is, iff the cardinality of <i>e</i> in <i>a</i> is
|
||||
* equal to the cardinality of <i>e</i> in <i>b</i>,
|
||||
* for each element <i>e</i> in <i>a</i> or <i>b</i>.
|
||||
* That is, iff the cardinality of <em>e</em> in <em>a</em> is
|
||||
* equal to the cardinality of <em>e</em> in <em>b</em>,
|
||||
* for each element <em>e</em> in <em>a</em> or <em>b</em>.
|
||||
* </p>
|
||||
*
|
||||
* @param a the first collection, must not be null
|
||||
|
@ -1221,9 +1221,9 @@ public class CollectionUtils {
|
|||
* Returns {@code true} iff the given {@link Collection}s contain
|
||||
* exactly the same elements with exactly the same cardinalities.
|
||||
* <p>
|
||||
* That is, iff the cardinality of <i>e</i> in <i>a</i> is
|
||||
* equal to the cardinality of <i>e</i> in <i>b</i>,
|
||||
* for each element <i>e</i> in <i>a</i> or <i>b</i>.
|
||||
* That is, iff the cardinality of <em>e</em> in <em>a</em> is
|
||||
* equal to the cardinality of <em>e</em> in <em>b</em>,
|
||||
* for each element <em>e</em> in <em>a</em> or <em>b</em>.
|
||||
* </p>
|
||||
* <p>
|
||||
* <b>Note:</b> from version 4.1 onwards this method requires the input
|
||||
|
@ -1303,24 +1303,24 @@ public class CollectionUtils {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>,
|
||||
* that is, iff the cardinality of <i>e</i> in <i>a</i> is less
|
||||
* than or equal to the cardinality of <i>e</i> in <i>b</i>,
|
||||
* for each element <i>e</i> in <i>a</i>, and there is at least one
|
||||
* element <i>f</i> such that the cardinality of <i>f</i> in <i>b</i>
|
||||
* is strictly greater than the cardinality of <i>f</i> in <i>a</i>.
|
||||
* Returns {@code true} iff <em>a</em> is a <em>proper</em> sub-collection of <em>b</em>,
|
||||
* that is, iff the cardinality of <em>e</em> in <em>a</em> is less
|
||||
* than or equal to the cardinality of <em>e</em> in <em>b</em>,
|
||||
* for each element <em>e</em> in <em>a</em>, and there is at least one
|
||||
* element <em>f</em> such that the cardinality of <em>f</em> in <em>b</em>
|
||||
* is strictly greater than the cardinality of <em>f</em> in <em>a</em>.
|
||||
* <p>
|
||||
* The implementation assumes
|
||||
* </p>
|
||||
* <ul>
|
||||
* <li>{@code a.size()} and {@code b.size()} represent the
|
||||
* total cardinality of <i>a</i> and <i>b</i>, resp. </li>
|
||||
* total cardinality of <em>a</em> and <em>b</em>, resp. </li>
|
||||
* <li>{@code a.size() < Integer.MAXVALUE}</li>
|
||||
* </ul>
|
||||
*
|
||||
* @param a the first (sub?) collection, must not be null
|
||||
* @param b the second (super?) collection, must not be null
|
||||
* @return {@code true} iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>
|
||||
* @return {@code true} iff <em>a</em> is a <em>proper</em> sub-collection of <em>b</em>
|
||||
* @throws NullPointerException if either collection is null
|
||||
* @see #isSubCollection
|
||||
* @see Collection#containsAll
|
||||
|
@ -1332,14 +1332,14 @@ public class CollectionUtils {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>a</i> is a sub-collection of <i>b</i>,
|
||||
* that is, iff the cardinality of <i>e</i> in <i>a</i> is less than or
|
||||
* equal to the cardinality of <i>e</i> in <i>b</i>, for each element <i>e</i>
|
||||
* in <i>a</i>.
|
||||
* Returns {@code true} iff <em>a</em> is a sub-collection of <em>b</em>,
|
||||
* that is, iff the cardinality of <em>e</em> in <em>a</em> is less than or
|
||||
* equal to the cardinality of <em>e</em> in <em>b</em>, for each element <em>e</em>
|
||||
* in <em>a</em>.
|
||||
*
|
||||
* @param a the first (sub?) collection, must not be null
|
||||
* @param b the second (super?) collection, must not be null
|
||||
* @return {@code true} iff <i>a</i> is a sub-collection of <i>b</i>
|
||||
* @return {@code true} iff <em>a</em> is a sub-collection of <em>b</em>
|
||||
* @throws NullPointerException if either collection is null
|
||||
* @see #isProperSubCollection
|
||||
* @see Collection#containsAll
|
||||
|
@ -1946,10 +1946,10 @@ public class CollectionUtils {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns a new {@link Collection} containing {@code <i>a</i> - <i>b</i>}.
|
||||
* The cardinality of each element <i>e</i> in the returned {@link Collection}
|
||||
* will be the cardinality of <i>e</i> in <i>a</i> minus the cardinality
|
||||
* of <i>e</i> in <i>b</i>, or zero, whichever is greater.
|
||||
* Returns a new {@link Collection} containing {@code <em>a</em> - <em>b</em>}.
|
||||
* The cardinality of each element <em>e</em> in the returned {@link Collection}
|
||||
* will be the cardinality of <em>e</em> in <em>a</em> minus the cardinality
|
||||
* of <em>e</em> in <em>b</em>, or zero, whichever is greater.
|
||||
*
|
||||
* @param a the collection to subtract from, must not be null
|
||||
* @param b the collection to subtract, must not be null
|
||||
|
@ -1964,23 +1964,23 @@ public class CollectionUtils {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns a new {@link Collection} containing <i>a</i> minus a subset of
|
||||
* <i>b</i>. Only the elements of <i>b</i> that satisfy the predicate
|
||||
* condition, <i>p</i> are subtracted from <i>a</i>.
|
||||
* Returns a new {@link Collection} containing <em>a</em> minus a subset of
|
||||
* <em>b</em>. Only the elements of <em>b</em> that satisfy the predicate
|
||||
* condition, <em>p</em> are subtracted from <em>a</em>.
|
||||
*
|
||||
* <p>
|
||||
* The cardinality of each element <i>e</i> in the returned {@link Collection}
|
||||
* that satisfies the predicate condition will be the cardinality of <i>e</i> in <i>a</i>
|
||||
* minus the cardinality of <i>e</i> in <i>b</i>, or zero, whichever is greater.
|
||||
* The cardinality of each element <em>e</em> in the returned {@link Collection}
|
||||
* that satisfies the predicate condition will be the cardinality of <em>e</em> in <em>a</em>
|
||||
* minus the cardinality of <em>e</em> in <em>b</em>, or zero, whichever is greater.
|
||||
* </p>
|
||||
* <p>
|
||||
* The cardinality of each element <i>e</i> in the returned {@link Collection} that does <b>not</b>
|
||||
* satisfy the predicate condition will be equal to the cardinality of <i>e</i> in <i>a</i>.
|
||||
* The cardinality of each element <em>e</em> in the returned {@link Collection} that does <b>not</b>
|
||||
* satisfy the predicate condition will be equal to the cardinality of <em>e</em> in <em>a</em>.
|
||||
* </p>
|
||||
*
|
||||
* @param a the collection to subtract from, must not be null
|
||||
* @param b the collection to subtract, must not be null
|
||||
* @param p the condition used to determine which elements of <i>b</i> are
|
||||
* @param p the condition used to determine which elements of <em>b</em> are
|
||||
* subtracted.
|
||||
* @param <O> the generic type that is able to represent the types contained
|
||||
* in both input collections.
|
||||
|
|
|
@ -294,8 +294,8 @@ public class ListUtils {
|
|||
* Compares the two list objects for equality. Returns
|
||||
* {@code true} if and only if both
|
||||
* lists have the same size, and all corresponding pairs of elements in
|
||||
* the two lists are <i>equal</i>. (Two elements {@code e1} and
|
||||
* {@code e2} are <i>equal</i> if <code>(e1==null ? e2==null :
|
||||
* the two lists are <em>equal</em>. (Two elements {@code e1} and
|
||||
* {@code e2} are <em>equal</em> if <code>(e1==null ? e2==null :
|
||||
* e1.equals(e2))</code>.) In other words, two lists are defined to be
|
||||
* equal if they contain the same elements in the same order. This
|
||||
* definition ensures that the equals method works properly across
|
||||
|
|
|
@ -53,7 +53,7 @@ public interface ListValuedMap<K, V> extends MultiValuedMap<K, V> {
|
|||
/**
|
||||
* Removes all values associated with the specified key.
|
||||
* <p>
|
||||
* The returned list <i>may</i> be modifiable, but updates will not be
|
||||
* The returned list <em>may</em> be modifiable, but updates will not be
|
||||
* propagated to this list-valued map. In case no mapping was stored for the
|
||||
* specified key, an empty, unmodifiable list will be returned.
|
||||
*
|
||||
|
|
|
@ -286,7 +286,7 @@ public interface MultiValuedMap<K, V> {
|
|||
/**
|
||||
* Removes all values associated with the specified key.
|
||||
* <p>
|
||||
* The returned collection <i>may</i> be modifiable, but updates will not be propagated
|
||||
* The returned collection <em>may</em> be modifiable, but updates will not be propagated
|
||||
* to this multivalued map. In case no mapping was stored for the specified
|
||||
* key, an empty, unmodifiable collection will be returned.
|
||||
* </p>
|
||||
|
|
|
@ -52,7 +52,7 @@ public interface SetValuedMap<K, V> extends MultiValuedMap<K, V> {
|
|||
/**
|
||||
* Removes all values associated with the specified key.
|
||||
* <p>
|
||||
* The returned set <i>may</i> be modifiable, but updates will not be
|
||||
* The returned set <em>may</em> be modifiable, but updates will not be
|
||||
* propagated to this set-valued map. In case no mapping was stored for the
|
||||
* specified key, an empty, unmodifiable set will be returned.
|
||||
* </p>
|
||||
|
|
|
@ -67,7 +67,7 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
|
|||
}
|
||||
|
||||
/**
|
||||
* <i>(Change)</i>
|
||||
* <em>(Change)</em>
|
||||
* Adds one copy of the specified object to the Bag.
|
||||
* <p>
|
||||
* Since this method always increases the size of the bag, it
|
||||
|
@ -82,7 +82,7 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
|
|||
}
|
||||
|
||||
/**
|
||||
* <i>(Change)</i>
|
||||
* <em>(Change)</em>
|
||||
* Adds {@code count} copies of the specified object to the Bag.
|
||||
* <p>
|
||||
* Since this method always increases the size of the bag, it
|
||||
|
@ -111,7 +111,7 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
|
|||
}
|
||||
|
||||
/**
|
||||
* <i>(Change)</i>
|
||||
* <em>(Change)</em>
|
||||
* Returns {@code true} if the bag contains all elements in
|
||||
* the given collection, <b>not</b> respecting cardinality. That is,
|
||||
* if the given collection {@code coll} contains at least one of
|
||||
|
@ -140,7 +140,7 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
|
|||
}
|
||||
|
||||
/**
|
||||
* <i>(Change)</i>
|
||||
* <em>(Change)</em>
|
||||
* Removes the first occurrence of the given object from the bag.
|
||||
* <p>
|
||||
* This will also remove the object from the {@link #uniqueSet()} if the
|
||||
|
@ -155,9 +155,9 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
|
|||
}
|
||||
|
||||
/**
|
||||
* <i>(Change)</i>
|
||||
* <em>(Change)</em>
|
||||
* Remove all elements represented in the given collection,
|
||||
* <b>not</b> respecting cardinality. That is, remove <i>all</i>
|
||||
* <b>not</b> respecting cardinality. That is, remove <em>all</em>
|
||||
* occurrences of every object contained in the given collection.
|
||||
*
|
||||
* @param coll the collection to remove
|
||||
|
@ -178,9 +178,9 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
|
|||
}
|
||||
|
||||
/**
|
||||
* <i>(Change)</i>
|
||||
* <em>(Change)</em>
|
||||
* Remove any members of the bag that are not in the given collection,
|
||||
* <i>not</i> respecting cardinality. That is, any object in the given
|
||||
* <em>not</em> respecting cardinality. That is, any object in the given
|
||||
* collection {@code coll} will be retained in the bag with the same
|
||||
* number of copies prior to this operation. All other objects will be
|
||||
* completely removed from this bag.
|
||||
|
|
|
@ -499,7 +499,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
|
|||
* Returns a new collection containing all of the elements
|
||||
*
|
||||
* @return A new ArrayList containing all of the elements in this composite.
|
||||
* The new collection is <i>not</i> backed by this composite.
|
||||
* The new collection is <em>not</em> backed by this composite.
|
||||
*/
|
||||
public Collection<E> toCollection() {
|
||||
return new ArrayList<>(this);
|
||||
|
|
|
@ -42,8 +42,8 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
|
|||
|
||||
/**
|
||||
* Returns a BooleanComparator instance that sorts
|
||||
* {@code <i>trueFirst</i>} values before
|
||||
* {@code !<i>trueFirst</i>} values.
|
||||
* {@code <em>trueFirst</em>} values before
|
||||
* {@code !<em>trueFirst</em>} values.
|
||||
* <p>
|
||||
* Clients are encouraged to use the value returned from
|
||||
* this method instead of constructing a new instance
|
||||
|
@ -112,8 +112,8 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
|
|||
|
||||
/**
|
||||
* Creates a {@code BooleanComparator} that sorts
|
||||
* {@code <i>trueFirst</i>} values before
|
||||
* {@code !<i>trueFirst</i>} values.
|
||||
* {@code <em>trueFirst</em>} values before
|
||||
* {@code !<em>trueFirst</em>} values.
|
||||
* <p>
|
||||
* Please use the static factories instead whenever possible.
|
||||
*
|
||||
|
@ -142,12 +142,12 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>that</i> Object is
|
||||
* Returns {@code true} iff <em>that</em> Object is
|
||||
* a {@link Comparator} whose ordering is known to be
|
||||
* equivalent to mine.
|
||||
* <p>
|
||||
* This implementation returns {@code true}
|
||||
* iff {@code <i>that</i>} is a {@link BooleanComparator}
|
||||
* iff {@code <em>that</em>} is a {@link BooleanComparator}
|
||||
* whose value of {@link #sortsTrueFirst()} is equal to mine.
|
||||
*
|
||||
* @param object the object to compare to
|
||||
|
|
|
@ -82,9 +82,9 @@ public class ComparableComparator<E extends Comparable<? super E>> implements Co
|
|||
* @param obj1 the first object to compare
|
||||
* @param obj2 the second object to compare
|
||||
* @return negative if obj1 is less, positive if greater, zero if equal
|
||||
* @throws NullPointerException if <i>obj1</i> is {@code null},
|
||||
* @throws NullPointerException if <em>obj1</em> is {@code null},
|
||||
* or when {@code ((Comparable)obj1).compareTo(obj2)} does
|
||||
* @throws ClassCastException if <i>obj1</i> is not a {@code Comparable},
|
||||
* @throws ClassCastException if <em>obj1</em> is not a {@code Comparable},
|
||||
* or when {@code ((Comparable)obj1).compareTo(obj2)} does
|
||||
*/
|
||||
@Override
|
||||
|
@ -93,11 +93,11 @@ public class ComparableComparator<E extends Comparable<? super E>> implements Co
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>that</i> Object is a {@link Comparator Comparator}
|
||||
* Returns {@code true} iff <em>that</em> Object is a {@link Comparator Comparator}
|
||||
* whose ordering is known to be equivalent to mine.
|
||||
* <p>
|
||||
* This implementation returns {@code true} iff
|
||||
* {@code <i>object</i>.{@link Object#getClass() getClass()}} equals
|
||||
* {@code <em>object</em>.{@link Object#getClass() getClass()}} equals
|
||||
* {@code this.getClass()}. Subclasses may want to override this behavior to remain
|
||||
* consistent with the {@link Comparator#equals(Object)} contract.
|
||||
*
|
||||
|
|
|
@ -38,13 +38,13 @@ import java.util.Objects;
|
|||
* </p>
|
||||
* <p>
|
||||
* Calling a method that adds new Comparators or changes the ascend/descend sort
|
||||
* <i>after compare(Object, Object) has been called</i> will result in an
|
||||
* UnsupportedOperationException. However, <i>take care</i> to not alter the
|
||||
* <em>after compare(Object, Object) has been called</em> will result in an
|
||||
* UnsupportedOperationException. However, <em>take care</em> to not alter the
|
||||
* underlying List of Comparators or the BitSet that defines the sort order.
|
||||
* </p>
|
||||
* <p>
|
||||
* Instances of ComparatorChain are not synchronized. The class is not
|
||||
* thread-safe at construction time, but it <i>is</i> thread-safe to perform
|
||||
* thread-safe at construction time, but it <em>is</em> thread-safe to perform
|
||||
* multiple comparisons after all the setup operations are complete.
|
||||
* </p>
|
||||
*
|
||||
|
@ -115,10 +115,10 @@ public class ComparatorChain<E> implements Comparator<E>, Serializable {
|
|||
* Constructs a ComparatorChain from the Comparators in the
|
||||
* given List. The sort order of each column will be
|
||||
* drawn from the given BitSet. When determining the sort
|
||||
* order for Comparator at index <i>i</i> in the List,
|
||||
* the ComparatorChain will call BitSet.get(<i>i</i>).
|
||||
* If that method returns <i>false</i>, the forward
|
||||
* sort order is used; a return value of <i>true</i>
|
||||
* order for Comparator at index <em>i</em> in the List,
|
||||
* the ComparatorChain will call BitSet.get(<em>i</em>).
|
||||
* If that method returns <em>false</em>, the forward
|
||||
* sort order is used; a return value of <em>true</em>
|
||||
* indicates reverse sort order.
|
||||
*
|
||||
* @param list List of Comparators. NOTE: This constructor does not perform a
|
||||
|
@ -220,12 +220,12 @@ public class ComparatorChain<E> implements Comparator<E>, Serializable {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>that</i> Object is
|
||||
* Returns {@code true} iff <em>that</em> Object is
|
||||
* a {@link Comparator} whose ordering is known to be
|
||||
* equivalent to mine.
|
||||
* <p>
|
||||
* This implementation returns {@code true}
|
||||
* iff {@code <i>object</i>.{@link Object#getClass() getClass()}}
|
||||
* iff {@code <em>object</em>.{@link Object#getClass() getClass()}}
|
||||
* equals {@code this.getClass()}, and the underlying
|
||||
* comparators and order bits are equal.
|
||||
* Subclasses may want to override this behavior to remain consistent
|
||||
|
|
|
@ -75,12 +75,12 @@ public class ReverseComparator<E> implements Comparator<E>, Serializable {
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>that</i> Object is
|
||||
* Returns {@code true} iff <em>that</em> Object is
|
||||
* a {@link Comparator} whose ordering is known to be
|
||||
* equivalent to mine.
|
||||
* <p>
|
||||
* This implementation returns {@code true}
|
||||
* iff {@code <i>object</i>.{@link Object#getClass() getClass()}}
|
||||
* iff {@code <em>object</em>.{@link Object#getClass() getClass()}}
|
||||
* equals {@code this.getClass()}, and the underlying
|
||||
* comparators are equal.
|
||||
* Subclasses may want to override this behavior to remain consistent
|
||||
|
|
|
@ -87,12 +87,12 @@ public class TransformingComparator<I, O> implements Comparator<I>, Serializable
|
|||
}
|
||||
|
||||
/**
|
||||
* Returns {@code true} iff <i>that</i> Object is
|
||||
* Returns {@code true} iff <em>that</em> Object is
|
||||
* a {@link Comparator} whose ordering is known to be
|
||||
* equivalent to mine.
|
||||
* <p>
|
||||
* This implementation returns {@code true}
|
||||
* iff {@code <i>that</i>} is a {@link TransformingComparator}
|
||||
* iff {@code <em>that</em>} is a {@link TransformingComparator}
|
||||
* whose attributes are equal to mine.
|
||||
*
|
||||
* @param object the object to compare to
|
||||
|
|
|
@ -204,7 +204,7 @@ public class CollatingIterator<E> implements Iterator<E> {
|
|||
|
||||
/**
|
||||
* Clears the {@link #values} and {@link #valueSet} attributes at position
|
||||
* <i>i</i>.
|
||||
* <em>i</em>.
|
||||
*/
|
||||
private void clear(final int i) {
|
||||
values.set(i, null);
|
||||
|
@ -321,8 +321,8 @@ public class CollatingIterator<E> implements Iterator<E> {
|
|||
|
||||
/**
|
||||
* Sets the {@link #values} and {@link #valueSet} attributes at position
|
||||
* <i>i</i> to the next value of the {@link #iterators iterator} at position
|
||||
* <i>i</i>, or clear them if the <i>i</i><sup>th</sup> iterator has no next
|
||||
* <em>i</em> to the next value of the {@link #iterators iterator} at position
|
||||
* <em>i</em>, or clear them if the <em>i</em><sup>th</sup> iterator has no next
|
||||
* value.
|
||||
*
|
||||
* @return {@code false} iff there was no value to set
|
||||
|
|
|
@ -122,7 +122,7 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
|
|||
* Mark this cursor as no longer being needed. Any resources
|
||||
* associated with this cursor are immediately released.
|
||||
* In previous versions of this class, it was mandatory to close
|
||||
* all cursor objects to avoid memory leaks. It is <i>no longer</i>
|
||||
* all cursor objects to avoid memory leaks. It is <em>no longer</em>
|
||||
* necessary to call this close method; an instance of this class
|
||||
* can now be treated exactly like a normal iterator.
|
||||
*/
|
||||
|
|
|
@ -177,7 +177,7 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
|
|||
/**
|
||||
* Adds an element to the list if it is not already present.
|
||||
* <p>
|
||||
* <i>(Violation)</i> The {@code List} interface requires that this
|
||||
* <em>(Violation)</em> The {@code List} interface requires that this
|
||||
* method returns {@code true} always. However, this class may return
|
||||
* {@code false} because of the {@code Set} behavior.
|
||||
*
|
||||
|
@ -200,7 +200,7 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
|
|||
* Adds an element to a specific index in the list if it is not already
|
||||
* present.
|
||||
* <p>
|
||||
* <i>(Violation)</i> The {@code List} interface makes the assumption
|
||||
* <em>(Violation)</em> The {@code List} interface makes the assumption
|
||||
* that the element is always inserted. This may not happen with this
|
||||
* implementation.
|
||||
*
|
||||
|
@ -222,7 +222,7 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
|
|||
* Only elements that are not already in this list will be added, and
|
||||
* duplicates from the specified collection will be ignored.
|
||||
* <p>
|
||||
* <i>(Violation)</i> The {@code List} interface makes the assumption
|
||||
* <em>(Violation)</em> The {@code List} interface makes the assumption
|
||||
* that the elements are always inserted. This may not happen with this
|
||||
* implementation.
|
||||
*
|
||||
|
@ -241,7 +241,7 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
|
|||
* Only elements that are not already in this list will be added, and
|
||||
* duplicates from the specified collection will be ignored.
|
||||
* <p>
|
||||
* <i>(Violation)</i> The {@code List} interface makes the assumption
|
||||
* <em>(Violation)</em> The {@code List} interface makes the assumption
|
||||
* that the elements are always inserted. This may not happen with this
|
||||
* implementation.
|
||||
*
|
||||
|
|
|
@ -69,7 +69,7 @@ import org.apache.commons.collections4.keyvalue.DefaultMapEntry;
|
|||
* hard keys and soft values, providing a memory-sensitive cache.
|
||||
* </p>
|
||||
* <p>
|
||||
* This {@link Map} implementation does <i>not</i> allow null elements.
|
||||
* This {@link Map} implementation does <em>not</em> allow null elements.
|
||||
* Attempting to add a null key or value to the map will raise a
|
||||
* {@code NullPointerException}.
|
||||
* </p>
|
||||
|
@ -350,7 +350,7 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
|
|||
* @param <T> the type of the referenced object
|
||||
* @param type HARD, SOFT or WEAK
|
||||
* @param referent the object to refer to
|
||||
* @param hash the hash code of the <i>key</i> of the mapping;
|
||||
* @param hash the hash code of the <em>key</em> of the mapping;
|
||||
* this number might be different from referent.hashCode() if
|
||||
* the referent represents a value and not a key
|
||||
* @return the reference to the object
|
||||
|
|
|
@ -315,7 +315,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
|
|||
/**
|
||||
* Returns the value to which this map maps the specified key. Returns
|
||||
* {@code null} if the map contains no mapping for this key. A return
|
||||
* value of {@code null} does not <i>necessarily</i> indicate that the
|
||||
* value of {@code null} does not <em>necessarily</em> indicate that the
|
||||
* map contains no mapping for the key; it's also possible that the map
|
||||
* explicitly maps the key to {@code null}. The {@code containsKey}
|
||||
* operation may be used to distinguish these two cases.
|
||||
|
|
|
@ -49,7 +49,7 @@ import java.lang.ref.Reference;
|
|||
* As a general rule, don't compare this map to other maps.
|
||||
* </p>
|
||||
* <p>
|
||||
* This {@link java.util.Map Map} implementation does <i>not</i> allow null elements.
|
||||
* This {@link java.util.Map Map} implementation does <em>not</em> allow null elements.
|
||||
* Attempting to add a null key or value to the map will raise a {@code NullPointerException}.
|
||||
* </p>
|
||||
* <p>
|
||||
|
|
|
@ -47,7 +47,7 @@ import java.io.Serializable;
|
|||
* It differs in that keys and values in this class are compared using {@code equals()}.
|
||||
* </p>
|
||||
* <p>
|
||||
* This {@link java.util.Map Map} implementation does <i>not</i> allow null elements.
|
||||
* This {@link java.util.Map Map} implementation does <em>not</em> allow null elements.
|
||||
* Attempting to add a null key or value to the map will raise a {@code NullPointerException}.
|
||||
* </p>
|
||||
* <p>
|
||||
|
|
|
@ -38,7 +38,7 @@ import org.apache.commons.collections4.keyvalue.TiedMapEntry;
|
|||
* <p>
|
||||
* The single key/value pair is specified at creation.
|
||||
* The map is fixed size so any action that would change the size is disallowed.
|
||||
* However, the {@code put} or {@code setValue} methods can <i>change</i>
|
||||
* However, the {@code put} or {@code setValue} methods can <em>change</em>
|
||||
* the value associated with the key.
|
||||
* </p>
|
||||
* <p>
|
||||
|
|
|
@ -41,7 +41,7 @@ import org.apache.commons.collections4.KeyValue;
|
|||
* number of entries exceeds the number of buckets or if the hash codes of the
|
||||
* objects are not uniformly distributed, these operations have a worst case
|
||||
* scenario that is proportional to the number of elements in the map
|
||||
* (<i>O(n)</i>).
|
||||
* (<em>O(n)</em>).
|
||||
* </p>
|
||||
* <p>
|
||||
* Each bucket in the hash table has its own monitor, so two threads can
|
||||
|
@ -52,7 +52,7 @@ import org.apache.commons.collections4.KeyValue;
|
|||
* that this map implementation behaves in ways you may find disconcerting.
|
||||
* Bulk operations, such as {@link #putAll(Map) putAll} or the
|
||||
* {@link Collection#retainAll(Collection) retainAll} operation in collection
|
||||
* views, are <i>not</i> atomic. If two threads are simultaneously
|
||||
* views, are <em>not</em> atomic. If two threads are simultaneously
|
||||
* executing
|
||||
* </p>
|
||||
*
|
||||
|
@ -77,8 +77,8 @@ import org.apache.commons.collections4.KeyValue;
|
|||
* {@link #isEmpty()} are out-of-date as soon as they are produced.
|
||||
* </p>
|
||||
* <p>
|
||||
* The iterators returned by the collection views of this class are <i>not</i>
|
||||
* fail-fast. They will <i>never</i> raise a
|
||||
* The iterators returned by the collection views of this class are <em>not</em>
|
||||
* fail-fast. They will <em>never</em> raise a
|
||||
* {@link java.util.ConcurrentModificationException}. Keys and values
|
||||
* added to the map after the iterator is created do not necessarily appear
|
||||
* during iteration. Similarly, the iterator does not necessarily fail to
|
||||
|
@ -86,7 +86,7 @@ import org.apache.commons.collections4.KeyValue;
|
|||
* </p>
|
||||
* <p>
|
||||
* Finally, unlike {@link java.util.HashMap}-style implementations, this
|
||||
* class <i>never</i> rehashes the map. The number of buckets is fixed
|
||||
* class <em>never</em> rehashes the map. The number of buckets is fixed
|
||||
* at construction time and never altered. Performance may degrade if
|
||||
* you do not allocate enough buckets upfront.
|
||||
* </p>
|
||||
|
|
|
@ -523,7 +523,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
|
|||
* Returns a new Set containing all of the elements.
|
||||
*
|
||||
* @return A new HashSet containing all of the elements in this composite.
|
||||
* The new collection is <i>not</i> backed by this composite.
|
||||
* The new collection is <em>not</em> backed by this composite.
|
||||
*/
|
||||
public Set<E> toSet() {
|
||||
return new HashSet<>(this);
|
||||
|
|
|
@ -19,7 +19,7 @@
|
|||
* Implements the "split map" concept. A split map is an object that implements
|
||||
* the {@link org.apache.commons.collections4.Put Put} and
|
||||
* {@link org.apache.commons.collections4.Get Get} interfaces,
|
||||
* with <i>differing</i> generic types. This is like a pre-generics
|
||||
* with <em>differing</em> generic types. This is like a pre-generics
|
||||
* {@link java.util.Map Map} whose input key/value constraints are
|
||||
* different from its output key/value constraints. While it would
|
||||
* be possible to declare a "split map" with matching input/output
|
||||
|
|
|
@ -90,7 +90,7 @@ import org.junit.jupiter.api.Test;
|
|||
* Fixtures are used to verify that the operation results in correct state
|
||||
* for the collection. Basically, the operation is performed against your
|
||||
* collection implementation, and an identical operation is performed against a
|
||||
* <i>confirmed</i> collection implementation. A confirmed collection
|
||||
* <em>confirmed</em> collection implementation. A confirmed collection
|
||||
* implementation is something like {@link java.util.ArrayList}, which is
|
||||
* known to conform exactly to its collection interface's contract. After the
|
||||
* operation takes place on both your collection implementation and the
|
||||
|
|
|
@ -215,7 +215,7 @@ public abstract class AbstractListTest<E> extends AbstractCollectionTest<E> {
|
|||
/**
|
||||
* Returns a {@link BulkTest} for testing {@link List#subList(int,int)}.
|
||||
* The returned bulk test will run through every {@code TestList}
|
||||
* method, <i>including</i> another {@code bulkTestSubList}.
|
||||
* method, <em>including</em> another {@code bulkTestSubList}.
|
||||
* Sublists are tested until the size of the sublist is less than 10.
|
||||
* Each sublist is 6 elements smaller than its parent list.
|
||||
* (By default this means that two rounds of sublists will be tested).
|
||||
|
|
Loading…
Reference in New Issue