This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-collections.git
The following commit(s) were added to refs/heads/master by this push:
new 4a73b69ab Javadoc
4a73b69ab is described below
commit 4a73b69ab3255054029d6513b80af34f844fc4ae
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Sun Jul 21 11:24:19 2024 -0400
Javadoc
Use HTML 'em' tag instead of 'i' tag
---
.../apache/commons/collections4/ArrayStack.java | 2 +-
.../java/org/apache/commons/collections4/Bag.java | 28 ++++----
.../commons/collections4/CollectionUtils.java | 78 +++++++++++-----------
.../org/apache/commons/collections4/ListUtils.java | 4 +-
.../apache/commons/collections4/ListValuedMap.java | 2 +-
.../commons/collections4/MultiValuedMap.java | 2 +-
.../apache/commons/collections4/SetValuedMap.java | 2 +-
.../commons/collections4/bag/CollectionBag.java | 16 ++---
.../collection/CompositeCollection.java | 2 +-
.../comparators/BooleanComparator.java | 12 ++--
.../comparators/ComparableComparator.java | 8 +--
.../collections4/comparators/ComparatorChain.java | 18 ++---
.../comparators/ReverseComparator.java | 4 +-
.../comparators/TransformingComparator.java | 4 +-
.../collections4/iterators/CollatingIterator.java | 6 +-
.../collections4/list/CursorableLinkedList.java | 2 +-
.../commons/collections4/list/SetUniqueList.java | 8 +--
.../collections4/map/AbstractReferenceMap.java | 4 +-
.../commons/collections4/map/CompositeMap.java | 2 +-
.../collections4/map/ReferenceIdentityMap.java | 2 +-
.../commons/collections4/map/ReferenceMap.java | 2 +-
.../commons/collections4/map/SingletonMap.java | 2 +-
.../commons/collections4/map/StaticBucketMap.java | 10 +--
.../commons/collections4/set/CompositeSet.java | 2 +-
.../collections4/splitmap/package-info.java | 2 +-
.../collection/AbstractCollectionTest.java | 2 +-
.../collections4/list/AbstractListTest.java | 2 +-
27 files changed, 114 insertions(+), 114 deletions(-)
diff --git a/src/main/java/org/apache/commons/collections4/ArrayStack.java
b/src/main/java/org/apache/commons/collections4/ArrayStack.java
index 2a2845135..f10f96f86 100644
--- a/src/main/java/org/apache/commons/collections4/ArrayStack.java
+++ b/src/main/java/org/apache/commons/collections4/ArrayStack.java
@@ -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>
diff --git a/src/main/java/org/apache/commons/collections4/Bag.java
b/src/main/java/org/apache/commons/collections4/Bag.java
index e86b1918c..186934016 100644
--- a/src/main/java/org/apache/commons/collections4/Bag.java
+++ b/src/main/java/org/apache/commons/collections4/Bag.java
@@ -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>
*
diff --git a/src/main/java/org/apache/commons/collections4/CollectionUtils.java
b/src/main/java/org/apache/commons/collections4/CollectionUtils.java
index 393f1ee88..d6d8d342e 100644
--- a/src/main/java/org/apache/commons/collections4/CollectionUtils.java
+++ b/src/main/java/org/apache/commons/collections4/CollectionUtils.java
@@ -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.
diff --git a/src/main/java/org/apache/commons/collections4/ListUtils.java
b/src/main/java/org/apache/commons/collections4/ListUtils.java
index 7a995286f..74db0b5d6 100644
--- a/src/main/java/org/apache/commons/collections4/ListUtils.java
+++ b/src/main/java/org/apache/commons/collections4/ListUtils.java
@@ -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
diff --git a/src/main/java/org/apache/commons/collections4/ListValuedMap.java
b/src/main/java/org/apache/commons/collections4/ListValuedMap.java
index 22d7c1fe2..75079bd32 100644
--- a/src/main/java/org/apache/commons/collections4/ListValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/ListValuedMap.java
@@ -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.
*
diff --git a/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
b/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
index 1e0c1cf60..5b1d6268e 100644
--- a/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
@@ -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>
diff --git a/src/main/java/org/apache/commons/collections4/SetValuedMap.java
b/src/main/java/org/apache/commons/collections4/SetValuedMap.java
index 42c448350..96316d665 100644
--- a/src/main/java/org/apache/commons/collections4/SetValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/SetValuedMap.java
@@ -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>
diff --git
a/src/main/java/org/apache/commons/collections4/bag/CollectionBag.java
b/src/main/java/org/apache/commons/collections4/bag/CollectionBag.java
index a1ed239ba..e5d3f137a 100644
--- a/src/main/java/org/apache/commons/collections4/bag/CollectionBag.java
+++ b/src/main/java/org/apache/commons/collections4/bag/CollectionBag.java
@@ -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.
diff --git
a/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
b/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
index 0442dd817..a24dacda3 100644
---
a/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
+++
b/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
@@ -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);
diff --git
a/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
b/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
index 093a28579..6df3e1ed2 100644
---
a/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
+++
b/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
@@ -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
diff --git
a/src/main/java/org/apache/commons/collections4/comparators/ComparableComparator.java
b/src/main/java/org/apache/commons/collections4/comparators/ComparableComparator.java
index fcd03fb78..2e0a109cc 100644
---
a/src/main/java/org/apache/commons/collections4/comparators/ComparableComparator.java
+++
b/src/main/java/org/apache/commons/collections4/comparators/ComparableComparator.java
@@ -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.
*
diff --git
a/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
b/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
index 37db15cb4..947eec633 100644
---
a/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
+++
b/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
@@ -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
diff --git
a/src/main/java/org/apache/commons/collections4/comparators/ReverseComparator.java
b/src/main/java/org/apache/commons/collections4/comparators/ReverseComparator.java
index 3ae2db6a4..3066c70d4 100644
---
a/src/main/java/org/apache/commons/collections4/comparators/ReverseComparator.java
+++
b/src/main/java/org/apache/commons/collections4/comparators/ReverseComparator.java
@@ -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
diff --git
a/src/main/java/org/apache/commons/collections4/comparators/TransformingComparator.java
b/src/main/java/org/apache/commons/collections4/comparators/TransformingComparator.java
index b8dbe4f0e..5d6b18027 100644
---
a/src/main/java/org/apache/commons/collections4/comparators/TransformingComparator.java
+++
b/src/main/java/org/apache/commons/collections4/comparators/TransformingComparator.java
@@ -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
diff --git
a/src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java
b/src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java
index 59dc9cb11..2e1c12901 100644
---
a/src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java
+++
b/src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java
@@ -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
diff --git
a/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
b/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
index 285098ff7..5b646c1a1 100644
---
a/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
+++
b/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
@@ -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.
*/
diff --git
a/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
b/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
index 2f7d318f9..0b75ccce4 100644
--- a/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
+++ b/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
@@ -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.
*
diff --git
a/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
b/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
index e08302356..632233495 100644
---
a/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
+++
b/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
@@ -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
diff --git
a/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
b/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
index debc3e79d..d385e7664 100644
--- a/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
@@ -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.
diff --git
a/src/main/java/org/apache/commons/collections4/map/ReferenceIdentityMap.java
b/src/main/java/org/apache/commons/collections4/map/ReferenceIdentityMap.java
index ec12c69ea..062ea2364 100644
---
a/src/main/java/org/apache/commons/collections4/map/ReferenceIdentityMap.java
+++
b/src/main/java/org/apache/commons/collections4/map/ReferenceIdentityMap.java
@@ -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>
diff --git
a/src/main/java/org/apache/commons/collections4/map/ReferenceMap.java
b/src/main/java/org/apache/commons/collections4/map/ReferenceMap.java
index 5f98bb6d6..c94ce1b5f 100644
--- a/src/main/java/org/apache/commons/collections4/map/ReferenceMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/ReferenceMap.java
@@ -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>
diff --git
a/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
b/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
index dce5b9f2e..4922cfd7b 100644
--- a/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
@@ -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>
diff --git
a/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
b/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
index 441436f86..2abd65ab1 100644
--- a/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
@@ -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>
diff --git
a/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
b/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
index 6816278c4..3d52484f6 100644
--- a/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
@@ -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);
diff --git
a/src/main/java/org/apache/commons/collections4/splitmap/package-info.java
b/src/main/java/org/apache/commons/collections4/splitmap/package-info.java
index d6ac0eb59..acb3c9766 100644
--- a/src/main/java/org/apache/commons/collections4/splitmap/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/splitmap/package-info.java
@@ -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
diff --git
a/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
b/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
index 0f5f2f57d..0eaa37aae 100644
---
a/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
+++
b/src/test/java/org/apache/commons/collections4/collection/AbstractCollectionTest.java
@@ -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
diff --git
a/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
b/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
index 4a93d6bdf..7a059c6be 100644
--- a/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
+++ b/src/test/java/org/apache/commons/collections4/list/AbstractListTest.java
@@ -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).
