You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2019/12/10 03:03:17 UTC
[commons-collections] branch master updated: Javadoc: Replace
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 0eb36e1 Javadoc: Replace <code></code> HTML tags with Javadoc {@code} notation.
0eb36e1 is described below
commit 0eb36e1c78285b95d0ca7303763aabd19ff8f75a
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Mon Dec 9 22:03:10 2019 -0500
Javadoc: Replace <code></code> HTML tags with Javadoc {@code} notation.
---
.../apache/commons/collections4/ArrayStack.java | 26 +--
.../java/org/apache/commons/collections4/Bag.java | 58 +++----
.../org/apache/commons/collections4/BagUtils.java | 4 +-
.../org/apache/commons/collections4/BidiMap.java | 24 +--
.../commons/collections4/BoundedCollection.java | 2 +-
.../apache/commons/collections4/BoundedMap.java | 2 +-
.../org/apache/commons/collections4/Closure.java | 2 +-
.../apache/commons/collections4/ClosureUtils.java | 30 ++--
.../commons/collections4/CollectionUtils.java | 184 ++++++++++----------
.../commons/collections4/ComparatorUtils.java | 14 +-
.../commons/collections4/EnumerationUtils.java | 12 +-
.../org/apache/commons/collections4/Factory.java | 2 +-
.../apache/commons/collections4/FactoryUtils.java | 10 +-
.../commons/collections4/FluentIterable.java | 4 +-
.../commons/collections4/FunctorException.java | 12 +-
.../java/org/apache/commons/collections4/Get.java | 10 +-
.../apache/commons/collections4/IterableGet.java | 2 +-
.../apache/commons/collections4/IterableUtils.java | 40 ++---
.../apache/commons/collections4/IteratorUtils.java | 48 +++---
.../org/apache/commons/collections4/ListUtils.java | 74 ++++----
.../apache/commons/collections4/MapIterator.java | 34 ++--
.../org/apache/commons/collections4/MapUtils.java | 188 ++++++++++-----------
.../org/apache/commons/collections4/MultiMap.java | 32 ++--
.../apache/commons/collections4/MultiMapUtils.java | 28 +--
.../org/apache/commons/collections4/MultiSet.java | 26 +--
.../apache/commons/collections4/MultiSetUtils.java | 2 +-
.../commons/collections4/MultiValuedMap.java | 6 +-
.../commons/collections4/OrderedBidiMap.java | 6 +-
.../commons/collections4/OrderedIterator.java | 2 +-
.../apache/commons/collections4/OrderedMap.java | 2 +-
.../commons/collections4/OrderedMapIterator.java | 6 +-
.../org/apache/commons/collections4/Predicate.java | 2 +-
.../commons/collections4/PredicateUtils.java | 42 ++---
.../java/org/apache/commons/collections4/Put.java | 10 +-
.../apache/commons/collections4/QueueUtils.java | 4 +-
.../org/apache/commons/collections4/SetUtils.java | 18 +-
.../org/apache/commons/collections4/SortedBag.java | 2 +-
.../apache/commons/collections4/SortedBidiMap.java | 6 +-
.../apache/commons/collections4/SplitMapUtils.java | 10 +-
.../apache/commons/collections4/Transformer.java | 2 +-
.../commons/collections4/TransformerUtils.java | 12 +-
.../collections4/bag/AbstractBagDecorator.java | 2 +-
.../commons/collections4/bag/AbstractMapBag.java | 16 +-
.../bag/AbstractSortedBagDecorator.java | 2 +-
.../commons/collections4/bag/CollectionBag.java | 28 +--
.../collections4/bidimap/AbstractDualBidiMap.java | 14 +-
.../collections4/bidimap/DualHashBidiMap.java | 10 +-
.../bidimap/DualLinkedHashBidiMap.java | 12 +-
.../collections4/bidimap/DualTreeBidiMap.java | 8 +-
.../commons/collections4/bidimap/TreeBidiMap.java | 22 +--
.../collection/AbstractCollectionDecorator.java | 8 +-
.../collection/CompositeCollection.java | 24 +--
.../collection/UnmodifiableBoundedCollection.java | 4 +-
.../comparators/BooleanComparator.java | 46 ++---
.../comparators/ComparableComparator.java | 14 +-
.../collections4/comparators/ComparatorChain.java | 8 +-
.../comparators/FixedOrderComparator.java | 8 +-
.../collections4/comparators/NullComparator.java | 90 +++++-----
.../comparators/ReverseComparator.java | 10 +-
.../comparators/TransformingComparator.java | 10 +-
.../collections4/functors/AllPredicate.java | 6 +-
.../collections4/functors/AndPredicate.java | 4 +-
.../collections4/functors/AnyPredicate.java | 6 +-
.../collections4/functors/ChainedClosure.java | 6 +-
.../collections4/functors/ChainedTransformer.java | 6 +-
.../collections4/functors/CloneTransformer.java | 2 +-
.../collections4/functors/ClosureTransformer.java | 4 +-
.../collections4/functors/ComparatorPredicate.java | 28 +--
.../collections4/functors/ConstantFactory.java | 4 +-
.../collections4/functors/ConstantTransformer.java | 4 +-
.../collections4/functors/DefaultEquator.java | 6 +-
.../collections4/functors/EqualPredicate.java | 4 +-
.../collections4/functors/FactoryTransformer.java | 4 +-
.../commons/collections4/functors/ForClosure.java | 8 +-
.../collections4/functors/IdentityPredicate.java | 2 +-
.../commons/collections4/functors/IfClosure.java | 8 +-
.../collections4/functors/IfTransformer.java | 6 +-
.../collections4/functors/InstanceofPredicate.java | 2 +-
.../collections4/functors/InstantiateFactory.java | 4 +-
.../functors/InstantiateTransformer.java | 2 +-
.../collections4/functors/InvokerTransformer.java | 2 +-
.../collections4/functors/MapTransformer.java | 4 +-
.../collections4/functors/NonePredicate.java | 6 +-
.../collections4/functors/NotPredicate.java | 2 +-
.../functors/NullIsExceptionPredicate.java | 2 +-
.../functors/NullIsFalsePredicate.java | 2 +-
.../collections4/functors/NullIsTruePredicate.java | 2 +-
.../collections4/functors/OnePredicate.java | 6 +-
.../commons/collections4/functors/OrPredicate.java | 4 +-
.../functors/PredicateTransformer.java | 4 +-
.../collections4/functors/PrototypeFactory.java | 2 +-
.../functors/StringValueTransformer.java | 4 +-
.../collections4/functors/SwitchClosure.java | 6 +-
.../collections4/functors/SwitchTransformer.java | 6 +-
.../functors/TransformedPredicate.java | 4 +-
.../collections4/functors/TransformerClosure.java | 6 +-
.../functors/TransformerPredicate.java | 2 +-
.../collections4/functors/UniquePredicate.java | 2 +-
.../collections4/functors/WhileClosure.java | 4 +-
.../collections4/iterators/ArrayIterator.java | 12 +-
.../collections4/iterators/ArrayListIterator.java | 24 +--
.../collections4/iterators/CollatingIterator.java | 26 +--
.../collections4/iterators/EmptyIterator.java | 2 +-
.../collections4/iterators/EmptyListIterator.java | 2 +-
.../iterators/EntrySetMapIterator.java | 30 ++--
.../iterators/EnumerationIterator.java | 10 +-
.../collections4/iterators/FilterIterator.java | 12 +-
.../collections4/iterators/FilterListIterator.java | 12 +-
.../collections4/iterators/IteratorChain.java | 6 +-
.../iterators/IteratorEnumeration.java | 4 +-
.../collections4/iterators/IteratorIterable.java | 10 +-
.../iterators/ListIteratorWrapper.java | 18 +-
.../collections4/iterators/LoopingIterator.java | 2 +-
.../iterators/LoopingListIterator.java | 4 +-
.../collections4/iterators/NodeListIterator.java | 2 +-
.../iterators/ObjectArrayIterator.java | 6 +-
.../iterators/ObjectArrayListIterator.java | 20 +--
.../iterators/ObjectGraphIterator.java | 6 +-
.../iterators/ReverseListIterator.java | 8 +-
.../collections4/iterators/SingletonIterator.java | 8 +-
.../iterators/SingletonListIterator.java | 4 +-
.../collections4/iterators/TransformIterator.java | 6 +-
.../iterators/UniqueFilterIterator.java | 2 +-
.../collections4/iterators/ZippingIterator.java | 6 +-
.../collections4/keyvalue/AbstractKeyValue.java | 2 +-
.../collections4/keyvalue/AbstractMapEntry.java | 6 +-
.../keyvalue/AbstractMapEntryDecorator.java | 4 +-
.../collections4/keyvalue/DefaultKeyValue.java | 14 +-
.../collections4/keyvalue/DefaultMapEntry.java | 4 +-
.../commons/collections4/keyvalue/MultiKey.java | 6 +-
.../collections4/keyvalue/TiedMapEntry.java | 2 +-
.../keyvalue/UnmodifiableMapEntry.java | 6 +-
.../collections4/list/AbstractLinkedList.java | 32 ++--
.../collections4/list/CursorableLinkedList.java | 34 ++--
.../commons/collections4/list/FixedSizeList.java | 2 +-
.../commons/collections4/list/GrowthList.java | 16 +-
.../apache/commons/collections4/list/LazyList.java | 10 +-
.../collections4/list/NodeCachingLinkedList.java | 10 +-
.../commons/collections4/list/PredicatedList.java | 2 +-
.../commons/collections4/list/SetUniqueList.java | 24 +--
.../commons/collections4/list/TransformedList.java | 2 +-
.../apache/commons/collections4/list/TreeList.java | 16 +-
.../collections4/list/UnmodifiableList.java | 2 +-
.../collections4/map/AbstractHashedMap.java | 56 +++---
.../map/AbstractInputCheckedMapDecorator.java | 8 +-
.../collections4/map/AbstractLinkedMap.java | 22 +--
.../collections4/map/AbstractReferenceMap.java | 34 ++--
.../collections4/map/CaseInsensitiveMap.java | 12 +-
.../commons/collections4/map/CompositeMap.java | 12 +-
.../commons/collections4/map/DefaultedMap.java | 8 +-
.../commons/collections4/map/FixedSizeMap.java | 2 +-
.../collections4/map/FixedSizeSortedMap.java | 2 +-
.../apache/commons/collections4/map/Flat3Map.java | 4 +-
.../apache/commons/collections4/map/HashedMap.java | 4 +-
.../apache/commons/collections4/map/LRUMap.java | 20 +--
.../apache/commons/collections4/map/LazyMap.java | 6 +-
.../commons/collections4/map/LazySortedMap.java | 6 +-
.../apache/commons/collections4/map/LinkedMap.java | 14 +-
.../commons/collections4/map/ListOrderedMap.java | 22 +--
.../commons/collections4/map/MultiKeyMap.java | 34 ++--
.../commons/collections4/map/MultiValueMap.java | 36 ++--
.../collections4/map/PassiveExpiringMap.java | 24 +--
.../commons/collections4/map/PredicatedMap.java | 4 +-
.../collections4/map/PredicatedSortedMap.java | 2 +-
.../collections4/map/ReferenceIdentityMap.java | 32 ++--
.../commons/collections4/map/ReferenceMap.java | 28 +--
.../commons/collections4/map/SingletonMap.java | 16 +-
.../commons/collections4/map/StaticBucketMap.java | 8 +-
.../commons/collections4/map/TransformedMap.java | 4 +-
.../collections4/map/TransformedSortedMap.java | 2 +-
.../collections4/map/UnmodifiableEntrySet.java | 2 +-
.../commons/collections4/map/UnmodifiableMap.java | 2 +-
.../collections4/map/UnmodifiableOrderedMap.java | 2 +-
.../collections4/map/UnmodifiableSortedMap.java | 2 +-
.../multimap/AbstractListValuedMap.java | 4 +-
.../multimap/AbstractMultiValuedMap.java | 6 +-
.../multimap/AbstractMultiValuedMapDecorator.java | 6 +-
.../multimap/AbstractSetValuedMap.java | 8 +-
.../multimap/ArrayListValuedHashMap.java | 4 +-
.../multimap/HashSetValuedHashMap.java | 4 +-
.../multimap/TransformedMultiValuedMap.java | 2 +-
.../multiset/AbstractMultiSetDecorator.java | 2 +-
.../org/apache/commons/collections4/overview.html | 14 +-
.../collections4/sequence/DeleteCommand.java | 2 +-
.../commons/collections4/sequence/EditCommand.java | 6 +-
.../commons/collections4/sequence/EditScript.java | 2 +-
.../collections4/sequence/InsertCommand.java | 2 +-
.../commons/collections4/sequence/KeepCommand.java | 4 +-
.../collections4/sequence/ReplacementsHandler.java | 4 +-
.../collections4/sequence/SequencesComparator.java | 22 +--
.../collections4/sequence/package-info.java | 22 +--
.../set/AbstractNavigableSetDecorator.java | 2 +-
.../collections4/set/AbstractSetDecorator.java | 2 +-
.../set/AbstractSortedSetDecorator.java | 2 +-
.../commons/collections4/set/CompositeSet.java | 28 +--
.../commons/collections4/set/ListOrderedSet.java | 22 +--
.../commons/collections4/set/MapBackedSet.java | 8 +-
.../collections4/set/PredicatedNavigableSet.java | 2 +-
.../commons/collections4/set/PredicatedSet.java | 2 +-
.../collections4/set/PredicatedSortedSet.java | 2 +-
.../collections4/set/TransformedNavigableSet.java | 2 +-
.../commons/collections4/set/TransformedSet.java | 2 +-
.../collections4/set/TransformedSortedSet.java | 2 +-
.../collections4/set/UnmodifiableNavigableSet.java | 2 +-
.../commons/collections4/set/UnmodifiableSet.java | 2 +-
.../collections4/set/UnmodifiableSortedSet.java | 2 +-
.../collections4/splitmap/TransformedSplitMap.java | 4 +-
207 files changed, 1294 insertions(+), 1294 deletions(-)
diff --git a/src/main/java/org/apache/commons/collections4/ArrayStack.java b/src/main/java/org/apache/commons/collections4/ArrayStack.java
index 7834d2d..51fe2a3 100644
--- a/src/main/java/org/apache/commons/collections4/ArrayStack.java
+++ b/src/main/java/org/apache/commons/collections4/ArrayStack.java
@@ -21,18 +21,18 @@ import java.util.EmptyStackException;
/**
* An implementation of the {@link java.util.Stack} API that is based on an
- * <code>ArrayList</code> instead of a <code>Vector</code>, so it is not
+ * {@code ArrayList} instead of a {@code Vector}, so it is not
* synchronized to protect against multi-threaded access. The implementation
* is therefore operates faster in environments where you do not need to
* worry about multiple thread contention.
* <p>
- * The removal order of an <code>ArrayStack</code> is based on insertion
+ * 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
* elements from the bottom up.
* </p>
* <p>
- * Unlike <code>Stack</code>, <code>ArrayStack</code> accepts null entries.
+ * Unlike {@code Stack}, {@code ArrayStack} accepts null entries.
* <p>
* <b>Note:</b> From version 4.0 onwards, this class does not implement the
* removed {@code Buffer} interface anymore.
@@ -50,15 +50,15 @@ public class ArrayStack<E> extends ArrayList<E> {
private static final long serialVersionUID = 2130079159931574599L;
/**
- * Constructs a new empty <code>ArrayStack</code>. The initial size
- * is controlled by <code>ArrayList</code> and is currently 10.
+ * Constructs a new empty {@code ArrayStack}. The initial size
+ * is controlled by {@code ArrayList} and is currently 10.
*/
public ArrayStack() {
super();
}
/**
- * Constructs a new empty <code>ArrayStack</code> with an initial size.
+ * Constructs a new empty {@code ArrayStack} with an initial size.
*
* @param initialSize the initial size to use
* @throws IllegalArgumentException if the specified initial size
@@ -69,10 +69,10 @@ public class ArrayStack<E> extends ArrayList<E> {
}
/**
- * Return <code>true</code> if this stack is currently empty.
+ * Return {@code true} if this stack is currently empty.
* <p>
- * This method exists for compatibility with <code>java.util.Stack</code>.
- * New users of this class should use <code>isEmpty</code> instead.
+ * This method exists for compatibility with {@code java.util.Stack}.
+ * New users of this class should use {@code isEmpty} instead.
*
* @return true if the stack is currently empty
*/
@@ -127,7 +127,7 @@ public class ArrayStack<E> extends ArrayList<E> {
/**
* Pushes a new item onto the top of this stack. The pushed item is also
- * returned. This is equivalent to calling <code>add</code>.
+ * returned. This is equivalent to calling {@code add}.
*
* @param item the item to be added
* @return the item just pushed
@@ -140,9 +140,9 @@ public class ArrayStack<E> extends ArrayList<E> {
/**
* Returns the one-based position of the distance from the top that the
* specified object exists on this stack, where the top-most element is
- * considered to be at distance <code>1</code>. If the object is not
- * present on the stack, return <code>-1</code> instead. The
- * <code>equals()</code> method is used to compare to the items
+ * considered to be at distance {@code 1}. If the object is not
+ * present on the stack, return {@code -1} instead. The
+ * {@code equals()} method is used to compare to the items
* in this stack.
*
* @param object the object to be searched for
diff --git a/src/main/java/org/apache/commons/collections4/Bag.java b/src/main/java/org/apache/commons/collections4/Bag.java
index 04a9c78..115d4d7 100644
--- a/src/main/java/org/apache/commons/collections4/Bag.java
+++ b/src/main/java/org/apache/commons/collections4/Bag.java
@@ -24,16 +24,16 @@ import java.util.Set;
* Defines a collection that counts the number of times an object appears in
* the collection.
* <p>
- * Suppose you have a Bag that contains <code>{a, a, b, c}</code>.
- * Calling {@link #getCount(Object)} on <code>a</code> would return 2, while
- * calling {@link #uniqueSet()} would return <code>{a, b, c}</code>.
+ * Suppose you have a Bag that contains {@code {a, a, b, c}}.
+ * Calling {@link #getCount(Object)} on {@code a} would return 2, while
+ * 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
- * as the behavior specified by <code>Collection</code>.
+ * as the behavior specified by {@code Collection}.
* The noncompliant methods are clearly marked with "(Violation)".
- * Exercise caution when using a bag as a <code>Collection</code>.
+ * Exercise caution when using a bag as a {@code Collection}.
* </p>
* <p>
* This violation resulted from the original specification of this interface.
@@ -67,27 +67,27 @@ public interface Bag<E> extends Collection<E> {
* <p>
* Since this method always increases the size of the bag,
* according to the {@link Collection#add(Object)} contract, it
- * should always return <code>true</code>. Since it sometimes returns
- * <code>false</code>, this method violates the contract.
+ * should always return {@code true}. Since it sometimes returns
+ * {@code false}, this method violates the contract.
* </p>
*
* @param object the object to add
- * @return <code>true</code> if the object was not already in the <code>uniqueSet</code>
+ * @return {@code true} if the object was not already in the {@code uniqueSet}
*/
@Override
boolean add(E object);
/**
- * Adds <code>nCopies</code> copies of the specified object to the Bag.
+ * Adds {@code nCopies} copies of the specified object to the Bag.
* <p>
* If the object is already in the {@link #uniqueSet()} then increment its
* count as reported by {@link #getCount(Object)}. Otherwise add it to the
- * {@link #uniqueSet()} and report its count as <code>nCopies</code>.
+ * {@link #uniqueSet()} and report its count as {@code nCopies}.
* </p>
*
* @param object the object to add
* @param nCopies the number of copies to add
- * @return <code>true</code> if the object was not already in the <code>uniqueSet</code>
+ * @return {@code true} if the object was not already in the {@code uniqueSet}
*/
boolean add(E object, int nCopies);
@@ -104,13 +104,13 @@ public interface Bag<E> extends Collection<E> {
* </p>
*
* @param object the object to remove
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
boolean remove(Object object);
/**
- * Removes <code>nCopies</code> copies of the specified object from the Bag.
+ * Removes {@code nCopies} copies of the specified object from the Bag.
* <p>
* If the number of copies to remove is greater than the actual number of
* copies in the Bag, no error is thrown.
@@ -118,7 +118,7 @@ public interface Bag<E> extends Collection<E> {
*
* @param object the object to remove
* @param nCopies the number of copies to remove
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
boolean remove(Object object, int nCopies);
@@ -142,11 +142,11 @@ public interface Bag<E> extends Collection<E> {
/**
* <i>(Violation)</i>
- * Returns <code>true</code> if the bag contains all elements in
+ * Returns {@code true} if the bag contains all elements in
* the given collection, respecting cardinality. That is, if the
- * given collection <code>coll</code> contains <code>n</code> copies
+ * given collection {@code coll} contains {@code n} copies
* of a given object, calling {@link #getCount(Object)} on that object must
- * be <code>>= n</code> for all <code>n</code> in <code>coll</code>.
+ * be {@code >= n} for all {@code n} in {@code coll}.
*
* <p>
* The {@link Collection#containsAll(Collection)} method specifies
@@ -156,7 +156,7 @@ public interface Bag<E> extends Collection<E> {
* </p>
*
* @param coll the collection to check against
- * @return <code>true</code> if the Bag contains all the collection
+ * @return {@code true} if the Bag contains all the collection
*/
@Override
boolean containsAll(Collection<?> coll);
@@ -165,9 +165,9 @@ public interface Bag<E> extends Collection<E> {
* <i>(Violation)</i>
* Remove all elements represented in the given collection,
* respecting cardinality. That is, if the given collection
- * <code>coll</code> contains <code>n</code> copies of a given object,
- * the bag will have <code>n</code> fewer copies, assuming the bag
- * had at least <code>n</code> copies to begin with.
+ * {@code coll} contains {@code n} copies of a given object,
+ * the bag will have {@code n} fewer copies, assuming the bag
+ * had at least {@code n} copies to begin with.
*
* <p>
* The {@link Collection#removeAll(Collection)} method specifies
@@ -177,7 +177,7 @@ public interface Bag<E> extends Collection<E> {
* </p>
*
* @param coll the collection to remove
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
boolean removeAll(Collection<?> coll);
@@ -186,11 +186,11 @@ public interface Bag<E> extends Collection<E> {
* <i>(Violation)</i>
* Remove any members of the bag that are not in the given
* collection, respecting cardinality. That is, if the given
- * collection <code>coll</code> contains <code>n</code> copies of a
- * given object and the bag has <code>m > n</code> copies, then
- * delete <code>m - n</code> copies from the bag. In addition, if
- * <code>e</code> is an object in the bag but
- * <code>!coll.contains(e)</code>, then remove <code>e</code> and any
+ * collection {@code coll} contains {@code n} copies of a
+ * given object and the bag has {@code m > n} copies, then
+ * delete {@code m - n} copies from the bag. In addition, if
+ * {@code e} is an object in the bag but
+ * {@code !coll.contains(e)}, then remove {@code e} and any
* of its copies.
*
* <p>
@@ -201,7 +201,7 @@ public interface Bag<E> extends Collection<E> {
* </p>
*
* @param coll the collection to retain
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
boolean retainAll(Collection<?> coll);
@@ -233,7 +233,7 @@ public interface Bag<E> extends Collection<E> {
// * Gets a hash code for the Bag compatible with the definition of equals.
// * The hash code is defined as the sum total of a hash code for each element.
// * The per element hash code is defined as
-// * <code>(e==null ? 0 : e.hashCode()) ^ noOccurances)</code>.
+// * {@code (e==null ? 0 : e.hashCode()) ^ noOccurances)}.
// * This hash code definition is compatible with the Set interface.
// *
// * @return the hash code of the Bag
diff --git a/src/main/java/org/apache/commons/collections4/BagUtils.java b/src/main/java/org/apache/commons/collections4/BagUtils.java
index 931a218..b5da468 100644
--- a/src/main/java/org/apache/commons/collections4/BagUtils.java
+++ b/src/main/java/org/apache/commons/collections4/BagUtils.java
@@ -246,7 +246,7 @@ public class BagUtils {
}
/**
- * Get an empty <code>Bag</code>.
+ * Get an empty {@code Bag}.
*
* @param <E> the element type
* @return an empty Bag
@@ -257,7 +257,7 @@ public class BagUtils {
}
/**
- * Get an empty <code>SortedBag</code>.
+ * Get an empty {@code SortedBag}.
*
* @param <E> the element type
* @return an empty sorted Bag
diff --git a/src/main/java/org/apache/commons/collections4/BidiMap.java b/src/main/java/org/apache/commons/collections4/BidiMap.java
index 2d9bcea..5834ae4 100644
--- a/src/main/java/org/apache/commons/collections4/BidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/BidiMap.java
@@ -21,11 +21,11 @@ import java.util.Set;
/**
* Defines a map that allows bidirectional lookup between key and values.
* <p>
- * This extended <code>Map</code> represents a mapping where a key may
+ * This extended {@code Map} represents a mapping where a key may
* lookup a value and a value may lookup a key with equal ease.
- * This interface extends <code>Map</code> and so may be used anywhere a map
+ * This interface extends {@code Map} and so may be used anywhere a map
* is required. The interface provides an inverse map view, enabling
- * full access to both directions of the <code>BidiMap</code>.
+ * full access to both directions of the {@code BidiMap}.
* </p>
* <p>
* Implementations should allow a value to be looked up from a key and
@@ -66,7 +66,7 @@ public interface BidiMap<K, V> extends IterableMap<K, V> {
* @param value the value to store
* @return the previous value mapped to this key
*
- * @throws UnsupportedOperationException if the <code>put</code> method is not supported
+ * @throws UnsupportedOperationException if the {@code put} method is not supported
* @throws ClassCastException (optional) if the map limits the type of the
* value and the specified value is inappropriate
* @throws IllegalArgumentException (optional) if the map limits the values
@@ -80,15 +80,15 @@ public interface BidiMap<K, V> extends IterableMap<K, V> {
/**
* Gets the key that is currently mapped to the specified value.
* <p>
- * If the value is not contained in the map, <code>null</code> is returned.
+ * If the value is not contained in the map, {@code null} is returned.
* </p>
* <p>
* Implementations should seek to make this method perform equally as well
- * as <code>get(Object)</code>.
+ * as {@code get(Object)}.
* </p>
*
* @param value the value to find the key for
- * @return the mapped key, or <code>null</code> if not found
+ * @return the mapped key, or {@code null} if not found
*
* @throws ClassCastException (optional) if the map limits the type of the
* value and the specified value is inappropriate
@@ -101,15 +101,15 @@ public interface BidiMap<K, V> extends IterableMap<K, V> {
* Removes the key-value pair that is currently mapped to the specified
* value (optional operation).
* <p>
- * If the value is not contained in the map, <code>null</code> is returned.
+ * If the value is not contained in the map, {@code null} is returned.
* </p>
* <p>
* Implementations should seek to make this method perform equally as well
- * as <code>remove(Object)</code>.
+ * as {@code remove(Object)}.
* </p>
*
* @param value the value to find the key-value pair for
- * @return the key that was removed, <code>null</code> if nothing removed
+ * @return the key that was removed, {@code null} if nothing removed
*
* @throws ClassCastException (optional) if the map limits the type of the
* value and the specified value is inappropriate
@@ -124,11 +124,11 @@ public interface BidiMap<K, V> extends IterableMap<K, V> {
* Gets a view of this map where the keys and values are reversed.
* <p>
* Changes to one map will be visible in the other and vice versa.
- * This enables both directions of the map to be accessed as a <code>Map</code>.
+ * This enables both directions of the map to be accessed as a {@code Map}.
* </p>
* <p>
* Implementations should seek to avoid creating a new object every time this
- * method is called. See <code>AbstractMap.values()</code> etc. Calling this
+ * method is called. See {@code AbstractMap.values()} etc. Calling this
* method on the inverse map should return the original.
* </p>
*
diff --git a/src/main/java/org/apache/commons/collections4/BoundedCollection.java b/src/main/java/org/apache/commons/collections4/BoundedCollection.java
index a5d2c01..d07fbd9 100644
--- a/src/main/java/org/apache/commons/collections4/BoundedCollection.java
+++ b/src/main/java/org/apache/commons/collections4/BoundedCollection.java
@@ -37,7 +37,7 @@ public interface BoundedCollection<E> extends Collection<E> {
/**
* Returns true if this collection is full and no new elements can be added.
*
- * @return <code>true</code> if the collection is full.
+ * @return {@code true} if the collection is full.
*/
boolean isFull();
diff --git a/src/main/java/org/apache/commons/collections4/BoundedMap.java b/src/main/java/org/apache/commons/collections4/BoundedMap.java
index 61a3bb4..3a45372 100644
--- a/src/main/java/org/apache/commons/collections4/BoundedMap.java
+++ b/src/main/java/org/apache/commons/collections4/BoundedMap.java
@@ -33,7 +33,7 @@ public interface BoundedMap<K, V> extends IterableMap<K, V> {
/**
* Returns true if this map is full and no new elements can be added.
*
- * @return <code>true</code> if the map is full
+ * @return {@code true} if the map is full
*/
boolean isFull();
diff --git a/src/main/java/org/apache/commons/collections4/Closure.java b/src/main/java/org/apache/commons/collections4/Closure.java
index 51ff59c..73dcbfb 100644
--- a/src/main/java/org/apache/commons/collections4/Closure.java
+++ b/src/main/java/org/apache/commons/collections4/Closure.java
@@ -19,7 +19,7 @@ package org.apache.commons.collections4;
/**
* Defines a functor interface implemented by classes that do something.
* <p>
- * A <code>Closure</code> represents a block of code which is executed from
+ * A {@code Closure} represents a block of code which is executed from
* inside some block, function or iteration. It operates an input object.
* </p>
* <p>
diff --git a/src/main/java/org/apache/commons/collections4/ClosureUtils.java b/src/main/java/org/apache/commons/collections4/ClosureUtils.java
index 44365a0..bee5854 100644
--- a/src/main/java/org/apache/commons/collections4/ClosureUtils.java
+++ b/src/main/java/org/apache/commons/collections4/ClosureUtils.java
@@ -32,7 +32,7 @@ import org.apache.commons.collections4.functors.TransformerClosure;
import org.apache.commons.collections4.functors.WhileClosure;
/**
- * <code>ClosureUtils</code> provides reference implementations and utilities
+ * {@code ClosureUtils} provides reference implementations and utilities
* for the Closure functor interface. The supplied closures are:
* <ul>
* <li>Invoker - invokes a method on the input object
@@ -107,16 +107,16 @@ public class ClosureUtils {
}
/**
- * Creates a Closure that will call the closure <code>count</code> times.
+ * Creates a Closure that will call the closure {@code count} times.
* <p>
- * A null closure or zero count returns the <code>NOPClosure</code>.
+ * A null closure or zero count returns the {@code NOPClosure}.
*
* @see org.apache.commons.collections4.functors.ForClosure
*
* @param <E> the type that the closure acts on
* @param count the number of times to loop
* @param closure the closure to call repeatedly
- * @return the <code>for</code> closure
+ * @return the {@code for} closure
*/
public static <E> Closure<E> forClosure(final int count, final Closure<? super E> closure) {
return ForClosure.forClosure(count, closure);
@@ -131,7 +131,7 @@ public class ClosureUtils {
* @param <E> the type that the closure acts on
* @param predicate the predicate to use as an end of loop test, not null
* @param closure the closure to call repeatedly, not null
- * @return the <code>while</code> closure
+ * @return the {@code while} closure
* @throws NullPointerException if either argument is null
*/
public static <E> Closure<E> whileClosure(final Predicate<? super E> predicate, final Closure<? super E> closure) {
@@ -147,7 +147,7 @@ public class ClosureUtils {
* @param <E> the type that the closure acts on
* @param closure the closure to call repeatedly, not null
* @param predicate the predicate to use as an end of loop test, not null
- * @return the <code>do-while</code> closure
+ * @return the {@code do-while} closure
* @throws NullPointerException if either argument is null
*/
public static <E> Closure<E> doWhileClosure(final Closure<? super E> closure,
@@ -164,7 +164,7 @@ public class ClosureUtils {
*
* @param <E> the type that the closure acts on
* @param methodName the name of the method
- * @return the <code>invoker</code> closure
+ * @return the {@code invoker} closure
* @throws NullPointerException if the method name is null
*/
public static <E> Closure<E> invokerClosure(final String methodName) {
@@ -183,7 +183,7 @@ public class ClosureUtils {
* @param methodName the name of the method
* @param paramTypes the parameter types
* @param args the arguments
- * @return the <code>invoker</code> closure
+ * @return the {@code invoker} closure
* @throws NullPointerException if the method name is null
* @throws IllegalArgumentException if the paramTypes and args don't match
*/
@@ -201,7 +201,7 @@ public class ClosureUtils {
*
* @param <E> the type that the closure acts on
* @param closures an array of closures to chain
- * @return the <code>chained</code> closure
+ * @return the {@code chained} closure
* @throws NullPointerException if the closures array is null
* @throws NullPointerException if any closure in the array is null
*/
@@ -218,7 +218,7 @@ public class ClosureUtils {
*
* @param <E> the type that the closure acts on
* @param closures a collection of closures to chain
- * @return the <code>chained</code> closure
+ * @return the {@code chained} closure
* @throws NullPointerException if the closures collection is null
* @throws NullPointerException if any closure in the collection is null
* @throws IllegalArgumentException if the closures collection is empty
@@ -236,7 +236,7 @@ public class ClosureUtils {
* @param <E> the type that the closure acts on
* @param predicate the validating predicate
* @param trueClosure the closure called if the predicate is true
- * @return the <code>if</code> closure
+ * @return the {@code if} closure
* @throws NullPointerException if the predicate or closure is null
* @since 3.2
*/
@@ -255,7 +255,7 @@ public class ClosureUtils {
* @param predicate the predicate to switch on
* @param trueClosure the closure called if the predicate is true
* @param falseClosure the closure called if the predicate is false
- * @return the <code>switch</code> closure
+ * @return the {@code switch} closure
* @throws NullPointerException if the predicate or either closure is null
*/
public static <E> Closure<E> ifClosure(final Predicate<? super E> predicate,
@@ -277,7 +277,7 @@ public class ClosureUtils {
* @param <E> the type that the closure acts on
* @param predicates an array of predicates to check, not null
* @param closures an array of closures to call, not null
- * @return the <code>switch</code> closure
+ * @return the {@code switch} closure
* @throws NullPointerException if the either array is null
* @throws NullPointerException if any element in the arrays is null
* @throws IllegalArgumentException if the arrays have different sizes
@@ -302,7 +302,7 @@ public class ClosureUtils {
* @param predicates an array of predicates to check, not null
* @param closures an array of closures to call, not null
* @param defaultClosure the default to call if no predicate matches
- * @return the <code>switch</code> closure
+ * @return the {@code switch} closure
* @throws NullPointerException if the either array is null
* @throws NullPointerException if any element in the arrays is null
* @throws IllegalArgumentException if the arrays are different sizes
@@ -328,7 +328,7 @@ public class ClosureUtils {
*
* @param <E> the type that the closure acts on
* @param predicatesAndClosures a map of predicates to closures
- * @return the <code>switch</code> closure
+ * @return the {@code switch} closure
* @throws NullPointerException if the map is null
* @throws NullPointerException if any closure in the map is null
* @throws IllegalArgumentException if the map is empty
diff --git a/src/main/java/org/apache/commons/collections4/CollectionUtils.java b/src/main/java/org/apache/commons/collections4/CollectionUtils.java
index 26e265e..1030a58 100644
--- a/src/main/java/org/apache/commons/collections4/CollectionUtils.java
+++ b/src/main/java/org/apache/commons/collections4/CollectionUtils.java
@@ -185,7 +185,7 @@ public class CollectionUtils {
public static final Collection EMPTY_COLLECTION = Collections.emptyList();
/**
- * <code>CollectionUtils</code> should not normally be instantiated.
+ * {@code CollectionUtils} should not normally be instantiated.
*/
private CollectionUtils() {}
@@ -203,12 +203,12 @@ public class CollectionUtils {
}
/**
- * Returns an immutable empty collection if the argument is <code>null</code>,
+ * Returns an immutable empty collection if the argument is {@code null},
* or the argument itself otherwise.
*
* @param <T> the element type
- * @param collection the collection, possibly <code>null</code>
- * @return an empty collection if the argument is <code>null</code>
+ * @param collection the collection, possibly {@code null}
+ * @return an empty collection if the argument is {@code null}
*/
public static <T> Collection<T> emptyIfNull(final Collection<T> collection) {
return collection == null ? CollectionUtils.<T>emptyCollection() : collection;
@@ -355,11 +355,11 @@ public class CollectionUtils {
}
/**
- * Returns <code>true</code> iff all elements of {@code coll2} are also contained
+ * Returns {@code true} iff all elements of {@code coll2} are also contained
* in {@code coll1}. The cardinality of values in {@code coll2} is not taken into account,
* which is the same behavior as {@link Collection#containsAll(Collection)}.
* <p>
- * In other words, this method returns <code>true</code> iff the
+ * 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
* the set of unique values from {@code coll2}. In case {@code coll2} is empty, {@code true}
* will be returned.
@@ -374,7 +374,7 @@ public class CollectionUtils {
*
* @param coll1 the first collection, must not be null
* @param coll2 the second collection, must not be null
- * @return <code>true</code> iff the intersection of the collections has the same cardinality
+ * @return {@code true} iff the intersection of the collections has the same cardinality
* as the set of unique elements from the second collection
* @since 4.0
*/
@@ -407,16 +407,16 @@ public class CollectionUtils {
}
/**
- * Returns <code>true</code> iff at least one element is in both collections.
+ * Returns {@code true} iff at least one element is in both collections.
* <p>
- * In other words, this method returns <code>true</code> iff the
+ * In other words, this method returns {@code true} iff the
* {@link #intersection} of <i>coll1</i> and <i>coll2</i> is not empty.
* </p>
*
- * @param <T> the type of object to lookup in <code>coll1</code>.
+ * @param <T> the type of object to lookup in {@code coll1}.
* @param coll1 the first collection, must not be null
* @param coll2 the second collection, must not be null
- * @return <code>true</code> iff the intersection of the collections is non-empty
+ * @return {@code true} iff the intersection of the collections is non-empty
* @since 4.2
* @see #intersection
*/
@@ -438,15 +438,15 @@ public class CollectionUtils {
}
/**
- * Returns <code>true</code> iff at least one element is in both collections.
+ * Returns {@code true} iff at least one element is in both collections.
* <p>
- * In other words, this method returns <code>true</code> iff the
+ * In other words, this method returns {@code true} iff the
* {@link #intersection} of <i>coll1</i> and <i>coll2</i> is not empty.
* </p>
*
* @param coll1 the first collection, must not be null
* @param coll2 the second collection, must not be null
- * @return <code>true</code> iff the intersection of the collections is non-empty
+ * @return {@code true} iff the intersection of the collections is non-empty
* @since 2.1
* @see #intersection
*/
@@ -501,7 +501,7 @@ public class CollectionUtils {
*
* @param a the first (sub?) collection, must not be null
* @param b the second (super?) collection, must not be null
- * @return <code>true</code> iff <i>a</i> is a sub-collection of <i>b</i>
+ * @return {@code true} iff <i>a</i> is a sub-collection of <i>b</i>
* @see #isProperSubCollection
* @see Collection#containsAll
*/
@@ -526,14 +526,14 @@ public class CollectionUtils {
* The implementation assumes
* </p>
* <ul>
- * <li><code>a.size()</code> and <code>b.size()</code> represent the
+ * <li>{@code a.size()} and {@code b.size()} represent the
* total cardinality of <i>a</i> and <i>b</i>, resp. </li>
- * <li><code>a.size() < Integer.MAXVALUE</code></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</code> iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>
+ * @return {@code true} iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>
* @see #isSubCollection
* @see Collection#containsAll
*/
@@ -552,7 +552,7 @@ public class CollectionUtils {
*
* @param a the first collection, must not be null
* @param b the second collection, must not be null
- * @return <code>true</code> iff the collections contain the same elements with the same cardinalities.
+ * @return {@code true} iff the collections contain the same elements with the same cardinalities.
*/
public static boolean isEqualCollection(final Collection<?> a, final Collection<?> b) {
if(a.size() != b.size()) {
@@ -589,7 +589,7 @@ public class CollectionUtils {
* @param a the first collection, must not be null
* @param b the second collection, must not be null
* @param equator the Equator used for testing equality
- * @return <code>true</code> iff the collections contain the same elements with the same cardinalities.
+ * @return {@code true} iff the collections contain the same elements with the same cardinalities.
* @throws NullPointerException if the equator is null
* @since 4.0
*/
@@ -792,7 +792,7 @@ public class CollectionUtils {
* Filter the collection by applying a Predicate to each element. If the
* predicate returns true, remove the element.
* <p>
- * This is equivalent to <code>filter(collection, PredicateUtils.notPredicate(predicate))</code>
+ * This is equivalent to {@code filter(collection, PredicateUtils.notPredicate(predicate))}
* if predicate is != null.
* </p>
* <p>
@@ -849,7 +849,7 @@ public class CollectionUtils {
* Counts the number of elements in the input collection that match the
* predicate.
* <p>
- * A <code>null</code> collection or predicate matches no elements.
+ * A {@code null} collection or predicate matches no elements.
* </p>
*
* @param <C> the type of object the {@link Iterable} contains
@@ -867,7 +867,7 @@ public class CollectionUtils {
* Answers true if a predicate is true for at least one element of a
* collection.
* <p>
- * A <code>null</code> collection or predicate returns false.
+ * A {@code null} collection or predicate returns false.
* </p>
*
* @param <C> the type of object the {@link Iterable} contains
@@ -886,10 +886,10 @@ public class CollectionUtils {
* collection.
*
* <p>
- * A <code>null</code> predicate returns false.
+ * A {@code null} predicate returns false.
* </p>
* <p>
- * A <code>null</code> or empty collection returns true.
+ * A {@code null} or empty collection returns true.
* </p>
*
* @param <C> the type of object the {@link Iterable} contains
@@ -909,7 +909,7 @@ public class CollectionUtils {
* Selects all elements from input collection which match the given
* predicate into an output collection.
* <p>
- * A <code>null</code> predicate matches no elements.
+ * A {@code null} predicate matches no elements.
* </p>
*
* @param <O> the type of object the {@link Iterable} contains
@@ -958,12 +958,12 @@ public class CollectionUtils {
* Selects all elements from inputCollection into an output and rejected collection,
* based on the evaluation of the given predicate.
* <p>
- * Elements matching the predicate are added to the <code>outputCollection</code>,
- * all other elements are added to the <code>rejectedCollection</code>.
+ * Elements matching the predicate are added to the {@code outputCollection},
+ * all other elements are added to the {@code rejectedCollection}.
* </p>
* <p>
- * If the input predicate is <code>null</code>, no elements are added to
- * <code>outputCollection</code> or <code>rejectedCollection</code>.
+ * If the input predicate is {@code null}, no elements are added to
+ * {@code outputCollection} or {@code rejectedCollection}.
* </p>
* <p>
* Note: calling the method is equivalent to the following code snippet:
@@ -1003,7 +1003,7 @@ public class CollectionUtils {
* Selects all elements from inputCollection which don't match the given
* predicate into an output collection.
* <p>
- * If the input predicate is <code>null</code>, the result is an empty
+ * If the input predicate is {@code null}, the result is an empty
* list.
* </p>
*
@@ -1024,8 +1024,8 @@ public class CollectionUtils {
* Selects all elements from inputCollection which don't match the given
* predicate and adds them to outputCollection.
* <p>
- * If the input predicate is <code>null</code>, no elements are added to
- * <code>outputCollection</code>.
+ * If the input predicate is {@code null}, no elements are added to
+ * {@code outputCollection}.
* </p>
*
* @param <O> the type of object the {@link Iterable} contains
@@ -1232,11 +1232,11 @@ public class CollectionUtils {
}
/**
- * Returns the <code>index</code>-th value in {@link Iterator}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code index}-th value in {@link Iterator}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* <p>
- * The Iterator is advanced to <code>index</code> (or to the end, if
- * <code>index</code> exceeds the number of entries) as a side effect of this method.
+ * The Iterator is advanced to {@code index} (or to the end, if
+ * {@code index} exceeds the number of entries) as a side effect of this method.
* </p>
*
* @param iterator the iterator to get a value from
@@ -1264,8 +1264,8 @@ public class CollectionUtils {
}
/**
- * Returns the <code>index</code>-th value in the <code>iterable</code>'s {@link Iterator}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code index}-th value in the {@code iterable}'s {@link Iterator}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* <p>
* If the {@link Iterable} is a {@link List}, then it will use {@link List#get(int)}.
* </p>
@@ -1283,27 +1283,27 @@ public class CollectionUtils {
}
/**
- * Returns the <code>index</code>-th value in <code>object</code>, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element or
- * <code>IllegalArgumentException</code> if <code>object</code> is not an
+ * Returns the {@code index}-th value in {@code object}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element or
+ * {@code IllegalArgumentException} if {@code object} is not an
* instance of one of the supported types.
* <p>
* The supported types, and associated semantics are:
* </p>
* <ul>
- * <li> Map -- the value returned is the <code>Map.Entry</code> in position
- * <code>index</code> in the map's <code>entrySet</code> iterator,
+ * <li> Map -- the value returned is the {@code Map.Entry} in position
+ * {@code index} in the map's {@code entrySet} iterator,
* if there is such an entry.</li>
* <li> List -- this method is equivalent to the list's get method.</li>
- * <li> Array -- the <code>index</code>-th array entry is returned,
- * if there is such an entry; otherwise an <code>IndexOutOfBoundsException</code>
+ * <li> Array -- the {@code index}-th array entry is returned,
+ * if there is such an entry; otherwise an {@code IndexOutOfBoundsException}
* is thrown.</li>
- * <li> Collection -- the value returned is the <code>index</code>-th object
+ * <li> Collection -- the value returned is the {@code index}-th object
* returned by the collection's default iterator, if there is such an element.</li>
* <li> Iterator or Enumeration -- the value returned is the
- * <code>index</code>-th object in the Iterator/Enumeration, if there
+ * {@code index}-th object in the Iterator/Enumeration, if there
* is such an element. The Iterator/Enumeration is advanced to
- * <code>index</code> (or to the end, if <code>index</code> exceeds the
+ * {@code index} (or to the end, if {@code index} exceeds the
* number of entries) as a side effect of this method.</li>
* </ul>
*
@@ -1345,8 +1345,8 @@ public class CollectionUtils {
}
/**
- * Returns the <code>index</code>-th <code>Map.Entry</code> in the <code>map</code>'s <code>entrySet</code>,
- * throwing <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code index}-th {@code Map.Entry} in the {@code map}'s {@code entrySet},
+ * throwing {@code IndexOutOfBoundsException} if there is no such element.
*
* @param <K> the key type in the {@link Map}
* @param <V> the key type in the {@link Map}
@@ -1708,25 +1708,25 @@ public class CollectionUtils {
//-----------------------------------------------------------------------
/**
- * Returns a collection containing all the elements in <code>collection</code>
- * that are also in <code>retain</code>. The cardinality of an element <code>e</code>
- * in the returned collection is the same as the cardinality of <code>e</code>
- * in <code>collection</code> unless <code>retain</code> does not contain <code>e</code>, in which
+ * Returns a collection containing all the elements in {@code collection}
+ * that are also in {@code retain}. The cardinality of an element {@code e}
+ * in the returned collection is the same as the cardinality of {@code e}
+ * in {@code collection} unless {@code retain} does not contain {@code e}, in which
* case the cardinality is zero. This method is useful if you do not wish to modify
- * the collection <code>c</code> and thus cannot call <code>c.retainAll(retain);</code>.
+ * the collection {@code c} and thus cannot call {@code c.retainAll(retain);}.
* <p>
- * This implementation iterates over <code>collection</code>, checking each element in
- * turn to see if it's contained in <code>retain</code>. If it's contained, it's added
+ * This implementation iterates over {@code collection}, checking each element in
+ * turn to see if it's contained in {@code retain}. If it's contained, it's added
* to the returned list. As a consequence, it is advised to use a collection type for
- * <code>retain</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code retain} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
* </p>
*
* @param <C> the type of object the {@link Collection} contains
* @param collection the collection whose contents are the target of the #retailAll operation
* @param retain the collection containing the elements to be retained in the returned collection
- * @return a <code>Collection</code> containing all the elements of <code>collection</code>
- * that occur at least once in <code>retain</code>.
+ * @return a {@code Collection} containing all the elements of {@code collection}
+ * that occur at least once in {@code retain}.
* @throws NullPointerException if either parameter is null
* @since 3.2
*/
@@ -1736,17 +1736,17 @@ public class CollectionUtils {
/**
* Returns a collection containing all the elements in
- * <code>collection</code> that are also in <code>retain</code>. The
- * cardinality of an element <code>e</code> in the returned collection is
- * the same as the cardinality of <code>e</code> in <code>collection</code>
- * unless <code>retain</code> does not contain <code>e</code>, in which case
+ * {@code collection} that are also in {@code retain}. The
+ * cardinality of an element {@code e} in the returned collection is
+ * the same as the cardinality of {@code e} in {@code collection}
+ * unless {@code retain} does not contain {@code e}, in which case
* the cardinality is zero. This method is useful if you do not wish to
- * modify the collection <code>c</code> and thus cannot call
- * <code>c.retainAll(retain);</code>.
+ * modify the collection {@code c} and thus cannot call
+ * {@code c.retainAll(retain);}.
* <p>
* Moreover this method uses an {@link Equator} instead of
* {@link Object#equals(Object)} to determine the equality of the elements
- * in <code>collection</code> and <code>retain</code>. Hence this method is
+ * in {@code collection} and {@code retain}. Hence this method is
* useful in cases where the equals behavior of an object needs to be
* modified without changing the object itself.
* </p>
@@ -1755,8 +1755,8 @@ public class CollectionUtils {
* @param collection the collection whose contents are the target of the {@code retainAll} operation
* @param retain the collection containing the elements to be retained in the returned collection
* @param equator the Equator used for testing equality
- * @return a <code>Collection</code> containing all the elements of <code>collection</code>
- * that occur at least once in <code>retain</code> according to the <code>equator</code>
+ * @return a {@code Collection} containing all the elements of {@code collection}
+ * that occur at least once in {@code retain} according to the {@code equator}
* @throws NullPointerException if any of the parameters is null
* @since 4.1
*/
@@ -1845,26 +1845,26 @@ public class CollectionUtils {
}
/**
- * Removes the elements in <code>remove</code> from <code>collection</code>. That is, this
- * method returns a collection containing all the elements in <code>c</code>
- * that are not in <code>remove</code>. The cardinality of an element <code>e</code>
- * in the returned collection is the same as the cardinality of <code>e</code>
- * in <code>collection</code> unless <code>remove</code> contains <code>e</code>, in which
+ * Removes the elements in {@code remove} from {@code collection}. That is, this
+ * method returns a collection containing all the elements in {@code c}
+ * that are not in {@code remove}. The cardinality of an element {@code e}
+ * in the returned collection is the same as the cardinality of {@code e}
+ * in {@code collection} unless {@code remove} contains {@code e}, in which
* case the cardinality is zero. This method is useful if you do not wish to modify
- * the collection <code>c</code> and thus cannot call <code>collection.removeAll(remove);</code>.
+ * the collection {@code c} and thus cannot call {@code collection.removeAll(remove);}.
* <p>
- * This implementation iterates over <code>collection</code>, checking each element in
- * turn to see if it's contained in <code>remove</code>. If it's not contained, it's added
+ * This implementation iterates over {@code collection}, checking each element in
+ * turn to see if it's contained in {@code remove}. If it's not contained, it's added
* to the returned list. As a consequence, it is advised to use a collection type for
- * <code>remove</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code remove} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
* </p>
*
* @param <E> the type of object the {@link Collection} contains
* @param collection the collection from which items are removed (in the returned collection)
- * @param remove the items to be removed from the returned <code>collection</code>
- * @return a <code>Collection</code> containing all the elements of <code>collection</code> except
- * any elements that also occur in <code>remove</code>.
+ * @param remove the items to be removed from the returned {@code collection}
+ * @return a {@code Collection} containing all the elements of {@code collection} except
+ * any elements that also occur in {@code remove}.
* @throws NullPointerException if either parameter is null
* @since 4.0 (method existed in 3.2 but was completely broken)
*/
@@ -1873,19 +1873,19 @@ public class CollectionUtils {
}
/**
- * Removes all elements in <code>remove</code> from <code>collection</code>.
+ * Removes all elements in {@code remove} from {@code collection}.
* That is, this method returns a collection containing all the elements in
- * <code>collection</code> that are not in <code>remove</code>. The
- * cardinality of an element <code>e</code> in the returned collection is
- * the same as the cardinality of <code>e</code> in <code>collection</code>
- * unless <code>remove</code> contains <code>e</code>, in which case the
+ * {@code collection} that are not in {@code remove}. The
+ * cardinality of an element {@code e} in the returned collection is
+ * the same as the cardinality of {@code e} in {@code collection}
+ * unless {@code remove} contains {@code e}, in which case the
* cardinality is zero. This method is useful if you do not wish to modify
- * the collection <code>c</code> and thus cannot call
- * <code>collection.removeAll(remove)</code>.
+ * the collection {@code c} and thus cannot call
+ * {@code collection.removeAll(remove)}.
* <p>
* Moreover this method uses an {@link Equator} instead of
* {@link Object#equals(Object)} to determine the equality of the elements
- * in <code>collection</code> and <code>remove</code>. Hence this method is
+ * in {@code collection} and {@code remove}. Hence this method is
* useful in cases where the equals behavior of an object needs to be
* modified without changing the object itself.
* </p>
@@ -1894,8 +1894,8 @@ public class CollectionUtils {
* @param collection the collection from which items are removed (in the returned collection)
* @param remove the items to be removed from the returned collection
* @param equator the Equator used for testing equality
- * @return a <code>Collection</code> containing all the elements of <code>collection</code>
- * except any element that if equal according to the <code>equator</code>
+ * @return a {@code Collection} containing all the elements of {@code collection}
+ * except any element that if equal according to the {@code equator}
* @throws NullPointerException if any of the parameters is null
* @since 4.1
*/
diff --git a/src/main/java/org/apache/commons/collections4/ComparatorUtils.java b/src/main/java/org/apache/commons/collections4/ComparatorUtils.java
index c5a3743..1459204 100644
--- a/src/main/java/org/apache/commons/collections4/ComparatorUtils.java
+++ b/src/main/java/org/apache/commons/collections4/ComparatorUtils.java
@@ -32,9 +32,9 @@ import org.apache.commons.collections4.comparators.TransformingComparator;
* objects.
* <p>
* Most of the functionality in this class can also be found in the
- * <code>comparators</code> package. This class merely provides a
+ * {@code comparators} package. This class merely provides a
* convenient central place if you have use for more than one class
- * in the <code>comparators</code> subpackage.
+ * in the {@code comparators} subpackage.
* </p>
*
* @since 2.1
@@ -123,9 +123,9 @@ public class ComparatorUtils {
* The comparator throws NullPointerException if a null value is compared.
* </p>
*
- * @param trueFirst when <code>true</code>, sort
- * <code>true</code> {@link Boolean}s before
- * <code>false</code> {@link Boolean}s.
+ * @param trueFirst when {@code true}, sort
+ * {@code true} {@link Boolean}s before
+ * {@code false} {@link Boolean}s.
* @return a comparator that sorts booleans
*/
public static Comparator<Boolean> booleanComparator(final boolean trueFirst) {
@@ -133,7 +133,7 @@ public class ComparatorUtils {
}
/**
- * Gets a Comparator that controls the comparison of <code>null</code> values.
+ * Gets a Comparator that controls the comparison of {@code null} values.
* <p>
* The returned comparator will consider a null value to be less than
* any nonnull value, and equal to any other null value. Two nonnull
@@ -154,7 +154,7 @@ public class ComparatorUtils {
}
/**
- * Gets a Comparator that controls the comparison of <code>null</code> values.
+ * Gets a Comparator that controls the comparison of {@code null} values.
* <p>
* The returned comparator will consider a null value to be greater than
* any nonnull value, and equal to any other null value. Two nonnull
diff --git a/src/main/java/org/apache/commons/collections4/EnumerationUtils.java b/src/main/java/org/apache/commons/collections4/EnumerationUtils.java
index 9c5fabe..224ab53 100644
--- a/src/main/java/org/apache/commons/collections4/EnumerationUtils.java
+++ b/src/main/java/org/apache/commons/collections4/EnumerationUtils.java
@@ -36,11 +36,11 @@ public class EnumerationUtils {
private EnumerationUtils() {}
/**
- * Returns the <code>index</code>-th value in the {@link Enumeration}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code index}-th value in the {@link Enumeration}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* <p>
- * The Enumeration is advanced to <code>index</code> (or to the end, if
- * <code>index</code> exceeds the number of entries) as a side effect of this method.
+ * The Enumeration is advanced to {@code index} (or to the end, if
+ * {@code index} exceeds the number of entries) as a side effect of this method.
*
* @param e the enumeration to get a value from
* @param index the index to get
@@ -70,9 +70,9 @@ public class EnumerationUtils {
* created. The new list is returned.</p>
*
* @param <E> the element type
- * @param enumeration the enumeration to traverse, which should not be <code>null</code>.
+ * @param enumeration the enumeration to traverse, which should not be {@code null}.
* @return a list containing all elements of the given enumeration
- * @throws NullPointerException if the enumeration parameter is <code>null</code>.
+ * @throws NullPointerException if the enumeration parameter is {@code null}.
*/
public static <E> List<E> toList(final Enumeration<? extends E> enumeration) {
return IteratorUtils.toList(new EnumerationIterator<>(enumeration));
diff --git a/src/main/java/org/apache/commons/collections4/Factory.java b/src/main/java/org/apache/commons/collections4/Factory.java
index aa53e10..38f6fa7 100644
--- a/src/main/java/org/apache/commons/collections4/Factory.java
+++ b/src/main/java/org/apache/commons/collections4/Factory.java
@@ -19,7 +19,7 @@ package org.apache.commons.collections4;
/**
* Defines a functor interface implemented by classes that create objects.
* <p>
- * A <code>Factory</code> creates an object without using an input parameter.
+ * A {@code Factory} creates an object without using an input parameter.
* If an input parameter is required, then {@link Transformer} is more appropriate.
* </p>
* <p>
diff --git a/src/main/java/org/apache/commons/collections4/FactoryUtils.java b/src/main/java/org/apache/commons/collections4/FactoryUtils.java
index b181251..b0f3be8 100644
--- a/src/main/java/org/apache/commons/collections4/FactoryUtils.java
+++ b/src/main/java/org/apache/commons/collections4/FactoryUtils.java
@@ -22,7 +22,7 @@ import org.apache.commons.collections4.functors.InstantiateFactory;
import org.apache.commons.collections4.functors.PrototypeFactory;
/**
- * <code>FactoryUtils</code> provides reference implementations and utilities
+ * {@code FactoryUtils} provides reference implementations and utilities
* for the Factory functor interface. The supplied factories are:
* <ul>
* <li>Prototype - clones a specified object
@@ -83,7 +83,7 @@ public class FactoryUtils {
*
* @param <T> the type that the factory creates
* @param constantToReturn the constant object to return each time in the factory
- * @return the <code>constant</code> factory.
+ * @return the {@code constant} factory.
*/
public static <T> Factory<T> constantFactory(final T constantToReturn) {
return ConstantFactory.constantFactory(constantToReturn);
@@ -104,7 +104,7 @@ public class FactoryUtils {
*
* @param <T> the type that the factory creates
* @param prototype the object to clone each time in the factory
- * @return the <code>prototype</code> factory, or a {@link ConstantFactory#NULL_INSTANCE} if
+ * @return the {@code prototype} factory, or a {@link ConstantFactory#NULL_INSTANCE} if
* the {@code prototype} is {@code null}
* @throws IllegalArgumentException if the prototype cannot be cloned
*/
@@ -120,7 +120,7 @@ public class FactoryUtils {
*
* @param <T> the type that the factory creates
* @param classToInstantiate the Class to instantiate each time in the factory
- * @return the <code>reflection</code> factory
+ * @return the {@code reflection} factory
* @throws NullPointerException if the classToInstantiate is null
*/
public static <T> Factory<T> instantiateFactory(final Class<T> classToInstantiate) {
@@ -137,7 +137,7 @@ public class FactoryUtils {
* @param classToInstantiate the Class to instantiate each time in the factory
* @param paramTypes parameter types for the constructor, can be null
* @param args the arguments to pass to the constructor, can be null
- * @return the <code>reflection</code> factory
+ * @return the {@code reflection} factory
* @throws NullPointerException if the classToInstantiate is null
* @throws IllegalArgumentException if the paramTypes and args don't match
* @throws IllegalArgumentException if the constructor doesn't exist
diff --git a/src/main/java/org/apache/commons/collections4/FluentIterable.java b/src/main/java/org/apache/commons/collections4/FluentIterable.java
index 0bf1dbb..53f57a9 100644
--- a/src/main/java/org/apache/commons/collections4/FluentIterable.java
+++ b/src/main/java/org/apache/commons/collections4/FluentIterable.java
@@ -380,7 +380,7 @@ public class FluentIterable<E> implements Iterable<E> {
* Checks if all elements contained in this iterable are matching the
* provided predicate.
* <p>
- * A <code>null</code> or empty iterable returns true.
+ * A {@code null} or empty iterable returns true.
*
* @param predicate the predicate to use, may not be null
* @return true if all elements contained in this iterable match the predicate,
@@ -394,7 +394,7 @@ public class FluentIterable<E> implements Iterable<E> {
/**
* Checks if this iterable contains any element matching the provided predicate.
* <p>
- * A <code>null</code> or empty iterable returns false.
+ * A {@code null} or empty iterable returns false.
*
* @param predicate the predicate to use, may not be null
* @return true if at least one element contained in this iterable matches the predicate,
diff --git a/src/main/java/org/apache/commons/collections4/FunctorException.java b/src/main/java/org/apache/commons/collections4/FunctorException.java
index a61d47b..8b8db71 100644
--- a/src/main/java/org/apache/commons/collections4/FunctorException.java
+++ b/src/main/java/org/apache/commons/collections4/FunctorException.java
@@ -28,7 +28,7 @@ public class FunctorException extends RuntimeException {
private static final long serialVersionUID = -4704772662059351193L;
/**
- * Constructs a new <code>FunctorException</code> without specified
+ * Constructs a new {@code FunctorException} without specified
* detail message.
*/
public FunctorException() {
@@ -36,7 +36,7 @@ public class FunctorException extends RuntimeException {
}
/**
- * Constructs a new <code>FunctorException</code> with specified
+ * Constructs a new {@code FunctorException} with specified
* detail message.
*
* @param msg the error message.
@@ -46,8 +46,8 @@ public class FunctorException extends RuntimeException {
}
/**
- * Constructs a new <code>FunctorException</code> with specified
- * nested <code>Throwable</code> root cause.
+ * Constructs a new {@code FunctorException} with specified
+ * nested {@code Throwable} root cause.
*
* @param rootCause the exception or error that caused this exception
* to be thrown.
@@ -57,8 +57,8 @@ public class FunctorException extends RuntimeException {
}
/**
- * Constructs a new <code>FunctorException</code> with specified
- * detail message and nested <code>Throwable</code> root cause.
+ * Constructs a new {@code FunctorException} with specified
+ * detail message and nested {@code Throwable} root cause.
*
* @param msg the error message.
* @param rootCause the exception or error that caused this exception
diff --git a/src/main/java/org/apache/commons/collections4/Get.java b/src/main/java/org/apache/commons/collections4/Get.java
index 1892da8..5c590e7 100644
--- a/src/main/java/org/apache/commons/collections4/Get.java
+++ b/src/main/java/org/apache/commons/collections4/Get.java
@@ -32,7 +32,7 @@ public interface Get<K, V> {
/**
* @param key key whose presence in this map is to be tested
- * @return <code>true</code> if this map contains a mapping for the specified
+ * @return {@code true} if this map contains a mapping for the specified
* key
* @see java.util.Map#containsKey(Object)
*/
@@ -40,7 +40,7 @@ public interface Get<K, V> {
/**
* @param value value whose presence in this map is to be tested
- * @return <code>true</code> if this map maps one or more keys to the
+ * @return {@code true} if this map maps one or more keys to the
* specified value
* @see java.util.Map#containsValue(Object)
*/
@@ -62,14 +62,14 @@ public interface Get<K, V> {
/**
* @param key key whose mapping is to be removed from the map
- * @return the previous value associated with <code>key</code>, or
- * <code>null</code> if there was no mapping for <code>key</code>.
+ * @return the previous value associated with {@code key}, or
+ * {@code null} if there was no mapping for {@code key}.
* @see java.util.Map#remove(Object)
*/
V remove(Object key);
/**
- * @return <code>true</code> if this map contains no key-value mappings
+ * @return {@code true} if this map contains no key-value mappings
* @see java.util.Map#isEmpty()
*/
boolean isEmpty();
diff --git a/src/main/java/org/apache/commons/collections4/IterableGet.java b/src/main/java/org/apache/commons/collections4/IterableGet.java
index e7012fd..39b7bca 100644
--- a/src/main/java/org/apache/commons/collections4/IterableGet.java
+++ b/src/main/java/org/apache/commons/collections4/IterableGet.java
@@ -27,7 +27,7 @@ package org.apache.commons.collections4;
*/
public interface IterableGet<K, V> extends Get<K, V> {
/**
- * Obtains a <code>MapIterator</code> over the map.
+ * Obtains a {@code MapIterator} over the map.
* <p>
* A map iterator is an efficient way of iterating over maps.
* There is no need to access the entry set or use Map Entry objects.
diff --git a/src/main/java/org/apache/commons/collections4/IterableUtils.java b/src/main/java/org/apache/commons/collections4/IterableUtils.java
index cce857c..0e3bcb4 100644
--- a/src/main/java/org/apache/commons/collections4/IterableUtils.java
+++ b/src/main/java/org/apache/commons/collections4/IterableUtils.java
@@ -599,7 +599,7 @@ public class IterableUtils {
/**
* Finds the first element in the given iterable which matches the given predicate.
* <p>
- * A <code>null</code> or empty iterator returns null.
+ * A {@code null} or empty iterator returns null.
*
* @param <E> the element type
* @param iterable the iterable to search, may be null
@@ -615,7 +615,7 @@ public class IterableUtils {
* Returns the index of the first element in the specified iterable that
* matches the given predicate.
* <p>
- * A <code>null</code> or empty iterable returns -1.
+ * A {@code null} or empty iterable returns -1.
*
* @param <E> the element type
* @param iterable the iterable to search, may be null
@@ -630,7 +630,7 @@ public class IterableUtils {
/**
* Answers true if a predicate is true for every element of an iterable.
* <p>
- * A <code>null</code> or empty iterable returns true.
+ * A {@code null} or empty iterable returns true.
*
* @param <E> the type of object the {@link Iterable} contains
* @param iterable the {@link Iterable} to use, may be null
@@ -646,7 +646,7 @@ public class IterableUtils {
/**
* Answers true if a predicate is true for any element of the iterable.
* <p>
- * A <code>null</code> or empty iterable returns false.
+ * A {@code null} or empty iterable returns false.
*
* @param <E> the type of object the {@link Iterable} contains
* @param iterable the {@link Iterable} to use, may be null
@@ -661,7 +661,7 @@ public class IterableUtils {
/**
* Counts the number of elements in the input iterable that match the predicate.
* <p>
- * A <code>null</code> iterable matches no elements.
+ * A {@code null} iterable matches no elements.
*
* @param <E> the type of object the {@link Iterable} contains
* @param input the {@link Iterable} to get the input from, may be null
@@ -677,7 +677,7 @@ public class IterableUtils {
/**
* Answers true if the provided iterable is empty.
* <p>
- * A <code>null</code> iterable returns true.
+ * A {@code null} iterable returns true.
*
* @param iterable the {@link Iterable to use}, may be null
* @return true if the iterable is null or empty, false otherwise
@@ -692,7 +692,7 @@ public class IterableUtils {
/**
* Checks if the object is contained in the given iterable.
* <p>
- * A <code>null</code> or empty iterable returns false.
+ * A {@code null} or empty iterable returns false.
*
* @param <E> the type of object the {@link Iterable} contains
* @param iterable the iterable to check, may be null
@@ -711,8 +711,8 @@ public class IterableUtils {
* is tested with an {@code equator} unlike {@link #contains(Iterable, Object)}
* which uses {@link Object#equals(Object)}.
* <p>
- * A <code>null</code> or empty iterable returns false.
- * A <code>null</code> object will not be passed to the equator, instead a
+ * A {@code null} or empty iterable returns false.
+ * A {@code null} object will not be passed to the equator, instead a
* {@link org.apache.commons.collections4.functors.NullPredicate NullPredicate}
* will be used.
*
@@ -749,8 +749,8 @@ public class IterableUtils {
}
/**
- * Returns the <code>index</code>-th value in the <code>iterable</code>'s {@link Iterator}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code index}-th value in the {@code iterable}'s {@link Iterator}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* <p>
* If the {@link Iterable} is a {@link List}, then it will use {@link List#get(int)}.
*
@@ -771,8 +771,8 @@ public class IterableUtils {
/**
* Shortcut for {@code get(iterator, 0)}.
* <p>
- * Returns the <code>first</code> value in the <code>iterable</code>'s {@link Iterator}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code first} value in the {@code iterable}'s {@link Iterator}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* </p>
* <p>
* If the {@link Iterable} is a {@link List}, then it will use {@link List#get(int)}.
@@ -791,7 +791,7 @@ public class IterableUtils {
/**
* Returns the number of elements contained in the given iterator.
* <p>
- * A <code>null</code> or empty iterator returns {@code 0}.
+ * A {@code null} or empty iterator returns {@code 0}.
*
* @param iterable the iterable to check, may be null
* @return the number of elements contained in the iterable
@@ -818,7 +818,7 @@ public class IterableUtils {
* R = collection of elements rejected by all predicates
* </pre>
* <p>
- * If the input iterable is <code>null</code>, the same is returned as for an
+ * If the input iterable is {@code null}, the same is returned as for an
* empty iterable.
* <p>
* Example: for an input list [1, 2, 3, 4, 5] calling partition with a predicate [x < 3]
@@ -860,7 +860,7 @@ public class IterableUtils {
* <b>Note</b>: elements are only added to the output collection of the first matching
* predicate, determined by the order of arguments.
* <p>
- * If the input iterable is <code>null</code>, the same is returned as for an
+ * If the input iterable is {@code null}, the same is returned as for an
* empty iterable.
* <p>
* Example: for an input list [1, 2, 3, 4, 5] calling partition with predicates [x < 3]
@@ -900,7 +900,7 @@ public class IterableUtils {
* <b>Note</b>: elements are only added to the output collection of the first matching
* predicate, determined by the order of arguments.
* <p>
- * If the input iterable is <code>null</code>, the same is returned as for an
+ * If the input iterable is {@code null}, the same is returned as for an
* empty iterable.
* If no predicates have been provided, all elements of the input collection
* will be added to the rejected collection.
@@ -1069,12 +1069,12 @@ public class IterableUtils {
}
/**
- * Returns an empty iterator if the argument is <code>null</code>,
+ * Returns an empty iterator if the argument is {@code null},
* or {@code iterable.iterator()} otherwise.
*
* @param <E> the element type
- * @param iterable the iterable, possibly <code>null</code>
- * @return an empty iterator if the argument is <code>null</code>
+ * @param iterable the iterable, possibly {@code null}
+ * @return an empty iterator if the argument is {@code null}
*/
private static <E> Iterator<E> emptyIteratorIfNull(final Iterable<E> iterable) {
return iterable != null ? iterable.iterator() : IteratorUtils.<E>emptyIterator();
diff --git a/src/main/java/org/apache/commons/collections4/IteratorUtils.java b/src/main/java/org/apache/commons/collections4/IteratorUtils.java
index d22b0e9..29296a9 100644
--- a/src/main/java/org/apache/commons/collections4/IteratorUtils.java
+++ b/src/main/java/org/apache/commons/collections4/IteratorUtils.java
@@ -556,9 +556,9 @@ public class IteratorUtils {
* Gets an iterator that provides an ordered iteration over the elements
* contained in a collection of ordered {@link Iterator}s.
* <p>
- * Given two ordered {@link Iterator}s <code>A</code> and <code>B</code>,
+ * Given two ordered {@link Iterator}s {@code A} and {@code B},
* the {@link Iterator#next()} method will return the lesser of
- * <code>A.next()</code> and <code>B.next()</code>.
+ * {@code A.next()} and {@code B.next()}.
* <p>
* The comparator is optional. If null is specified then natural order is used.
*
@@ -582,9 +582,9 @@ public class IteratorUtils {
* Gets an iterator that provides an ordered iteration over the elements
* contained in an array of {@link Iterator}s.
* <p>
- * Given two ordered {@link Iterator}s <code>A</code> and <code>B</code>,
+ * Given two ordered {@link Iterator}s {@code A} and {@code B},
* the {@link Iterator#next()} method will return the lesser of
- * <code>A.next()</code> and <code>B.next()</code> and so on.
+ * {@code A.next()} and {@code B.next()} and so on.
* <p>
* The comparator is optional. If null is specified then natural order is used.
*
@@ -606,9 +606,9 @@ public class IteratorUtils {
* Gets an iterator that provides an ordered iteration over the elements
* contained in a collection of {@link Iterator}s.
* <p>
- * Given two ordered {@link Iterator}s <code>A</code> and <code>B</code>,
+ * Given two ordered {@link Iterator}s {@code A} and {@code B},
* the {@link Iterator#next()} method will return the lesser of
- * <code>A.next()</code> and <code>B.next()</code> and so on.
+ * {@code A.next()} and {@code B.next()} and so on.
* <p>
* The comparator is optional. If null is specified then natural order is used.
*
@@ -634,8 +634,8 @@ public class IteratorUtils {
* <p>
* This iterator can extract multiple objects from a complex tree-like object graph.
* The iteration starts from a single root object.
- * It uses a <code>Transformer</code> to extract the iterators and elements.
- * Its main benefit is that no intermediate <code>List</code> is created.
+ * It uses a {@code Transformer} to extract the iterators and elements.
+ * Its main benefit is that no intermediate {@code List} is created.
* <p>
* For example, consider an object graph:
* <pre>
@@ -649,7 +649,7 @@ public class IteratorUtils {
* |- Tree | /- Leaf
* |- Branch -- Leaf
* |- Branch -- Leaf</pre>
- * The following <code>Transformer</code>, used in this class, will extract all
+ * The following {@code Transformer}, used in this class, will extract all
* the Leaf objects without creating a combined intermediate list:
* <pre>
* public Object transform(Object input) {
@@ -1207,7 +1207,7 @@ public class IteratorUtils {
/**
* Finds the first element in the given iterator which matches the given predicate.
* <p>
- * A <code>null</code> or empty iterator returns null.
+ * A {@code null} or empty iterator returns null.
*
* @param <E> the element type
* @param iterator the iterator to search, may be null
@@ -1234,7 +1234,7 @@ public class IteratorUtils {
* Returns the index of the first element in the specified iterator that
* matches the given predicate.
* <p>
- * A <code>null</code> or empty iterator returns -1.
+ * A {@code null} or empty iterator returns -1.
*
* @param <E> the element type
* @param iterator the iterator to search, may be null
@@ -1260,7 +1260,7 @@ public class IteratorUtils {
/**
* Answers true if a predicate is true for any element of the iterator.
* <p>
- * A <code>null</code> or empty iterator returns false.
+ * A {@code null} or empty iterator returns false.
*
* @param <E> the type of object the {@link Iterator} contains
* @param iterator the {@link Iterator} to use, may be null
@@ -1276,7 +1276,7 @@ public class IteratorUtils {
/**
* Answers true if a predicate is true for every element of an iterator.
* <p>
- * A <code>null</code> or empty iterator returns true.
+ * A {@code null} or empty iterator returns true.
*
* @param <E> the type of object the {@link Iterator} contains
* @param iterator the {@link Iterator} to use, may be null
@@ -1303,7 +1303,7 @@ public class IteratorUtils {
/**
* Checks if the given iterator is empty.
* <p>
- * A <code>null</code> or empty iterator returns true.
+ * A {@code null} or empty iterator returns true.
*
* @param iterator the {@link Iterator} to use, may be null
* @return true if the iterator is exhausted or null, false otherwise
@@ -1316,7 +1316,7 @@ public class IteratorUtils {
/**
* Checks if the object is contained in the given iterator.
* <p>
- * A <code>null</code> or empty iterator returns false.
+ * A {@code null} or empty iterator returns false.
*
* @param <E> the type of object the {@link Iterator} contains
* @param iterator the iterator to check, may be null
@@ -1329,11 +1329,11 @@ public class IteratorUtils {
}
/**
- * Returns the <code>index</code>-th value in {@link Iterator}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code index}-th value in {@link Iterator}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* <p>
- * The Iterator is advanced to <code>index</code> (or to the end, if
- * <code>index</code> exceeds the number of entries) as a side effect of this method.
+ * The Iterator is advanced to {@code index} (or to the end, if
+ * {@code index} exceeds the number of entries) as a side effect of this method.
*
* @param <E> the type of object in the {@link Iterator}
* @param iterator the iterator to get a value from
@@ -1358,12 +1358,12 @@ public class IteratorUtils {
/**
* Shortcut for {@code get(iterator, 0)}.
* <p>
- * Returns the <code>first</code> value in {@link Iterator}, throwing
- * <code>IndexOutOfBoundsException</code> if there is no such element.
+ * Returns the {@code first} value in {@link Iterator}, throwing
+ * {@code IndexOutOfBoundsException} if there is no such element.
* </p>
* <p>
- * The Iterator is advanced to <code>0</code> (or to the end, if
- * <code>0</code> exceeds the number of entries) as a side effect of this method.
+ * The Iterator is advanced to {@code 0} (or to the end, if
+ * {@code 0} exceeds the number of entries) as a side effect of this method.
* </p>
* @param <E> the type of object in the {@link Iterator}
* @param iterator the iterator to get a value from
@@ -1378,7 +1378,7 @@ public class IteratorUtils {
/**
* Returns the number of elements contained in the given iterator.
* <p>
- * A <code>null</code> or empty iterator returns {@code 0}.
+ * A {@code null} or empty iterator returns {@code 0}.
*
* @param iterator the iterator to check, may be null
* @return the number of elements contained in the iterator
diff --git a/src/main/java/org/apache/commons/collections4/ListUtils.java b/src/main/java/org/apache/commons/collections4/ListUtils.java
index 493aefd..3073e4d 100644
--- a/src/main/java/org/apache/commons/collections4/ListUtils.java
+++ b/src/main/java/org/apache/commons/collections4/ListUtils.java
@@ -44,19 +44,19 @@ import org.apache.commons.collections4.sequence.SequencesComparator;
public class ListUtils {
/**
- * <code>ListUtils</code> should not normally be instantiated.
+ * {@code ListUtils} should not normally be instantiated.
*/
private ListUtils() {}
//-----------------------------------------------------------------------
/**
- * Returns an immutable empty list if the argument is <code>null</code>,
+ * Returns an immutable empty list if the argument is {@code null},
* or the argument itself otherwise.
*
* @param <T> the element type
- * @param list the list, possibly <code>null</code>
- * @return an empty list if the argument is <code>null</code>
+ * @param list the list, possibly {@code null}
+ * @return an empty list if the argument is {@code null}
*/
public static <T> List<T> emptyIfNull(final List<T> list) {
return list == null ? Collections.<T>emptyList() : list;
@@ -69,7 +69,7 @@ public class ListUtils {
* @param <T> the element type
* @param list the list, possibly {@code null}
* @param defaultList the returned values if list is {@code null}
- * @return an empty list if the argument is <code>null</code>
+ * @return an empty list if the argument is {@code null}
* @since 4.0
*/
public static <T> List<T> defaultIfNull(final List<T> list, final List<T> defaultList) {
@@ -170,7 +170,7 @@ public class ListUtils {
* Selects all elements from input collection which match the given
* predicate into an output list.
* <p>
- * A <code>null</code> predicate matches no elements.
+ * A {@code null} predicate matches no elements.
*
* @param <E> the element type
* @param inputCollection the collection to get the input from, may not be null
@@ -190,7 +190,7 @@ public class ListUtils {
* Selects all elements from inputCollection which don't match the given
* predicate into an output collection.
* <p>
- * If the input predicate is <code>null</code>, the result is an empty list.
+ * If the input predicate is {@code null}, the result is an empty list.
*
* @param <E> the element type
* @param inputCollection the collection to get the input from, may not be null
@@ -210,7 +210,7 @@ public class ListUtils {
* Tests two lists for value-equality as per the equality contract in
* {@link java.util.List#equals(java.lang.Object)}.
* <p>
- * This method is useful for implementing <code>List</code> when you cannot
+ * This method is useful for implementing {@code List} when you cannot
* extend AbstractList. The method takes Collection instances to enable other
* collection types to use the List implementation algorithm.
* <p>
@@ -264,7 +264,7 @@ public class ListUtils {
* Generates a hash code using the algorithm specified in
* {@link java.util.List#hashCode()}.
* <p>
- * This method is useful for implementing <code>List</code> when you cannot
+ * This method is useful for implementing {@code List} when you cannot
* extend AbstractList. The method takes Collection instances to enable other
* collection types to use the List implementation algorithm.
*
@@ -288,24 +288,24 @@ public class ListUtils {
//-----------------------------------------------------------------------
/**
- * Returns a List containing all the elements in <code>collection</code>
- * that are also in <code>retain</code>. The cardinality of an element <code>e</code>
- * in the returned list is the same as the cardinality of <code>e</code>
- * in <code>collection</code> unless <code>retain</code> does not contain <code>e</code>, in which
+ * Returns a List containing all the elements in {@code collection}
+ * that are also in {@code retain}. The cardinality of an element {@code e}
+ * in the returned list is the same as the cardinality of {@code e}
+ * in {@code collection} unless {@code retain} does not contain {@code e}, in which
* case the cardinality is zero. This method is useful if you do not wish to modify
- * the collection <code>c</code> and thus cannot call <code>collection.retainAll(retain);</code>.
+ * the collection {@code c} and thus cannot call {@code collection.retainAll(retain);}.
* <p>
- * This implementation iterates over <code>collection</code>, checking each element in
- * turn to see if it's contained in <code>retain</code>. If it's contained, it's added
+ * This implementation iterates over {@code collection}, checking each element in
+ * turn to see if it's contained in {@code retain}. If it's contained, it's added
* to the returned list. As a consequence, it is advised to use a collection type for
- * <code>retain</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code retain} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
*
* @param <E> the element type
* @param collection the collection whose contents are the target of the #retailAll operation
* @param retain the collection containing the elements to be retained in the returned collection
- * @return a <code>List</code> containing all the elements of <code>c</code>
- * that occur at least once in <code>retain</code>.
+ * @return a {@code List} containing all the elements of {@code c}
+ * that occur at least once in {@code retain}.
* @throws NullPointerException if either parameter is null
* @since 3.2
*/
@@ -321,25 +321,25 @@ public class ListUtils {
}
/**
- * Removes the elements in <code>remove</code> from <code>collection</code>. That is, this
- * method returns a list containing all the elements in <code>collection</code>
- * that are not in <code>remove</code>. The cardinality of an element <code>e</code>
- * in the returned collection is the same as the cardinality of <code>e</code>
- * in <code>collection</code> unless <code>remove</code> contains <code>e</code>, in which
+ * Removes the elements in {@code remove} from {@code collection}. That is, this
+ * method returns a list containing all the elements in {@code collection}
+ * that are not in {@code remove}. The cardinality of an element {@code e}
+ * in the returned collection is the same as the cardinality of {@code e}
+ * in {@code collection} unless {@code remove} contains {@code e}, in which
* case the cardinality is zero. This method is useful if you do not wish to modify
- * <code>collection</code> and thus cannot call <code>collection.removeAll(remove);</code>.
+ * {@code collection} and thus cannot call {@code collection.removeAll(remove);}.
* <p>
- * This implementation iterates over <code>collection</code>, checking each element in
- * turn to see if it's contained in <code>remove</code>. If it's not contained, it's added
+ * This implementation iterates over {@code collection}, checking each element in
+ * turn to see if it's contained in {@code remove}. If it's not contained, it's added
* to the returned list. As a consequence, it is advised to use a collection type for
- * <code>remove</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code remove} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
*
* @param <E> the element type
* @param collection the collection from which items are removed (in the returned collection)
- * @param remove the items to be removed from the returned <code>collection</code>
- * @return a <code>List</code> containing all the elements of <code>c</code> except
- * any elements that also occur in <code>remove</code>.
+ * @param remove the items to be removed from the returned {@code collection}
+ * @return a {@code List} containing all the elements of {@code c} except
+ * any elements that also occur in {@code remove}.
* @throws NullPointerException if either parameter is null
* @since 3.2
*/
@@ -457,10 +457,10 @@ public class ListUtils {
* Date date = lazy.get(3);
* </pre>
*
- * After the above code is executed, <code>date</code> will refer to
- * a new <code>Date</code> instance. Furthermore, that <code>Date</code>
+ * After the above code is executed, {@code date} will refer to
+ * a new {@code Date} instance. Furthermore, that {@code Date}
* instance is the fourth element in the list. The first, second,
- * and third element are all set to <code>null</code>.
+ * and third element are all set to {@code null}.
*
* @param <E> the element type
* @param list the list to make lazy, must not be null
@@ -488,10 +488,10 @@ public class ListUtils {
* Date date = lazy.get(3);
* </pre>
*
- * After the above code is executed, <code>date</code> will refer to
- * a new <code>Date</code> instance. Furthermore, that <code>Date</code>
+ * After the above code is executed, {@code date} will refer to
+ * a new {@code Date} instance. Furthermore, that {@code Date}
* instance is the fourth element in the list. The first, second,
- * and third element are all set to <code>null</code>.
+ * and third element are all set to {@code null}.
*
* @param <E> the element type
* @param list the list to make lazy, must not be null
diff --git a/src/main/java/org/apache/commons/collections4/MapIterator.java b/src/main/java/org/apache/commons/collections4/MapIterator.java
index bc91158..7a86a5d 100644
--- a/src/main/java/org/apache/commons/collections4/MapIterator.java
+++ b/src/main/java/org/apache/commons/collections4/MapIterator.java
@@ -19,7 +19,7 @@ package org.apache.commons.collections4;
import java.util.Iterator;
/**
- * Defines an iterator that operates over a <code>Map</code>.
+ * Defines an iterator that operates over a {@code Map}.
* <p>
* This iterator is a special version designed for maps. It can be more
* efficient to use this rather than an entry set iterator where the option
@@ -31,8 +31,8 @@ import java.util.Iterator;
* </p>
* <p>
* In use, this iterator iterates through the keys in the map. After each call
- * to <code>next()</code>, the <code>getValue()</code> method provides direct
- * access to the value. The value can also be set using <code>setValue()</code>.
+ * to {@code next()}, the {@code getValue()} method provides direct
+ * access to the value. The value can also be set using {@code setValue()}.
* </p>
* <pre>{@code
* MapIterator<String,Integer> it = map.mapIterator();
@@ -52,13 +52,13 @@ public interface MapIterator<K, V> extends Iterator<K> {
/**
* Checks to see if there are more entries still to be iterated.
*
- * @return <code>true</code> if the iterator has more elements
+ * @return {@code true} if the iterator has more elements
*/
@Override
boolean hasNext();
/**
- * Gets the next <em>key</em> from the <code>Map</code>.
+ * Gets the next <em>key</em> from the {@code Map}.
*
* @return the next key in the iteration
* @throws java.util.NoSuchElementException if the iteration is finished
@@ -69,32 +69,32 @@ public interface MapIterator<K, V> extends Iterator<K> {
//-----------------------------------------------------------------------
/**
* Gets the current key, which is the key returned by the last call
- * to <code>next()</code>.
+ * to {@code next()}.
*
* @return the current key
- * @throws IllegalStateException if <code>next()</code> has not yet been called
+ * @throws IllegalStateException if {@code next()} has not yet been called
*/
K getKey();
/**
* Gets the current value, which is the value associated with the last key
- * returned by <code>next()</code>.
+ * returned by {@code next()}.
*
* @return the current value
- * @throws IllegalStateException if <code>next()</code> has not yet been called
+ * @throws IllegalStateException if {@code next()} has not yet been called
*/
V getValue();
//-----------------------------------------------------------------------
/**
- * Removes the last returned key from the underlying <code>Map</code> (optional operation).
+ * Removes the last returned key from the underlying {@code Map} (optional operation).
* <p>
- * This method can be called once per call to <code>next()</code>.
+ * This method can be called once per call to {@code next()}.
*
* @throws UnsupportedOperationException if remove is not supported by the map
- * @throws IllegalStateException if <code>next()</code> has not yet been called
- * @throws IllegalStateException if <code>remove()</code> has already been called
- * since the last call to <code>next()</code>
+ * @throws IllegalStateException if {@code next()} has not yet been called
+ * @throws IllegalStateException if {@code remove()} has already been called
+ * since the last call to {@code next()}
*/
@Override
void remove();
@@ -105,9 +105,9 @@ public interface MapIterator<K, V> extends Iterator<K> {
* @param value the new value
* @return the previous value
* @throws UnsupportedOperationException if setValue is not supported by the map
- * @throws IllegalStateException if <code>next()</code> has not yet been called
- * @throws IllegalStateException if <code>remove()</code> has been called since the
- * last call to <code>next()</code>
+ * @throws IllegalStateException if {@code next()} has not yet been called
+ * @throws IllegalStateException if {@code remove()} has been called since the
+ * last call to {@code next()}
*/
V setValue(V value);
diff --git a/src/main/java/org/apache/commons/collections4/MapUtils.java b/src/main/java/org/apache/commons/collections4/MapUtils.java
index 2570d20..b89c404 100644
--- a/src/main/java/org/apache/commons/collections4/MapUtils.java
+++ b/src/main/java/org/apache/commons/collections4/MapUtils.java
@@ -161,22 +161,22 @@ public class MapUtils {
* </p>
*
* @param out the stream to print to, must not be null
- * @param label The label to be used, may be <code>null</code>. If <code>null</code>, the label is not output. It
+ * @param label The label to be used, may be {@code null}. If {@code null}, the label is not output. It
* typically represents the name of the property in a bean or similar.
- * @param map The map to print, may be <code>null</code>. If <code>null</code>, the text 'null' is output.
- * @throws NullPointerException if the stream is <code>null</code>
+ * @param map The map to print, may be {@code null}. If {@code null}, the text 'null' is output.
+ * @throws NullPointerException if the stream is {@code null}
*/
public static void debugPrint(final PrintStream out, final Object label, final Map<?, ?> map) {
verbosePrintInternal(out, label, map, new ArrayDeque<Map<?, ?>>(), true);
}
/**
- * Returns an immutable empty map if the argument is <code>null</code>, or the argument itself otherwise.
+ * Returns an immutable empty map if the argument is {@code null}, or the argument itself otherwise.
*
* @param <K> the key type
* @param <V> the value type
- * @param map the map, possibly <code>null</code>
- * @return an empty map if the argument is <code>null</code>
+ * @param map the map, possibly {@code null}
+ * @return an empty map if the argument is {@code null}
*/
public static <K, V> Map<K, V> emptyIfNull(final Map<K, V> map) {
return map == null ? Collections.<K, V>emptyMap() : map;
@@ -213,15 +213,15 @@ public class MapUtils {
/**
* Gets a Boolean from a Map in a null-safe manner.
* <p>
- * If the value is a <code>Boolean</code> it is returned directly. If the value is a <code>String</code> and it
- * equals 'true' ignoring case then <code>true</code> is returned, otherwise <code>false</code>. If the value is a
- * <code>Number</code> an integer zero value returns <code>false</code> and non-zero returns <code>true</code>.
- * Otherwise, <code>null</code> is returned.
+ * If the value is a {@code Boolean} it is returned directly. If the value is a {@code String} and it
+ * equals 'true' ignoring case then {@code true} is returned, otherwise {@code false}. If the value is a
+ * {@code Number} an integer zero value returns {@code false} and non-zero returns {@code true}.
+ * Otherwise, {@code null} is returned.
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Boolean, <code>null</code> if null map input
+ * @return the value in the Map as a Boolean, {@code null} if null map input
*/
public static <K> Boolean getBoolean(final Map<? super K, ?> map, final K key) {
if (map != null) {
@@ -279,16 +279,16 @@ public class MapUtils {
/**
* Gets a boolean from a Map in a null-safe manner.
* <p>
- * If the value is a <code>Boolean</code> its value is returned. If the value is a <code>String</code> and it equals
- * 'true' ignoring case then <code>true</code> is returned, otherwise <code>false</code>. If the value is a
- * <code>Number</code> an integer zero value returns <code>false</code> and non-zero returns <code>true</code>.
- * Otherwise, <code>false</code> is returned.
+ * If the value is a {@code Boolean} its value is returned. If the value is a {@code String} and it equals
+ * 'true' ignoring case then {@code true} is returned, otherwise {@code false}. If the value is a
+ * {@code Number} an integer zero value returns {@code false} and non-zero returns {@code true}.
+ * Otherwise, {@code false} is returned.
* </p>
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Boolean, <code>false</code> if null map input
+ * @return the value in the Map as a Boolean, {@code false} if null map input
*/
public static <K> boolean getBooleanValue(final Map<? super K, ?> map, final K key) {
return Boolean.TRUE.equals(getBoolean(map, key));
@@ -299,17 +299,17 @@ public class MapUtils {
/**
* Gets a boolean from a Map in a null-safe manner, using the default value if the conversion fails.
* <p>
- * If the value is a <code>Boolean</code> its value is returned. If the value is a <code>String</code> and it equals
- * 'true' ignoring case then <code>true</code> is returned, otherwise <code>false</code>. If the value is a
- * <code>Number</code> an integer zero value returns <code>false</code> and non-zero returns <code>true</code>.
- * Otherwise, <code>defaultValue</code> is returned.
+ * If the value is a {@code Boolean} its value is returned. If the value is a {@code String} and it equals
+ * 'true' ignoring case then {@code true} is returned, otherwise {@code false}. If the value is a
+ * {@code Number} an integer zero value returns {@code false} and non-zero returns {@code true}.
+ * Otherwise, {@code defaultValue} is returned.
* </p>
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as a Boolean, <code>defaultValue</code> if null map input
+ * @return the value in the Map as a Boolean, {@code defaultValue} if null map input
*/
public static <K> boolean getBooleanValue(final Map<? super K, ?> map, final K key, final boolean defaultValue) {
return applyDefaultValue(map, key, MapUtils::getBoolean, defaultValue).booleanValue();
@@ -319,17 +319,17 @@ public class MapUtils {
* Gets a boolean from a Map in a null-safe manner, using the default value produced by the defaultFunction if the
* conversion fails.
* <p>
- * If the value is a <code>Boolean</code> its value is returned. If the value is a <code>String</code> and it equals
- * 'true' ignoring case then <code>true</code> is returned, otherwise <code>false</code>. If the value is a
- * <code>Number</code> an integer zero value returns <code>false</code> and non-zero returns <code>true</code>.
- * Otherwise, defaultValue produced by the <code>defaultFunction</code> is returned.
+ * If the value is a {@code Boolean} its value is returned. If the value is a {@code String} and it equals
+ * 'true' ignoring case then {@code true} is returned, otherwise {@code false}. If the value is a
+ * {@code Number} an integer zero value returns {@code false} and non-zero returns {@code true}.
+ * Otherwise, defaultValue produced by the {@code defaultFunction} is returned.
* </p>
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as a Boolean, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as a Boolean, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -347,7 +347,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Byte, <code>null</code> if null map input
+ * @return the value in the Map as a Byte, {@code null} if null map input
*/
public static <K> Byte getByte(final Map<? super K, ?> map, final K key) {
final Number answer = getNumber(map, key);
@@ -400,7 +400,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a byte, <code>0</code> if null map input
+ * @return the value in the Map as a byte, {@code 0} if null map input
*/
public static <K> byte getByteValue(final Map<? super K, ?> map, final K key) {
return applyDefaultValue(map, key, MapUtils::getByte, 0).byteValue();
@@ -416,7 +416,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as a byte, <code>defaultValue</code> if null map input
+ * @return the value in the Map as a byte, {@code defaultValue} if null map input
*/
public static <K> byte getByteValue(final Map<? super K, ?> map, final K key, final byte defaultValue) {
return applyDefaultValue(map, key, MapUtils::getByte, defaultValue).byteValue();
@@ -433,7 +433,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as a byte, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as a byte, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -451,7 +451,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Double, <code>null</code> if null map input
+ * @return the value in the Map as a Double, {@code null} if null map input
*/
public static <K> Double getDouble(final Map<? super K, ?> map, final K key) {
final Number answer = getNumber(map, key);
@@ -505,7 +505,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a double, <code>0.0</code> if null map input
+ * @return the value in the Map as a double, {@code 0.0} if null map input
*/
public static <K> double getDoubleValue(final Map<? super K, ?> map, final K key) {
return applyDefaultValue(map, key, MapUtils::getDouble, 0d).doubleValue();
@@ -521,7 +521,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as a double, <code>defaultValue</code> if null map input
+ * @return the value in the Map as a double, {@code defaultValue} if null map input
*/
public static <K> double getDoubleValue(final Map<? super K, ?> map, final K key, final double defaultValue) {
return applyDefaultValue(map, key, MapUtils::getDouble, defaultValue).doubleValue();
@@ -538,7 +538,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as a double, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as a double, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -556,7 +556,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Float, <code>null</code> if null map input
+ * @return the value in the Map as a Float, {@code null} if null map input
*/
public static <K> Float getFloat(final Map<? super K, ?> map, final K key) {
final Number answer = getNumber(map, key);
@@ -610,7 +610,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a float, <code>0.0F</code> if null map input
+ * @return the value in the Map as a float, {@code 0.0F} if null map input
*/
public static <K> float getFloatValue(final Map<? super K, ?> map, final K key) {
return applyDefaultValue(map, key, MapUtils::getFloat, 0f).floatValue();
@@ -626,7 +626,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as a float, <code>defaultValue</code> if null map input
+ * @return the value in the Map as a float, {@code defaultValue} if null map input
*/
public static <K> float getFloatValue(final Map<? super K, ?> map, final K key, final float defaultValue) {
return applyDefaultValue(map, key, MapUtils::getFloat, defaultValue).floatValue();
@@ -643,7 +643,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as a float, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as a float, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -661,7 +661,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Integer, <code>null</code> if null map input
+ * @return the value in the Map as a Integer, {@code null} if null map input
*/
public static <K> Integer getInteger(final Map<? super K, ?> map, final K key) {
final Number answer = getNumber(map, key);
@@ -715,7 +715,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as an int, <code>0</code> if null map input
+ * @return the value in the Map as an int, {@code 0} if null map input
*/
public static <K> int getIntValue(final Map<? super K, ?> map, final K key) {
return applyDefaultValue(map, key, MapUtils::getInteger, 0).intValue();
@@ -732,7 +732,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as an int, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as an int, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -751,7 +751,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as an int, <code>defaultValue</code> if null map input
+ * @return the value in the Map as an int, {@code defaultValue} if null map input
*/
public static <K> int getIntValue(final Map<? super K, ?> map, final K key, final int defaultValue) {
return applyDefaultValue(map, key, MapUtils::getInteger, defaultValue).intValue();
@@ -766,7 +766,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Long, <code>null</code> if null map input
+ * @return the value in the Map as a Long, {@code null} if null map input
*/
public static <K> Long getLong(final Map<? super K, ?> map, final K key) {
final Number answer = getNumber(map, key);
@@ -819,7 +819,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a long, <code>0L</code> if null map input
+ * @return the value in the Map as a long, {@code 0L} if null map input
*/
public static <K> long getLongValue(final Map<? super K, ?> map, final K key) {
return applyDefaultValue(map, key, MapUtils::getLong, 0L).longValue();
@@ -836,7 +836,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as a long, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as a long, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -855,7 +855,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as a long, <code>defaultValue</code> if null map input
+ * @return the value in the Map as a long, {@code defaultValue} if null map input
*/
public static <K> long getLongValue(final Map<? super K, ?> map, final K key, final long defaultValue) {
return applyDefaultValue(map, key, MapUtils::getLong, defaultValue).longValue();
@@ -864,13 +864,13 @@ public class MapUtils {
/**
* Gets a Map from a Map in a null-safe manner.
* <p>
- * If the value returned from the specified map is not a Map then <code>null</code> is returned.
+ * If the value returned from the specified map is not a Map then {@code null} is returned.
* </p>
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Map, <code>null</code> if null map input
+ * @return the value in the Map as a Map, {@code null} if null map input
*/
public static <K> Map<?, ?> getMap(final Map<? super K, ?> map, final K key) {
if (map != null) {
@@ -917,15 +917,15 @@ public class MapUtils {
/**
* Gets a Number from a Map in a null-safe manner.
* <p>
- * If the value is a <code>Number</code> it is returned directly. If the value is a <code>String</code> it is
- * converted using {@link NumberFormat#parse(String)} on the system default formatter returning <code>null</code> if
- * the conversion fails. Otherwise, <code>null</code> is returned.
+ * If the value is a {@code Number} it is returned directly. If the value is a {@code String} it is
+ * converted using {@link NumberFormat#parse(String)} on the system default formatter returning {@code null} if
+ * the conversion fails. Otherwise, {@code null} is returned.
* </p>
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Number, <code>null</code> if null map input
+ * @return the value in the Map as a Number, {@code null} if null map input
*/
public static <K> Number getNumber(final Map<? super K, ?> map, final K key) {
if (map != null) {
@@ -987,7 +987,7 @@ public class MapUtils {
* @param <V> the value type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map, <code>null</code> if null map input
+ * @return the value in the Map, {@code null} if null map input
*/
public static <K, V> V getObject(final Map<? super K, V> map, final K key) {
if (map != null) {
@@ -1026,7 +1026,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a Short, <code>null</code> if null map input
+ * @return the value in the Map as a Short, {@code null} if null map input
*/
public static <K> Short getShort(final Map<? super K, ?> map, final K key) {
final Number answer = getNumber(map, key);
@@ -1080,7 +1080,7 @@ public class MapUtils {
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a short, <code>0</code> if null map input
+ * @return the value in the Map as a short, {@code 0} if null map input
*/
public static <K> short getShortValue(final Map<? super K, ?> map, final K key) {
return applyDefaultValue(map, key, MapUtils::getShort, 0).shortValue();
@@ -1097,7 +1097,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultFunction produce the default value to return if the value is null or if the conversion fails
- * @return the value in the Map as a short, default value produced by the <code>defaultFunction</code> if null map
+ * @return the value in the Map as a short, default value produced by the {@code defaultFunction} if null map
* input
* @since 4.5
*/
@@ -1116,7 +1116,7 @@ public class MapUtils {
* @param map the map to use
* @param key the key to look up
* @param defaultValue return if the value is null or if the conversion fails
- * @return the value in the Map as a short, <code>defaultValue</code> if null map input
+ * @return the value in the Map as a short, {@code defaultValue} if null map input
*/
public static <K> short getShortValue(final Map<? super K, ?> map, final K key, final short defaultValue) {
return applyDefaultValue(map, key, MapUtils::getShort, defaultValue).shortValue();
@@ -1125,13 +1125,13 @@ public class MapUtils {
/**
* Gets a String from a Map in a null-safe manner.
* <p>
- * The String is obtained via <code>toString</code>.
+ * The String is obtained via {@code toString}.
* </p>
*
* @param <K> the key type
* @param map the map to use
* @param key the key to look up
- * @return the value in the Map as a String, <code>null</code> if null map input
+ * @return the value in the Map as a String, {@code null} if null map input
*/
public static <K> String getString(final Map<? super K, ?> map, final K key) {
if (map != null) {
@@ -1282,8 +1282,8 @@ public class MapUtils {
* </pre>
*
* <p>
- * After the above code is executed, <code>obj</code> will contain a new <code>Date</code> instance. Furthermore,
- * that <code>Date</code> instance is the value for the <code>"test"</code> key in the map.
+ * After the above code is executed, {@code obj} will contain a new {@code Date} instance. Furthermore,
+ * that {@code Date} instance is the value for the {@code "test"} key in the map.
* </p>
*
* @param <K> the key type
@@ -1320,8 +1320,8 @@ public class MapUtils {
* </pre>
*
* <p>
- * After the above code is executed, <code>obj</code> will contain a new <code>File</code> instance for the C drive
- * dev directory. Furthermore, that <code>File</code> instance is the value for the <code>"C:/dev"</code> key in the
+ * After the above code is executed, {@code obj} will contain a new {@code File} instance for the C drive
+ * dev directory. Furthermore, that {@code File} instance is the value for the {@code "C:/dev"} key in the
* map.
* </p>
* <p>
@@ -1361,8 +1361,8 @@ public class MapUtils {
* Object obj = lazy.get("test");
* </pre>
* <p>
- * After the above code is executed, <code>obj</code> will contain a new <code>Date</code> instance. Furthermore,
- * that <code>Date</code> instance is the value for the <code>"test"</code> key.
+ * After the above code is executed, {@code obj} will contain a new {@code Date} instance. Furthermore,
+ * that {@code Date} instance is the value for the {@code "test"} key.
* </p>
*
* @param <K> the key type
@@ -1396,8 +1396,8 @@ public class MapUtils {
* Object obj = lazy.get("C:/dev");
* </pre>
* <p>
- * After the above code is executed, <code>obj</code> will contain a new <code>File</code> instance for the C drive
- * dev directory. Furthermore, that <code>File</code> instance is the value for the <code>"C:/dev"</code> key in the
+ * After the above code is executed, {@code obj} will contain a new {@code File} instance for the C drive
+ * dev directory. Furthermore, that {@code File} instance is the value for the {@code "C:/dev"} key in the
* map.
* </p>
* <p>
@@ -1493,15 +1493,15 @@ public class MapUtils {
}
/**
- * Populates a Map using the supplied <code>Transformer</code>s to transform the elements into keys and values.
+ * Populates a Map using the supplied {@code Transformer}s to transform the elements into keys and values.
*
* @param <K> the key type
* @param <V> the value type
* @param <E> the type of object contained in the {@link Iterable}
- * @param map the <code>Map</code> to populate.
- * @param elements the <code>Iterable</code> containing the input values for the map.
- * @param keyTransformer the <code>Transformer</code> used to transform the element into a key value
- * @param valueTransformer the <code>Transformer</code> used to transform the element into a value
+ * @param map the {@code Map} to populate.
+ * @param elements the {@code Iterable} containing the input values for the map.
+ * @param keyTransformer the {@code Transformer} used to transform the element into a key value
+ * @param valueTransformer the {@code Transformer} used to transform the element into a value
* @throws NullPointerException if the map, elements or transformers are null
*/
public static <K, V, E> void populateMap(final Map<K, V> map, final Iterable<? extends E> elements,
@@ -1514,14 +1514,14 @@ public class MapUtils {
}
/**
- * Populates a Map using the supplied <code>Transformer</code> to transform the elements into keys, using the
- * unaltered element as the value in the <code>Map</code>.
+ * Populates a Map using the supplied {@code Transformer} to transform the elements into keys, using the
+ * unaltered element as the value in the {@code Map}.
*
* @param <K> the key type
* @param <V> the value type
- * @param map the <code>Map</code> to populate.
- * @param elements the <code>Iterable</code> containing the input values for the map.
- * @param keyTransformer the <code>Transformer</code> used to transform the element into a key value
+ * @param map the {@code Map} to populate.
+ * @param elements the {@code Iterable} containing the input values for the map.
+ * @param keyTransformer the {@code Transformer} used to transform the element into a key value
* @throws NullPointerException if the map, elements or transformer are null
*/
public static <K, V> void populateMap(final Map<K, V> map, final Iterable<? extends V> elements,
@@ -1530,15 +1530,15 @@ public class MapUtils {
}
/**
- * Populates a MultiMap using the supplied <code>Transformer</code>s to transform the elements into keys and values.
+ * Populates a MultiMap using the supplied {@code Transformer}s to transform the elements into keys and values.
*
* @param <K> the key type
* @param <V> the value type
* @param <E> the type of object contained in the {@link Iterable}
- * @param map the <code>MultiMap</code> to populate.
- * @param elements the <code>Iterable</code> containing the input values for the map.
- * @param keyTransformer the <code>Transformer</code> used to transform the element into a key value
- * @param valueTransformer the <code>Transformer</code> used to transform the element into a value
+ * @param map the {@code MultiMap} to populate.
+ * @param elements the {@code Iterable} containing the input values for the map.
+ * @param keyTransformer the {@code Transformer} used to transform the element into a key value
+ * @param valueTransformer the {@code Transformer} used to transform the element into a value
* @throws NullPointerException if the map, collection or transformers are null
*/
public static <K, V, E> void populateMap(final MultiMap<K, V> map, final Iterable<? extends E> elements,
@@ -1551,14 +1551,14 @@ public class MapUtils {
}
/**
- * Populates a MultiMap using the supplied <code>Transformer</code> to transform the elements into keys, using the
- * unaltered element as the value in the <code>MultiMap</code>.
+ * Populates a MultiMap using the supplied {@code Transformer} to transform the elements into keys, using the
+ * unaltered element as the value in the {@code MultiMap}.
*
* @param <K> the key type
* @param <V> the value type
- * @param map the <code>MultiMap</code> to populate.
- * @param elements the <code>Iterable</code> to use as input values for the map.
- * @param keyTransformer the <code>Transformer</code> used to transform the element into a key value
+ * @param map the {@code MultiMap} to populate.
+ * @param elements the {@code Iterable} to use as input values for the map.
+ * @param keyTransformer the {@code Transformer} used to transform the element into a key value
* @throws NullPointerException if the map, elements or transformer are null
*/
public static <K, V> void populateMap(final MultiMap<K, V> map, final Iterable<? extends V> elements,
@@ -1957,10 +1957,10 @@ public class MapUtils {
* </p>
*
* @param out the stream to print to, must not be null
- * @param label The label to be used, may be <code>null</code>. If <code>null</code>, the label is not output. It
+ * @param label The label to be used, may be {@code null}. If {@code null}, the label is not output. It
* typically represents the name of the property in a bean or similar.
- * @param map The map to print, may be <code>null</code>. If <code>null</code>, the text 'null' is output.
- * @throws NullPointerException if the stream is <code>null</code>
+ * @param map The map to print, may be {@code null}. If {@code null}, the text 'null' is output.
+ * @throws NullPointerException if the stream is {@code null}
*/
public static void verbosePrint(final PrintStream out, final Object label, final Map<?, ?> map) {
verbosePrintInternal(out, label, map, new ArrayDeque<Map<?, ?>>(), false);
@@ -1975,13 +1975,13 @@ public class MapUtils {
* grandfather, great-grandfather, etc).
*
* @param out the stream to print to
- * @param label the label to be used, may be <code>null</code>. If <code>null</code>, the label is not output. It
+ * @param label the label to be used, may be {@code null}. If {@code null}, the label is not output. It
* typically represents the name of the property in a bean or similar.
- * @param map the map to print, may be <code>null</code>. If <code>null</code>, the text 'null' is output
+ * @param map the map to print, may be {@code null}. If {@code null}, the text 'null' is output
* @param lineage a stack consisting of any maps in which the previous argument is contained. This is checked to
* avoid infinite recursion when printing the output
* @param debug flag indicating whether type names should be output.
- * @throws NullPointerException if the stream is <code>null</code>
+ * @throws NullPointerException if the stream is {@code null}
*/
private static void verbosePrintInternal(final PrintStream out, final Object label, final Map<?, ?> map,
final Deque<Map<?, ?>> lineage, final boolean debug) {
@@ -2040,7 +2040,7 @@ public class MapUtils {
}
/**
- * <code>MapUtils</code> should not normally be instantiated.
+ * {@code MapUtils} should not normally be instantiated.
*/
private MapUtils() {
}
diff --git a/src/main/java/org/apache/commons/collections4/MultiMap.java b/src/main/java/org/apache/commons/collections4/MultiMap.java
index 6b238c0..dfdbe14 100644
--- a/src/main/java/org/apache/commons/collections4/MultiMap.java
+++ b/src/main/java/org/apache/commons/collections4/MultiMap.java
@@ -21,7 +21,7 @@ import java.util.Collection;
/**
* Defines a map that holds a collection of values against each key.
* <p>
- * A <code>MultiMap</code> is a Map with slightly different semantics.
+ * A {@code MultiMap} is a Map with slightly different semantics.
* Putting a value into the map will add the value to a Collection at that key.
* Getting a value will return a Collection, holding all the values put to that key.
* </p>
@@ -35,12 +35,12 @@ import java.util.Collection;
* mhm.put(key, "C");
* Collection coll = (Collection) mhm.get(key);</pre>
* <p>
- * <code>coll</code> will be a collection containing "A", "B", "C".
+ * {@code coll} will be a collection containing "A", "B", "C".
* </p>
* <p>
* NOTE: Additional methods were added to this interface in Commons Collections 3.1.
* These were added solely for documentation purposes and do not change the interface
- * as they were defined in the superinterface <code>Map</code> anyway.
+ * as they were defined in the superinterface {@code Map} anyway.
* </p>
*
* @param <K> the type of the keys in this map
@@ -59,7 +59,7 @@ public interface MultiMap<K, V> extends IterableMap<K, Object> {
* Other values attached to that key are unaffected.
* <p>
* If the last value for a key is removed, implementations typically
- * return <code>null</code> from a subsequent <code>get(Object)</code>, however
+ * return {@code null} from a subsequent {@code get(Object)}, however
* they may choose to return an empty collection.
*
* @param key the key to remove from
@@ -87,19 +87,19 @@ public interface MultiMap<K, V> extends IterableMap<K, Object> {
/**
* Gets the collection of values associated with the specified key.
* <p>
- * The returned value will implement <code>Collection</code>. Implementations
- * are free to declare that they return <code>Collection</code> subclasses
- * such as <code>List</code> or <code>Set</code>.
+ * The returned value will implement {@code Collection}. Implementations
+ * are free to declare that they return {@code Collection} subclasses
+ * such as {@code List} or {@code Set}.
* <p>
- * Implementations typically return <code>null</code> if no values have
+ * Implementations typically return {@code null} if no values have
* been mapped to the key, however the implementation may choose to
* return an empty collection.
* <p>
* Implementations may choose to return a clone of the internal collection.
*
* @param key the key to retrieve
- * @return the <code>Collection</code> of values, implementations should
- * return <code>null</code> for no mapping, but may return an empty collection
+ * @return the {@code Collection} of values, implementations should
+ * return {@code null} for no mapping, but may return an empty collection
* @throws ClassCastException if the key is of an invalid type
* @throws NullPointerException if the key is null and null keys are invalid
*/
@@ -123,9 +123,9 @@ public interface MultiMap<K, V> extends IterableMap<K, Object> {
/**
* Adds the value to the collection associated with the specified key.
* <p>
- * Unlike a normal <code>Map</code> the previous value is not replaced.
+ * Unlike a normal {@code Map} the previous value is not replaced.
* Instead the new value is added to the collection stored against the key.
- * The collection may be a <code>List</code>, <code>Set</code> or other
+ * The collection may be a {@code List}, {@code Set} or other
* collection dependent on implementation.
*
* @param key the key to store against
@@ -142,12 +142,12 @@ public interface MultiMap<K, V> extends IterableMap<K, Object> {
/**
* Removes all values associated with the specified key.
* <p>
- * Implementations typically return <code>null</code> from a subsequent
- * <code>get(Object)</code>, however they may choose to return an empty collection.
+ * Implementations typically return {@code null} from a subsequent
+ * {@code get(Object)}, however they may choose to return an empty collection.
*
* @param key the key to remove values from
- * @return the <code>Collection</code> of values removed, implementations should
- * return <code>null</code> for no mapping found, but may return an empty collection
+ * @return the {@code Collection} of values removed, implementations should
+ * return {@code null} for no mapping found, but may return an empty collection
* @throws UnsupportedOperationException if the map is unmodifiable
* @throws ClassCastException if the key is of an invalid type
* @throws NullPointerException if the key is null and null keys are invalid
diff --git a/src/main/java/org/apache/commons/collections4/MultiMapUtils.java b/src/main/java/org/apache/commons/collections4/MultiMapUtils.java
index f870517..9c69535 100644
--- a/src/main/java/org/apache/commons/collections4/MultiMapUtils.java
+++ b/src/main/java/org/apache/commons/collections4/MultiMapUtils.java
@@ -44,7 +44,7 @@ import org.apache.commons.collections4.multimap.UnmodifiableMultiValuedMap;
public class MultiMapUtils {
/**
- * <code>MultiMapUtils</code> should not normally be instantiated.
+ * {@code MultiMapUtils} should not normally be instantiated.
*/
private MultiMapUtils() {}
@@ -60,7 +60,7 @@ public class MultiMapUtils {
*
* @param <K> the type of key in the map
* @param <V> the type of value in the map
- * @return immutable and empty <code>MultiValuedMap</code>
+ * @return immutable and empty {@code MultiValuedMap}
*/
@SuppressWarnings("unchecked")
public static <K, V> MultiValuedMap<K, V> emptyMultiValuedMap() {
@@ -70,8 +70,8 @@ public class MultiMapUtils {
// Null safe methods
/**
- * Returns an immutable empty <code>MultiValuedMap</code> if the argument is
- * <code>null</code>, or the argument itself otherwise.
+ * Returns an immutable empty {@code MultiValuedMap} if the argument is
+ * {@code null}, or the argument itself otherwise.
*
* @param <K> the type of key in the map
* @param <V> the type of value in the map
@@ -84,7 +84,7 @@ public class MultiMapUtils {
}
/**
- * Null-safe check if the specified <code>MultiValuedMap</code> is empty.
+ * Null-safe check if the specified {@code MultiValuedMap} is empty.
* <p>
* If the provided map is null, returns true.
*
@@ -99,7 +99,7 @@ public class MultiMapUtils {
// -------------------------------------------------------------------------
/**
- * Gets a Collection from <code>MultiValuedMap</code> in a null-safe manner.
+ * Gets a Collection from {@code MultiValuedMap} in a null-safe manner.
*
* @param <K> the key type
* @param <V> the value type
@@ -118,7 +118,7 @@ public class MultiMapUtils {
// to the returned collection might update the backing map. This should be clarified and/or prevented.
/**
- * Gets a List from <code>MultiValuedMap</code> in a null-safe manner.
+ * Gets a List from {@code MultiValuedMap} in a null-safe manner.
*
* @param <K> the key type
* @param <V> the value type
@@ -138,7 +138,7 @@ public class MultiMapUtils {
}
/**
- * Gets a Set from <code>MultiValuedMap</code> in a null-safe manner.
+ * Gets a Set from {@code MultiValuedMap} in a null-safe manner.
*
* @param <K> the key type
* @param <V> the value type
@@ -158,7 +158,7 @@ public class MultiMapUtils {
}
/**
- * Gets a Bag from <code>MultiValuedMap</code> in a null-safe manner.
+ * Gets a Bag from {@code MultiValuedMap} in a null-safe manner.
*
* @param <K> the key type
* @param <V> the value type
@@ -186,7 +186,7 @@ public class MultiMapUtils {
*
* @param <K> the key type
* @param <V> the value type
- * @return a new <code>ListValuedMap</code>
+ * @return a new {@code ListValuedMap}
*/
public static <K, V> ListValuedMap<K, V> newListValuedHashMap() {
return new ArrayListValuedHashMap<>();
@@ -208,7 +208,7 @@ public class MultiMapUtils {
// -----------------------------------------------------------------------
/**
- * Returns an <code>UnmodifiableMultiValuedMap</code> backed by the given
+ * Returns an {@code UnmodifiableMultiValuedMap} backed by the given
* map.
*
* @param <K> the key type
@@ -223,9 +223,9 @@ public class MultiMapUtils {
}
/**
- * Returns a <code>TransformedMultiValuedMap</code> backed by the given map.
+ * Returns a {@code TransformedMultiValuedMap} backed by the given map.
* <p>
- * This method returns a new <code>MultiValuedMap</code> (decorating the
+ * This method returns a new {@code MultiValuedMap} (decorating the
* specified map) that will transform any new entries added to it. Existing
* entries in the specified map will not be transformed. If you want that
* behaviour, see {@link TransformedMultiValuedMap#transformedMap}.
@@ -242,7 +242,7 @@ public class MultiMapUtils {
* @param map the {@link MultiValuedMap} to transform, must not be null, typically empty
* @param keyTransformer the transformer for the map keys, null means no transformation
* @param valueTransformer the transformer for the map values, null means no transformation
- * @return a transformed <code>MultiValuedMap</code> backed by the given map
+ * @return a transformed {@code MultiValuedMap} backed by the given map
* @throws NullPointerException if map is null
*/
public static <K, V> MultiValuedMap<K, V> transformedMultiValuedMap(final MultiValuedMap<K, V> map,
diff --git a/src/main/java/org/apache/commons/collections4/MultiSet.java b/src/main/java/org/apache/commons/collections4/MultiSet.java
index 4edffc1..bbf9f2d 100644
--- a/src/main/java/org/apache/commons/collections4/MultiSet.java
+++ b/src/main/java/org/apache/commons/collections4/MultiSet.java
@@ -24,9 +24,9 @@ import java.util.Set;
* Defines a collection that counts the number of times an object appears in
* the collection.
* <p>
- * Suppose you have a MultiSet that contains <code>{a, a, b, c}</code>.
- * Calling {@link #getCount(Object)} on <code>a</code> would return 2, while
- * calling {@link #uniqueSet()} would return <code>{a, b, c}</code>.
+ * Suppose you have a MultiSet that contains {@code {a, a, b, c}}.
+ * Calling {@link #getCount(Object)} on {@code a} would return 2, while
+ * calling {@link #uniqueSet()} would return {@code {a, b, c}}.
* </p>
*
* @param <E> the type held in the multiset
@@ -67,7 +67,7 @@ public interface MultiSet<E> extends Collection<E> {
* {@link #uniqueSet()} and report its count as 1.
*
* @param object the object to add
- * @return <code>true</code> always, as the size of the MultiSet is increased
+ * @return {@code true} always, as the size of the MultiSet is increased
* in any case
*/
@Override
@@ -78,7 +78,7 @@ public interface MultiSet<E> extends Collection<E> {
* <p>
* If the object is already in the {@link #uniqueSet()} then increment its
* count as reported by {@link #getCount(Object)}. Otherwise add it to the
- * {@link #uniqueSet()} and report its count as <code>occurrences</code>.
+ * {@link #uniqueSet()} and report its count as {@code occurrences}.
*
* @param object the object to add
* @param occurrences the number of occurrences to add, may be zero,
@@ -96,7 +96,7 @@ public interface MultiSet<E> extends Collection<E> {
* to zero, the object will be removed from the {@link #uniqueSet()}.
*
* @param object the object to remove
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
boolean remove(Object object);
@@ -159,11 +159,11 @@ public interface MultiSet<E> extends Collection<E> {
int size();
/**
- * Returns <code>true</code> if the MultiSet contains at least one
+ * Returns {@code true} if the MultiSet contains at least one
* occurrence for each element contained in the given collection.
*
* @param coll the collection to check against
- * @return <code>true</code> if the MultiSet contains all the collection
+ * @return {@code true} if the MultiSet contains all the collection
*/
@Override
boolean containsAll(Collection<?> coll);
@@ -173,7 +173,7 @@ public interface MultiSet<E> extends Collection<E> {
* in the given collection.
*
* @param coll the collection of elements to remove
- * @return <code>true</code> if this call changed the multiset
+ * @return {@code true} if this call changed the multiset
*/
@Override
boolean removeAll(Collection<?> coll);
@@ -183,7 +183,7 @@ public interface MultiSet<E> extends Collection<E> {
* given collection.
*
* @param coll the collection of elements to retain
- * @return <code>true</code> if this call changed the multiset
+ * @return {@code true} if this call changed the multiset
*/
@Override
boolean retainAll(Collection<?> coll);
@@ -204,7 +204,7 @@ public interface MultiSet<E> extends Collection<E> {
* Gets a hash code for the MultiSet compatible with the definition of equals.
* The hash code is defined as the sum total of a hash code for each element.
* The per element hash code is defined as
- * <code>(e==null ? 0 : e.hashCode()) ^ noOccurances)</code>.
+ * {@code (e==null ? 0 : e.hashCode()) ^ noOccurances)}.
*
* @return the hash code of the MultiSet
*/
@@ -241,7 +241,7 @@ public interface MultiSet<E> extends Collection<E> {
* and the two entries represent the same element with the same
* number of occurrences.
* <p>
- * More formally, two entries <code>e1</code> and <code>e2</code> represent
+ * More formally, two entries {@code e1} and {@code e2} represent
* the same mapping if
* <pre>
* (e1.getElement()==null ? e2.getElement()==null
@@ -258,7 +258,7 @@ public interface MultiSet<E> extends Collection<E> {
/**
* Returns the hash code value for this multiset entry.
* <p>
- * The hash code of a multiset entry <code>e</code> is defined to be:
+ * The hash code of a multiset entry {@code e} is defined to be:
* <pre>
* (e==null ? 0 : e.hashCode()) ^ noOccurances)
* </pre>
diff --git a/src/main/java/org/apache/commons/collections4/MultiSetUtils.java b/src/main/java/org/apache/commons/collections4/MultiSetUtils.java
index ba3c019..9eb25b0 100644
--- a/src/main/java/org/apache/commons/collections4/MultiSetUtils.java
+++ b/src/main/java/org/apache/commons/collections4/MultiSetUtils.java
@@ -105,7 +105,7 @@ public class MultiSetUtils {
}
/**
- * Get an empty <code>MultiSet</code>.
+ * Get an empty {@code MultiSet}.
*
* @param <E> the element type
* @return an empty MultiSet
diff --git a/src/main/java/org/apache/commons/collections4/MultiValuedMap.java b/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
index 8e303ef..61b5dec 100644
--- a/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/MultiValuedMap.java
@@ -41,7 +41,7 @@ import java.util.Set;
* Collection<String> coll = map.get(1);
* }</pre>
* <p>
- * <code>coll</code> will be a collection containing "A", "B", "C".
+ * {@code coll} will be a collection containing "A", "B", "C".
* </p>
*
* @param <K> the type of the keys in this map
@@ -219,7 +219,7 @@ public interface MultiValuedMap<K, V> {
* Other values attached to that key are unaffected.
* <p>
* If the last value for a key is removed, implementations typically return
- * an empty collection from a subsequent <code>get(Object)</code>.
+ * an empty collection from a subsequent {@code get(Object)}.
*
* @param key the key to remove from
* @param item the item to remove
@@ -311,7 +311,7 @@ public interface MultiValuedMap<K, V> {
// Iterators
/**
- * Obtains a <code>MapIterator</code> over this multi-valued map.
+ * Obtains a {@code MapIterator} over this multi-valued map.
* <p>
* A map iterator is an efficient way of iterating over maps. There is no
* need to access the entries collection or use {@code Map.Entry} objects.
diff --git a/src/main/java/org/apache/commons/collections4/OrderedBidiMap.java b/src/main/java/org/apache/commons/collections4/OrderedBidiMap.java
index 8b7ca3a..36f3cc4 100644
--- a/src/main/java/org/apache/commons/collections4/OrderedBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/OrderedBidiMap.java
@@ -38,11 +38,11 @@ public interface OrderedBidiMap<K, V> extends BidiMap<K, V>, OrderedMap<K, V> {
* This enables both directions of the map to be accessed equally.
* <p>
* Implementations should seek to avoid creating a new object every time this
- * method is called. See <code>AbstractMap.values()</code> etc. Calling this
+ * method is called. See {@code AbstractMap.values()} etc. Calling this
* method on the inverse map should return the original.
* <p>
- * Implementations must return an <code>OrderedBidiMap</code> instance,
- * usually by forwarding to <code>inverseOrderedBidiMap()</code>.
+ * Implementations must return an {@code OrderedBidiMap} instance,
+ * usually by forwarding to {@code inverseOrderedBidiMap()}.
*
* @return an inverted bidirectional map
*/
diff --git a/src/main/java/org/apache/commons/collections4/OrderedIterator.java b/src/main/java/org/apache/commons/collections4/OrderedIterator.java
index 9ad992f..9782515 100644
--- a/src/main/java/org/apache/commons/collections4/OrderedIterator.java
+++ b/src/main/java/org/apache/commons/collections4/OrderedIterator.java
@@ -32,7 +32,7 @@ public interface OrderedIterator<E> extends Iterator<E> {
/**
* Checks to see if there is a previous element that can be iterated to.
*
- * @return <code>true</code> if the iterator has a previous element
+ * @return {@code true} if the iterator has a previous element
*/
boolean hasPrevious();
diff --git a/src/main/java/org/apache/commons/collections4/OrderedMap.java b/src/main/java/org/apache/commons/collections4/OrderedMap.java
index 57c3e63..324710f 100644
--- a/src/main/java/org/apache/commons/collections4/OrderedMap.java
+++ b/src/main/java/org/apache/commons/collections4/OrderedMap.java
@@ -28,7 +28,7 @@ package org.apache.commons.collections4;
public interface OrderedMap<K, V> extends IterableMap<K, V> {
/**
- * Obtains an <code>OrderedMapIterator</code> over the map.
+ * Obtains an {@code OrderedMapIterator} over the map.
* <p>
* A ordered map iterator is an efficient way of iterating over maps
* in both directions.
diff --git a/src/main/java/org/apache/commons/collections4/OrderedMapIterator.java b/src/main/java/org/apache/commons/collections4/OrderedMapIterator.java
index fedebeb..344bb46 100644
--- a/src/main/java/org/apache/commons/collections4/OrderedMapIterator.java
+++ b/src/main/java/org/apache/commons/collections4/OrderedMapIterator.java
@@ -17,7 +17,7 @@
package org.apache.commons.collections4;
/**
- * Defines an iterator that operates over an ordered <code>Map</code>.
+ * Defines an iterator that operates over an ordered {@code Map}.
* <p>
* This iterator allows both forward and reverse iteration through the map.
* </p>
@@ -31,13 +31,13 @@ public interface OrderedMapIterator<K, V> extends MapIterator<K, V>, OrderedIter
/**
* Checks to see if there is a previous entry that can be iterated to.
*
- * @return <code>true</code> if the iterator has a previous element
+ * @return {@code true} if the iterator has a previous element
*/
@Override
boolean hasPrevious();
/**
- * Gets the previous <em>key</em> from the <code>Map</code>.
+ * Gets the previous <em>key</em> from the {@code Map}.
*
* @return the previous key in the iteration
* @throws java.util.NoSuchElementException if the iteration is finished
diff --git a/src/main/java/org/apache/commons/collections4/Predicate.java b/src/main/java/org/apache/commons/collections4/Predicate.java
index dcd9c61..c7af795 100644
--- a/src/main/java/org/apache/commons/collections4/Predicate.java
+++ b/src/main/java/org/apache/commons/collections4/Predicate.java
@@ -20,7 +20,7 @@ package org.apache.commons.collections4;
* Defines a functor interface implemented by classes that perform a predicate
* test on an object.
* <p>
- * A <code>Predicate</code> is the object equivalent of an <code>if</code> statement.
+ * A {@code Predicate} is the object equivalent of an {@code if} statement.
* It uses the input object to return a true or false value, and is often used in
* validation or filtering.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/PredicateUtils.java b/src/main/java/org/apache/commons/collections4/PredicateUtils.java
index 2243edf..8dd5d0f 100644
--- a/src/main/java/org/apache/commons/collections4/PredicateUtils.java
+++ b/src/main/java/org/apache/commons/collections4/PredicateUtils.java
@@ -42,7 +42,7 @@ import org.apache.commons.collections4.functors.TruePredicate;
import org.apache.commons.collections4.functors.UniquePredicate;
/**
- * <code>PredicateUtils</code> provides reference implementations and utilities
+ * {@code PredicateUtils} provides reference implementations and utilities
* for the Predicate functor interface. The supplied predicates are:
* <ul>
* <li>Invoker - returns the result of a method call on the input object
@@ -162,8 +162,8 @@ public class PredicateUtils {
/**
* Creates a Predicate that checks if the object passed in is of
- * a particular type, using instanceof. A <code>null</code> input
- * object will return <code>false</code>.
+ * a particular type, using instanceof. A {@code null} input
+ * object will return {@code false}.
*
* @param type the type to check for, may not be null
* @return the predicate
@@ -177,7 +177,7 @@ public class PredicateUtils {
/**
* Creates a Predicate that returns true the first time an object is
* encountered, and false if the same object is received
- * again. The comparison is by equals(). A <code>null</code> input object
+ * again. The comparison is by equals(). A {@code null} input object
* is accepted and will return true the first time, and false subsequently
* as well.
*
@@ -196,8 +196,8 @@ public class PredicateUtils {
* and have no parameters. If the input object is null, a
* PredicateException is thrown.
* <p>
- * For example, <code>PredicateUtils.invokerPredicate("isEmpty");</code>
- * will call the <code>isEmpty</code> method on the input object to
+ * For example, {@code PredicateUtils.invokerPredicate("isEmpty");}
+ * will call the {@code isEmpty} method on the input object to
* determine the predicate result.
*
* @param <T> the type that the predicate queries
@@ -218,8 +218,8 @@ public class PredicateUtils {
* and have no parameters. If the input object is null, a
* PredicateException is thrown.
* <p>
- * For example, <code>PredicateUtils.invokerPredicate("isEmpty");</code>
- * will call the <code>isEmpty</code> method on the input object to
+ * For example, {@code PredicateUtils.invokerPredicate("isEmpty");}
+ * will call the {@code isEmpty} method on the input object to
* determine the predicate result.
*
* @param <T> the type that the predicate queries
@@ -248,7 +248,7 @@ public class PredicateUtils {
* @param <T> the type that the predicate queries
* @param predicate1 the first predicate, may not be null
* @param predicate2 the second predicate, may not be null
- * @return the <code>and</code> predicate
+ * @return the {@code and} predicate
* @throws NullPointerException if either predicate is null
* @see AndPredicate
*/
@@ -264,7 +264,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates an array of predicates to check, may not be null
- * @return the <code>all</code> predicate
+ * @return the {@code all} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
* @see AllPredicate
@@ -280,7 +280,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates a collection of predicates to check, may not be null
- * @return the <code>all</code> predicate
+ * @return the {@code all} predicate
* @throws NullPointerException if the predicates collection is null
* @throws NullPointerException if any predicate in the collection is null
* @see AllPredicate
@@ -296,7 +296,7 @@ public class PredicateUtils {
* @param <T> the type that the predicate queries
* @param predicate1 the first predicate, may not be null
* @param predicate2 the second predicate, may not be null
- * @return the <code>or</code> predicate
+ * @return the {@code or} predicate
* @throws NullPointerException if either predicate is null
* @see OrPredicate
*/
@@ -312,7 +312,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates an array of predicates to check, may not be null
- * @return the <code>any</code> predicate
+ * @return the {@code any} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
* @see AnyPredicate
@@ -328,7 +328,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates a collection of predicates to check, may not be null
- * @return the <code>any</code> predicate
+ * @return the {@code any} predicate
* @throws NullPointerException if the predicates collection is null
* @throws NullPointerException if any predicate in the collection is null
* @see AnyPredicate
@@ -344,7 +344,7 @@ public class PredicateUtils {
* @param <T> the type that the predicate queries
* @param predicate1 the first predicate, may not be null
* @param predicate2 the second predicate, may not be null
- * @return the <code>either</code> predicate
+ * @return the {@code either} predicate
* @throws NullPointerException if either predicate is null
* @see OnePredicate
*/
@@ -362,7 +362,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates an array of predicates to check, may not be null
- * @return the <code>one</code> predicate
+ * @return the {@code one} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
* @see OnePredicate
@@ -378,7 +378,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates a collection of predicates to check, may not be null
- * @return the <code>one</code> predicate
+ * @return the {@code one} predicate
* @throws NullPointerException if the predicates collection is null
* @throws NullPointerException if any predicate in the collection is null
* @see OnePredicate
@@ -394,7 +394,7 @@ public class PredicateUtils {
* @param <T> the type that the predicate queries
* @param predicate1 the first predicate, may not be null
* @param predicate2 the second predicate, may not be null
- * @return the <code>neither</code> predicate
+ * @return the {@code neither} predicate
* @throws NullPointerException if either predicate is null
* @see NonePredicate
*/
@@ -412,7 +412,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates an array of predicates to check, may not be null
- * @return the <code>none</code> predicate
+ * @return the {@code none} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
* @see NonePredicate
@@ -428,7 +428,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicates a collection of predicates to check, may not be null
- * @return the <code>none</code> predicate
+ * @return the {@code none} predicate
* @throws NullPointerException if the predicates collection is null
* @throws NullPointerException if any predicate in the collection is null
* @see NonePredicate
@@ -443,7 +443,7 @@ public class PredicateUtils {
*
* @param <T> the type that the predicate queries
* @param predicate the predicate to not
- * @return the <code>not</code> predicate
+ * @return the {@code not} predicate
* @throws NullPointerException if the predicate is null
* @see NotPredicate
*/
diff --git a/src/main/java/org/apache/commons/collections4/Put.java b/src/main/java/org/apache/commons/collections4/Put.java
index cab99bf..687fd66 100644
--- a/src/main/java/org/apache/commons/collections4/Put.java
+++ b/src/main/java/org/apache/commons/collections4/Put.java
@@ -47,11 +47,11 @@ public interface Put<K, V> {
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
- * @return the previous value associated with <code>key</code>, or
- * <code>null</code> if there was no mapping for <code>key</code>.
- * (A <code>null</code> return can also indicate that the map
- * previously associated <code>null</code> with <code>key</code>,
- * if the implementation supports <code>null</code> values.)
+ * @return the previous value associated with {@code key}, or
+ * {@code null} if there was no mapping for {@code key}.
+ * (A {@code null} return can also indicate that the map
+ * previously associated {@code null} with {@code key},
+ * if the implementation supports {@code null} values.)
* @see Map#put(Object, Object)
*/
Object put(K key, V value);
diff --git a/src/main/java/org/apache/commons/collections4/QueueUtils.java b/src/main/java/org/apache/commons/collections4/QueueUtils.java
index ee4114b..27d8c3d 100644
--- a/src/main/java/org/apache/commons/collections4/QueueUtils.java
+++ b/src/main/java/org/apache/commons/collections4/QueueUtils.java
@@ -38,7 +38,7 @@ public class QueueUtils {
public static final Queue EMPTY_QUEUE = UnmodifiableQueue.unmodifiableQueue(new LinkedList<>());
/**
- * <code>QueueUtils</code> should not normally be instantiated.
+ * {@code QueueUtils} should not normally be instantiated.
*/
private QueueUtils() {}
@@ -127,7 +127,7 @@ public class QueueUtils {
}
/**
- * Get an empty <code>Queue</code>.
+ * Get an empty {@code Queue}.
*
* @param <E> the type of the elements in the queue
* @return an empty {@link Queue}
diff --git a/src/main/java/org/apache/commons/collections4/SetUtils.java b/src/main/java/org/apache/commons/collections4/SetUtils.java
index 1205ece..658af05 100644
--- a/src/main/java/org/apache/commons/collections4/SetUtils.java
+++ b/src/main/java/org/apache/commons/collections4/SetUtils.java
@@ -187,12 +187,12 @@ public class SetUtils {
}
/**
- * Returns an immutable empty set if the argument is <code>null</code>,
+ * Returns an immutable empty set if the argument is {@code null},
* or the argument itself otherwise.
*
* @param <T> the element type
- * @param set the set, possibly <code>null</code>
- * @return an empty set if the argument is <code>null</code>
+ * @param set the set, possibly {@code null}
+ * @return an empty set if the argument is {@code null}
*/
public static <T> Set<T> emptyIfNull(final Set<T> set) {
return set == null ? Collections.<T>emptySet() : set;
@@ -223,7 +223,7 @@ public class SetUtils {
* Generates a hash code using the algorithm specified in
* {@link java.util.Set#hashCode()}.
* <p>
- * This method is useful for implementing <code>Set</code> when you cannot
+ * This method is useful for implementing {@code Set} when you cannot
* extend AbstractSet. The method takes Collection instances to enable other
* collection types to use the Set implementation algorithm.
*
@@ -294,10 +294,10 @@ public class SetUtils {
}
/**
- * Tests two sets for equality as per the <code>equals()</code> contract
+ * Tests two sets for equality as per the {@code equals()} contract
* in {@link java.util.Set#equals(java.lang.Object)}.
* <p>
- * This method is useful for implementing <code>Set</code> when you cannot
+ * This method is useful for implementing {@code Set} when you cannot
* extend AbstractSet. The method takes Collection instances to enable other
* collection types to use the Set implementation algorithm.
* <p>
@@ -333,8 +333,8 @@ public class SetUtils {
}
/**
- * Returns a new hash set that matches elements based on <code>==</code> not
- * <code>equals()</code>.
+ * Returns a new hash set that matches elements based on {@code ==} not
+ * {@code equals()}.
* <p>
* <strong>This set will violate the detail of various Set contracts.</strong>
* As a general rule, don't compare this set to other sets. In particular, you can't
@@ -656,7 +656,7 @@ public class SetUtils {
}
/**
- * <code>SetUtils</code> should not normally be instantiated.
+ * {@code SetUtils} should not normally be instantiated.
*/
private SetUtils() {}
}
diff --git a/src/main/java/org/apache/commons/collections4/SortedBag.java b/src/main/java/org/apache/commons/collections4/SortedBag.java
index 24324b0..b1ce6e0 100644
--- a/src/main/java/org/apache/commons/collections4/SortedBag.java
+++ b/src/main/java/org/apache/commons/collections4/SortedBag.java
@@ -19,7 +19,7 @@ package org.apache.commons.collections4;
import java.util.Comparator;
/**
- * Defines a type of <code>Bag</code> that maintains a sorted order among
+ * Defines a type of {@code Bag} that maintains a sorted order among
* its unique representative members.
*
* @param <E> the type of elements in this bag
diff --git a/src/main/java/org/apache/commons/collections4/SortedBidiMap.java b/src/main/java/org/apache/commons/collections4/SortedBidiMap.java
index d9c7189..e2254ea 100644
--- a/src/main/java/org/apache/commons/collections4/SortedBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/SortedBidiMap.java
@@ -40,11 +40,11 @@ public interface SortedBidiMap<K, V> extends OrderedBidiMap<K, V>, SortedMap<K,
* This enables both directions of the map to be accessed equally.
* <p>
* Implementations should seek to avoid creating a new object every time this
- * method is called. See <code>AbstractMap.values()</code> etc. Calling this
+ * method is called. See {@code AbstractMap.values()} etc. Calling this
* method on the inverse map should return the original.
* <p>
- * Implementations must return a <code>SortedBidiMap</code> instance,
- * usually by forwarding to <code>inverseSortedBidiMap()</code>.
+ * Implementations must return a {@code SortedBidiMap} instance,
+ * usually by forwarding to {@code inverseSortedBidiMap()}.
*
* @return an inverted bidirectional map
*/
diff --git a/src/main/java/org/apache/commons/collections4/SplitMapUtils.java b/src/main/java/org/apache/commons/collections4/SplitMapUtils.java
index c5c58b5..cff8dc6 100644
--- a/src/main/java/org/apache/commons/collections4/SplitMapUtils.java
+++ b/src/main/java/org/apache/commons/collections4/SplitMapUtils.java
@@ -39,7 +39,7 @@ import org.apache.commons.collections4.set.UnmodifiableSet;
public class SplitMapUtils {
/**
- * <code>SplitMapUtils</code> should not normally be instantiated.
+ * {@code SplitMapUtils} should not normally be instantiated.
*/
private SplitMapUtils() {}
@@ -223,8 +223,8 @@ public class SplitMapUtils {
/**
* Get the specified {@link Get} as an instance of {@link IterableMap}.
- * If <code>get</code> implements {@link IterableMap} directly, no conversion will take place.
- * If <code>get</code> implements {@link Map} but not {@link IterableMap} it will be decorated.
+ * If {@code get} implements {@link IterableMap} directly, no conversion will take place.
+ * If {@code get} implements {@link Map} but not {@link IterableMap} it will be decorated.
* Otherwise an {@link Unmodifiable} {@link IterableMap} will be returned.
* @param <K> the key type
* @param <V> the value type
@@ -245,10 +245,10 @@ public class SplitMapUtils {
/**
* Get the specified {@link Put} as an instanceof {@link Map}.
- * If <code>put</code> implements {@link Map} directly, no conversion will take place.
+ * If {@code put} implements {@link Map} directly, no conversion will take place.
* Otherwise a <em>write-only</em> {@link Map} will be returned. On such a {@link Map}
* it is recommended that the result of #put(K, V) be discarded as it likely will not
- * match <code>V</code> at runtime.
+ * match {@code V} at runtime.
*
* @param <K> the key type
* @param <V> the element type
diff --git a/src/main/java/org/apache/commons/collections4/Transformer.java b/src/main/java/org/apache/commons/collections4/Transformer.java
index 5cf6698..cdf2ab9 100644
--- a/src/main/java/org/apache/commons/collections4/Transformer.java
+++ b/src/main/java/org/apache/commons/collections4/Transformer.java
@@ -20,7 +20,7 @@ package org.apache.commons.collections4;
* Defines a functor interface implemented by classes that transform one
* object into another.
* <p>
- * A <code>Transformer</code> converts the input object to the output object.
+ * A {@code Transformer} converts the input object to the output object.
* The input object should be left unchanged.
* Transformers are typically used for type conversions, or extracting data
* from an object.
diff --git a/src/main/java/org/apache/commons/collections4/TransformerUtils.java b/src/main/java/org/apache/commons/collections4/TransformerUtils.java
index 12293ac..76c09d5 100644
--- a/src/main/java/org/apache/commons/collections4/TransformerUtils.java
+++ b/src/main/java/org/apache/commons/collections4/TransformerUtils.java
@@ -37,7 +37,7 @@ import org.apache.commons.collections4.functors.StringValueTransformer;
import org.apache.commons.collections4.functors.SwitchTransformer;
/**
- * <code>TransformerUtils</code> provides reference implementations and
+ * {@code TransformerUtils} provides reference implementations and
* utilities for the Transformer functor interface. The supplied transformers are:
* <ul>
* <li>Invoker - returns the result of a method call on the input object
@@ -55,7 +55,7 @@ import org.apache.commons.collections4.functors.SwitchTransformer;
* <li>Null - always returns null
* <li>NOP - returns the input object, which should be immutable
* <li>Exception - always throws an exception
- * <li>StringValue - returns a <code>java.lang.String</code> representation of the input object
+ * <li>StringValue - returns a {@code java.lang.String} representation of the input object
* </ul>
* <p>
* Since v4.1 only transformers which are considered to be safe are
@@ -433,8 +433,8 @@ public class TransformerUtils {
* {@code null} is returned.
*
* <p>
- * For example, <code>TransformerUtils.invokerTransformer("getName");</code>
- * will call the <code>getName</code> method on the input object to
+ * For example, {@code TransformerUtils.invokerTransformer("getName");}
+ * will call the {@code getName} method on the input object to
* determine the transformer result.
* </p>
*
@@ -470,9 +470,9 @@ public class TransformerUtils {
}
/**
- * Gets a transformer that returns a <code>java.lang.String</code>
+ * Gets a transformer that returns a {@code java.lang.String}
* representation of the input object. This is achieved via the
- * <code>toString</code> method, <code>null</code> returns 'null'.
+ * {@code toString} method, {@code null} returns 'null'.
*
* @param <T> the input type
* @return the transformer
diff --git a/src/main/java/org/apache/commons/collections4/bag/AbstractBagDecorator.java b/src/main/java/org/apache/commons/collections4/bag/AbstractBagDecorator.java
index a1486ea..3d4bf60 100644
--- a/src/main/java/org/apache/commons/collections4/bag/AbstractBagDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/bag/AbstractBagDecorator.java
@@ -22,7 +22,7 @@ import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
/**
- * Decorates another <code>Bag</code> to provide additional behaviour.
+ * Decorates another {@code Bag} to provide additional behaviour.
* <p>
* Methods are forwarded directly to the decorated bag.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/bag/AbstractMapBag.java b/src/main/java/org/apache/commons/collections4/bag/AbstractMapBag.java
index 9ee1ae3..b5b9845 100644
--- a/src/main/java/org/apache/commons/collections4/bag/AbstractMapBag.java
+++ b/src/main/java/org/apache/commons/collections4/bag/AbstractMapBag.java
@@ -135,7 +135,7 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
* Determines if the bag contains the given elements.
*
* @param coll the collection to check against
- * @return <code>true</code> if the Bag contains all the collection
+ * @return {@code true} if the Bag contains all the collection
*/
@Override
public boolean containsAll(final Collection<?> coll) {
@@ -146,11 +146,11 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
}
/**
- * Returns <code>true</code> if the bag contains all elements in the given
+ * Returns {@code true} if the bag contains all elements in the given
* collection, respecting cardinality.
*
* @param other the bag to check against
- * @return <code>true</code> if the Bag contains all the collection
+ * @return {@code true} if the Bag contains all the collection
*/
boolean containsAll(final Bag<?> other) {
final Iterator<?> it = other.uniqueSet().iterator();
@@ -245,7 +245,7 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
* Adds a new element to the bag, incrementing its count in the underlying map.
*
* @param object the object to add
- * @return <code>true</code> if the object was not already in the <code>uniqueSet</code>
+ * @return {@code true} if the object was not already in the {@code uniqueSet}
*/
@Override
public boolean add(final E object) {
@@ -257,7 +257,7 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
*
* @param object the object to search for
* @param nCopies the number of copies to add
- * @return <code>true</code> if the object was not already in the <code>uniqueSet</code>
+ * @return {@code true} if the object was not already in the {@code uniqueSet}
*/
@Override
public boolean add(final E object, final int nCopies) {
@@ -279,7 +279,7 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
* Invokes {@link #add(Object)} for each element in the given collection.
*
* @param coll the collection to add
- * @return <code>true</code> if this call changed the bag
+ * @return {@code true} if this call changed the bag
*/
@Override
public boolean addAll(final Collection<? extends E> coll) {
@@ -389,7 +389,7 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
* @see #retainAll(Collection)
*
* @param other the bag to retain
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
boolean retainAll(final Bag<?> other) {
boolean result = false;
@@ -579,7 +579,7 @@ public abstract class AbstractMapBag<E> implements Bag<E> {
* Gets a hash code for the Bag compatible with the definition of equals.
* The hash code is defined as the sum total of a hash code for each
* element. The per element hash code is defined as
- * <code>(e==null ? 0 : e.hashCode()) ^ noOccurances)</code>. This hash code
+ * {@code (e==null ? 0 : e.hashCode()) ^ noOccurances)}. This hash code
* is compatible with the Set interface.
*
* @return the hash code of the Bag
diff --git a/src/main/java/org/apache/commons/collections4/bag/AbstractSortedBagDecorator.java b/src/main/java/org/apache/commons/collections4/bag/AbstractSortedBagDecorator.java
index 42daebc..1682b56 100644
--- a/src/main/java/org/apache/commons/collections4/bag/AbstractSortedBagDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/bag/AbstractSortedBagDecorator.java
@@ -21,7 +21,7 @@ import java.util.Comparator;
import org.apache.commons.collections4.SortedBag;
/**
- * Decorates another <code>SortedBag</code> to provide additional behaviour.
+ * Decorates another {@code SortedBag} to provide additional behaviour.
* <p>
* Methods are forwarded directly to the decorated bag.
* </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 f8e22f1..4ae4d42 100644
--- a/src/main/java/org/apache/commons/collections4/bag/CollectionBag.java
+++ b/src/main/java/org/apache/commons/collections4/bag/CollectionBag.java
@@ -99,13 +99,13 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
/**
* <i>(Change)</i>
- * Returns <code>true</code> if the bag contains all elements in
+ * 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</code> contains at least one of
+ * if the given collection {@code coll} contains at least one of
* every object contained in this object.
*
* @param coll the collection to check against
- * @return <code>true</code> if the Bag contains at least one of every object in the collection
+ * @return {@code true} if the Bag contains at least one of every object in the collection
*/
@Override
public boolean containsAll(final Collection<?> coll) {
@@ -123,10 +123,10 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
* Adds one copy of the specified object to the Bag.
* <p>
* Since this method always increases the size of the bag, it
- * will always return <code>true</code>.
+ * will always return {@code true}.
*
* @param object the object to add
- * @return <code>true</code>, always
+ * @return {@code true}, always
*/
@Override
public boolean add(final E object) {
@@ -152,7 +152,7 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
* bag contains no occurrence anymore of the object after this operation.
*
* @param object the object to remove
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
public boolean remove(final Object object) {
@@ -166,7 +166,7 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
* occurrences of every object contained in the given collection.
*
* @param coll the collection to remove
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
public boolean removeAll(final Collection<?> coll) {
@@ -188,18 +188,18 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
* <i>(Change)</i>
* 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
- * collection <code>coll</code> will be retained in the bag with the same
+ * 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.
* <p>
* This implementation iterates over the elements of this bag, checking
- * each element in turn to see if it's contained in <code>coll</code>.
+ * each element in turn to see if it's contained in {@code coll}.
* If it's not contained, it's removed from this bag. As a consequence,
- * it is advised to use a collection type for <code>coll</code> that provides
+ * it is advised to use a collection type for {@code coll} that provides
* a fast (e.g. O(1)) implementation of {@link Collection#contains(Object)}.
*
* @param coll the collection to retain
- * @return <code>true</code> if this call changed the collection
+ * @return {@code true} if this call changed the collection
*/
@Override
public boolean retainAll(final Collection<?> coll) {
@@ -224,14 +224,14 @@ public final class CollectionBag<E> extends AbstractBagDecorator<E> {
/**
* <i>(Change)</i>
- * Adds <code>count</code> copies of the specified object to the Bag.
+ * Adds {@code count} copies of the specified object to the Bag.
* <p>
* Since this method always increases the size of the bag, it
- * will always return <code>true</code>.
+ * will always return {@code true}.
*
* @param object the object to add
* @param count the number of copies to add
- * @return <code>true</code>, always
+ * @return {@code true}, always
*/
@Override
public boolean add(final E object, final int count) {
diff --git a/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java b/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
index 790ace2..ddef8f2 100644
--- a/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/bidimap/AbstractDualBidiMap.java
@@ -77,7 +77,7 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
transient Set<Map.Entry<K, V>> entrySet = null;
/**
- * Creates an empty map, initialised by <code>createMap</code>.
+ * Creates an empty map, initialised by {@code createMap}.
* <p>
* This constructor remains in place for deserialization.
* All other usage is deprecated in favour of
@@ -95,7 +95,7 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
* <p>
* Neither map is validated, so nulls may be passed in.
* If you choose to do this then the subclass constructor must populate
- * the <code>maps[]</code> instance variable itself.
+ * the {@code maps[]} instance variable itself.
*
* @param normalMap the normal direction map
* @param reverseMap the reverse direction map
@@ -109,7 +109,7 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
/**
* Constructs a map that decorates the specified maps,
- * used by the subclass <code>createBidiMap</code> implementation.
+ * used by the subclass {@code createBidiMap} implementation.
*
* @param normalMap the normal direction map
* @param reverseMap the reverse direction map
@@ -218,8 +218,8 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
// BidiMap
//-----------------------------------------------------------------------
/**
- * Obtains a <code>MapIterator</code> over the map.
- * The iterator implements <code>ResetableMapIterator</code>.
+ * Obtains a {@code MapIterator} over the map.
+ * The iterator implements {@code ResetableMapIterator}.
* This implementation relies on the entrySet iterator.
* <p>
* The setValue() methods only allow a new value to be set.
@@ -411,9 +411,9 @@ public abstract class AbstractDualBidiMap<K, V> implements BidiMap<K, V> {
* {@inheritDoc}
* <p>
* This implementation iterates over the elements of this bidi map, checking each element in
- * turn to see if it's contained in <code>coll</code>. If it's not contained, it's removed
+ * turn to see if it's contained in {@code coll}. If it's not contained, it's removed
* from this bidi map. As a consequence, it is advised to use a collection type for
- * <code>coll</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code coll} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/bidimap/DualHashBidiMap.java b/src/main/java/org/apache/commons/collections4/bidimap/DualHashBidiMap.java
index fa0d9f2..3d791ac 100644
--- a/src/main/java/org/apache/commons/collections4/bidimap/DualHashBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/bidimap/DualHashBidiMap.java
@@ -35,7 +35,7 @@ import org.apache.commons.collections4.BidiMap;
* </p>
* <p>
* NOTE: From Commons Collections 3.1, all subclasses will use {@link HashMap}
- * and the flawed <code>createMap</code> method is ignored.
+ * and the flawed {@code createMap} method is ignored.
* </p>
*
* @param <K> the type of the keys in the map
@@ -49,15 +49,15 @@ public class DualHashBidiMap<K, V> extends AbstractDualBidiMap<K, V> implements
private static final long serialVersionUID = 721969328361808L;
/**
- * Creates an empty <code>HashBidiMap</code>.
+ * Creates an empty {@code HashBidiMap}.
*/
public DualHashBidiMap() {
super(new HashMap<K, V>(), new HashMap<V, K>());
}
/**
- * Constructs a <code>HashBidiMap</code> and copies the mappings from
- * specified <code>Map</code>.
+ * Constructs a {@code HashBidiMap} and copies the mappings from
+ * specified {@code Map}.
*
* @param map the map whose mappings are to be placed in this map
*/
@@ -67,7 +67,7 @@ public class DualHashBidiMap<K, V> extends AbstractDualBidiMap<K, V> implements
}
/**
- * Constructs a <code>HashBidiMap</code> that decorates the specified maps.
+ * Constructs a {@code HashBidiMap} that decorates the specified maps.
*
* @param normalMap the normal direction map
* @param reverseMap the reverse direction map
diff --git a/src/main/java/org/apache/commons/collections4/bidimap/DualLinkedHashBidiMap.java b/src/main/java/org/apache/commons/collections4/bidimap/DualLinkedHashBidiMap.java
index 36df6ad..d486707 100644
--- a/src/main/java/org/apache/commons/collections4/bidimap/DualLinkedHashBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/bidimap/DualLinkedHashBidiMap.java
@@ -26,9 +26,9 @@ import java.util.Map;
import org.apache.commons.collections4.BidiMap;
/**
- * Implementation of <code>BidiMap</code> that uses two <code>LinkedHashMap</code> instances.
+ * Implementation of {@code BidiMap} that uses two {@code LinkedHashMap} instances.
* <p>
- * Two <code>LinkedHashMap</code> instances are used in this class.
+ * Two {@code LinkedHashMap} instances are used in this class.
* This provides fast lookups at the expense of storing two sets of map entries and two linked lists.
* </p>
*
@@ -43,15 +43,15 @@ public class DualLinkedHashBidiMap<K, V> extends AbstractDualBidiMap<K, V> imple
private static final long serialVersionUID = 721969328361810L;
/**
- * Creates an empty <code>HashBidiMap</code>.
+ * Creates an empty {@code HashBidiMap}.
*/
public DualLinkedHashBidiMap() {
super(new LinkedHashMap<K, V>(), new LinkedHashMap<V, K>());
}
/**
- * Constructs a <code>LinkedHashBidiMap</code> and copies the mappings from
- * specified <code>Map</code>.
+ * Constructs a {@code LinkedHashBidiMap} and copies the mappings from
+ * specified {@code Map}.
*
* @param map the map whose mappings are to be placed in this map
*/
@@ -61,7 +61,7 @@ public class DualLinkedHashBidiMap<K, V> extends AbstractDualBidiMap<K, V> imple
}
/**
- * Constructs a <code>LinkedHashBidiMap</code> that decorates the specified maps.
+ * Constructs a {@code LinkedHashBidiMap} that decorates the specified maps.
*
* @param normalMap the normal direction map
* @param reverseMap the reverse direction map
diff --git a/src/main/java/org/apache/commons/collections4/bidimap/DualTreeBidiMap.java b/src/main/java/org/apache/commons/collections4/bidimap/DualTreeBidiMap.java
index 748eecc..78c2584 100644
--- a/src/main/java/org/apache/commons/collections4/bidimap/DualTreeBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/bidimap/DualTreeBidiMap.java
@@ -49,7 +49,7 @@ import org.apache.commons.collections4.map.AbstractSortedMapDecorator;
* </p>
* <p>
* NOTE: From Commons Collections 3.1, all subclasses will use {@link TreeMap}
- * and the flawed <code>createMap</code> method is ignored.
+ * and the flawed {@code createMap} method is ignored.
* </p>
*
* @param <K> the type of the keys in this map
@@ -69,7 +69,7 @@ public class DualTreeBidiMap<K, V> extends AbstractDualBidiMap<K, V>
private final Comparator<? super V> valueComparator;
/**
- * Creates an empty <code>DualTreeBidiMap</code>
+ * Creates an empty {@code DualTreeBidiMap}
*/
public DualTreeBidiMap() {
super(new TreeMap<K, V>(), new TreeMap<V, K>());
@@ -78,8 +78,8 @@ public class DualTreeBidiMap<K, V> extends AbstractDualBidiMap<K, V>
}
/**
- * Constructs a <code>DualTreeBidiMap</code> and copies the mappings from
- * specified <code>Map</code>.
+ * Constructs a {@code DualTreeBidiMap} and copies the mappings from
+ * specified {@code Map}.
*
* @param map the map whose mappings are to be placed in this map
*/
diff --git a/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java b/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java
index 9f32827..0022b5d 100644
--- a/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java
+++ b/src/main/java/org/apache/commons/collections4/bidimap/TreeBidiMap.java
@@ -41,7 +41,7 @@ import org.apache.commons.collections4.keyvalue.UnmodifiableMapEntry;
/**
* Red-Black tree-based implementation of BidiMap where all objects added
- * implement the <code>Comparable</code> interface.
+ * implement the {@code Comparable} interface.
* <p>
* This class guarantees that the map will be in both ascending key order
* and ascending value order, sorted according to the natural order for
@@ -163,7 +163,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Checks whether this map contains the a mapping for the specified key.
* <p>
- * The key must implement <code>Comparable</code>.
+ * The key must implement {@code Comparable}.
*
* @param key key whose presence in this map is to be tested
* @return true if this map contains a mapping for the specified key
@@ -179,7 +179,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Checks whether this map contains the a mapping for the specified value.
* <p>
- * The value must implement <code>Comparable</code>.
+ * The value must implement {@code Comparable}.
*
* @param value value whose presence in this map is to be tested
* @return true if this map contains a mapping for the specified value
@@ -196,7 +196,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
* Gets the value to which this map maps the specified key.
* Returns null if the map contains no mapping for this key.
* <p>
- * The key must implement <code>Comparable</code>.
+ * The key must implement {@code Comparable}.
*
* @param key key whose associated value is to be returned
* @return the value to which this map maps the specified key,
@@ -227,7 +227,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
* map.put("C","B"); // contains C mapped to B, key A is removed
* </pre>
* <p>
- * Both key and value must implement <code>Comparable</code>.
+ * Both key and value must implement {@code Comparable}.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
@@ -245,7 +245,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Puts all the mappings from the specified map into this map.
* <p>
- * All keys and values must implement <code>Comparable</code>.
+ * All keys and values must implement {@code Comparable}.
*
* @param map the map to copy from
*/
@@ -259,7 +259,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Removes the mapping for this key from this map if present.
* <p>
- * The key must implement <code>Comparable</code>.
+ * The key must implement {@code Comparable}.
*
* @param key key whose mapping is to be removed from the map.
* @return previous value associated with specified key,
@@ -289,7 +289,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
* Returns the key to which this map maps the specified value.
* Returns null if the map contains no mapping for this value.
* <p>
- * The value must implement <code>Comparable</code>.
+ * The value must implement {@code Comparable}.
*
* @param value value whose associated key is to be returned.
* @return the key to which this map maps the specified value,
@@ -307,7 +307,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Removes the mapping for this value from this map if present.
* <p>
- * The value must implement <code>Comparable</code>.
+ * The value must implement {@code Comparable}.
*
* @param value value whose mapping is to be removed from the map
* @return previous key associated with specified value,
@@ -352,7 +352,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Gets the next key after the one specified.
* <p>
- * The key must implement <code>Comparable</code>.
+ * The key must implement {@code Comparable}.
*
* @param key the key to search for next from
* @return the next key, null if no match or at end
@@ -367,7 +367,7 @@ public class TreeBidiMap<K extends Comparable<K>, V extends Comparable<V>>
/**
* Gets the previous key before the one specified.
* <p>
- * The key must implement <code>Comparable</code>.
+ * The key must implement {@code Comparable}.
*
* @param key the key to search for previous from
* @return the previous key, null if no match or at start
diff --git a/src/main/java/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java b/src/main/java/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java
index c8d7280..7b58c8e 100644
--- a/src/main/java/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java
@@ -23,13 +23,13 @@ import java.util.Objects;
import java.util.function.Predicate;
/**
- * Decorates another <code>Collection</code> to provide additional behaviour.
+ * Decorates another {@code Collection} to provide additional behaviour.
* <p>
- * Each method call made on this <code>Collection</code> is forwarded to the
- * decorated <code>Collection</code>. This class is used as a framework on which
+ * Each method call made on this {@code Collection} is forwarded to the
+ * decorated {@code Collection}. This class is used as a framework on which
* to build to extensions such as synchronized and unmodifiable behaviour. The
* main advantage of decoration is that one decorator can wrap any implementation
- * of <code>Collection</code>, whereas sub-classing requires a new class to be
+ * of {@code Collection}, whereas sub-classing requires a new class to be
* written for each implementation.
* </p>
* <p>
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 1f41be2..4e6b575 100644
--- a/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
+++ b/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
@@ -94,7 +94,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Gets the size of this composite collection.
* <p>
- * This implementation calls <code>size()</code> on each collection.
+ * This implementation calls {@code size()} on each collection.
* </p>
* @return total number of elements in all contained containers
*/
@@ -110,7 +110,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Checks whether this composite collection is empty.
* <p>
- * This implementation calls <code>isEmpty()</code> on each collection.
+ * This implementation calls {@code isEmpty()} on each collection.
* </p>
* @return true if all of the contained collections are empty
*/
@@ -127,7 +127,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Checks whether this composite collection contains the object.
* <p>
- * This implementation calls <code>contains()</code> on each collection.
+ * This implementation calls {@code contains()} on each collection.
* </p>
* @param obj the object to search for
* @return true if obj is contained in any of the contained collections
@@ -145,10 +145,10 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Gets an iterator over all the collections in this composite.
* <p>
- * This implementation uses an <code>IteratorChain</code>.
+ * This implementation uses an {@code IteratorChain}.
* </p>
- * @return an <code>IteratorChain</code> instance which supports
- * <code>remove()</code>. Iteration occurs over contained collections in
+ * @return an {@code IteratorChain} instance which supports
+ * {@code remove()}. Iteration occurs over contained collections in
* the order they were added, but this behavior should not be relied upon.
* @see IteratorChain
*/
@@ -181,7 +181,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Returns an object array, populating the supplied array if possible.
- * See <code>Collection</code> interface for full details.
+ * See {@code Collection} interface for full details.
*
* @param <T> the type of the elements in the collection
* @param array the array to use, populating if possible
@@ -254,7 +254,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Checks whether this composite contains all the elements in the specified collection.
* <p>
- * This implementation calls <code>contains()</code> for each element in the
+ * This implementation calls {@code contains()} for each element in the
* specified collection.
* </p>
* @param coll the collection to check for
@@ -297,7 +297,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Removes the elements in the specified collection from this composite collection.
* <p>
- * This implementation calls <code>removeAll</code> on each collection.
+ * This implementation calls {@code removeAll} on each collection.
* </p>
* @param coll the collection to remove
* @return true if the collection was modified
@@ -318,7 +318,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Removes all of the elements of this collection that satisfy the given predicate from this composite collection.
* <p>
- * This implementation calls <code>removeIf</code> on each collection.
+ * This implementation calls {@code removeIf} on each collection.
* </p>
* @param filter a predicate which returns true for elements to be removed
* @return true if the collection was modified
@@ -341,7 +341,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
* Retains all the elements in the specified collection in this composite collection,
* removing all others.
* <p>
- * This implementation calls <code>retainAll()</code> on each collection.
+ * This implementation calls {@code retainAll()} on each collection.
* </p>
* @param coll the collection to remove
* @return true if the collection was modified
@@ -361,7 +361,7 @@ public class CompositeCollection<E> implements Collection<E>, Serializable {
/**
* Removes all of the elements from this collection .
* <p>
- * This implementation calls <code>clear()</code> on each collection.
+ * This implementation calls {@code clear()} on each collection.
* </p>
* @throws UnsupportedOperationException if clear is unsupported
*/
diff --git a/src/main/java/org/apache/commons/collections4/collection/UnmodifiableBoundedCollection.java b/src/main/java/org/apache/commons/collections4/collection/UnmodifiableBoundedCollection.java
index 3a2b9f2..baa36f5 100644
--- a/src/main/java/org/apache/commons/collections4/collection/UnmodifiableBoundedCollection.java
+++ b/src/main/java/org/apache/commons/collections4/collection/UnmodifiableBoundedCollection.java
@@ -55,7 +55,7 @@ public final class UnmodifiableBoundedCollection<E> extends AbstractCollectionDe
* Factory method to create an unmodifiable bounded collection.
*
* @param <E> the type of the elements in the collection
- * @param coll the <code>BoundedCollection</code> to decorate, must not be null
+ * @param coll the {@code BoundedCollection} to decorate, must not be null
* @return a new unmodifiable bounded collection
* @throws NullPointerException if {@code coll} is {@code null}
* @since 4.0
@@ -76,7 +76,7 @@ public final class UnmodifiableBoundedCollection<E> extends AbstractCollectionDe
* to find a suitable BoundedCollection.
*
* @param <E> the type of the elements in the collection
- * @param collection the <code>BoundedCollection</code> to decorate, must not be null
+ * @param collection the {@code BoundedCollection} to decorate, must not be null
* @return a new unmodifiable bounded collection
* @throws NullPointerException if coll is null
* @throws IllegalArgumentException if coll is not a {@code BoundedCollection}
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 83be390..7d27355 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
@@ -40,13 +40,13 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
/** Constant "false first" reference. */
private static final BooleanComparator FALSE_FIRST = new BooleanComparator(false);
- /** <code>true</code> iff <code>true</code> values sort before <code>false</code> values. */
+ /** {@code true} iff {@code true} values sort before {@code false} values. */
private boolean trueFirst = false;
//-----------------------------------------------------------------------
/**
* Returns a BooleanComparator instance that sorts
- * <code>true</code> values before <code>false</code> values.
+ * {@code true} values before {@code false} values.
* <p>
* Clients are encouraged to use the value returned from
* this method instead of constructing a new instance
@@ -63,7 +63,7 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
/**
* Returns a BooleanComparator instance that sorts
- * <code>false</code> values before <code>true</code> values.
+ * {@code false} values before {@code true} values.
* <p>
* Clients are encouraged to use the value returned from
* this method instead of constructing a new instance
@@ -80,8 +80,8 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
/**
* Returns a BooleanComparator instance that sorts
- * <code><i>trueFirst</i></code> values before
- * <code>!<i>trueFirst</i></code> values.
+ * {@code <i>trueFirst</i>} values before
+ * {@code !<i>trueFirst</i>} values.
* <p>
* Clients are encouraged to use the value returned from
* this method instead of constructing a new instance
@@ -90,8 +90,8 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
* virtual machine.
* </p>
*
- * @param trueFirst when <code>true</code>, sort
- * <code>true</code> <code>Boolean</code>s before <code>false</code>
+ * @param trueFirst when {@code true}, sort
+ * {@code true} {@code Boolean}s before {@code false}
* @return a singleton BooleanComparator instance
* @since 4.0
*/
@@ -101,8 +101,8 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
//-----------------------------------------------------------------------
/**
- * Creates a <code>BooleanComparator</code> that sorts
- * <code>false</code> values before <code>true</code> values.
+ * Creates a {@code BooleanComparator} that sorts
+ * {@code false} values before {@code true} values.
* <p>
* Equivalent to {@link #BooleanComparator(boolean) BooleanComparator(false)}.
* <p>
@@ -113,14 +113,14 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
}
/**
- * Creates a <code>BooleanComparator</code> that sorts
- * <code><i>trueFirst</i></code> values before
- * <code>!<i>trueFirst</i></code> values.
+ * Creates a {@code BooleanComparator} that sorts
+ * {@code <i>trueFirst</i>} values before
+ * {@code !<i>trueFirst</i>} values.
* <p>
* Please use the static factories instead whenever possible.
*
- * @param trueFirst when <code>true</code>, sort
- * <code>true</code> boolean values before <code>false</code>
+ * @param trueFirst when {@code true}, sort
+ * {@code true} boolean values before {@code false}
*/
public BooleanComparator(final boolean trueFirst) {
this.trueFirst = trueFirst;
@@ -128,13 +128,13 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
//-----------------------------------------------------------------------
/**
- * Compares two non-<code>null</code> <code>Boolean</code> objects
+ * Compares two non-{@code null} {@code Boolean} objects
* according to the value of {@link #sortsTrueFirst()}.
*
* @param b1 the first boolean to compare
* @param b2 the second boolean to compare
* @return negative if obj1 is less, positive if greater, zero if equal
- * @throws NullPointerException when either argument <code>null</code>
+ * @throws NullPointerException when either argument {@code null}
*/
@Override
public int compare(final Boolean b1, final Boolean b2) {
@@ -158,12 +158,12 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
}
/**
- * Returns <code>true</code> iff <i>that</i> Object is
+ * Returns {@code true} iff <i>that</i> Object is
* is a {@link Comparator} whose ordering is known to be
* equivalent to mine.
* <p>
- * This implementation returns <code>true</code>
- * iff <code><i>that</i></code> is a {@link BooleanComparator}
+ * This implementation returns {@code true}
+ * iff {@code <i>that</i>} is a {@link BooleanComparator}
* whose value of {@link #sortsTrueFirst()} is equal to mine.
*
* @param object the object to compare to
@@ -178,10 +178,10 @@ public final class BooleanComparator implements Comparator<Boolean>, Serializabl
//-----------------------------------------------------------------------
/**
- * Returns <code>true</code> iff
- * I sort <code>true</code> values before
- * <code>false</code> values. In other words,
- * returns <code>true</code> iff
+ * Returns {@code true} iff
+ * I sort {@code true} values before
+ * {@code false} values. In other words,
+ * returns {@code true} iff
* {@link #compare(Boolean,Boolean) compare(Boolean.FALSE,Boolean.TRUE)}
* returns a positive value.
*
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 c22fd5c..0412c58 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/ComparableComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/ComparableComparator.java
@@ -30,7 +30,7 @@ import java.util.Comparator;
* <p>
* Note: In the 2.0 and 2.1 releases of Commons Collections, this class would
* throw a {@link ClassCastException} if either of the arguments to
- * {@link #compare(Object, Object) compare} were <code>null</code>, not
+ * {@link #compare(Object, Object) compare} were {@code null}, not
* {@link Comparable Comparable}, or for which
* {@link Comparable#compareTo(Object) compareTo} gave inconsistent results.
* This is no longer the case. See {@link #compare(Object, Object) compare} for
@@ -86,10 +86,10 @@ 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</code>,
- * or when <code>((Comparable)obj1).compareTo(obj2)</code> does
- * @throws ClassCastException if <i>obj1</i> is not a <code>Comparable</code>,
- * or when <code>((Comparable)obj1).compareTo(obj2)</code> does
+ * @throws NullPointerException if <i>obj1</i> is {@code null},
+ * or when {@code ((Comparable)obj1).compareTo(obj2)} does
+ * @throws ClassCastException if <i>obj1</i> is not a {@code Comparable},
+ * or when {@code ((Comparable)obj1).compareTo(obj2)} does
*/
@Override
public int compare(final E obj1, final E obj2) {
@@ -114,8 +114,8 @@ public class ComparableComparator<E extends Comparable<? super E>> implements Co
* whose ordering is known to be equivalent to mine.
* <p>
* This implementation returns {@code true} iff
- * <code><i>object</i>.{@link Object#getClass() getClass()}</code> equals
- * <code>this.getClass()</code>. Subclasses may want to override this behavior to remain
+ * {@code <i>object</i>.{@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.
*
* @param object the object to compare with
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 576d850..0af0d5d 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
@@ -317,13 +317,13 @@ public class ComparatorChain<E> implements Comparator<E>, Serializable {
}
/**
- * Returns <code>true</code> iff <i>that</i> Object is
+ * Returns {@code true} iff <i>that</i> Object is
* is a {@link Comparator} whose ordering is known to be
* equivalent to mine.
* <p>
- * This implementation returns <code>true</code>
- * iff <code><i>object</i>.{@link Object#getClass() getClass()}</code>
- * equals <code>this.getClass()</code>, and the underlying
+ * This implementation returns {@code true}
+ * iff {@code <i>object</i>.{@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
* with the {@link Comparator#equals(Object)} contract.
diff --git a/src/main/java/org/apache/commons/collections4/comparators/FixedOrderComparator.java b/src/main/java/org/apache/commons/collections4/comparators/FixedOrderComparator.java
index fe3b51c..c03a80b 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/FixedOrderComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/FixedOrderComparator.java
@@ -35,7 +35,7 @@ import java.util.Objects;
* Arrays.sort(planets, distanceFromSun); // Back to original order
* </pre>
* <p>
- * Once <code>compare</code> has been called, the FixedOrderComparator is locked
+ * Once {@code compare} has been called, the FixedOrderComparator is locked
* and attempts to modify it yield an UnsupportedOperationException.
* </p>
* <p>
@@ -260,12 +260,12 @@ public class FixedOrderComparator<T> implements Comparator<T>, Serializable {
}
/**
- * Returns <code>true</code> iff <i>that</i> Object is
+ * Returns {@code true} iff <i>that</i> Object is
* is a {@link Comparator} whose ordering is known to be
* equivalent to mine.
* <p>
- * This implementation returns <code>true</code>
- * iff <code><i>that</i></code> is a {@link FixedOrderComparator}
+ * This implementation returns {@code true}
+ * iff {@code <i>that</i>} is a {@link FixedOrderComparator}
* whose attributes are equal to mine.
*
* @param object the object to compare to
diff --git a/src/main/java/org/apache/commons/collections4/comparators/NullComparator.java b/src/main/java/org/apache/commons/collections4/comparators/NullComparator.java
index eca1376..6693735 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/NullComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/NullComparator.java
@@ -35,21 +35,21 @@ public class NullComparator<E> implements Comparator<E>, Serializable {
private static final long serialVersionUID = -5820772575483504339L;
/**
- * The comparator to use when comparing two non-<code>null</code> objects.
+ * The comparator to use when comparing two non-{@code null} objects.
**/
private final Comparator<? super E> nonNullComparator;
/**
- * Specifies whether a <code>null</code> are compared as higher than
- * non-<code>null</code> objects.
+ * Specifies whether a {@code null} are compared as higher than
+ * non-{@code null} objects.
**/
private final boolean nullsAreHigh;
//-----------------------------------------------------------------------
/**
- * Construct an instance that sorts <code>null</code> higher than any
- * non-<code>null</code> object it is compared with. When comparing two
- * non-<code>null</code> objects, the {@link ComparableComparator} is
+ * Construct an instance that sorts {@code null} higher than any
+ * non-{@code null} object it is compared with. When comparing two
+ * non-{@code null} objects, the {@link ComparableComparator} is
* used.
**/
public NullComparator() {
@@ -57,56 +57,56 @@ public class NullComparator<E> implements Comparator<E>, Serializable {
}
/**
- * Construct an instance that sorts <code>null</code> higher than any
- * non-<code>null</code> object it is compared with. When comparing two
- * non-<code>null</code> objects, the specified {@link Comparator} is
+ * Construct an instance that sorts {@code null} higher than any
+ * non-{@code null} object it is compared with. When comparing two
+ * non-{@code null} objects, the specified {@link Comparator} is
* used.
*
* @param nonNullComparator the comparator to use when comparing two
- * non-<code>null</code> objects. This argument cannot be
- * <code>null</code>
+ * non-{@code null} objects. This argument cannot be
+ * {@code null}
*
- * @throws NullPointerException if <code>nonNullComparator</code> is
- * <code>null</code>
+ * @throws NullPointerException if {@code nonNullComparator} is
+ * {@code null}
**/
public NullComparator(final Comparator<? super E> nonNullComparator) {
this(nonNullComparator, true);
}
/**
- * Construct an instance that sorts <code>null</code> higher or lower than
- * any non-<code>null</code> object it is compared with. When comparing
- * two non-<code>null</code> objects, the {@link ComparableComparator} is
+ * Construct an instance that sorts {@code null} higher or lower than
+ * any non-{@code null} object it is compared with. When comparing
+ * two non-{@code null} objects, the {@link ComparableComparator} is
* used.
*
- * @param nullsAreHigh a <code>true</code> value indicates that
- * <code>null</code> should be compared as higher than a
- * non-<code>null</code> object. A <code>false</code> value indicates
- * that <code>null</code> should be compared as lower than a
- * non-<code>null</code> object.
+ * @param nullsAreHigh a {@code true} value indicates that
+ * {@code null} should be compared as higher than a
+ * non-{@code null} object. A {@code false} value indicates
+ * that {@code null} should be compared as lower than a
+ * non-{@code null} object.
**/
public NullComparator(final boolean nullsAreHigh) {
this(ComparatorUtils.NATURAL_COMPARATOR, nullsAreHigh);
}
/**
- * Construct an instance that sorts <code>null</code> higher or lower than
- * any non-<code>null</code> object it is compared with. When comparing
- * two non-<code>null</code> objects, the specified {@link Comparator} is
+ * Construct an instance that sorts {@code null} higher or lower than
+ * any non-{@code null} object it is compared with. When comparing
+ * two non-{@code null} objects, the specified {@link Comparator} is
* used.
*
* @param nonNullComparator the comparator to use when comparing two
- * non-<code>null</code> objects. This argument cannot be
- * <code>null</code>
+ * non-{@code null} objects. This argument cannot be
+ * {@code null}
*
- * @param nullsAreHigh a <code>true</code> value indicates that
- * <code>null</code> should be compared as higher than a
- * non-<code>null</code> object. A <code>false</code> value indicates
- * that <code>null</code> should be compared as lower than a
- * non-<code>null</code> object.
+ * @param nullsAreHigh a {@code true} value indicates that
+ * {@code null} should be compared as higher than a
+ * non-{@code null} object. A {@code false} value indicates
+ * that {@code null} should be compared as lower than a
+ * non-{@code null} object.
*
- * @throws NullPointerException if <code>nonNullComparator</code> is
- * <code>null</code>
+ * @throws NullPointerException if {@code nonNullComparator} is
+ * {@code null}
**/
public NullComparator(final Comparator<? super E> nonNullComparator, final boolean nullsAreHigh) {
this.nonNullComparator = Objects.requireNonNull(nonNullComparator, "nonNullComparator");
@@ -116,19 +116,19 @@ public class NullComparator<E> implements Comparator<E>, Serializable {
//-----------------------------------------------------------------------
/**
* Perform a comparison between two objects. If both objects are
- * <code>null</code>, a <code>0</code> value is returned. If one object
- * is <code>null</code> and the other is not, the result is determined on
+ * {@code null}, a {@code 0} value is returned. If one object
+ * is {@code null} and the other is not, the result is determined on
* whether the Comparator was constructed to have nulls as higher or lower
- * than other objects. If neither object is <code>null</code>, an
+ * than other objects. If neither object is {@code null}, an
* underlying comparator specified in the constructor (or the default) is
- * used to compare the non-<code>null</code> objects.
+ * used to compare the non-{@code null} objects.
*
* @param o1 the first object to compare
* @param o2 the object to compare it to.
- * @return <code>-1</code> if <code>o1</code> is "lower" than (less than,
- * before, etc.) <code>o2</code>; <code>1</code> if <code>o1</code> is
- * "higher" than (greater than, after, etc.) <code>o2</code>; or
- * <code>0</code> if <code>o1</code> and <code>o2</code> are equal.
+ * @return {@code -1} if {@code o1} is "lower" than (less than,
+ * before, etc.) {@code o2}; {@code 1} if {@code o1} is
+ * "higher" than (greater than, after, etc.) {@code o2}; or
+ * {@code 0} if {@code o1} and {@code o2} are equal.
**/
@Override
public int compare(final E o1, final E o2) {
@@ -156,10 +156,10 @@ public class NullComparator<E> implements Comparator<E>, Serializable {
*
* @param obj the object to compare this comparator with.
*
- * @return <code>true</code> if the specified object is a NullComparator
- * with equivalent <code>null</code> comparison behavior
- * (i.e. <code>null</code> high or low) and with equivalent underlying
- * non-<code>null</code> object comparators.
+ * @return {@code true} if the specified object is a NullComparator
+ * with equivalent {@code null} comparison behavior
+ * (i.e. {@code null} high or low) and with equivalent underlying
+ * non-{@code null} object comparators.
**/
@Override
public boolean equals(final Object obj) {
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 77cf67c..f9a368d 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/ReverseComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/ReverseComparator.java
@@ -53,7 +53,7 @@ public class ReverseComparator<E> implements Comparator<E>, Serializable {
/**
* Creates a comparator that inverts the comparison
- * of the given comparator. If you pass in <code>null</code>,
+ * of the given comparator. If you pass in {@code null},
* the ReverseComparator defaults to reversing the
* natural order, as per {@link java.util.Collections#reverseOrder()}.
*
@@ -90,13 +90,13 @@ public class ReverseComparator<E> implements Comparator<E>, Serializable {
}
/**
- * Returns <code>true</code> iff <i>that</i> Object is
+ * Returns {@code true} iff <i>that</i> Object is
* is a {@link Comparator} whose ordering is known to be
* equivalent to mine.
* <p>
- * This implementation returns <code>true</code>
- * iff <code><i>object</i>.{@link Object#getClass() getClass()}</code>
- * equals <code>this.getClass()</code>, and the underlying
+ * This implementation returns {@code true}
+ * iff {@code <i>object</i>.{@link Object#getClass() getClass()}}
+ * equals {@code this.getClass()}, and the underlying
* comparators are equal.
* Subclasses may want to override this behavior to remain consistent
* with the {@link Comparator#equals(Object) equals} contract.
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 3d5ec90..41a75cb 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/TransformingComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/TransformingComparator.java
@@ -53,7 +53,7 @@ public class TransformingComparator<I, O> implements Comparator<I>, Serializable
* Constructs an instance with the given Transformer and a
* {@link ComparableComparator ComparableComparator}.
*
- * @param transformer what will transform the arguments to <code>compare</code>
+ * @param transformer what will transform the arguments to {@code compare}
*/
public TransformingComparator(final Transformer<? super I, ? extends O> transformer) {
this(transformer, ComparatorUtils.NATURAL_COMPARATOR);
@@ -62,7 +62,7 @@ public class TransformingComparator<I, O> implements Comparator<I>, Serializable
/**
* Constructs an instance with the given Transformer and Comparator.
*
- * @param transformer what will transform the arguments to <code>compare</code>
+ * @param transformer what will transform the arguments to {@code compare}
* @param decorated the decorated Comparator
*/
public TransformingComparator(final Transformer<? super I, ? extends O> transformer,
@@ -102,12 +102,12 @@ public class TransformingComparator<I, O> implements Comparator<I>, Serializable
}
/**
- * Returns <code>true</code> iff <i>that</i> Object is
+ * Returns {@code true} iff <i>that</i> Object is
* is a {@link Comparator} whose ordering is known to be
* equivalent to mine.
* <p>
- * This implementation returns <code>true</code>
- * iff <code><i>that</i></code> is a {@link TransformingComparator}
+ * This implementation returns {@code true}
+ * iff {@code <i>that</i>} 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/functors/AllPredicate.java b/src/main/java/org/apache/commons/collections4/functors/AllPredicate.java
index dc66f41..92cd3a0 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AllPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AllPredicate.java
@@ -48,7 +48,7 @@ public final class AllPredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>all</code> predicate
+ * @return the {@code all} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -72,7 +72,7 @@ public final class AllPredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>all</code> predicate
+ * @return the {@code all} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -89,7 +89,7 @@ public final class AllPredicate<T> extends AbstractQuantifierPredicate<T> {
/**
* Constructor that performs no validation.
- * Use <code>allPredicate</code> if you want that.
+ * Use {@code allPredicate} if you want that.
*
* @param predicates the predicates to check, not cloned, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java b/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
index b53c59c..0c14cf2 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
@@ -42,7 +42,7 @@ public final class AndPredicate<T> implements PredicateDecorator<T>, Serializabl
* @param <T> the type that the predicate queries
* @param predicate1 the first predicate to check, not null
* @param predicate2 the second predicate to check, not null
- * @return the <code>and</code> predicate
+ * @return the {@code and} predicate
* @throws NullPointerException if either predicate is null
*/
public static <T> Predicate<T> andPredicate(final Predicate<? super T> predicate1,
@@ -53,7 +53,7 @@ public final class AndPredicate<T> implements PredicateDecorator<T>, Serializabl
/**
* Constructor that performs no validation.
- * Use <code>andPredicate</code> if you want that.
+ * Use {@code andPredicate} if you want that.
*
* @param predicate1 the first predicate to check, not null
* @param predicate2 the second predicate to check, not null
diff --git a/src/main/java/org/apache/commons/collections4/functors/AnyPredicate.java b/src/main/java/org/apache/commons/collections4/functors/AnyPredicate.java
index e735800..19679c1 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AnyPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AnyPredicate.java
@@ -44,7 +44,7 @@ public final class AnyPredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>any</code> predicate
+ * @return the {@code any} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -68,7 +68,7 @@ public final class AnyPredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>all</code> predicate
+ * @return the {@code all} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -86,7 +86,7 @@ public final class AnyPredicate<T> extends AbstractQuantifierPredicate<T> {
/**
* Constructor that performs no validation.
- * Use <code>anyPredicate</code> if you want that.
+ * Use {@code anyPredicate} if you want that.
*
* @param predicates the predicates to check, not cloned, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/ChainedClosure.java b/src/main/java/org/apache/commons/collections4/functors/ChainedClosure.java
index 235e7c9..94a360e 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ChainedClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ChainedClosure.java
@@ -40,7 +40,7 @@ public class ChainedClosure<E> implements Closure<E>, Serializable {
*
* @param <E> the type that the closure acts on
* @param closures the closures to chain, copied, no nulls
- * @return the <code>chained</code> closure
+ * @return the {@code chained} closure
* @throws NullPointerException if the closures array is null
* @throws NullPointerException if any closure in the array is null
*/
@@ -59,7 +59,7 @@ public class ChainedClosure<E> implements Closure<E>, Serializable {
*
* @param <E> the type that the closure acts on
* @param closures a collection of closures to chain
- * @return the <code>chained</code> closure
+ * @return the {@code chained} closure
* @throws NullPointerException if the closures collection is null
* @throws NullPointerException if any closure in the collection is null
*/
@@ -92,7 +92,7 @@ public class ChainedClosure<E> implements Closure<E>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>chainedClosure</code> if you want that.
+ * Use {@code chainedClosure} if you want that.
*
* @param closures the closures to chain, copied, no nulls
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/ChainedTransformer.java b/src/main/java/org/apache/commons/collections4/functors/ChainedTransformer.java
index 34368c5..28ab875 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ChainedTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ChainedTransformer.java
@@ -44,7 +44,7 @@ public class ChainedTransformer<T> implements Transformer<T, T>, Serializable {
*
* @param <T> the object type
* @param transformers the transformers to chain, copied, no nulls
- * @return the <code>chained</code> transformer
+ * @return the {@code chained} transformer
* @throws NullPointerException if the transformers array is null
* @throws NullPointerException if any transformer in the array is null
*/
@@ -63,7 +63,7 @@ public class ChainedTransformer<T> implements Transformer<T, T>, Serializable {
*
* @param <T> the object type
* @param transformers a collection of transformers to chain
- * @return the <code>chained</code> transformer
+ * @return the {@code chained} transformer
* @throws NullPointerException if the transformers collection is null
* @throws NullPointerException if any transformer in the collection is null
*/
@@ -92,7 +92,7 @@ public class ChainedTransformer<T> implements Transformer<T, T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>chainedTransformer</code> if you want that.
+ * Use {@code chainedTransformer} if you want that.
*
* @param transformers the transformers to chain, copied, no nulls
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/CloneTransformer.java b/src/main/java/org/apache/commons/collections4/functors/CloneTransformer.java
index a01eba0..6775b1a 100644
--- a/src/main/java/org/apache/commons/collections4/functors/CloneTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/CloneTransformer.java
@@ -21,7 +21,7 @@ import org.apache.commons.collections4.Transformer;
/**
* Transformer implementation that returns a clone of the input object.
* <p>
- * Clone is performed using <code>PrototypeFactory.prototypeFactory(input).create()</code>.
+ * Clone is performed using {@code PrototypeFactory.prototypeFactory(input).create()}.
* </p>
* <p>
* <b>WARNING:</b> from v4.1 onwards this class will <b>not</b> be serializable anymore
diff --git a/src/main/java/org/apache/commons/collections4/functors/ClosureTransformer.java b/src/main/java/org/apache/commons/collections4/functors/ClosureTransformer.java
index 91c1c34..8ab9f8f 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ClosureTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ClosureTransformer.java
@@ -41,7 +41,7 @@ public class ClosureTransformer<T> implements Transformer<T, T>, Serializable {
*
* @param <T> the type of the object to transform
* @param closure the closure to call, not null
- * @return the <code>closure</code> transformer
+ * @return the {@code closure} transformer
* @throws NullPointerException if the closure is null
*/
public static <T> Transformer<T, T> closureTransformer(final Closure<? super T> closure) {
@@ -50,7 +50,7 @@ public class ClosureTransformer<T> implements Transformer<T, T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>closureTransformer</code> if you want that.
+ * Use {@code closureTransformer} if you want that.
*
* @param closure the closure to call, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/ComparatorPredicate.java b/src/main/java/org/apache/commons/collections4/functors/ComparatorPredicate.java
index 7f17933..17ef0bd 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ComparatorPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ComparatorPredicate.java
@@ -41,16 +41,16 @@ import org.apache.commons.collections4.Predicate;
* };
* </pre>
*
- * <p>Using the declared variables, the <code>ComparatorPredicate</code> can be used used in the
+ * <p>Using the declared variables, the {@code ComparatorPredicate} can be used used in the
* following way:</p>
*
* <pre>
* ComparatorPredicate.comparatorPredicate(ONE, comparator).evaluate(TWO);
* </pre>
*
- * <p>The input variable <code>TWO</code> in compared to the stored variable <code>ONE</code> using
- * the supplied <code>comparator</code>. This is the default usage of the predicate and will return
- * <code>true</code> if the underlying comparator returns <code>0</code>. In addition to the default
+ * <p>The input variable {@code TWO} in compared to the stored variable {@code ONE} using
+ * the supplied {@code comparator}. This is the default usage of the predicate and will return
+ * {@code true} if the underlying comparator returns {@code 0}. In addition to the default
* usage of the predicate, it is possible to evaluate the comparator's result in several ways. The
* following {@link Criterion} enumeration values are provided by the predicate:
* </p>
@@ -70,9 +70,9 @@ import org.apache.commons.collections4.Predicate;
* ComparatorPredicate.comparatorPredicate(ONE, comparator,<b>ComparatorPredicate.Criterion.GREATER</b>).evaluate(TWO);
* </pre>
*
- * <p>The input variable TWO is compared to the stored variable ONE using the supplied <code>comparator</code>
- * using the <code>GREATER</code> evaluation criterion constant. This instructs the predicate to
- * return <code>true</code> if the comparator returns a value greater than <code>0</code>.</p>
+ * <p>The input variable TWO is compared to the stored variable ONE using the supplied {@code comparator}
+ * using the {@code GREATER} evaluation criterion constant. This instructs the predicate to
+ * return {@code true} if the comparator returns a value greater than {@code 0}.</p>
*
* @since 4.0
*/
@@ -126,7 +126,7 @@ public class ComparatorPredicate<T> implements Predicate<T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>comparatorPredicate</code> if you want that.
+ * Use {@code comparatorPredicate} if you want that.
*
* @param object the object to compare to
* @param comparator the comparator to use for comparison
@@ -140,14 +140,14 @@ public class ComparatorPredicate<T> implements Predicate<T>, Serializable {
}
/**
- * Evaluates the predicate. The predicate evaluates to <code>true</code> in the following cases:
+ * Evaluates the predicate. The predicate evaluates to {@code true} in the following cases:
*
* <ul>
- * <li><code>comparator.compare(object, input) == 0 && criterion == EQUAL</code></li>
- * <li><code>comparator.compare(object, input) < 0 && criterion == LESS</code></li>
- * <li><code>comparator.compare(object, input) > 0 && criterion == GREATER</code></li>
- * <li><code>comparator.compare(object, input) >= 0 && criterion == GREATER_OR_EQUAL</code></li>
- * <li><code>comparator.compare(object, input) <= 0 && criterion == LESS_OR_EQUAL</code></li>
+ * <li>{@code comparator.compare(object, input) == 0 && criterion == EQUAL}</li>
+ * <li>{@code comparator.compare(object, input) < 0 && criterion == LESS}</li>
+ * <li>{@code comparator.compare(object, input) > 0 && criterion == GREATER}</li>
+ * <li>{@code comparator.compare(object, input) >= 0 && criterion == GREATER_OR_EQUAL}</li>
+ * <li>{@code comparator.compare(object, input) <= 0 && criterion == LESS_OR_EQUAL}</li>
* </ul>
*
* @see org.apache.commons.collections4.Predicate#evaluate(java.lang.Object)
diff --git a/src/main/java/org/apache/commons/collections4/functors/ConstantFactory.java b/src/main/java/org/apache/commons/collections4/functors/ConstantFactory.java
index b915ee4..a033bc0 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ConstantFactory.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ConstantFactory.java
@@ -47,7 +47,7 @@ public class ConstantFactory<T> implements Factory<T>, Serializable {
*
* @param <T> the type of the constant
* @param constantToReturn the constant object to return each time in the factory
- * @return the <code>constant</code> factory.
+ * @return the {@code constant} factory.
*/
public static <T> Factory<T> constantFactory(final T constantToReturn) {
if (constantToReturn == null) {
@@ -58,7 +58,7 @@ public class ConstantFactory<T> implements Factory<T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>constantFactory</code> if you want that.
+ * Use {@code constantFactory} if you want that.
*
* @param constantToReturn the constant to return each time
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/ConstantTransformer.java b/src/main/java/org/apache/commons/collections4/functors/ConstantTransformer.java
index dd33e47..cf1eb04 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ConstantTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ConstantTransformer.java
@@ -59,7 +59,7 @@ public class ConstantTransformer<I, O> implements Transformer<I, O>, Serializabl
* @param <I> the input type
* @param <O> the output type
* @param constantToReturn the constant object to return each time in the factory
- * @return the <code>constant</code> factory.
+ * @return the {@code constant} factory.
*/
public static <I, O> Transformer<I, O> constantTransformer(final O constantToReturn) {
if (constantToReturn == null) {
@@ -70,7 +70,7 @@ public class ConstantTransformer<I, O> implements Transformer<I, O>, Serializabl
/**
* Constructor that performs no validation.
- * Use <code>constantTransformer</code> if you want that.
+ * Use {@code constantTransformer} if you want that.
*
* @param constantToReturn the constant to return each time
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/DefaultEquator.java b/src/main/java/org/apache/commons/collections4/functors/DefaultEquator.java
index c2d719d..4149658 100644
--- a/src/main/java/org/apache/commons/collections4/functors/DefaultEquator.java
+++ b/src/main/java/org/apache/commons/collections4/functors/DefaultEquator.java
@@ -36,7 +36,7 @@ public class DefaultEquator<T> implements Equator<T>, Serializable {
public static final DefaultEquator INSTANCE = new DefaultEquator<>();
/**
- * Hashcode used for <code>null</code> objects.
+ * Hashcode used for {@code null} objects.
*/
public static final int HASHCODE_NULL = -1;
@@ -68,8 +68,8 @@ public class DefaultEquator<T> implements Equator<T>, Serializable {
/**
* {@inheritDoc}
*
- * @return <code>o.hashCode()</code> if <code>o</code> is non-
- * <code>null</code>, else {@link #HASHCODE_NULL}.
+ * @return {@code o.hashCode()} if {@code o} is non-
+ * {@code null}, else {@link #HASHCODE_NULL}.
*/
@Override
public int hash(final T o) {
diff --git a/src/main/java/org/apache/commons/collections4/functors/EqualPredicate.java b/src/main/java/org/apache/commons/collections4/functors/EqualPredicate.java
index 90ed037..b7ca4be 100644
--- a/src/main/java/org/apache/commons/collections4/functors/EqualPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/EqualPredicate.java
@@ -70,7 +70,7 @@ public final class EqualPredicate<T> implements Predicate<T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>equalPredicate</code> if you want that.
+ * Use {@code equalPredicate} if you want that.
*
* @param object the object to compare to
*/
@@ -82,7 +82,7 @@ public final class EqualPredicate<T> implements Predicate<T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>equalPredicate</code> if you want that.
+ * Use {@code equalPredicate} if you want that.
*
* @param object the object to compare to
* @param equator the equator to use for comparison
diff --git a/src/main/java/org/apache/commons/collections4/functors/FactoryTransformer.java b/src/main/java/org/apache/commons/collections4/functors/FactoryTransformer.java
index 53a465f..a6feef7 100644
--- a/src/main/java/org/apache/commons/collections4/functors/FactoryTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/FactoryTransformer.java
@@ -41,7 +41,7 @@ public class FactoryTransformer<I, O> implements Transformer<I, O>, Serializable
* @param <I> the input type
* @param <O> the output type
* @param factory the factory to call, not null
- * @return the <code>factory</code> transformer
+ * @return the {@code factory} transformer
* @throws NullPointerException if the factory is null
*/
public static <I, O> Transformer<I, O> factoryTransformer(final Factory<? extends O> factory) {
@@ -50,7 +50,7 @@ public class FactoryTransformer<I, O> implements Transformer<I, O>, Serializable
/**
* Constructor that performs no validation.
- * Use <code>factoryTransformer</code> if you want that.
+ * Use {@code factoryTransformer} if you want that.
*
* @param factory the factory to call, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/ForClosure.java b/src/main/java/org/apache/commons/collections4/functors/ForClosure.java
index 0055af5..f4a7235 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ForClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ForClosure.java
@@ -39,13 +39,13 @@ public class ForClosure<E> implements Closure<E> {
/**
* Factory method that performs validation.
* <p>
- * A null closure or zero count returns the <code>NOPClosure</code>.
+ * A null closure or zero count returns the {@code NOPClosure}.
* A count of one returns the specified closure.
*
* @param <E> the type that the closure acts on
* @param count the number of times to execute the closure
* @param closure the closure to execute, not null
- * @return the <code>for</code> closure
+ * @return the {@code for} closure
*/
@SuppressWarnings("unchecked")
public static <E> Closure<E> forClosure(final int count, final Closure<? super E> closure) {
@@ -60,7 +60,7 @@ public class ForClosure<E> implements Closure<E> {
/**
* Constructor that performs no validation.
- * Use <code>forClosure</code> if you want that.
+ * Use {@code forClosure} if you want that.
*
* @param count the number of times to execute the closure
* @param closure the closure to execute, not null
@@ -72,7 +72,7 @@ public class ForClosure<E> implements Closure<E> {
}
/**
- * Executes the closure <code>count</code> times.
+ * Executes the closure {@code count} times.
*
* @param input the input object
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/IdentityPredicate.java b/src/main/java/org/apache/commons/collections4/functors/IdentityPredicate.java
index 2687c14..eb20300 100644
--- a/src/main/java/org/apache/commons/collections4/functors/IdentityPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/IdentityPredicate.java
@@ -50,7 +50,7 @@ public final class IdentityPredicate<T> implements Predicate<T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>identityPredicate</code> if you want that.
+ * Use {@code identityPredicate} if you want that.
*
* @param object the object to compare to
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/IfClosure.java b/src/main/java/org/apache/commons/collections4/functors/IfClosure.java
index 0d8e59c..6fd7146 100644
--- a/src/main/java/org/apache/commons/collections4/functors/IfClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/IfClosure.java
@@ -49,7 +49,7 @@ public class IfClosure<E> implements Closure<E>, Serializable {
* @param <E> the type that the closure acts on
* @param predicate predicate to switch on
* @param trueClosure closure used if true
- * @return the <code>if</code> closure
+ * @return the {@code if} closure
* @throws NullPointerException if either argument is null
* @since 3.2
*/
@@ -64,7 +64,7 @@ public class IfClosure<E> implements Closure<E>, Serializable {
* @param predicate predicate to switch on
* @param trueClosure closure used if true
* @param falseClosure closure used if false
- * @return the <code>if</code> closure
+ * @return the {@code if} closure
* @throws NullPointerException if any argument is null
*/
public static <E> Closure<E> ifClosure(final Predicate<? super E> predicate,
@@ -77,7 +77,7 @@ public class IfClosure<E> implements Closure<E>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>ifClosure</code> if you want that.
+ * Use {@code ifClosure} if you want that.
* <p>
* This constructor creates a closure that performs no action when
* the predicate is false.
@@ -92,7 +92,7 @@ public class IfClosure<E> implements Closure<E>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>ifClosure</code> if you want that.
+ * Use {@code ifClosure} if you want that.
*
* @param predicate predicate to switch on, not null
* @param trueClosure closure used if true, not null
diff --git a/src/main/java/org/apache/commons/collections4/functors/IfTransformer.java b/src/main/java/org/apache/commons/collections4/functors/IfTransformer.java
index 37bd67a..f9e7911 100644
--- a/src/main/java/org/apache/commons/collections4/functors/IfTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/IfTransformer.java
@@ -51,7 +51,7 @@ public class IfTransformer<I, O> implements Transformer<I, O>, Serializable {
* @param predicate predicate to switch on
* @param trueTransformer transformer used if true
* @param falseTransformer transformer used if false
- * @return the <code>if</code> transformer
+ * @return the {@code if} transformer
* @throws NullPointerException if either argument is null
*/
public static <I, O> Transformer<I, O> ifTransformer(final Predicate<? super I> predicate,
@@ -71,7 +71,7 @@ public class IfTransformer<I, O> implements Transformer<I, O>, Serializable {
* @param <T> input and output type for the transformer
* @param predicate predicate to switch on
* @param trueTransformer transformer used if true
- * @return the <code>if</code> transformer
+ * @return the {@code if} transformer
* @throws NullPointerException if either argument is null
*/
public static <T> Transformer<T, T> ifTransformer(
@@ -83,7 +83,7 @@ public class IfTransformer<I, O> implements Transformer<I, O>, Serializable {
/**
* Constructor that performs no validation.
- * Use the static factory method <code>ifTransformer</code> if you want that.
+ * Use the static factory method {@code ifTransformer} if you want that.
*
* @param predicate predicate to switch on, not null
* @param trueTransformer transformer used if true, not null
diff --git a/src/main/java/org/apache/commons/collections4/functors/InstanceofPredicate.java b/src/main/java/org/apache/commons/collections4/functors/InstanceofPredicate.java
index 3a1c7a7..991dd0f 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InstanceofPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InstanceofPredicate.java
@@ -48,7 +48,7 @@ public final class InstanceofPredicate implements Predicate<Object>, Serializabl
/**
* Constructor that performs no validation.
- * Use <code>instanceOfPredicate</code> if you want that.
+ * Use {@code instanceOfPredicate} if you want that.
*
* @param type the type to check for
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/InstantiateFactory.java b/src/main/java/org/apache/commons/collections4/functors/InstantiateFactory.java
index 7cbb456..23c4612 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InstantiateFactory.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InstantiateFactory.java
@@ -74,7 +74,7 @@ public class InstantiateFactory<T> implements Factory<T> {
/**
* Constructor that performs no validation.
- * Use <code>instantiateFactory</code> if you want that.
+ * Use {@code instantiateFactory} if you want that.
*
* @param classToInstantiate the class to instantiate
*/
@@ -88,7 +88,7 @@ public class InstantiateFactory<T> implements Factory<T> {
/**
* Constructor that performs no validation.
- * Use <code>instantiateFactory</code> if you want that.
+ * Use {@code instantiateFactory} if you want that.
*
* @param classToInstantiate the class to instantiate
* @param paramTypes the constructor parameter types, cloned
diff --git a/src/main/java/org/apache/commons/collections4/functors/InstantiateTransformer.java b/src/main/java/org/apache/commons/collections4/functors/InstantiateTransformer.java
index 7ae7246..cd419a9 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InstantiateTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InstantiateTransformer.java
@@ -88,7 +88,7 @@ public class InstantiateTransformer<T> implements Transformer<Class<? extends T>
/**
* Constructor that performs no validation.
- * Use <code>instantiateTransformer</code> if you want that.
+ * Use {@code instantiateTransformer} if you want that.
* <p>
* Note: from 4.0, the input parameters will be cloned
*
diff --git a/src/main/java/org/apache/commons/collections4/functors/InvokerTransformer.java b/src/main/java/org/apache/commons/collections4/functors/InvokerTransformer.java
index d15d3ec..293f808 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InvokerTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InvokerTransformer.java
@@ -97,7 +97,7 @@ public class InvokerTransformer<I, O> implements Transformer<I, O> {
/**
* Constructor that performs no validation.
- * Use <code>invokerTransformer</code> if you want that.
+ * Use {@code invokerTransformer} if you want that.
* <p>
* Note: from 4.0, the input parameters will be cloned
*
diff --git a/src/main/java/org/apache/commons/collections4/functors/MapTransformer.java b/src/main/java/org/apache/commons/collections4/functors/MapTransformer.java
index 7e9b75a..01f16fa 100644
--- a/src/main/java/org/apache/commons/collections4/functors/MapTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/MapTransformer.java
@@ -54,7 +54,7 @@ public final class MapTransformer<I, O> implements Transformer<I, O>, Serializab
/**
* Constructor that performs no validation.
- * Use <code>mapTransformer</code> if you want that.
+ * Use {@code mapTransformer} if you want that.
*
* @param map the map to use for lookup, not cloned
*/
@@ -64,7 +64,7 @@ public final class MapTransformer<I, O> implements Transformer<I, O>, Serializab
}
/**
- * Transforms the input to result by looking it up in a <code>Map</code>.
+ * Transforms the input to result by looking it up in a {@code Map}.
*
* @param input the input object to transform
* @return the transformed result
diff --git a/src/main/java/org/apache/commons/collections4/functors/NonePredicate.java b/src/main/java/org/apache/commons/collections4/functors/NonePredicate.java
index bf5cae1..6de6e8d 100644
--- a/src/main/java/org/apache/commons/collections4/functors/NonePredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/NonePredicate.java
@@ -43,7 +43,7 @@ public final class NonePredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>any</code> predicate
+ * @return the {@code any} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -62,7 +62,7 @@ public final class NonePredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>one</code> predicate
+ * @return the {@code one} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -76,7 +76,7 @@ public final class NonePredicate<T> extends AbstractQuantifierPredicate<T> {
/**
* Constructor that performs no validation.
- * Use <code>nonePredicate</code> if you want that.
+ * Use {@code nonePredicate} if you want that.
*
* @param predicates the predicates to check, not cloned, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/NotPredicate.java b/src/main/java/org/apache/commons/collections4/functors/NotPredicate.java
index bc56917..77f36d6 100644
--- a/src/main/java/org/apache/commons/collections4/functors/NotPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/NotPredicate.java
@@ -48,7 +48,7 @@ public final class NotPredicate<T> implements PredicateDecorator<T>, Serializabl
/**
* Constructor that performs no validation.
- * Use <code>notPredicate</code> if you want that.
+ * Use {@code notPredicate} if you want that.
*
* @param predicate the predicate to call after the null check
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/NullIsExceptionPredicate.java b/src/main/java/org/apache/commons/collections4/functors/NullIsExceptionPredicate.java
index 875c246..4f90dd3 100644
--- a/src/main/java/org/apache/commons/collections4/functors/NullIsExceptionPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/NullIsExceptionPredicate.java
@@ -49,7 +49,7 @@ public final class NullIsExceptionPredicate<T> implements PredicateDecorator<T>,
/**
* Constructor that performs no validation.
- * Use <code>nullIsExceptionPredicate</code> if you want that.
+ * Use {@code nullIsExceptionPredicate} if you want that.
*
* @param predicate the predicate to call after the null check
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/NullIsFalsePredicate.java b/src/main/java/org/apache/commons/collections4/functors/NullIsFalsePredicate.java
index 1ee6c9d..f52038a 100644
--- a/src/main/java/org/apache/commons/collections4/functors/NullIsFalsePredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/NullIsFalsePredicate.java
@@ -48,7 +48,7 @@ public final class NullIsFalsePredicate<T> implements PredicateDecorator<T>, Ser
/**
* Constructor that performs no validation.
- * Use <code>nullIsFalsePredicate</code> if you want that.
+ * Use {@code nullIsFalsePredicate} if you want that.
*
* @param predicate the predicate to call after the null check
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/NullIsTruePredicate.java b/src/main/java/org/apache/commons/collections4/functors/NullIsTruePredicate.java
index a86ee5f..028455c 100644
--- a/src/main/java/org/apache/commons/collections4/functors/NullIsTruePredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/NullIsTruePredicate.java
@@ -48,7 +48,7 @@ public final class NullIsTruePredicate<T> implements PredicateDecorator<T>, Seri
/**
* Constructor that performs no validation.
- * Use <code>nullIsTruePredicate</code> if you want that.
+ * Use {@code nullIsTruePredicate} if you want that.
*
* @param predicate the predicate to call after the null check
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/OnePredicate.java b/src/main/java/org/apache/commons/collections4/functors/OnePredicate.java
index d565fc0..3ff773c 100644
--- a/src/main/java/org/apache/commons/collections4/functors/OnePredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/OnePredicate.java
@@ -44,7 +44,7 @@ public final class OnePredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>any</code> predicate
+ * @return the {@code any} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -65,7 +65,7 @@ public final class OnePredicate<T> extends AbstractQuantifierPredicate<T> {
*
* @param <T> the type that the predicate queries
* @param predicates the predicates to check, cloned, not null
- * @return the <code>one</code> predicate
+ * @return the {@code one} predicate
* @throws NullPointerException if the predicates array is null
* @throws NullPointerException if any predicate in the array is null
*/
@@ -76,7 +76,7 @@ public final class OnePredicate<T> extends AbstractQuantifierPredicate<T> {
/**
* Constructor that performs no validation.
- * Use <code>onePredicate</code> if you want that.
+ * Use {@code onePredicate} if you want that.
*
* @param predicates the predicates to check, not cloned, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java b/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
index 9a6bda4..c2642b6 100644
--- a/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
@@ -42,7 +42,7 @@ public final class OrPredicate<T> implements PredicateDecorator<T>, Serializable
* @param <T> the type that the predicate queries
* @param predicate1 the first predicate to check, not null
* @param predicate2 the second predicate to check, not null
- * @return the <code>and</code> predicate
+ * @return the {@code and} predicate
* @throws NullPointerException if either predicate is null
*/
public static <T> Predicate<T> orPredicate(final Predicate<? super T> predicate1,
@@ -53,7 +53,7 @@ public final class OrPredicate<T> implements PredicateDecorator<T>, Serializable
/**
* Constructor that performs no validation.
- * Use <code>orPredicate</code> if you want that.
+ * Use {@code orPredicate} if you want that.
*
* @param predicate1 the first predicate to check, not null
* @param predicate2 the second predicate to check, not null
diff --git a/src/main/java/org/apache/commons/collections4/functors/PredicateTransformer.java b/src/main/java/org/apache/commons/collections4/functors/PredicateTransformer.java
index 3c41534..e7c81ad 100644
--- a/src/main/java/org/apache/commons/collections4/functors/PredicateTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/PredicateTransformer.java
@@ -40,7 +40,7 @@ public class PredicateTransformer<T> implements Transformer<T, Boolean>, Seriali
*
* @param <T> the input type
* @param predicate the predicate to call, not null
- * @return the <code>predicate</code> transformer
+ * @return the {@code predicate} transformer
* @throws IllegalArgumentException if the predicate is null
*/
public static <T> Transformer<T, Boolean> predicateTransformer(final Predicate<? super T> predicate) {
@@ -52,7 +52,7 @@ public class PredicateTransformer<T> implements Transformer<T, Boolean>, Seriali
/**
* Constructor that performs no validation.
- * Use <code>predicateTransformer</code> if you want that.
+ * Use {@code predicateTransformer} if you want that.
*
* @param predicate the predicate to call, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/PrototypeFactory.java b/src/main/java/org/apache/commons/collections4/functors/PrototypeFactory.java
index f87b0d9..20045af 100644
--- a/src/main/java/org/apache/commons/collections4/functors/PrototypeFactory.java
+++ b/src/main/java/org/apache/commons/collections4/functors/PrototypeFactory.java
@@ -58,7 +58,7 @@ public class PrototypeFactory {
*
* @param <T> the type the factory creates
* @param prototype the object to clone each time in the factory
- * @return the <code>prototype</code> factory, or a {@link ConstantFactory#NULL_INSTANCE} if
+ * @return the {@code prototype} factory, or a {@link ConstantFactory#NULL_INSTANCE} if
* the {@code prototype} is {@code null}
* @throws IllegalArgumentException if the prototype cannot be cloned
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/StringValueTransformer.java b/src/main/java/org/apache/commons/collections4/functors/StringValueTransformer.java
index 46e9033..1b096dc 100644
--- a/src/main/java/org/apache/commons/collections4/functors/StringValueTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/StringValueTransformer.java
@@ -22,7 +22,7 @@ import org.apache.commons.collections4.Transformer;
/**
* Transformer implementation that returns the result of calling
- * <code>String.valueOf</code> on the input object.
+ * {@code String.valueOf} on the input object.
*
* @since 3.0
*/
@@ -54,7 +54,7 @@ public final class StringValueTransformer<T> implements Transformer<T, String>,
}
/**
- * Transforms the input to result by calling <code>String.valueOf</code>.
+ * Transforms the input to result by calling {@code String.valueOf}.
*
* @param input the input object to transform
* @return the transformed result
diff --git a/src/main/java/org/apache/commons/collections4/functors/SwitchClosure.java b/src/main/java/org/apache/commons/collections4/functors/SwitchClosure.java
index 76a507f..71955c7 100644
--- a/src/main/java/org/apache/commons/collections4/functors/SwitchClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/SwitchClosure.java
@@ -48,7 +48,7 @@ public class SwitchClosure<E> implements Closure<E>, Serializable {
* @param predicates array of predicates, cloned, no nulls
* @param closures matching array of closures, cloned, no nulls
* @param defaultClosure the closure to use if no match, null means nop
- * @return the <code>chained</code> closure
+ * @return the {@code chained} closure
* @throws NullPointerException if array is null
* @throws NullPointerException if any element in the array is null
* @throws IllegalArgumentException if the array lengths of predicates and closures do not match
@@ -81,7 +81,7 @@ public class SwitchClosure<E> implements Closure<E>, Serializable {
*
* @param <E> the type that the closure acts on
* @param predicatesAndClosures a map of predicates to closures
- * @return the <code>switch</code> closure
+ * @return the {@code switch} closure
* @throws NullPointerException if the map is null
* @throws NullPointerException if any closure in the map is null
* @throws ClassCastException if the map elements are of the wrong type
@@ -125,7 +125,7 @@ public class SwitchClosure<E> implements Closure<E>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>switchClosure</code> if you want that.
+ * Use {@code switchClosure} if you want that.
*
* @param predicates array of predicates, cloned, no nulls
* @param closures matching array of closures, cloned, no nulls
diff --git a/src/main/java/org/apache/commons/collections4/functors/SwitchTransformer.java b/src/main/java/org/apache/commons/collections4/functors/SwitchTransformer.java
index 3c759f6..205b75e 100644
--- a/src/main/java/org/apache/commons/collections4/functors/SwitchTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/SwitchTransformer.java
@@ -49,7 +49,7 @@ public class SwitchTransformer<I, O> implements Transformer<I, O>, Serializable
* @param predicates array of predicates, cloned, no nulls
* @param transformers matching array of transformers, cloned, no nulls
* @param defaultTransformer the transformer to use if no match, null means return null
- * @return the <code>chained</code> transformer
+ * @return the {@code chained} transformer
* @throws NullPointerException if either array is null
* @throws NullPointerException if any element in the arrays is null
* @throws IllegalArgumentException if the arrays have different sizes
@@ -84,7 +84,7 @@ public class SwitchTransformer<I, O> implements Transformer<I, O>, Serializable
* @param <I> the input type
* @param <O> the output type
* @param map a map of predicates to transformers
- * @return the <code>switch</code> transformer
+ * @return the {@code switch} transformer
* @throws NullPointerException if the map is null
* @throws NullPointerException if any transformer in the map is null
* @throws ClassCastException if the map elements are of the wrong type
@@ -137,7 +137,7 @@ public class SwitchTransformer<I, O> implements Transformer<I, O>, Serializable
/**
* Constructor that performs no validation.
- * Use <code>switchTransformer</code> if you want that.
+ * Use {@code switchTransformer} if you want that.
*
* @param predicates array of predicates, cloned, no nulls
* @param transformers matching array of transformers, cloned, no nulls
diff --git a/src/main/java/org/apache/commons/collections4/functors/TransformedPredicate.java b/src/main/java/org/apache/commons/collections4/functors/TransformedPredicate.java
index 2a4e697..1836b68 100644
--- a/src/main/java/org/apache/commons/collections4/functors/TransformedPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/TransformedPredicate.java
@@ -24,7 +24,7 @@ import org.apache.commons.collections4.Transformer;
/**
* Predicate implementation that transforms the given object before invoking
- * another <code>Predicate</code>.
+ * another {@code Predicate}.
*
* @since 3.1
*/
@@ -56,7 +56,7 @@ public final class TransformedPredicate<T> implements PredicateDecorator<T>, Ser
/**
* Constructor that performs no validation.
- * Use <code>transformedPredicate</code> if you want that.
+ * Use {@code transformedPredicate} if you want that.
*
* @param transformer the transformer to use
* @param predicate the predicate to decorate
diff --git a/src/main/java/org/apache/commons/collections4/functors/TransformerClosure.java b/src/main/java/org/apache/commons/collections4/functors/TransformerClosure.java
index 31cc738..3c6e947 100644
--- a/src/main/java/org/apache/commons/collections4/functors/TransformerClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/TransformerClosure.java
@@ -38,11 +38,11 @@ public class TransformerClosure<E> implements Closure<E>, Serializable {
/**
* Factory method that performs validation.
* <p>
- * A null transformer will return the <code>NOPClosure</code>.
+ * A null transformer will return the {@code NOPClosure}.
*
* @param <E> the type that the closure acts on
* @param transformer the transformer to call, null means nop
- * @return the <code>transformer</code> closure
+ * @return the {@code transformer} closure
*/
public static <E> Closure<E> transformerClosure(final Transformer<? super E, ?> transformer) {
if (transformer == null) {
@@ -53,7 +53,7 @@ public class TransformerClosure<E> implements Closure<E>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>transformerClosure</code> if you want that.
+ * Use {@code transformerClosure} if you want that.
*
* @param transformer the transformer to call, not null
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/TransformerPredicate.java b/src/main/java/org/apache/commons/collections4/functors/TransformerPredicate.java
index f72bfd8..b226180 100644
--- a/src/main/java/org/apache/commons/collections4/functors/TransformerPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/TransformerPredicate.java
@@ -50,7 +50,7 @@ public final class TransformerPredicate<T> implements Predicate<T>, Serializable
/**
* Constructor that performs no validation.
- * Use <code>transformerPredicate</code> if you want that.
+ * Use {@code transformerPredicate} if you want that.
*
* @param transformer the transformer to decorate
*/
diff --git a/src/main/java/org/apache/commons/collections4/functors/UniquePredicate.java b/src/main/java/org/apache/commons/collections4/functors/UniquePredicate.java
index 5800963..4aaf231 100644
--- a/src/main/java/org/apache/commons/collections4/functors/UniquePredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/UniquePredicate.java
@@ -49,7 +49,7 @@ public final class UniquePredicate<T> implements Predicate<T>, Serializable {
/**
* Constructor that performs no validation.
- * Use <code>uniquePredicate</code> if you want that.
+ * Use {@code uniquePredicate} if you want that.
*/
public UniquePredicate() {
super();
diff --git a/src/main/java/org/apache/commons/collections4/functors/WhileClosure.java b/src/main/java/org/apache/commons/collections4/functors/WhileClosure.java
index db26be2..0700039 100644
--- a/src/main/java/org/apache/commons/collections4/functors/WhileClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/WhileClosure.java
@@ -49,7 +49,7 @@ public class WhileClosure<E> implements Closure<E> {
* @param predicate the predicate used to evaluate when the loop terminates, not null
* @param closure the closure the execute, not null
* @param doLoop true to act as a do-while loop, always executing the closure once
- * @return the <code>while</code> closure
+ * @return the {@code while} closure
* @throws NullPointerException if the predicate or closure is null
*/
public static <E> Closure<E> whileClosure(final Predicate<? super E> predicate,
@@ -60,7 +60,7 @@ public class WhileClosure<E> implements Closure<E> {
/**
* Constructor that performs no validation.
- * Use <code>whileClosure</code> if you want that.
+ * Use {@code whileClosure} if you want that.
*
* @param predicate the predicate used to evaluate when the loop terminates, not null
* @param closure the closure the execute, not null
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ArrayIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ArrayIterator.java
index e1b4c58..f3d3599 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ArrayIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ArrayIterator.java
@@ -53,8 +53,8 @@ public class ArrayIterator<E> implements ResettableIterator<E> {
* specified array.
*
* @param array the array to iterate over.
- * @throws IllegalArgumentException if <code>array</code> is not an array.
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code array} is not an array.
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ArrayIterator(final Object array) {
this(array, 0);
@@ -66,8 +66,8 @@ public class ArrayIterator<E> implements ResettableIterator<E> {
*
* @param array the array to iterate over.
* @param startIndex the index to start iterating at.
- * @throws IllegalArgumentException if <code>array</code> is not an array.
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code array} is not an array.
+ * @throws NullPointerException if {@code array} is {@code null}
* @throws IndexOutOfBoundsException if the index is invalid
*/
public ArrayIterator(final Object array, final int startIndex) {
@@ -81,8 +81,8 @@ public class ArrayIterator<E> implements ResettableIterator<E> {
* @param array the array to iterate over.
* @param startIndex the index to start iterating at.
* @param endIndex the index to finish iterating at.
- * @throws IllegalArgumentException if <code>array</code> is not an array.
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code array} is not an array.
+ * @throws NullPointerException if {@code array} is {@code null}
* @throws IndexOutOfBoundsException if either index is invalid
*/
public ArrayIterator(final Object array, final int startIndex, final int endIndex) {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ArrayListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ArrayListIterator.java
index 071ffaf..d01597c 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ArrayListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ArrayListIterator.java
@@ -42,9 +42,9 @@ public class ArrayListIterator<E> extends ArrayIterator<E>
implements ResettableListIterator<E> {
/**
- * Holds the index of the last item returned by a call to <code>next()</code>
- * or <code>previous()</code>. This is set to <code>-1</code> if neither method
- * has yet been invoked. <code>lastItemIndex</code> is used to to implement
+ * Holds the index of the last item returned by a call to {@code next()}
+ * or {@code previous()}. This is set to {@code -1} if neither method
+ * has yet been invoked. {@code lastItemIndex} is used to to implement
* the {@link #set} method.
*/
private int lastItemIndex = -1;
@@ -56,8 +56,8 @@ public class ArrayListIterator<E> extends ArrayIterator<E>
* specified array.
*
* @param array the array to iterate over
- * @throws IllegalArgumentException if <code>array</code> is not an array.
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code array} is not an array.
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ArrayListIterator(final Object array) {
super(array);
@@ -69,8 +69,8 @@ public class ArrayListIterator<E> extends ArrayIterator<E>
*
* @param array the array to iterate over
* @param startIndex the index to start iterating at
- * @throws IllegalArgumentException if <code>array</code> is not an array.
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws IllegalArgumentException if {@code array} is not an array.
+ * @throws NullPointerException if {@code array} is {@code null}
* @throws IndexOutOfBoundsException if the start index is out of bounds
*/
public ArrayListIterator(final Object array, final int startIndex) {
@@ -84,10 +84,10 @@ public class ArrayListIterator<E> extends ArrayIterator<E>
* @param array the array to iterate over
* @param startIndex the index to start iterating at
* @param endIndex the index (exclusive) to finish iterating at
- * @throws IllegalArgumentException if <code>array</code> is not an array.
+ * @throws IllegalArgumentException if {@code array} is not an array.
* @throws IndexOutOfBoundsException if the start or end index is out of bounds
* @throws IllegalArgumentException if end index is before the start
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ArrayListIterator(final Object array, final int startIndex, final int endIndex) {
super(array, startIndex, endIndex);
@@ -177,10 +177,10 @@ public class ArrayListIterator<E> extends ArrayIterator<E>
* to {@link #next()} of {@link #previous()}.
* <p>
* <b>Note:</b> {@link java.util.ListIterator} implementations that support
- * <code>add()</code> and <code>remove()</code> only allow <code>set()</code> to be called
- * once per call to <code>next()</code> or <code>previous</code> (see the {@link java.util.ListIterator}
+ * {@code add()} and {@code remove()} only allow {@code set()} to be called
+ * once per call to {@code next()} or {@code previous} (see the {@link java.util.ListIterator}
* javadoc for more details). Since this implementation does
- * not support <code>add()</code> or <code>remove()</code>, <code>set()</code> may be
+ * not support {@code add()} or {@code remove()}, {@code set()} may be
* called as often as desired.
*
* @param o the element to set
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 960fa13..3d1ff4a 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java
@@ -31,9 +31,9 @@ import org.apache.commons.collections4.list.UnmodifiableList;
* Provides an ordered iteration over the elements contained in a collection of
* ordered Iterators.
* <p>
- * Given two ordered {@link Iterator} instances <code>A</code> and
- * <code>B</code>, the {@link #next} method on this iterator will return the
- * lesser of <code>A.next()</code> and <code>B.next()</code>.
+ * Given two ordered {@link Iterator} instances {@code A} and
+ * {@code B}, the {@link #next} method on this iterator will return the
+ * lesser of {@code A.next()} and {@code B.next()}.
*
* @since 2.1
*/
@@ -60,7 +60,7 @@ public class CollatingIterator<E> implements Iterator<E> {
// Constructors
// ----------------------------------------------------------------------
/**
- * Constructs a new <code>CollatingIterator</code>. A comparator must be
+ * Constructs a new {@code CollatingIterator}. A comparator must be
* set by calling {@link #setComparator(Comparator)} before invoking
* {@link #hasNext()}, or {@link #next()} for the first time. Child
* iterators will have to be manually added using the
@@ -71,7 +71,7 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>CollatingIterator</code> that will used the
+ * Constructs a new {@code CollatingIterator} that will used the
* specified comparator for ordering. Child iterators will have to be
* manually added using the {@link #addIterator(Iterator)} method.
*
@@ -83,7 +83,7 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>CollatingIterator</code> that will used the
+ * Constructs a new {@code CollatingIterator} that will used the
* specified comparator for ordering and have the specified initial
* capacity. Child iterators will have to be manually added using the
* {@link #addIterator(Iterator)} method.
@@ -99,7 +99,7 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>CollatingIterator</code> that will use the
+ * Constructs a new {@code CollatingIterator} that will use the
* specified comparator to provide ordered iteration over the two given
* iterators.
*
@@ -117,7 +117,7 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>CollatingIterator</code> that will use the
+ * Constructs a new {@code CollatingIterator} that will use the
* specified comparator to provide ordered iteration over the array of
* iterators.
*
@@ -134,7 +134,7 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>CollatingIterator</code> that will use the
+ * Constructs a new {@code CollatingIterator} that will use the
* specified comparator to provide ordered iteration over the collection of
* iterators.
*
@@ -222,7 +222,7 @@ public class CollatingIterator<E> implements Iterator<E> {
// Iterator Methods
// -------------------------------------------------------------------
/**
- * Returns <code>true</code> if any child iterator has remaining elements.
+ * Returns {@code true} if any child iterator has remaining elements.
*
* @return true if this iterator has remaining elements
*/
@@ -371,8 +371,8 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Returns <code>true</code> iff any bit in the given set is
- * <code>true</code>.
+ * Returns {@code true} iff any bit in the given set is
+ * {@code true}.
*/
private boolean anyValueSet(final BitSet set) {
for (int i = 0; i < set.size(); i++) {
@@ -384,7 +384,7 @@ public class CollatingIterator<E> implements Iterator<E> {
}
/**
- * Returns <code>true</code> iff any {@link Iterator} in the given list has
+ * Returns {@code true} iff any {@link Iterator} in the given list has
* a next value.
*/
private boolean anyHasNext(final List<Iterator<? extends E>> iters) {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/EmptyIterator.java b/src/main/java/org/apache/commons/collections4/iterators/EmptyIterator.java
index 7ab8bb1..2bcf193 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EmptyIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EmptyIterator.java
@@ -25,7 +25,7 @@ import org.apache.commons.collections4.ResettableIterator;
* <p>
* This class provides an implementation of an empty iterator.
* This class provides for binary compatibility between Commons Collections
- * 2.1.1 and 3.1 due to issues with <code>IteratorUtils</code>.
+ * 2.1.1 and 3.1 due to issues with {@code IteratorUtils}.
*
* @since 2.1.1 and 3.1
*/
diff --git a/src/main/java/org/apache/commons/collections4/iterators/EmptyListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/EmptyListIterator.java
index b178579..0b9f672 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EmptyListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EmptyListIterator.java
@@ -25,7 +25,7 @@ import org.apache.commons.collections4.ResettableListIterator;
* <p>
* This class provides an implementation of an empty list iterator. This class
* provides for binary compatibility between Commons Collections 2.1.1 and 3.1
- * due to issues with <code>IteratorUtils</code>.
+ * due to issues with {@code IteratorUtils}.
*
* @since 2.1.1 and 3.1
*/
diff --git a/src/main/java/org/apache/commons/collections4/iterators/EntrySetMapIterator.java b/src/main/java/org/apache/commons/collections4/iterators/EntrySetMapIterator.java
index 7cae5d6..49926a3 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EntrySetMapIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EntrySetMapIterator.java
@@ -23,7 +23,7 @@ import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.ResettableIterator;
/**
- * Implements a <code>MapIterator</code> using a Map entrySet.
+ * Implements a {@code MapIterator} using a Map entrySet.
* Reverse iteration is not supported.
* <pre>
* MapIterator it = map.mapIterator();
@@ -60,7 +60,7 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
/**
* Checks to see if there are more entries still to be iterated.
*
- * @return <code>true</code> if the iterator has more elements
+ * @return {@code true} if the iterator has more elements
*/
@Override
public boolean hasNext() {
@@ -68,7 +68,7 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
}
/**
- * Gets the next <em>key</em> from the <code>Map</code>.
+ * Gets the next <em>key</em> from the {@code Map}.
*
* @return the next key in the iteration
* @throws java.util.NoSuchElementException if the iteration is finished
@@ -82,14 +82,14 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
//-----------------------------------------------------------------------
/**
- * Removes the last returned key from the underlying <code>Map</code>.
+ * Removes the last returned key from the underlying {@code Map}.
* <p>
- * This method can be called once per call to <code>next()</code>.
+ * This method can be called once per call to {@code next()}.
*
* @throws UnsupportedOperationException if remove is not supported by the map
- * @throws IllegalStateException if <code>next()</code> has not yet been called
- * @throws IllegalStateException if <code>remove()</code> has already been called
- * since the last call to <code>next()</code>
+ * @throws IllegalStateException if {@code next()} has not yet been called
+ * @throws IllegalStateException if {@code remove()} has already been called
+ * since the last call to {@code next()}
*/
@Override
public void remove() {
@@ -104,10 +104,10 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
//-----------------------------------------------------------------------
/**
* Gets the current key, which is the key returned by the last call
- * to <code>next()</code>.
+ * to {@code next()}.
*
* @return the current key
- * @throws IllegalStateException if <code>next()</code> has not yet been called
+ * @throws IllegalStateException if {@code next()} has not yet been called
*/
@Override
public K getKey() {
@@ -119,10 +119,10 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
/**
* Gets the current value, which is the value associated with the last key
- * returned by <code>next()</code>.
+ * returned by {@code next()}.
*
* @return the current value
- * @throws IllegalStateException if <code>next()</code> has not yet been called
+ * @throws IllegalStateException if {@code next()} has not yet been called
*/
@Override
public V getValue() {
@@ -138,9 +138,9 @@ public class EntrySetMapIterator<K, V> implements MapIterator<K, V>, ResettableI
* @param value the new value
* @return the previous value
* @throws UnsupportedOperationException if setValue is not supported by the map
- * @throws IllegalStateException if <code>next()</code> has not yet been called
- * @throws IllegalStateException if <code>remove()</code> has been called since the
- * last call to <code>next()</code>
+ * @throws IllegalStateException if {@code next()} has not yet been called
+ * @throws IllegalStateException if {@code remove()} has been called since the
+ * last call to {@code next()}
*/
@Override
public V setValue(final V value) {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/EnumerationIterator.java b/src/main/java/org/apache/commons/collections4/iterators/EnumerationIterator.java
index fa0449e..518ffdd 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EnumerationIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EnumerationIterator.java
@@ -38,7 +38,7 @@ public class EnumerationIterator<E> implements Iterator<E> {
// Constructors
//-----------------------------------------------------------------------
/**
- * Constructs a new <code>EnumerationIterator</code> that will not
+ * Constructs a new {@code EnumerationIterator} that will not
* function until {@link #setEnumeration(Enumeration)} is called.
*/
public EnumerationIterator() {
@@ -46,7 +46,7 @@ public class EnumerationIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>EnumerationIterator</code> that provides
+ * Constructs a new {@code EnumerationIterator} that provides
* an iterator view of the given enumeration.
*
* @param enumeration the enumeration to use
@@ -56,7 +56,7 @@ public class EnumerationIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>EnumerationIterator</code> that will remove
+ * Constructs a new {@code EnumerationIterator} that will remove
* elements from the specified collection.
*
* @param enumeration the enumeration to use
@@ -97,11 +97,11 @@ public class EnumerationIterator<E> implements Iterator<E> {
/**
* Removes the last retrieved element if a collection is attached.
* <p>
- * Functions if an associated <code>Collection</code> is known.
+ * Functions if an associated {@code Collection} is known.
* If so, the first occurrence of the last returned object from this
* iterator will be removed from the collection.
*
- * @throws IllegalStateException <code>next()</code> not called.
+ * @throws IllegalStateException {@code next()} not called.
* @throws UnsupportedOperationException if no associated collection
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/iterators/FilterIterator.java b/src/main/java/org/apache/commons/collections4/iterators/FilterIterator.java
index 7789578..3da4b71 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/FilterIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/FilterIterator.java
@@ -42,7 +42,7 @@ public class FilterIterator<E> implements Iterator<E> {
//-----------------------------------------------------------------------
/**
- * Constructs a new <code>FilterIterator</code> that will not function
+ * Constructs a new {@code FilterIterator} that will not function
* until {@link #setIterator(Iterator) setIterator} is invoked.
*/
public FilterIterator() {
@@ -50,7 +50,7 @@ public class FilterIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>FilterIterator</code> that will not function
+ * Constructs a new {@code FilterIterator} that will not function
* until {@link #setPredicate(Predicate) setPredicate} is invoked.
*
* @param iterator the iterator to use
@@ -61,7 +61,7 @@ public class FilterIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>FilterIterator</code> that will use the
+ * Constructs a new {@code FilterIterator} that will use the
* given iterator and predicate.
*
* @param iterator the iterator to use
@@ -107,11 +107,11 @@ public class FilterIterator<E> implements Iterator<E> {
* Removes from the underlying collection of the base iterator the last
* element returned by this iterator.
* This method can only be called
- * if <code>next()</code> was called, but not after
- * <code>hasNext()</code>, because the <code>hasNext()</code> call
+ * if {@code next()} was called, but not after
+ * {@code hasNext()}, because the {@code hasNext()} call
* changes the base iterator.
*
- * @throws IllegalStateException if <code>hasNext()</code> has already
+ * @throws IllegalStateException if {@code hasNext()} has already
* been called.
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/iterators/FilterListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/FilterListIterator.java
index 1f2bef2..8e4f83b 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/FilterListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/FilterListIterator.java
@@ -45,7 +45,7 @@ public class FilterListIterator<E> implements ListIterator<E> {
/**
* Whether or not the {@link #nextObject} has been set
- * (possibly to <code>null</code>).
+ * (possibly to {@code null}).
*/
private boolean nextObjectSet = false;
@@ -57,7 +57,7 @@ public class FilterListIterator<E> implements ListIterator<E> {
/**
* Whether or not the {@link #previousObject} has been set
- * (possibly to <code>null</code>).
+ * (possibly to {@code null}).
*/
private boolean previousObjectSet = false;
@@ -68,7 +68,7 @@ public class FilterListIterator<E> implements ListIterator<E> {
//-----------------------------------------------------------------------
/**
- * Constructs a new <code>FilterListIterator</code> that will not function
+ * Constructs a new {@code FilterListIterator} that will not function
* until {@link #setListIterator(ListIterator) setListIterator}
* and {@link #setPredicate(Predicate) setPredicate} are invoked.
*/
@@ -77,7 +77,7 @@ public class FilterListIterator<E> implements ListIterator<E> {
}
/**
- * Constructs a new <code>FilterListIterator</code> that will not
+ * Constructs a new {@code FilterListIterator} that will not
* function until {@link #setPredicate(Predicate) setPredicate} is invoked.
*
* @param iterator the iterator to use
@@ -88,7 +88,7 @@ public class FilterListIterator<E> implements ListIterator<E> {
}
/**
- * Constructs a new <code>FilterListIterator</code>.
+ * Constructs a new {@code FilterListIterator}.
*
* @param iterator the iterator to use
* @param predicate the predicate to use
@@ -100,7 +100,7 @@ public class FilterListIterator<E> implements ListIterator<E> {
}
/**
- * Constructs a new <code>FilterListIterator</code> that will not function
+ * Constructs a new {@code FilterListIterator} that will not function
* until {@link #setListIterator(ListIterator) setListIterator} is invoked.
*
* @param predicate the predicate to use.
diff --git a/src/main/java/org/apache/commons/collections4/iterators/IteratorChain.java b/src/main/java/org/apache/commons/collections4/iterators/IteratorChain.java
index 1cf120a..cda26ef 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/IteratorChain.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/IteratorChain.java
@@ -98,7 +98,7 @@ public class IteratorChain<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>IteratorChain</code> over the two given iterators.
+ * Constructs a new {@code IteratorChain} over the two given iterators.
* <p>
* This method takes two iterators. The newly constructed iterator will
* iterate through each one of the input iterators in turn.
@@ -114,7 +114,7 @@ public class IteratorChain<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>IteratorChain</code> over the array of iterators.
+ * Constructs a new {@code IteratorChain} over the array of iterators.
* <p>
* This method takes an array of iterators. The newly constructed iterator
* will iterate through each one of the input iterators in turn.
@@ -130,7 +130,7 @@ public class IteratorChain<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>IteratorChain</code> over the collection of
+ * Constructs a new {@code IteratorChain} over the collection of
* iterators.
* <p>
* This method takes a collection of iterators. The newly constructed
diff --git a/src/main/java/org/apache/commons/collections4/iterators/IteratorEnumeration.java b/src/main/java/org/apache/commons/collections4/iterators/IteratorEnumeration.java
index 0b35289..289ebf5 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/IteratorEnumeration.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/IteratorEnumeration.java
@@ -31,14 +31,14 @@ public class IteratorEnumeration<E> implements Enumeration<E> {
private Iterator<? extends E> iterator;
/**
- * Constructs a new <code>IteratorEnumeration</code> that will not function
+ * Constructs a new {@code IteratorEnumeration} that will not function
* until {@link #setIterator(Iterator) setIterator} is invoked.
*/
public IteratorEnumeration() {
}
/**
- * Constructs a new <code>IteratorEnumeration</code> that will use the given
+ * Constructs a new {@code IteratorEnumeration} that will use the given
* iterator.
*
* @param iterator the iterator to use
diff --git a/src/main/java/org/apache/commons/collections4/iterators/IteratorIterable.java b/src/main/java/org/apache/commons/collections4/iterators/IteratorIterable.java
index 364bef3..86b7bd1 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/IteratorIterable.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/IteratorIterable.java
@@ -51,8 +51,8 @@ import org.apache.commons.collections4.ResettableIterator;
*
* <p>
* A multiple use iterable can also be explicitly constructed using any
- * {@link Iterator} and specifying <code>true</code> for the
- * <code>multipleUse</code> flag:
+ * {@link Iterator} and specifying {@code true} for the
+ * {@code multipleUse} flag:
* </p>
*
* <pre>
@@ -94,7 +94,7 @@ public class IteratorIterable<E> implements Iterable<E> {
private final Iterator<E> typeSafeIterator;
/**
- * Constructs a new <code>IteratorIterable</code> that will use the given
+ * Constructs a new {@code IteratorIterable} that will use the given
* iterator.
*
* @param iterator the iterator to use.
@@ -104,11 +104,11 @@ public class IteratorIterable<E> implements Iterable<E> {
}
/**
- * Constructs a new <code>IteratorIterable</code> that will use the given
+ * Constructs a new {@code IteratorIterable} that will use the given
* iterator.
*
* @param iterator the iterator to use.
- * @param multipleUse <code>true</code> if the new iterable can be used in multiple iterations
+ * @param multipleUse {@code true} if the new iterable can be used in multiple iterations
*/
public IteratorIterable(final Iterator<? extends E> iterator, final boolean multipleUse) {
super();
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ListIteratorWrapper.java b/src/main/java/org/apache/commons/collections4/iterators/ListIteratorWrapper.java
index 0ade288..52a89d2 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ListIteratorWrapper.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ListIteratorWrapper.java
@@ -28,18 +28,18 @@ import org.apache.commons.collections4.ResettableListIterator;
/**
* Converts an {@link Iterator} into a {@link ResettableListIterator}.
- * For plain <code>Iterator</code>s this is accomplished by caching the returned
+ * For plain {@code Iterator}s this is accomplished by caching the returned
* elements. This class can also be used to simply add
* {@link org.apache.commons.collections4.ResettableIterator ResettableIterator}
* functionality to a given {@link ListIterator}.
* <p>
- * The <code>ListIterator</code> interface has additional useful methods
- * for navigation - <code>previous()</code> and the index methods.
- * This class allows a regular <code>Iterator</code> to behave as a
- * <code>ListIterator</code>. It achieves this by building a list internally
+ * The {@code ListIterator} interface has additional useful methods
+ * for navigation - {@code previous()} and the index methods.
+ * This class allows a regular {@code Iterator} to behave as a
+ * {@code ListIterator}. It achieves this by building a list internally
* of as the underlying iterator is traversed.
* <p>
- * The optional operations of <code>ListIterator</code> are not supported for plain <code>Iterator</code>s.
+ * The optional operations of {@code ListIterator} are not supported for plain {@code Iterator}s.
* <p>
* This class implements ResettableListIterator from Commons Collections 3.2.
*
@@ -69,7 +69,7 @@ public class ListIteratorWrapper<E> implements ResettableListIterator<E> {
// Constructor
//-------------------------------------------------------------------------
/**
- * Constructs a new <code>ListIteratorWrapper</code> that will wrap
+ * Constructs a new {@code ListIteratorWrapper} that will wrap
* the given iterator.
*
* @param iterator the iterator to wrap
@@ -84,7 +84,7 @@ public class ListIteratorWrapper<E> implements ResettableListIterator<E> {
//-------------------------------------------------------------------------
/**
* Throws {@link UnsupportedOperationException}
- * unless the underlying <code>Iterator</code> is a <code>ListIterator</code>.
+ * unless the underlying {@code Iterator} is a {@code ListIterator}.
*
* @param obj the object to add
* @throws UnsupportedOperationException if the underlying iterator is not of
@@ -229,7 +229,7 @@ public class ListIteratorWrapper<E> implements ResettableListIterator<E> {
/**
* Throws {@link UnsupportedOperationException}
- * unless the underlying <code>Iterator</code> is a <code>ListIterator</code>.
+ * unless the underlying {@code Iterator} is a {@code ListIterator}.
*
* @param obj the object to set
* @throws UnsupportedOperationException if the underlying iterator is not of
diff --git a/src/main/java/org/apache/commons/collections4/iterators/LoopingIterator.java b/src/main/java/org/apache/commons/collections4/iterators/LoopingIterator.java
index 5de2397..a3cbb4f 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/LoopingIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/LoopingIterator.java
@@ -62,7 +62,7 @@ public class LoopingIterator<E> implements ResettableIterator<E> {
* Returns false only if the collection originally had zero elements, or
* all the elements have been {@link #remove removed}.
*
- * @return <code>true</code> if there are more elements
+ * @return {@code true} if there are more elements
*/
@Override
public boolean hasNext() {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/LoopingListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/LoopingListIterator.java
index cd3bc76..50b5c6a 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/LoopingListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/LoopingListIterator.java
@@ -65,7 +65,7 @@ public class LoopingListIterator<E> implements ResettableListIterator<E> {
* Returns false only if the list originally had zero elements, or
* all elements have been {@link #remove removed}.
*
- * @return <code>true</code> if there are more elements
+ * @return {@code true} if there are more elements
*/
@Override
public boolean hasNext() {
@@ -121,7 +121,7 @@ public class LoopingListIterator<E> implements ResettableListIterator<E> {
* Returns false only if the list originally had zero elements, or
* all elements have been {@link #remove removed}.
*
- * @return <code>true</code> if there are more elements
+ * @return {@code true} if there are more elements
*/
@Override
public boolean hasPrevious() {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/NodeListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/NodeListIterator.java
index 66c1721..955483e 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/NodeListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/NodeListIterator.java
@@ -52,7 +52,7 @@ public class NodeListIterator implements Iterator<Node> {
/**
* Constructor, that creates a new NodeListIterator from the specified
- * <code>org.w3c.NodeList</code>
+ * {@code org.w3c.NodeList}
*
* @param nodeList node list, which is wrapped by this class. Must not be null
* @throws NullPointerException if nodeList is null
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayIterator.java
index ca3d664..7d6883e 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayIterator.java
@@ -49,7 +49,7 @@ public class ObjectArrayIterator<E> implements ResettableIterator<E> {
* specified array.
*
* @param array the array to iterate over
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ObjectArrayIterator(final E... array) {
this(array, 0, array.length);
@@ -61,7 +61,7 @@ public class ObjectArrayIterator<E> implements ResettableIterator<E> {
*
* @param array the array to iterate over
* @param start the index to start iterating at
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
* @throws IndexOutOfBoundsException if the start index is out of bounds
*/
public ObjectArrayIterator(final E array[], final int start) {
@@ -77,7 +77,7 @@ public class ObjectArrayIterator<E> implements ResettableIterator<E> {
* @param end the index (exclusive) to finish iterating at
* @throws IndexOutOfBoundsException if the start or end index is out of bounds
* @throws IllegalArgumentException if end index is before the start
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ObjectArrayIterator(final E array[], final int start, final int end) {
super();
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayListIterator.java
index db46045..758f1e2 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayListIterator.java
@@ -39,9 +39,9 @@ public class ObjectArrayListIterator<E> extends ObjectArrayIterator<E>
implements ResettableListIterator<E> {
/**
- * Holds the index of the last item returned by a call to <code>next()</code>
- * or <code>previous()</code>. This is set to <code>-1</code> if neither method
- * has yet been invoked. <code>lastItemIndex</code> is used to to implement the
+ * Holds the index of the last item returned by a call to {@code next()}
+ * or {@code previous()}. This is set to {@code -1} if neither method
+ * has yet been invoked. {@code lastItemIndex} is used to to implement the
* {@link #set} method.
*/
private int lastItemIndex = -1;
@@ -52,7 +52,7 @@ public class ObjectArrayListIterator<E> extends ObjectArrayIterator<E>
* specified array.
*
* @param array the array to iterate over
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ObjectArrayListIterator(final E... array) {
super(array);
@@ -64,7 +64,7 @@ public class ObjectArrayListIterator<E> extends ObjectArrayIterator<E>
*
* @param array the array to iterate over
* @param start the index to start iterating at
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
* @throws IndexOutOfBoundsException if the start index is out of bounds
*/
public ObjectArrayListIterator(final E[] array, final int start) {
@@ -80,7 +80,7 @@ public class ObjectArrayListIterator<E> extends ObjectArrayIterator<E>
* @param end the index (exclusive) to finish iterating at
* @throws IndexOutOfBoundsException if the start or end index is out of bounds
* @throws IllegalArgumentException if end index is before the start
- * @throws NullPointerException if <code>array</code> is <code>null</code>
+ * @throws NullPointerException if {@code array} is {@code null}
*/
public ObjectArrayListIterator(final E[] array, final int start, final int end) {
super(array, start, end);
@@ -167,11 +167,11 @@ public class ObjectArrayListIterator<E> extends ObjectArrayIterator<E>
* This method sets the element that was returned by the last call
* to {@link #next()} of {@link #previous()}.
*
- * <b>Note:</b> {@link java.util.ListIterator} implementations that support <code>add()</code>
- * and <code>remove()</code> only allow <code>set()</code> to be called once per call
- * to <code>next()</code> or <code>previous</code> (see the {@link java.util.ListIterator}
+ * <b>Note:</b> {@link java.util.ListIterator} implementations that support {@code add()}
+ * and {@code remove()} only allow {@code set()} to be called once per call
+ * to {@code next()} or {@code previous} (see the {@link java.util.ListIterator}
* javadoc for more details). Since this implementation does not support
- * <code>add()</code> or <code>remove()</code>, <code>set()</code> may be
+ * {@code add()} or {@code remove()}, {@code set()} may be
* called as often as desired.
*
* @param obj the object to set into the array
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ObjectGraphIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ObjectGraphIterator.java
index 162f170..0eb97a0 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ObjectGraphIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ObjectGraphIterator.java
@@ -28,8 +28,8 @@ import org.apache.commons.collections4.Transformer;
* <p>
* This iterator can extract multiple objects from a complex tree-like object graph.
* The iteration starts from a single root object.
- * It uses a <code>Transformer</code> to extract the iterators and elements.
- * Its main benefit is that no intermediate <code>List</code> is created.
+ * It uses a {@code Transformer} to extract the iterators and elements.
+ * Its main benefit is that no intermediate {@code List} is created.
* <p>
* For example, consider an object graph:
* <pre>
@@ -43,7 +43,7 @@ import org.apache.commons.collections4.Transformer;
* |- Tree | /- Leaf
* |- Branch -- Leaf
* |- Branch -- Leaf</pre>
- * The following <code>Transformer</code>, used in this class, will extract all
+ * The following {@code Transformer}, used in this class, will extract all
* the Leaf objects without creating a combined intermediate list:
* <pre>
* public Object transform(Object input) {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ReverseListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ReverseListIterator.java
index e38b960..ff4c2d8 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ReverseListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ReverseListIterator.java
@@ -27,10 +27,10 @@ import org.apache.commons.collections4.ResettableListIterator;
* and continuing to the first. This is useful for looping around
* a list in reverse order without needing to actually reverse the list.
* <p>
- * The first call to <code>next()</code> will return the last element
- * from the list, and so on. The <code>hasNext()</code> method works
- * in concert with the <code>next()</code> method as expected.
- * However, the <code>nextIndex()</code> method returns the correct
+ * The first call to {@code next()} will return the last element
+ * from the list, and so on. The {@code hasNext()} method works
+ * in concert with the {@code next()} method as expected.
+ * However, the {@code nextIndex()} method returns the correct
* index in the list, thus it starts high and reduces as the iteration
* continues. The previous methods work similarly.
*
diff --git a/src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java b/src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java
index 451d490..6ccec88 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java
@@ -21,7 +21,7 @@ import java.util.NoSuchElementException;
import org.apache.commons.collections4.ResettableIterator;
/**
- * <code>SingletonIterator</code> is an {@link java.util.Iterator} over a single
+ * {@code SingletonIterator} is an {@link java.util.Iterator} over a single
* object instance.
*
* @since 2.0
@@ -39,7 +39,7 @@ public class SingletonIterator<E>
private E object;
/**
- * Constructs a new <code>SingletonIterator</code> where <code>remove</code>
+ * Constructs a new {@code SingletonIterator} where {@code remove}
* is a permitted operation.
*
* @param object the single object to return from the iterator
@@ -49,8 +49,8 @@ public class SingletonIterator<E>
}
/**
- * Constructs a new <code>SingletonIterator</code> optionally choosing if
- * <code>remove</code> is a permitted operation.
+ * Constructs a new {@code SingletonIterator} optionally choosing if
+ * {@code remove} is a permitted operation.
*
* @param object the single object to return from the iterator
* @param removeAllowed true if remove is allowed
diff --git a/src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java b/src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java
index c554bf4..312f393 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java
@@ -21,7 +21,7 @@ import java.util.NoSuchElementException;
import org.apache.commons.collections4.ResettableListIterator;
/**
- * <code>SingletonIterator</code> is an {@link java.util.ListIterator} over a single
+ * {@code SingletonIterator} is an {@link java.util.ListIterator} over a single
* object instance.
*
* @since 2.1
@@ -34,7 +34,7 @@ public class SingletonListIterator<E> implements ResettableListIterator<E> {
private E object;
/**
- * Constructs a new <code>SingletonListIterator</code>.
+ * Constructs a new {@code SingletonListIterator}.
*
* @param object the single object to return from the iterator
*/
diff --git a/src/main/java/org/apache/commons/collections4/iterators/TransformIterator.java b/src/main/java/org/apache/commons/collections4/iterators/TransformIterator.java
index e930c05..61709ba 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/TransformIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/TransformIterator.java
@@ -34,7 +34,7 @@ public class TransformIterator<I, O> implements Iterator<O> {
//-----------------------------------------------------------------------
/**
- * Constructs a new <code>TransformIterator</code> that will not function
+ * Constructs a new {@code TransformIterator} that will not function
* until the {@link #setIterator(Iterator) setIterator} and
* {@link #setTransformer(Transformer)} methods are invoked.
*/
@@ -43,7 +43,7 @@ public class TransformIterator<I, O> implements Iterator<O> {
}
/**
- * Constructs a new <code>TransformIterator</code> that won't transform
+ * Constructs a new {@code TransformIterator} that won't transform
* elements from the given iterator.
*
* @param iterator the iterator to use
@@ -54,7 +54,7 @@ public class TransformIterator<I, O> implements Iterator<O> {
}
/**
- * Constructs a new <code>TransformIterator</code> that will use the
+ * Constructs a new {@code TransformIterator} that will use the
* given iterator and transformer. If the given transformer is null,
* then objects will not be transformed.
*
diff --git a/src/main/java/org/apache/commons/collections4/iterators/UniqueFilterIterator.java b/src/main/java/org/apache/commons/collections4/iterators/UniqueFilterIterator.java
index f95c31c..80b01de 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/UniqueFilterIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/UniqueFilterIterator.java
@@ -32,7 +32,7 @@ public class UniqueFilterIterator<E> extends FilterIterator<E> {
//-------------------------------------------------------------------------
/**
- * Constructs a new <code>UniqueFilterIterator</code>.
+ * Constructs a new {@code UniqueFilterIterator}.
*
* @param iterator the iterator to use
*/
diff --git a/src/main/java/org/apache/commons/collections4/iterators/ZippingIterator.java b/src/main/java/org/apache/commons/collections4/iterators/ZippingIterator.java
index b12a35e..5e6ba8d 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ZippingIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ZippingIterator.java
@@ -50,7 +50,7 @@ public class ZippingIterator<E> implements Iterator<E> {
// ----------------------------------------------------------------------
/**
- * Constructs a new <code>ZippingIterator</code> that will provide
+ * Constructs a new {@code ZippingIterator} that will provide
* interleaved iteration over the two given iterators.
*
* @param a the first child iterator
@@ -63,7 +63,7 @@ public class ZippingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>ZippingIterator</code> that will provide
+ * Constructs a new {@code ZippingIterator} that will provide
* interleaved iteration over the three given iterators.
*
* @param a the first child iterator
@@ -79,7 +79,7 @@ public class ZippingIterator<E> implements Iterator<E> {
}
/**
- * Constructs a new <code>ZippingIterator</code> that will provide
+ * Constructs a new {@code ZippingIterator} that will provide
* interleaved iteration of the specified iterators.
*
* @param iterators the array of iterators
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractKeyValue.java b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractKeyValue.java
index 3cc008c..c6d7c28 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractKeyValue.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractKeyValue.java
@@ -19,7 +19,7 @@ package org.apache.commons.collections4.keyvalue;
import org.apache.commons.collections4.KeyValue;
/**
- * Abstract pair class to assist with creating <code>KeyValue</code>
+ * Abstract pair class to assist with creating {@code KeyValue}
* and {@link java.util.Map.Entry Map.Entry} implementations.
*
* @param <K> the type of keys
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntry.java b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntry.java
index b27d4d5..f5f8717 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntry.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntry.java
@@ -41,9 +41,9 @@ public abstract class AbstractMapEntry<K, V> extends AbstractKeyValue<K, V> impl
// Map.Entry interface
//-------------------------------------------------------------------------
/**
- * Sets the value stored in this <code>Map.Entry</code>.
+ * Sets the value stored in this {@code Map.Entry}.
* <p>
- * This <code>Map.Entry</code> is not connected to a Map, so only the
+ * This {@code Map.Entry} is not connected to a Map, so only the
* local data is changed.
*
* @param value the new value
@@ -55,7 +55,7 @@ public abstract class AbstractMapEntry<K, V> extends AbstractKeyValue<K, V> impl
}
/**
- * Compares this <code>Map.Entry</code> with another <code>Map.Entry</code>.
+ * Compares this {@code Map.Entry} with another {@code Map.Entry}.
* <p>
* Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
*
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntryDecorator.java b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntryDecorator.java
index 5ceea1a..2cd4542 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntryDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractMapEntryDecorator.java
@@ -31,13 +31,13 @@ import org.apache.commons.collections4.KeyValue;
*/
public abstract class AbstractMapEntryDecorator<K, V> implements Map.Entry<K, V>, KeyValue<K, V> {
- /** The <code>Map.Entry</code> to decorate */
+ /** The {@code Map.Entry} to decorate */
private final Map.Entry<K, V> entry;
/**
* Constructor that wraps (not copies).
*
- * @param entry the <code>Map.Entry</code> to decorate, must not be null
+ * @param entry the {@code Map.Entry} to decorate, must not be null
* @throws NullPointerException if the collection is null
*/
public AbstractMapEntryDecorator(final Map.Entry<K, V> entry) {
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/DefaultKeyValue.java b/src/main/java/org/apache/commons/collections4/keyvalue/DefaultKeyValue.java
index 05b5cea..1795076 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/DefaultKeyValue.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/DefaultKeyValue.java
@@ -21,10 +21,10 @@ import java.util.Map;
import org.apache.commons.collections4.KeyValue;
/**
- * A mutable <code>KeyValue</code> pair that does not implement
+ * A mutable {@code KeyValue} pair that does not implement
* {@link java.util.Map.Entry Map.Entry}.
* <p>
- * Note that a <code>DefaultKeyValue</code> instance may not contain
+ * Note that a {@code DefaultKeyValue} instance may not contain
* itself as a key or value.
* </p>
*
@@ -52,7 +52,7 @@ public class DefaultKeyValue<K, V> extends AbstractKeyValue<K, V> {
}
/**
- * Constructs a new pair from the specified <code>KeyValue</code>.
+ * Constructs a new pair from the specified {@code KeyValue}.
*
* @param pair the pair to copy, must not be null
* @throws NullPointerException if the entry is null
@@ -62,7 +62,7 @@ public class DefaultKeyValue<K, V> extends AbstractKeyValue<K, V> {
}
/**
- * Constructs a new pair from the specified <code>Map.Entry</code>.
+ * Constructs a new pair from the specified {@code Map.Entry}.
*
* @param entry the entry to copy, must not be null
* @throws NullPointerException if the entry is null
@@ -106,7 +106,7 @@ public class DefaultKeyValue<K, V> extends AbstractKeyValue<K, V> {
//-----------------------------------------------------------------------
/**
- * Returns a new <code>Map.Entry</code> object with key and value from this pair.
+ * Returns a new {@code Map.Entry} object with key and value from this pair.
*
* @return a MapEntry instance
*/
@@ -116,9 +116,9 @@ public class DefaultKeyValue<K, V> extends AbstractKeyValue<K, V> {
//-----------------------------------------------------------------------
/**
- * Compares this <code>Map.Entry</code> with another <code>Map.Entry</code>.
+ * Compares this {@code Map.Entry} with another {@code Map.Entry}.
* <p>
- * Returns true if the compared object is also a <code>DefaultKeyValue</code>,
+ * Returns true if the compared object is also a {@code DefaultKeyValue},
* and its key and value are equal to this object's key and value.
*
* @param obj the object to compare to
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/DefaultMapEntry.java b/src/main/java/org/apache/commons/collections4/keyvalue/DefaultMapEntry.java
index 29c2d7d..19b99ea 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/DefaultMapEntry.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/DefaultMapEntry.java
@@ -41,7 +41,7 @@ public final class DefaultMapEntry<K, V> extends AbstractMapEntry<K, V> {
}
/**
- * Constructs a new entry from the specified <code>KeyValue</code>.
+ * Constructs a new entry from the specified {@code KeyValue}.
*
* @param pair the pair to copy, must not be null
* @throws NullPointerException if the entry is null
@@ -51,7 +51,7 @@ public final class DefaultMapEntry<K, V> extends AbstractMapEntry<K, V> {
}
/**
- * Constructs a new entry from the specified <code>Map.Entry</code>.
+ * Constructs a new entry from the specified {@code Map.Entry}.
*
* @param entry the entry to copy, must not be null
* @throws NullPointerException if the entry is null
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/MultiKey.java b/src/main/java/org/apache/commons/collections4/keyvalue/MultiKey.java
index 1897c20..1261a06 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/MultiKey.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/MultiKey.java
@@ -21,7 +21,7 @@ import java.util.Arrays;
import java.util.Objects;
/**
- * A <code>MultiKey</code> allows multiple map keys to be merged together.
+ * A {@code MultiKey} allows multiple map keys to be merged together.
* <p>
* The purpose of this class is to avoid the need to write code to handle
* maps of maps. An example might be the need to look up a file name by
@@ -124,7 +124,7 @@ public class MultiKey<K> implements Serializable {
* The keys should be immutable
* If they are not then they must not be changed after adding to the MultiKey.
* <p>
- * This is equivalent to <code>new MultiKey(keys, true)</code>.
+ * This is equivalent to {@code new MultiKey(keys, true)}.
*
* @param keys the array of keys, not null
* @throws NullPointerException if the key array is null
@@ -211,7 +211,7 @@ public class MultiKey<K> implements Serializable {
/**
* Compares this object to another.
* <p>
- * To be equal, the other object must be a <code>MultiKey</code> with the
+ * To be equal, the other object must be a {@code MultiKey} with the
* same number of keys which are also equal.
*
* @param other the other object to compare to
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/TiedMapEntry.java b/src/main/java/org/apache/commons/collections4/keyvalue/TiedMapEntry.java
index 5748778..0400f45 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/TiedMapEntry.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/TiedMapEntry.java
@@ -93,7 +93,7 @@ public class TiedMapEntry<K, V> implements Map.Entry<K, V>, KeyValue<K, V>, Seri
}
/**
- * Compares this <code>Map.Entry</code> with another <code>Map.Entry</code>.
+ * Compares this {@code Map.Entry} with another {@code Map.Entry}.
* <p>
* Implemented per API documentation of {@link java.util.Map.Entry#equals(Object)}
*
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/UnmodifiableMapEntry.java b/src/main/java/org/apache/commons/collections4/keyvalue/UnmodifiableMapEntry.java
index 83c6817..a966420 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/UnmodifiableMapEntry.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/UnmodifiableMapEntry.java
@@ -23,7 +23,7 @@ import org.apache.commons.collections4.Unmodifiable;
/**
* A {@link java.util.Map.Entry Map.Entry} that throws
- * UnsupportedOperationException when <code>setValue</code> is called.
+ * UnsupportedOperationException when {@code setValue} is called.
*
* @param <K> the type of keys
* @param <V> the type of mapped values
@@ -42,7 +42,7 @@ public final class UnmodifiableMapEntry<K, V> extends AbstractMapEntry<K, V> imp
}
/**
- * Constructs a new entry from the specified <code>KeyValue</code>.
+ * Constructs a new entry from the specified {@code KeyValue}.
*
* @param pair the pair to copy, must not be null
* @throws NullPointerException if the entry is null
@@ -52,7 +52,7 @@ public final class UnmodifiableMapEntry<K, V> extends AbstractMapEntry<K, V> imp
}
/**
- * Constructs a new entry from the specified <code>Map.Entry</code>.
+ * Constructs a new entry from the specified {@code Map.Entry}.
*
* @param entry the entry to copy, must not be null
* @throws NullPointerException if the entry is null
diff --git a/src/main/java/org/apache/commons/collections4/list/AbstractLinkedList.java b/src/main/java/org/apache/commons/collections4/list/AbstractLinkedList.java
index 3dfdf71..6eebc37 100644
--- a/src/main/java/org/apache/commons/collections4/list/AbstractLinkedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/AbstractLinkedList.java
@@ -56,8 +56,8 @@ public abstract class AbstractLinkedList<E> implements List<E> {
/**
* A {@link Node} which indicates the start and end of the list and does not
- * hold a value. The value of <code>next</code> is the first item in the
- * list. The value of of <code>previous</code> is the last item in the list.
+ * hold a value. The value of {@code next} is the first item in the
+ * list. The value of of {@code previous} is the last item in the list.
*/
transient Node<E> header;
@@ -90,7 +90,7 @@ public abstract class AbstractLinkedList<E> implements List<E> {
/**
* The equivalent of a default constructor, broken out so it can be called
- * by any constructor and by <code>readObject</code>.
+ * by any constructor and by {@code readObject}.
* Subclasses which override this method should make sure they call super,
* so the list is initialised properly.
*/
@@ -266,9 +266,9 @@ public abstract class AbstractLinkedList<E> implements List<E> {
* {@inheritDoc}
* <p>
* This implementation iterates over the elements of this list, checking each element in
- * turn to see if it's contained in <code>coll</code>. If it's contained, it's removed
+ * turn to see if it's contained in {@code coll}. If it's contained, it's removed
* from this list. As a consequence, it is advised to use a collection type for
- * <code>coll</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code coll} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
*/
@Override
@@ -290,9 +290,9 @@ public abstract class AbstractLinkedList<E> implements List<E> {
* {@inheritDoc}
* <p>
* This implementation iterates over the elements of this list, checking each element in
- * turn to see if it's contained in <code>coll</code>. If it's not contained, it's removed
+ * turn to see if it's contained in {@code coll}. If it's not contained, it's removed
* from this list. As a consequence, it is advised to use a collection type for
- * <code>coll</code> that provides a fast (e.g. O(1)) implementation of
+ * {@code coll} that provides a fast (e.g. O(1)) implementation of
* {@link Collection#contains(Object)}.
*/
@Override
@@ -476,14 +476,14 @@ public abstract class AbstractLinkedList<E> implements List<E> {
/**
* Creates a new node with the specified object as its
- * <code>value</code> and inserts it before <code>node</code>.
+ * {@code value} and inserts it before {@code node}.
* <p>
* This implementation uses {@link #createNode(Object)} and
* {@link #addNode(AbstractLinkedList.Node,AbstractLinkedList.Node)}.
*
* @param node node to insert before
* @param value value of the newly added node
- * @throws NullPointerException if <code>node</code> is null
+ * @throws NullPointerException if {@code node} is null
*/
protected void addNodeBefore(final Node<E> node, final E value) {
final Node<E> newNode = createNode(value);
@@ -492,14 +492,14 @@ public abstract class AbstractLinkedList<E> implements List<E> {
/**
* Creates a new node with the specified object as its
- * <code>value</code> and inserts it after <code>node</code>.
+ * {@code value} and inserts it after {@code node}.
* <p>
* This implementation uses {@link #createNode(Object)} and
* {@link #addNode(AbstractLinkedList.Node,AbstractLinkedList.Node)}.
*
* @param node node to insert after
* @param value value of the newly added node
- * @throws NullPointerException if <code>node</code> is null
+ * @throws NullPointerException if {@code node} is null
*/
protected void addNodeAfter(final Node<E> node, final E value) {
final Node<E> newNode = createNode(value);
@@ -526,7 +526,7 @@ public abstract class AbstractLinkedList<E> implements List<E> {
* Removes the specified node from the list.
*
* @param node the node to remove
- * @throws NullPointerException if <code>node</code> is null
+ * @throws NullPointerException if {@code node} is null
*/
protected void removeNode(final Node<E> node) {
node.previous.next = node.next;
@@ -616,7 +616,7 @@ public abstract class AbstractLinkedList<E> implements List<E> {
* Serializes the data held in this object to the stream specified.
* <p>
* The first serializable subclass must call this method from
- * <code>writeObject</code>.
+ * {@code writeObject}.
*
* @param outputStream the stream to write the object to
* @throws IOException if anything goes wrong
@@ -633,7 +633,7 @@ public abstract class AbstractLinkedList<E> implements List<E> {
* Deserializes the data held in this object to the stream specified.
* <p>
* The first serializable subclass must call this method from
- * <code>readObject</code>.
+ * {@code readObject}.
*
* @param inputStream the stream to read the object from
* @throws IOException if any error occurs while reading from the stream
@@ -652,7 +652,7 @@ public abstract class AbstractLinkedList<E> implements List<E> {
/**
* A node within the linked list.
* <p>
- * From Commons Collections 3.1, all access to the <code>value</code> property
+ * From Commons Collections 3.1, all access to the {@code value} property
* is via the methods on this class.
*/
protected static class Node<E> {
@@ -780,7 +780,7 @@ public abstract class AbstractLinkedList<E> implements List<E> {
/**
* The last node that was returned by {@link #next()} or {@link
- * #previous()}. Set to <code>null</code> if {@link #next()} or {@link
+ * #previous()}. Set to {@code null} if {@link #next()} or {@link
* #previous()} haven't been called, or if the node has been removed
* with {@link #remove()} or a new node added with {@link #add(Object)}.
* Should be accessed through {@link #getLastNodeReturned()} to enforce
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 ea02b21..e2d8cc0 100644
--- a/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
@@ -29,25 +29,25 @@ import java.util.List;
import java.util.ListIterator;
/**
- * A <code>List</code> implementation with a <code>ListIterator</code> that
+ * A {@code List} implementation with a {@code ListIterator} that
* allows concurrent modifications to the underlying list.
* <p>
* This implementation supports all of the optional {@link List} operations.
- * It extends <code>AbstractLinkedList</code> and thus provides the
+ * It extends {@code AbstractLinkedList} and thus provides the
* stack/queue/dequeue operations available in {@link java.util.LinkedList}.
* </p>
* <p>
* The main feature of this class is the ability to modify the list and the
* iterator at the same time. Both the {@link #listIterator()} and {@link #cursor()}
- * methods provides access to a <code>Cursor</code> instance which extends
- * <code>ListIterator</code>. The cursor allows changes to the list concurrent
+ * methods provides access to a {@code Cursor} instance which extends
+ * {@code ListIterator}. The cursor allows changes to the list concurrent
* with changes to the iterator. Note that the {@link #iterator()} method and
* sublists do <b>not</b> provide this cursor behaviour.
* </p>
* <p>
- * The <code>Cursor</code> class is provided partly for backwards compatibility
+ * The {@code Cursor} class is provided partly for backwards compatibility
* and partly because it allows the cursor to be directly closed. Closing the
- * cursor is optional because references are held via a <code>WeakReference</code>.
+ * cursor is optional because references are held via a {@code WeakReference}.
* For most purposes, simply modify the iterator and list at will, and then let
* the garbage collector to the rest.
* </p>
@@ -86,7 +86,7 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
/**
* The equivalent of a default constructor called
- * by any constructor and by <code>readObject</code>.
+ * by any constructor and by {@code readObject}.
*/
@Override
protected void init() {
@@ -153,10 +153,10 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
/**
* Returns a {@link Cursor} for iterating through the elements of this list.
* <p>
- * A <code>Cursor</code> is a <code>ListIterator</code> with an additional
- * <code>close()</code> method. Calling this method immediately discards the
+ * A {@code Cursor} is a {@code ListIterator} with an additional
+ * {@code close()} method. Calling this method immediately discards the
* references to the cursor. If it is not called, then the garbage collector
- * will still remove the reference as it is held via a <code>WeakReference</code>.
+ * will still remove the reference as it is held via a {@code WeakReference}.
* <p>
* The cursor enables iteration and list changes to occur in any order without
* invalidating the iterator (from one thread). When elements are added to the
@@ -169,7 +169,7 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
* last returned value such that it cannot be removed).
* <p>
* The {@link #listIterator()} method returns the same as this method, and can
- * be cast to a <code>Cursor</code> if the <code>close</code> method is required.
+ * be cast to a {@code Cursor} if the {@code close} method is required.
*
* @return a new cursor iterator
*/
@@ -181,10 +181,10 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
* Returns a {@link Cursor} for iterating through the elements of this list
* starting from a specified index.
* <p>
- * A <code>Cursor</code> is a <code>ListIterator</code> with an additional
- * <code>close()</code> method. Calling this method immediately discards the
+ * A {@code Cursor} is a {@code ListIterator} with an additional
+ * {@code close()} method. Calling this method immediately discards the
* references to the cursor. If it is not called, then the garbage collector
- * will still remove the reference as it is held via a <code>WeakReference</code>.
+ * will still remove the reference as it is held via a {@code WeakReference}.
* <p>
* The cursor enables iteration and list changes to occur in any order without
* invalidating the iterator (from one thread). When elements are added to the
@@ -197,7 +197,7 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
* last returned value such that it cannot be removed).
* <p>
* The {@link #listIterator(int)} method returns the same as this method, and can
- * be cast to a <code>Cursor</code> if the <code>close</code> method is required.
+ * be cast to a {@code Cursor} if the {@code close} method is required.
*
* @param fromIndex the index to start from
* @return a new cursor iterator
@@ -242,7 +242,7 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
* Removes the specified node from the list.
*
* @param node the node to remove
- * @throws NullPointerException if <code>node</code> is null
+ * @throws NullPointerException if {@code node} is null
*/
@Override
protected void removeNode(final Node<E> node) {
@@ -399,7 +399,7 @@ public class CursorableLinkedList<E> extends AbstractLinkedList<E> implements Se
//-----------------------------------------------------------------------
/**
- * An extended <code>ListIterator</code> that allows concurrent changes to
+ * An extended {@code ListIterator} that allows concurrent changes to
* the underlying list.
*/
public static class Cursor<E> extends AbstractLinkedList.LinkedListIterator<E> {
diff --git a/src/main/java/org/apache/commons/collections4/list/FixedSizeList.java b/src/main/java/org/apache/commons/collections4/list/FixedSizeList.java
index 5bdcb63..9a87de8 100644
--- a/src/main/java/org/apache/commons/collections4/list/FixedSizeList.java
+++ b/src/main/java/org/apache/commons/collections4/list/FixedSizeList.java
@@ -27,7 +27,7 @@ import org.apache.commons.collections4.iterators.AbstractListIteratorDecorator;
import org.apache.commons.collections4.iterators.UnmodifiableIterator;
/**
- * Decorates another <code>List</code> to fix the size preventing add/remove.
+ * Decorates another {@code List} to fix the size preventing add/remove.
* <p>
* The add, remove, clear and retain operations are unsupported.
* The set method is allowed (as it doesn't change the list size).
diff --git a/src/main/java/org/apache/commons/collections4/list/GrowthList.java b/src/main/java/org/apache/commons/collections4/list/GrowthList.java
index 79d28d1..4ade5d1 100644
--- a/src/main/java/org/apache/commons/collections4/list/GrowthList.java
+++ b/src/main/java/org/apache/commons/collections4/list/GrowthList.java
@@ -22,7 +22,7 @@ import java.util.Collections;
import java.util.List;
/**
- * Decorates another <code>List</code> to make it seamlessly grow when
+ * Decorates another {@code List} to make it seamlessly grow when
* indices larger than the list size are used on add and set,
* avoiding most IndexOutOfBoundsExceptions.
* <p>
@@ -32,7 +32,7 @@ import java.util.List;
* </p>
* <p>
* Trying to set or add to an index larger than the size will cause the list
- * to grow (using <code>null</code> elements). Clearly, care must be taken
+ * to grow (using {@code null} elements). Clearly, care must be taken
* not to use excessively large indices, as the internal list will grow to
* match.
* </p>
@@ -41,8 +41,8 @@ import java.util.List;
* call the underlying list and probably result in an IndexOutOfBoundsException.
* </p>
* <p>
- * Take care when using this list with <code>null</code> values, as
- * <code>null</code> is the value added when growing the list.
+ * Take care when using this list with {@code null} values, as
+ * {@code null} is the value added when growing the list.
* </p>
* <p>
* All sub-lists will access the underlying list directly, and will throw
@@ -50,7 +50,7 @@ import java.util.List;
* </p>
* <p>
* This class differs from {@link LazyList} because here growth occurs on
- * set and add, where <code>LazyList</code> grows on get. However, they
+ * set and add, where {@code LazyList} grows on get. However, they
* can be used together by decorating twice.
* </p>
*
@@ -109,7 +109,7 @@ public class GrowthList<E> extends AbstractSerializableListDecorator<E> {
* <p>
* If the requested index is greater than the current size, the list will
* grow to the new size. Indices between the old size and the requested
- * size will be filled with <code>null</code>.
+ * size will be filled with {@code null}.
* <p>
* If the index is less than the current size, the value will be added to
* the underlying list directly.
@@ -137,7 +137,7 @@ public class GrowthList<E> extends AbstractSerializableListDecorator<E> {
* <p>
* If the requested index is greater than the current size, the list will
* grow to the new size. Indices between the old size and the requested
- * size will be filled with <code>null</code>.
+ * size will be filled with {@code null}.
* <p>
* If the index is less than the current size, the values will be added to
* the underlying list directly.
@@ -168,7 +168,7 @@ public class GrowthList<E> extends AbstractSerializableListDecorator<E> {
* <p>
* If the requested index is greater than the current size, the list will
* grow to the new size. Indices between the old size and the requested
- * size will be filled with <code>null</code>.
+ * size will be filled with {@code null}.
* <p>
* If the index is less than the current size, the value will be set onto
* the underlying list directly.
diff --git a/src/main/java/org/apache/commons/collections4/list/LazyList.java b/src/main/java/org/apache/commons/collections4/list/LazyList.java
index e9e2270..d23672c 100644
--- a/src/main/java/org/apache/commons/collections4/list/LazyList.java
+++ b/src/main/java/org/apache/commons/collections4/list/LazyList.java
@@ -23,7 +23,7 @@ import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>List</code> to create objects in the list on demand.
+ * Decorates another {@code List} to create objects in the list on demand.
* <p>
* When the {@link #get(int)} method is called with an index greater than
* the size of the list, the list will automatically grow in size and return
@@ -47,14 +47,14 @@ import org.apache.commons.collections4.Transformer;
* </pre>
*
* <p>
- * After the above code is executed, <code>date</code> will contain
- * a new <code>Date</code> instance. Furthermore, that <code>Date</code>
+ * After the above code is executed, {@code date} will contain
+ * a new {@code Date} instance. Furthermore, that {@code Date}
* instance is the fourth element in the list. The first, second,
- * and third element are all set to <code>null</code>.
+ * and third element are all set to {@code null}.
* </p>
* <p>
* This class differs from {@link GrowthList} because here growth occurs on
- * get, where <code>GrowthList</code> grows on set and add. However, they
+ * get, where {@code GrowthList} grows on set and add. However, they
* could easily be used together by decorating twice.
* </p>
* <p>
diff --git a/src/main/java/org/apache/commons/collections4/list/NodeCachingLinkedList.java b/src/main/java/org/apache/commons/collections4/list/NodeCachingLinkedList.java
index a128557..658f8b8 100644
--- a/src/main/java/org/apache/commons/collections4/list/NodeCachingLinkedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/NodeCachingLinkedList.java
@@ -23,7 +23,7 @@ import java.io.Serializable;
import java.util.Collection;
/**
- * A <code>List</code> implementation that stores a cache of internal Node objects
+ * A {@code List} implementation that stores a cache of internal Node objects
* in an effort to reduce wasteful object creation.
* <p>
* A linked list creates one Node for each item of data added. This can result in
@@ -52,9 +52,9 @@ public class NodeCachingLinkedList<E> extends AbstractLinkedList<E> implements S
private static final int DEFAULT_MAXIMUM_CACHE_SIZE = 20;
/**
- * The first cached node, or <code>null</code> if no nodes are cached.
+ * The first cached node, or {@code null} if no nodes are cached.
* Cached nodes are stored in a singly-linked list with
- * <code>next</code> pointing to the next element.
+ * {@code next} pointing to the next element.
*/
private transient Node<E> firstCachedNode;
@@ -130,9 +130,9 @@ public class NodeCachingLinkedList<E> extends AbstractLinkedList<E> implements S
/**
* Gets a node from the cache. If a node is returned, then the value of
* {@link #cacheSize} is decreased accordingly. The node that is returned
- * will have <code>null</code> values for next, previous and element.
+ * will have {@code null} values for next, previous and element.
*
- * @return a node, or <code>null</code> if there are no nodes in the cache.
+ * @return a node, or {@code null} if there are no nodes in the cache.
*/
protected Node<E> getNodeFromCache() {
if (cacheSize == 0) {
diff --git a/src/main/java/org/apache/commons/collections4/list/PredicatedList.java b/src/main/java/org/apache/commons/collections4/list/PredicatedList.java
index a665b49..3ca7557 100644
--- a/src/main/java/org/apache/commons/collections4/list/PredicatedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/PredicatedList.java
@@ -25,7 +25,7 @@ import org.apache.commons.collections4.collection.PredicatedCollection;
import org.apache.commons.collections4.iterators.AbstractListIteratorDecorator;
/**
- * Decorates another <code>List</code> to validate that all additions
+ * Decorates another {@code List} to validate that all additions
* match a specified predicate.
* <p>
* This list exists to provide validation for the decorated list.
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 7a43146..ac5a277 100644
--- a/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
+++ b/src/main/java/org/apache/commons/collections4/list/SetUniqueList.java
@@ -33,10 +33,10 @@ import org.apache.commons.collections4.iterators.AbstractListIteratorDecorator;
import org.apache.commons.collections4.set.UnmodifiableSet;
/**
- * Decorates a <code>List</code> to ensure that no duplicates are present much
- * like a <code>Set</code>.
+ * Decorates a {@code List} to ensure that no duplicates are present much
+ * like a {@code Set}.
* <p>
- * The <code>List</code> interface makes certain assumptions/requirements. This
+ * The {@code List} interface makes certain assumptions/requirements. This
* implementation breaks these in certain ways, but this is merely the result of
* rejecting duplicates. Each violation is explained in the method, but it
* should not affect you. Bear in mind that Sets require immutable objects to
@@ -65,7 +65,7 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
* Factory method to create a SetList using the supplied list to retain order.
* <p>
* If the list contains duplicates, these are removed (first indexed one
- * kept). A <code>HashSet</code> is used for the set behaviour.
+ * kept). A {@code HashSet} is used for the set behaviour.
*
* @param <E> the element type
* @param list the list to decorate, must not be null
@@ -114,9 +114,9 @@ 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</code> interface requires that this
- * method returns <code>true</code> always. However this class may return
- * <code>false</code> because of the <code>Set</code> behaviour.
+ * <i>(Violation)</i> The {@code List} interface requires that this
+ * method returns {@code true} always. However this class may return
+ * {@code false} because of the {@code Set} behaviour.
*
* @param object the object to add
* @return true if object was added
@@ -137,7 +137,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</code> interface makes the assumption
+ * <i>(Violation)</i> The {@code List} interface makes the assumption
* that the element is always inserted. This may not happen with this
* implementation.
*
@@ -159,7 +159,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</code> interface makes the assumption
+ * <i>(Violation)</i> The {@code List} interface makes the assumption
* that the elements are always inserted. This may not happen with this
* implementation.
*
@@ -178,7 +178,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</code> interface makes the assumption
+ * <i>(Violation)</i> The {@code List} interface makes the assumption
* that the elements are always inserted. This may not happen with this
* implementation.
*
@@ -265,9 +265,9 @@ public class SetUniqueList<E> extends AbstractSerializableListDecorator<E> {
* {@inheritDoc}
* <p>
* This implementation iterates over the elements of this list, checking
- * each element in turn to see if it's contained in <code>coll</code>.
+ * each element in turn to see if it's contained in {@code coll}.
* If it's not contained, it's removed from this list. As a consequence,
- * it is advised to use a collection type for <code>coll</code> that provides
+ * it is advised to use a collection type for {@code coll} that provides
* a fast (e.g. O(1)) implementation of {@link Collection#contains(Object)}.
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/list/TransformedList.java b/src/main/java/org/apache/commons/collections4/list/TransformedList.java
index 8ce2165..d51bd36 100644
--- a/src/main/java/org/apache/commons/collections4/list/TransformedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/TransformedList.java
@@ -25,7 +25,7 @@ import org.apache.commons.collections4.collection.TransformedCollection;
import org.apache.commons.collections4.iterators.AbstractListIteratorDecorator;
/**
- * Decorates another <code>List</code> to transform objects that are added.
+ * Decorates another {@code List} to transform objects that are added.
* <p>
* The add and set methods are affected by this class.
* Thus objects must be removed or searched for using their transformed form.
diff --git a/src/main/java/org/apache/commons/collections4/list/TreeList.java b/src/main/java/org/apache/commons/collections4/list/TreeList.java
index fc24215..90d3be5 100644
--- a/src/main/java/org/apache/commons/collections4/list/TreeList.java
+++ b/src/main/java/org/apache/commons/collections4/list/TreeList.java
@@ -29,12 +29,12 @@ import java.util.Objects;
import org.apache.commons.collections4.OrderedIterator;
/**
- * A <code>List</code> implementation that is optimised for fast insertions and
+ * A {@code List} implementation that is optimised for fast insertions and
* removals at any index in the list.
* <p>
* This list implementation utilises a tree structure internally to ensure that
* all insertions and removals are O(log n). This provides much faster performance
- * than both an <code>ArrayList</code> and a <code>LinkedList</code> where elements
+ * than both an {@code ArrayList} and a {@code LinkedList} where elements
* are inserted and removed repeatedly from anywhere in the list.
* </p>
* <p>
@@ -47,14 +47,14 @@ import org.apache.commons.collections4.OrderedIterator;
* LinkedList 5800 1 350 2 325
* </pre>
* <p>
- * <code>ArrayList</code> is a good general purpose list implementation.
- * It is faster than <code>TreeList</code> for most operations except inserting
- * and removing in the middle of the list. <code>ArrayList</code> also uses less
- * memory as <code>TreeList</code> uses one object per entry.
+ * {@code ArrayList} is a good general purpose list implementation.
+ * It is faster than {@code TreeList} for most operations except inserting
+ * and removing in the middle of the list. {@code ArrayList} also uses less
+ * memory as {@code TreeList} uses one object per entry.
* </p>
* <p>
- * <code>LinkedList</code> is rarely a good choice of implementation.
- * <code>TreeList</code> is almost always a good replacement for it, although it
+ * {@code LinkedList} is rarely a good choice of implementation.
+ * {@code TreeList} is almost always a good replacement for it, although it
* does use slightly more memory.
* </p>
*
diff --git a/src/main/java/org/apache/commons/collections4/list/UnmodifiableList.java b/src/main/java/org/apache/commons/collections4/list/UnmodifiableList.java
index bc37d73..09695ea 100644
--- a/src/main/java/org/apache/commons/collections4/list/UnmodifiableList.java
+++ b/src/main/java/org/apache/commons/collections4/list/UnmodifiableList.java
@@ -27,7 +27,7 @@ import org.apache.commons.collections4.iterators.UnmodifiableIterator;
import org.apache.commons.collections4.iterators.UnmodifiableListIterator;
/**
- * Decorates another <code>List</code> to ensure it can't be altered.
+ * Decorates another {@code List} to ensure it can't be altered.
* <p>
* This class is Serializable from Commons Collections 3.1.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java b/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
index 8efb96b..8198baf 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
@@ -40,7 +40,7 @@ import org.apache.commons.collections4.iterators.EmptyMapIterator;
* subclasses to override.
* <p>
* This class implements all the features necessary for a subclass hash-based map.
- * Key-value entries are stored in instances of the <code>HashEntry</code> class,
+ * Key-value entries are stored in instances of the {@code HashEntry} class,
* which can be overridden and replaced. The iterators can similarly be replaced,
* without the need to replace the KeySet, EntrySet and Values view classes.
* <p>
@@ -407,7 +407,7 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
* Subclasses can override this to match differently.
*
* @param key1 the first key to compare passed in from outside
- * @param key2 the second key extracted from the entry via <code>entry.key</code>
+ * @param key2 the second key extracted from the entry via {@code entry.key}
* @return true if equal
*/
protected boolean isEqualKey(final Object key1, final Object key2) {
@@ -420,7 +420,7 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
* Subclasses can override this to match differently.
*
* @param value1 the first value to compare passed in from outside
- * @param value2 the second value extracted from the entry via <code>getValue()</code>
+ * @param value2 the second value extracted from the entry via {@code getValue()}
* @return true if equal
*/
protected boolean isEqualValue(final Object value1, final Object value2) {
@@ -468,7 +468,7 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
/**
* Updates an existing key-value mapping to change the value.
* <p>
- * This implementation calls <code>setValue()</code> on the entry.
+ * This implementation calls {@code setValue()} on the entry.
* Subclasses could override to handle changes to the map.
*
* @param entry the entry to update
@@ -502,9 +502,9 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
/**
* Adds a new key-value mapping into this map.
* <p>
- * This implementation calls <code>createEntry()</code>, <code>addEntry()</code>
- * and <code>checkCapacity()</code>.
- * It also handles changes to <code>modCount</code> and <code>size</code>.
+ * This implementation calls {@code createEntry()}, {@code addEntry()}
+ * and {@code checkCapacity()}.
+ * It also handles changes to {@code modCount} and {@code size}.
* Subclasses could override to fully control adds to the map.
*
* @param hashIndex the index into the data array to store at
@@ -554,8 +554,8 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
/**
* Removes a mapping from the map.
* <p>
- * This implementation calls <code>removeEntry()</code> and <code>destroyEntry()</code>.
- * It also handles changes to <code>modCount</code> and <code>size</code>.
+ * This implementation calls {@code removeEntry()} and {@code destroyEntry()}.
+ * It also handles changes to {@code modCount} and {@code size}.
* Subclasses could override to fully control removals from the map.
*
* @param entry the entry to remove
@@ -690,11 +690,11 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
//-----------------------------------------------------------------------
/**
- * Gets the <code>next</code> field from a <code>HashEntry</code>.
+ * Gets the {@code next} field from a {@code HashEntry}.
* Used in subclasses that have no visibility of the field.
*
* @param entry the entry to query, must not be null
- * @return the <code>next</code> field of the entry
+ * @return the {@code next} field of the entry
* @throws NullPointerException if the entry is null
* @since 3.1
*/
@@ -703,11 +703,11 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
}
/**
- * Gets the <code>hashCode</code> field from a <code>HashEntry</code>.
+ * Gets the {@code hashCode} field from a {@code HashEntry}.
* Used in subclasses that have no visibility of the field.
*
* @param entry the entry to query, must not be null
- * @return the <code>hashCode</code> field of the entry
+ * @return the {@code hashCode} field of the entry
* @throws NullPointerException if the entry is null
* @since 3.1
*/
@@ -716,11 +716,11 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
}
/**
- * Gets the <code>key</code> field from a <code>HashEntry</code>.
+ * Gets the {@code key} field from a {@code HashEntry}.
* Used in subclasses that have no visibility of the field.
*
* @param entry the entry to query, must not be null
- * @return the <code>key</code> field of the entry
+ * @return the {@code key} field of the entry
* @throws NullPointerException if the entry is null
* @since 3.1
*/
@@ -729,11 +729,11 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
}
/**
- * Gets the <code>value</code> field from a <code>HashEntry</code>.
+ * Gets the {@code value} field from a {@code HashEntry}.
* Used in subclasses that have no visibility of the field.
*
* @param entry the entry to query, must not be null
- * @return the <code>value</code> field of the entry
+ * @return the {@code value} field of the entry
* @throws NullPointerException if the entry is null
* @since 3.1
*/
@@ -1065,9 +1065,9 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
/**
* HashEntry used to store the data.
* <p>
- * If you subclass <code>AbstractHashedMap</code> but not <code>HashEntry</code>
+ * If you subclass {@code AbstractHashedMap} but not {@code HashEntry}
* then you will not be able to access the protected fields.
- * The <code>entryXxx()</code> methods on <code>AbstractHashedMap</code> exist
+ * The {@code entryXxx()} methods on {@code AbstractHashedMap} exist
* to provide the necessary access.
*/
protected static class HashEntry<K, V> implements Map.Entry<K, V>, KeyValue<K, V> {
@@ -1219,16 +1219,16 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
//-----------------------------------------------------------------------
/**
* Writes the map data to the stream. This method must be overridden if a
- * subclass must be setup before <code>put()</code> is used.
+ * subclass must be setup before {@code put()} is used.
* <p>
* Serialization is not one of the JDK's nicest topics. Normal serialization will
* initialise the superclass before the subclass. Sometimes however, this isn't
- * what you want, as in this case the <code>put()</code> method on read can be
+ * what you want, as in this case the {@code put()} method on read can be
* affected by subclass state.
* <p>
* The solution adopted here is to serialize the state data of this class in
* this protected method. This method must be called by the
- * <code>writeObject()</code> of the first serializable subclass.
+ * {@code writeObject()} of the first serializable subclass.
* <p>
* Subclasses may override if they have a specific field that must be present
* on read before this implementation will work. Generally, the read determines
@@ -1249,19 +1249,19 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
/**
* Reads the map data from the stream. This method must be overridden if a
- * subclass must be setup before <code>put()</code> is used.
+ * subclass must be setup before {@code put()} is used.
* <p>
* Serialization is not one of the JDK's nicest topics. Normal serialization will
* initialise the superclass before the subclass. Sometimes however, this isn't
- * what you want, as in this case the <code>put()</code> method on read can be
+ * what you want, as in this case the {@code put()} method on read can be
* affected by subclass state.
* <p>
* The solution adopted here is to deserialize the state data of this class in
* this protected method. This method must be called by the
- * <code>readObject()</code> of the first serializable subclass.
+ * {@code readObject()} of the first serializable subclass.
* <p>
* Subclasses may override if the subclass has a specific field that must be present
- * before <code>put()</code> or <code>calculateThreshold()</code> will work correctly.
+ * before {@code put()} or {@code calculateThreshold()} will work correctly.
*
* @param in the input stream
* @throws IOException if an error occurs while reading from the stream
@@ -1286,8 +1286,8 @@ public class AbstractHashedMap<K, V> extends AbstractMap<K, V> implements Iterab
/**
* Clones the map without cloning the keys or values.
* <p>
- * To implement <code>clone()</code>, a subclass must implement the
- * <code>Cloneable</code> interface and make this method public.
+ * To implement {@code clone()}, a subclass must implement the
+ * {@code Cloneable} interface and make this method public.
*
* @return a shallow clone
* @throws InternalError if {@link AbstractMap#clone()} failed
diff --git a/src/main/java/org/apache/commons/collections4/map/AbstractInputCheckedMapDecorator.java b/src/main/java/org/apache/commons/collections4/map/AbstractInputCheckedMapDecorator.java
index 45028ce..5dfe004 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractInputCheckedMapDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractInputCheckedMapDecorator.java
@@ -66,7 +66,7 @@ abstract class AbstractInputCheckedMapDecorator<K, V>
//-----------------------------------------------------------------------
/**
- * Hook method called when a value is being set using <code>setValue</code>.
+ * Hook method called when a value is being set using {@code setValue}.
* <p>
* An implementation may validate the value and throw an exception
* or it may transform the value into another object.
@@ -85,12 +85,12 @@ abstract class AbstractInputCheckedMapDecorator<K, V>
protected abstract V checkSetValue(V value);
/**
- * Hook method called to determine if <code>checkSetValue</code> has any effect.
+ * Hook method called to determine if {@code checkSetValue} has any effect.
* <p>
- * An implementation should return false if the <code>checkSetValue</code> method
+ * An implementation should return false if the {@code checkSetValue} method
* has no effect as this optimises the implementation.
* <p>
- * This implementation returns <code>true</code>.
+ * This implementation returns {@code true}.
*
* @return true always
*/
diff --git a/src/main/java/org/apache/commons/collections4/map/AbstractLinkedMap.java b/src/main/java/org/apache/commons/collections4/map/AbstractLinkedMap.java
index 2fb1356..25b980b 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractLinkedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractLinkedMap.java
@@ -34,7 +34,7 @@ import org.apache.commons.collections4.iterators.EmptyOrderedMapIterator;
* <p>
* This class implements all the features necessary for a subclass linked
* hash-based map. Key-value entries are stored in instances of the
- * <code>LinkEntry</code> class which can be overridden and replaced.
+ * {@code LinkEntry} class which can be overridden and replaced.
* The iterators can similarly be replaced, without the need to replace the KeySet,
* EntrySet and Values view classes.
* </p>
@@ -45,17 +45,17 @@ import org.apache.commons.collections4.iterators.EmptyOrderedMapIterator;
* </p>
* <p>
* This implementation maintains order by original insertion, but subclasses
- * may work differently. The <code>OrderedMap</code> interface is implemented
+ * may work differently. The {@code OrderedMap} interface is implemented
* to provide access to bidirectional iteration and extra convenience methods.
* </p>
* <p>
- * The <code>orderedMapIterator()</code> method provides direct access to a
+ * The {@code orderedMapIterator()} method provides direct access to a
* bidirectional iterator. The iterators from the other views can also be cast
- * to <code>OrderedIterator</code> if required.
+ * to {@code OrderedIterator} if required.
* </p>
* <p>
* All the available iterators can be reset back to the start by casting to
- * <code>ResettableIterator</code> and calling <code>reset()</code>.
+ * {@code ResettableIterator} and calling {@code reset()}.
* </p>
* <p>
* The implementation is also designed to be subclassed, with lots of useful
@@ -317,11 +317,11 @@ public abstract class AbstractLinkedMap<K, V> extends AbstractHashedMap<K, V> im
//-----------------------------------------------------------------------
/**
- * Gets the <code>before</code> field from a <code>LinkEntry</code>.
+ * Gets the {@code before} field from a {@code LinkEntry}.
* Used in subclasses that have no visibility of the field.
*
* @param entry the entry to query, must not be null
- * @return the <code>before</code> field of the entry
+ * @return the {@code before} field of the entry
* @throws NullPointerException if the entry is null
* @since 3.1
*/
@@ -330,11 +330,11 @@ public abstract class AbstractLinkedMap<K, V> extends AbstractHashedMap<K, V> im
}
/**
- * Gets the <code>after</code> field from a <code>LinkEntry</code>.
+ * Gets the {@code after} field from a {@code LinkEntry}.
* Used in subclasses that have no visibility of the field.
*
* @param entry the entry to query, must not be null
- * @return the <code>after</code> field of the entry
+ * @return the {@code after} field of the entry
* @throws NullPointerException if the entry is null
* @since 3.1
*/
@@ -516,9 +516,9 @@ public abstract class AbstractLinkedMap<K, V> extends AbstractHashedMap<K, V> im
/**
* LinkEntry that stores the data.
* <p>
- * If you subclass <code>AbstractLinkedMap</code> but not <code>LinkEntry</code>
+ * If you subclass {@code AbstractLinkedMap} but not {@code LinkEntry}
* then you will not be able to access the protected fields.
- * The <code>entryXxx()</code> methods on <code>AbstractLinkedMap</code> exist
+ * The {@code entryXxx()} methods on {@code AbstractLinkedMap} exist
* to provide the necessary access.
*/
protected static class LinkEntry<K, V> extends HashEntry<K, V> {
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 26c577b..794c535 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
@@ -42,7 +42,7 @@ import org.apache.commons.collections4.keyvalue.DefaultMapEntry;
* <p>
* This class implements all the features necessary for a subclass reference
* hash-based map. Key-value entries are stored in instances of the
- * <code>ReferenceEntry</code> class which can be overridden and replaced.
+ * {@code ReferenceEntry} class which can be overridden and replaced.
* The iterators can similarly be replaced, without the need to replace the KeySet,
* EntrySet and Values view classes.
* </p>
@@ -52,7 +52,7 @@ import org.apache.commons.collections4.keyvalue.DefaultMapEntry;
* need for unusual subclasses is here.
* </p>
* <p>
- * When you construct an <code>AbstractReferenceMap</code>, you can specify what
+ * When you construct an {@code AbstractReferenceMap}, you can specify what
* kind of references are used to store the map's keys and values.
* If non-hard references are used, then the garbage collector can remove
* mappings if a key or value becomes unreachable, or if the JVM's memory is
@@ -64,23 +64,23 @@ import org.apache.commons.collections4.keyvalue.DefaultMapEntry;
* The keys can be configured to be weak but the values hard,
* in which case this class will behave like a
* <a href="http://java.sun.com/j2se/1.4/docs/api/java/util/WeakHashMap.html">
- * <code>WeakHashMap</code></a>. However, you can also specify hard keys and
+ * {@code WeakHashMap}</a>. However, you can also specify hard keys and
* weak values, or any other combination. The default constructor uses
* hard keys and soft values, providing a memory-sensitive cache.
* </p>
* <p>
* This {@link Map} implementation does <i>not</i> allow null elements.
* Attempting to add a null key or value to the map will raise a
- * <code>NullPointerException</code>.
+ * {@code NullPointerException}.
* </p>
* <p>
* All the available iterators can be reset back to the start by casting to
- * <code>ResettableIterator</code> and calling <code>reset()</code>.
+ * {@code ResettableIterator} and calling {@code reset()}.
* </p>
* <p>
* This implementation is not synchronized.
* You can use {@link java.util.Collections#synchronizedMap} to
- * provide synchronized access to a <code>ReferenceMap</code>.
+ * provide synchronized access to a {@code ReferenceMap}.
* </p>
*
* @param <K> the type of the keys in this map
@@ -317,8 +317,8 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
/**
* Returns a set view of this map's entries.
- * An iterator returned entry is valid until <code>next()</code> is called again.
- * The <code>setValue()</code> method on the <code>toArray</code> entries has no effect.
+ * An iterator returned entry is valid until {@code next()} is called again.
+ * The {@code setValue()} method on the {@code toArray} entries has no effect.
*
* @return a set view of this map's entries
*/
@@ -457,7 +457,7 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
* before comparison.
*
* @param key1 the first key to compare passed in from outside
- * @param key2 the second key extracted from the entry via <code>entry.key</code>
+ * @param key2 the second key extracted from the entry via {@code entry.key}
* @return true if equal
*/
@Override
@@ -664,8 +664,8 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
/**
* Compares this map entry to another.
* <p>
- * This implementation uses <code>isEqualKey</code> and
- * <code>isEqualValue</code> on the main map for comparison.
+ * This implementation uses {@code isEqualKey} and
+ * {@code isEqualValue} on the main map for comparison.
*
* @param obj the other map entry to compare to
* @return true if equal, false if not
@@ -694,7 +694,7 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
/**
* Gets the hashcode of the entry using temporary hard references.
* <p>
- * This implementation uses <code>hashEntry</code> on the main map.
+ * This implementation uses {@code hashEntry} on the main map.
*
* @return the hashcode of the entry
*/
@@ -1008,12 +1008,12 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
* <p>
* Serialization is not one of the JDK's nicest topics. Normal serialization will
* initialise the superclass before the subclass. Sometimes however, this isn't
- * what you want, as in this case the <code>put()</code> method on read can be
+ * what you want, as in this case the {@code put()} method on read can be
* affected by subclass state.
* <p>
* The solution adopted here is to serialize the state data of this class in
* this protected method. This method must be called by the
- * <code>writeObject()</code> of the first serializable subclass.
+ * {@code writeObject()} of the first serializable subclass.
* <p>
* Subclasses may override if they have a specific field that must be present
* on read before this implementation will work. Generally, the read determines
@@ -1042,15 +1042,15 @@ public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V>
* <p>
* Serialization is not one of the JDK's nicest topics. Normal serialization will
* initialise the superclass before the subclass. Sometimes however, this isn't
- * what you want, as in this case the <code>put()</code> method on read can be
+ * what you want, as in this case the {@code put()} method on read can be
* affected by subclass state.
* <p>
* The solution adopted here is to deserialize the state data of this class in
* this protected method. This method must be called by the
- * <code>readObject()</code> of the first serializable subclass.
+ * {@code readObject()} of the first serializable subclass.
* <p>
* Subclasses may override if the subclass has a specific field that must be present
- * before <code>put()</code> or <code>calculateThreshold()</code> will work correctly.
+ * before {@code put()} or {@code calculateThreshold()} will work correctly.
*
* @param in the input stream
* @throws IOException if an error occurs while reading from the stream
diff --git a/src/main/java/org/apache/commons/collections4/map/CaseInsensitiveMap.java b/src/main/java/org/apache/commons/collections4/map/CaseInsensitiveMap.java
index e57388f..58b4c75 100644
--- a/src/main/java/org/apache/commons/collections4/map/CaseInsensitiveMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/CaseInsensitiveMap.java
@@ -23,7 +23,7 @@ import java.io.Serializable;
import java.util.Map;
/**
- * A case-insensitive <code>Map</code>.
+ * A case-insensitive {@code Map}.
* <p>
* Before keys are added to the map or compared to other existing keys, they are converted
* to all lowercase in a locale-independent fashion by using information from the Unicode
@@ -33,7 +33,7 @@ import java.util.Map;
* Null keys are supported.
* </p>
* <p>
- * The <code>keySet()</code> method returns all lowercase keys, or nulls.
+ * The {@code keySet()} method returns all lowercase keys, or nulls.
* </p>
* <p>
* Example:
@@ -46,12 +46,12 @@ import java.util.Map;
* map.put("one", "Four");
* </code></pre>
* <p>
- * The example above creates a <code>CaseInsensitiveMap</code> with three entries.
+ * The example above creates a {@code CaseInsensitiveMap} with three entries.
* </p>
* <p>
- * <code>map.get(null)</code> returns <code>"Three"</code> and <code>map.get("ONE")</code>
- * returns <code>"Four".</code> The <code>Set</code> returned by <code>keySet()</code>
- * equals <code>{"one", "two", null}.</code>
+ * {@code map.get(null)} returns {@code "Three"} and {@code map.get("ONE")}
+ * returns {@code "Four".} The {@code Set} returned by {@code keySet()}
+ * equals {@code {"one", "two", null}.}
* </p>
* <p>
* <strong>This map will violate the detail of various Map and map view contracts.</strong>
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 170127e..e3feed6 100644
--- a/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
@@ -155,7 +155,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
* Remove a Map from the composite.
*
* @param map the Map to be removed from the composite
- * @return The removed Map or <code>null</code> if map is not in the composite
+ * @return The removed Map or {@code null} if map is not in the composite
*/
@SuppressWarnings("unchecked")
public synchronized Map<K, V> removeComposited(final Map<K, V> map) {
@@ -174,7 +174,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
//-----------------------------------------------------------------------
/**
- * Calls <code>clear()</code> on all composited Maps.
+ * Calls {@code clear()} on all composited Maps.
*
* @throws UnsupportedOperationException if any of the composited Maps do not support clear()
*/
@@ -239,7 +239,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
/**
* Returns a set view of the mappings contained in this map. Each element
- * in the returned set is a <code>Map.Entry</code>. The set is backed by the
+ * in the returned set is a {@code Map.Entry}. The set is backed by the
* map, so changes to the map are reflected in the set, and vice-versa.
* If the map is modified while an iteration over the set is in progress,
* the results of the iteration are undefined. The set supports element
@@ -248,7 +248,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
* {@code retainAll} and {@code clear} operations. It does not support
* the {@code add} or {@code addAll} operations.
* <p>
- * This implementation returns a <code>CompositeSet</code> which
+ * This implementation returns a {@code CompositeSet} which
* composites the entry sets from all of the composited maps.
*
* @see CompositeSet
@@ -322,7 +322,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
* {@code removeAll} {@code retainAll}, and {@code clear} operations.
* It does not support the add or {@code addAll} operations.
* <p>
- * This implementation returns a <code>CompositeSet</code> which
+ * This implementation returns a {@code CompositeSet} which
* composites the key sets from all of the composited maps.
*
* @return a set view of the keys contained in this map.
@@ -403,7 +403,7 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
* Removes the mapping for this key from this map if it is present
* (optional operation). More formally, if this map contains a mapping
* from key {@code k} to value {@code v} such that
- * <code>(key==null ? k==null : key.equals(k))</code>, that mapping
+ * {@code (key==null ? k==null : key.equals(k))}, that mapping
* is removed. (The map can contain at most one such mapping.)
*
* <p>Returns the value to which the map previously associated the key, or
diff --git a/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java b/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java
index f7211b8..e489d82 100644
--- a/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/DefaultedMap.java
@@ -30,7 +30,7 @@ import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.FactoryTransformer;
/**
- * Decorates another <code>Map</code> returning a default value if the map
+ * Decorates another {@code Map} returning a default value if the map
* does not contain the requested key.
* <p>
* When the {@link #get(Object)} method is called with a key that does not
@@ -141,8 +141,8 @@ public class DefaultedMap<K, V> extends AbstractMapDecorator<K, V> implements Se
//-----------------------------------------------------------------------
/**
- * Constructs a new empty <code>DefaultedMap</code> that decorates
- * a <code>HashMap</code>.
+ * Constructs a new empty {@code DefaultedMap} that decorates
+ * a {@code HashMap}.
* <p>
* The object passed in will be returned by the map whenever an
* unknown key is requested.
@@ -154,7 +154,7 @@ public class DefaultedMap<K, V> extends AbstractMapDecorator<K, V> implements Se
}
/**
- * Constructs a new empty <code>DefaultedMap</code> that decorates a <code>HashMap</code>.
+ * Constructs a new empty {@code DefaultedMap} that decorates a {@code HashMap}.
*
* @param defaultValueTransformer transformer to use to generate missing values.
*/
diff --git a/src/main/java/org/apache/commons/collections4/map/FixedSizeMap.java b/src/main/java/org/apache/commons/collections4/map/FixedSizeMap.java
index bbeac46..0895894 100644
--- a/src/main/java/org/apache/commons/collections4/map/FixedSizeMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/FixedSizeMap.java
@@ -29,7 +29,7 @@ import org.apache.commons.collections4.collection.UnmodifiableCollection;
import org.apache.commons.collections4.set.UnmodifiableSet;
/**
- * Decorates another <code>Map</code> to fix the size, preventing add/remove.
+ * Decorates another {@code Map} to fix the size, preventing add/remove.
* <p>
* Any action that would change the size of the map is disallowed.
* The put method is allowed to change the value associated with an existing
diff --git a/src/main/java/org/apache/commons/collections4/map/FixedSizeSortedMap.java b/src/main/java/org/apache/commons/collections4/map/FixedSizeSortedMap.java
index 15fe470..2ac2440 100644
--- a/src/main/java/org/apache/commons/collections4/map/FixedSizeSortedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/FixedSizeSortedMap.java
@@ -31,7 +31,7 @@ import org.apache.commons.collections4.collection.UnmodifiableCollection;
import org.apache.commons.collections4.set.UnmodifiableSet;
/**
- * Decorates another <code>SortedMap</code> to fix the size blocking add/remove.
+ * Decorates another {@code SortedMap} to fix the size blocking add/remove.
* <p>
* Any action that would change the size of the map is disallowed.
* The put method is allowed to change the value associated with an existing
diff --git a/src/main/java/org/apache/commons/collections4/map/Flat3Map.java b/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
index c506c53..fbb71c7 100644
--- a/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
+++ b/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
@@ -35,7 +35,7 @@ import org.apache.commons.collections4.iterators.EmptyIterator;
import org.apache.commons.collections4.iterators.EmptyMapIterator;
/**
- * A <code>Map</code> implementation that stores data in simple fields until
+ * A {@code Map} implementation that stores data in simple fields until
* the size is greater than 3.
* <p>
* This map is designed for performance and can outstrip HashMap.
@@ -64,7 +64,7 @@ import org.apache.commons.collections4.iterators.EmptyMapIterator;
* This is because it contains no complex objects or arrays which slow the progress.
* </p>
* <p>
- * Do not use <code>Flat3Map</code> if the size is likely to grow beyond 3.
+ * Do not use {@code Flat3Map} if the size is likely to grow beyond 3.
* </p>
* <p>
* <strong>Note that Flat3Map is not synchronized and is not thread-safe.</strong>
diff --git a/src/main/java/org/apache/commons/collections4/map/HashedMap.java b/src/main/java/org/apache/commons/collections4/map/HashedMap.java
index e0ec9d0..3c1ae1c 100644
--- a/src/main/java/org/apache/commons/collections4/map/HashedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/HashedMap.java
@@ -23,8 +23,8 @@ import java.io.Serializable;
import java.util.Map;
/**
- * A <code>Map</code> implementation that is a general purpose alternative
- * to <code>HashMap</code>.
+ * A {@code Map} implementation that is a general purpose alternative
+ * to {@code HashMap}.
* <p>
* This implementation improves on the JDK1.4 HashMap by adding the
* {@link org.apache.commons.collections4.MapIterator MapIterator}
diff --git a/src/main/java/org/apache/commons/collections4/map/LRUMap.java b/src/main/java/org/apache/commons/collections4/map/LRUMap.java
index fb83ad2..8fbf872 100644
--- a/src/main/java/org/apache/commons/collections4/map/LRUMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/LRUMap.java
@@ -25,7 +25,7 @@ import java.util.Map;
import org.apache.commons.collections4.BoundedMap;
/**
- * A <code>Map</code> implementation with a fixed maximum size which removes
+ * A {@code Map} implementation with a fixed maximum size which removes
* the least recently used entry if an entry is added when full.
* <p>
* The least recently used algorithm works on the get and put operations only.
@@ -42,21 +42,21 @@ import org.apache.commons.collections4.BoundedMap;
* {@link org.apache.commons.collections4.MapIterator MapIterator} or {@link #entrySet()} iterator.
* </p>
* <p>
- * The map implements <code>OrderedMap</code> and entries may be queried using
- * the bidirectional <code>OrderedMapIterator</code>. The order returned is
+ * The map implements {@code OrderedMap} and entries may be queried using
+ * the bidirectional {@code OrderedMapIterator}. The order returned is
* least recently used to most recently used. Iterators from map views can
- * also be cast to <code>OrderedIterator</code> if required.
+ * also be cast to {@code OrderedIterator} if required.
* </p>
* <p>
* All the available iterators can be reset back to the start by casting to
- * <code>ResettableIterator</code> and calling <code>reset()</code>.
+ * {@code ResettableIterator} and calling {@code reset()}.
* </p>
* <p>
* <strong>Note that LRUMap is not synchronized and is not thread-safe.</strong>
* If you wish to use this map from multiple threads concurrently, you must use
* appropriate synchronization. The simplest approach is to wrap this map
* using {@link java.util.Collections#synchronizedMap(Map)}. This class may throw
- * <code>NullPointerException</code>'s when accessed by concurrent threads.
+ * {@code NullPointerException}'s when accessed by concurrent threads.
* </p>
*
* @param <K> the type of the keys in this map
@@ -308,7 +308,7 @@ public class LRUMap<K, V>
* discard an entry or not using {@link #removeLRU(AbstractLinkedMap.LinkEntry)}.
* <p>
* From Commons Collections 3.1 this method uses {@link #isFull()} rather
- * than accessing <code>size</code> and <code>maxSize</code> directly.
+ * than accessing {@code size} and {@code maxSize} directly.
* It also handles the scanUntilRemovable functionality.
*
* @param hashIndex the index into the data array to store at
@@ -442,7 +442,7 @@ public class LRUMap<K, V>
/**
* Returns true if this map is full and no new mappings can be added.
*
- * @return <code>true</code> if the map is full
+ * @return {@code true} if the map is full
*/
@Override
public boolean isFull() {
@@ -505,7 +505,7 @@ public class LRUMap<K, V>
}
/**
- * Writes the data necessary for <code>put()</code> to work in deserialization.
+ * Writes the data necessary for {@code put()} to work in deserialization.
*
* @param out the output stream
* @throws IOException if an error occurs while writing to the stream
@@ -517,7 +517,7 @@ public class LRUMap<K, V>
}
/**
- * Reads the data necessary for <code>put()</code> to work in the superclass.
+ * Reads the data necessary for {@code put()} to work in the superclass.
*
* @param in the input stream
* @throws IOException if an error occurs while reading from the stream
diff --git a/src/main/java/org/apache/commons/collections4/map/LazyMap.java b/src/main/java/org/apache/commons/collections4/map/LazyMap.java
index 1317c69..d12ce49 100644
--- a/src/main/java/org/apache/commons/collections4/map/LazyMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/LazyMap.java
@@ -28,7 +28,7 @@ import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.FactoryTransformer;
/**
- * Decorates another <code>Map</code> to create objects in the map on demand.
+ * Decorates another {@code Map} to create objects in the map on demand.
* <p>
* When the {@link #get(Object)} method is called with a key that does not
* exist in the map, the factory is used to create the object. The created
@@ -48,8 +48,8 @@ import org.apache.commons.collections4.functors.FactoryTransformer;
* </pre>
*
* <p>
- * After the above code is executed, <code>date</code> will refer to
- * a new <code>Date</code> instance. Furthermore, that <code>Date</code>
+ * After the above code is executed, {@code date} will refer to
+ * a new {@code Date} instance. Furthermore, that {@code Date}
* instance is mapped to the "NOW" key in the map.
* </p>
* <p>
diff --git a/src/main/java/org/apache/commons/collections4/map/LazySortedMap.java b/src/main/java/org/apache/commons/collections4/map/LazySortedMap.java
index 4d97d46..36418e7 100644
--- a/src/main/java/org/apache/commons/collections4/map/LazySortedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/LazySortedMap.java
@@ -23,7 +23,7 @@ import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>SortedMap</code> to create objects in the map on demand.
+ * Decorates another {@code SortedMap} to create objects in the map on demand.
* <p>
* When the {@link #get(Object)} method is called with a key that does not
* exist in the map, the factory is used to create the object. The created
@@ -44,8 +44,8 @@ import org.apache.commons.collections4.Transformer;
* </pre>
*
* <p>
- * After the above code is executed, <code>date</code> will refer to
- * a new <code>Date</code> instance. Furthermore, that <code>Date</code>
+ * After the above code is executed, {@code date} will refer to
+ * a new {@code Date} instance. Furthermore, that {@code Date}
* instance is mapped to the "NOW" key in the map.
* </p>
* <p>
diff --git a/src/main/java/org/apache/commons/collections4/map/LinkedMap.java b/src/main/java/org/apache/commons/collections4/map/LinkedMap.java
index ad4047c..b2953b6 100644
--- a/src/main/java/org/apache/commons/collections4/map/LinkedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/LinkedMap.java
@@ -33,23 +33,23 @@ import org.apache.commons.collections4.iterators.UnmodifiableListIterator;
import org.apache.commons.collections4.list.UnmodifiableList;
/**
- * A <code>Map</code> implementation that maintains the order of the entries.
+ * A {@code Map} implementation that maintains the order of the entries.
* In this implementation order is maintained by original insertion.
* <p>
* This implementation improves on the JDK1.4 LinkedHashMap by adding the
* {@link org.apache.commons.collections4.MapIterator MapIterator}
* functionality, additional convenience methods and allowing
- * bidirectional iteration. It also implements <code>OrderedMap</code>.
+ * bidirectional iteration. It also implements {@code OrderedMap}.
* In addition, non-interface methods are provided to access the map by index.
* </p>
* <p>
- * The <code>orderedMapIterator()</code> method provides direct access to a
+ * The {@code orderedMapIterator()} method provides direct access to a
* bidirectional iterator. The iterators from the other views can also be cast
- * to <code>OrderedIterator</code> if required.
+ * to {@code OrderedIterator} if required.
* </p>
* <p>
* All the available iterators can be reset back to the start by casting to
- * <code>ResettableIterator</code> and calling <code>reset()</code>.
+ * {@code ResettableIterator} and calling {@code reset()}.
* </p>
* <p>
* The implementation is also designed to be subclassed, with lots of useful
@@ -190,8 +190,8 @@ public class LinkedMap<K, V> extends AbstractLinkedMap<K, V> implements Serializ
* Removes the element at the specified index.
*
* @param index the index of the object to remove
- * @return the previous value corresponding the <code>key</code>,
- * or <code>null</code> if none existed
+ * @return the previous value corresponding the {@code key},
+ * or {@code null} if none existed
* @throws IndexOutOfBoundsException if the index is invalid
*/
public V remove(final int index) {
diff --git a/src/main/java/org/apache/commons/collections4/map/ListOrderedMap.java b/src/main/java/org/apache/commons/collections4/map/ListOrderedMap.java
index 468cc2b..46b8a68 100644
--- a/src/main/java/org/apache/commons/collections4/map/ListOrderedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/ListOrderedMap.java
@@ -40,12 +40,12 @@ import org.apache.commons.collections4.keyvalue.AbstractMapEntry;
import org.apache.commons.collections4.list.UnmodifiableList;
/**
- * Decorates a <code>Map</code> to ensure that the order of addition is retained
- * using a <code>List</code> to maintain order.
+ * Decorates a {@code Map} to ensure that the order of addition is retained
+ * using a {@code List} to maintain order.
* <p>
* The order will be used via the iterators and toArray methods on the views.
- * The order is also returned by the <code>MapIterator</code>.
- * The <code>orderedMapIterator()</code> method accesses an iterator that can
+ * The order is also returned by the {@code MapIterator}.
+ * The {@code orderedMapIterator()} method accesses an iterator that can
* iterate both forwards and backwards through the map.
* In addition, non-interface methods are provided to access the map by index.
* </p>
@@ -64,12 +64,12 @@ import org.apache.commons.collections4.list.UnmodifiableList;
* <strong>Note that ListOrderedMap doesn't work with
* {@link java.util.IdentityHashMap IdentityHashMap}, {@link CaseInsensitiveMap},
* or similar maps that violate the general contract of {@link java.util.Map}.</strong>
- * The <code>ListOrderedMap</code> (or, more precisely, the underlying <code>List</code>)
+ * The {@code ListOrderedMap} (or, more precisely, the underlying {@code List})
* is relying on {@link Object#equals(Object) equals()}. This is fine, as long as the
- * decorated <code>Map</code> is also based on {@link Object#equals(Object) equals()},
+ * decorated {@code Map} is also based on {@link Object#equals(Object) equals()},
* and {@link Object#hashCode() hashCode()}, which
* {@link java.util.IdentityHashMap IdentityHashMap}, and
- * {@link CaseInsensitiveMap} don't: The former uses <code>==</code>, and
+ * {@link CaseInsensitiveMap} don't: The former uses {@code ==}, and
* the latter uses {@link Object#equals(Object) equals()} on a lower-cased
* key.
* </p>
@@ -94,7 +94,7 @@ public class ListOrderedMap<K, V>
/**
* Factory method to create an ordered map.
* <p>
- * An <code>ArrayList</code> is used to retain order.
+ * An {@code ArrayList} is used to retain order.
*
* @param <K> the key type
* @param <V> the value type
@@ -109,8 +109,8 @@ public class ListOrderedMap<K, V>
//-----------------------------------------------------------------------
/**
- * Constructs a new empty <code>ListOrderedMap</code> that decorates
- * a <code>HashMap</code>.
+ * Constructs a new empty {@code ListOrderedMap} that decorates
+ * a {@code HashMap}.
*
* @since 3.1
*/
@@ -479,7 +479,7 @@ public class ListOrderedMap<K, V>
* Removes the element at the specified index.
*
* @param index the index of the object to remove
- * @return the removed value, or <code>null</code> if none existed
+ * @return the removed value, or {@code null} if none existed
* @throws IndexOutOfBoundsException if the index is invalid
*/
public V remove(final int index) {
diff --git a/src/main/java/org/apache/commons/collections4/map/MultiKeyMap.java b/src/main/java/org/apache/commons/collections4/map/MultiKeyMap.java
index d6859d3..f96c85f 100644
--- a/src/main/java/org/apache/commons/collections4/map/MultiKeyMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/MultiKeyMap.java
@@ -27,34 +27,34 @@ import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.keyvalue.MultiKey;
/**
- * A <code>Map</code> implementation that uses multiple keys to map the value.
+ * A {@code Map} implementation that uses multiple keys to map the value.
* <p>
* This class is the most efficient way to uses multiple keys to map to a value.
* The best way to use this class is via the additional map-style methods.
- * These provide <code>get</code>, <code>containsKey</code>, <code>put</code> and
- * <code>remove</code> for individual keys which operate without extra object creation.
+ * These provide {@code get}, {@code containsKey}, {@code put} and
+ * {@code remove} for individual keys which operate without extra object creation.
* </p>
* <p>
* The additional methods are the main interface of this map.
- * As such, you will not normally hold this map in a variable of type <code>Map</code>.
+ * As such, you will not normally hold this map in a variable of type {@code Map}.
* </p>
* <p>
* The normal map methods take in and return a {@link MultiKey}.
- * If you try to use <code>put()</code> with any other object type a
- * <code>ClassCastException</code> is thrown. If you try to use <code>null</code> as
- * the key in <code>put()</code> a <code>NullPointerException</code> is thrown.
+ * If you try to use {@code put()} with any other object type a
+ * {@code ClassCastException} is thrown. If you try to use {@code null} as
+ * the key in {@code put()} a {@code NullPointerException} is thrown.
* </p>
* <p>
- * This map is implemented as a decorator of a <code>AbstractHashedMap</code> which
+ * This map is implemented as a decorator of a {@code AbstractHashedMap} which
* enables extra behaviour to be added easily.
* </p>
* <ul>
- * <li><code>MultiKeyMap.decorate(new LinkedMap())</code> creates an ordered map.
- * <li><code>MultiKeyMap.decorate(new LRUMap())</code> creates an least recently used map.
- * <li><code>MultiKeyMap.decorate(new ReferenceMap())</code> creates a garbage collector sensitive map.
+ * <li>{@code MultiKeyMap.decorate(new LinkedMap())} creates an ordered map.
+ * <li>{@code MultiKeyMap.decorate(new LRUMap())} creates an least recently used map.
+ * <li>{@code MultiKeyMap.decorate(new ReferenceMap())} creates a garbage collector sensitive map.
* </ul>
* <p>
- * Note that <code>IdentityMap</code> and <code>ReferenceIdentityMap</code> are unsuitable
+ * Note that {@code IdentityMap} and {@code ReferenceIdentityMap} are unsuitable
* for use as the key comparison would work on the whole MultiKey, not the elements within.
* </p>
* <p>
@@ -113,7 +113,7 @@ public class MultiKeyMap<K, V> extends AbstractMapDecorator<MultiKey<? extends K
//-----------------------------------------------------------------------
/**
- * Constructs a new MultiKeyMap that decorates a <code>HashedMap</code>.
+ * Constructs a new MultiKeyMap that decorates a {@code HashedMap}.
*/
public MultiKeyMap() {
this(new HashedMap<MultiKey<? extends K>, V>());
@@ -714,7 +714,7 @@ public class MultiKeyMap<K, V> extends AbstractMapDecorator<MultiKey<? extends K
/**
* Removes all mappings where the first key is that specified.
* <p>
- * This method removes all the mappings where the <code>MultiKey</code>
+ * This method removes all the mappings where the {@code MultiKey}
* has one or more keys, and the first matches that specified.
*
* @param key1 the first key
@@ -737,7 +737,7 @@ public class MultiKeyMap<K, V> extends AbstractMapDecorator<MultiKey<? extends K
/**
* Removes all mappings where the first two keys are those specified.
* <p>
- * This method removes all the mappings where the <code>MultiKey</code>
+ * This method removes all the mappings where the {@code MultiKey}
* has two or more keys, and the first two match those specified.
*
* @param key1 the first key
@@ -762,7 +762,7 @@ public class MultiKeyMap<K, V> extends AbstractMapDecorator<MultiKey<? extends K
/**
* Removes all mappings where the first three keys are those specified.
* <p>
- * This method removes all the mappings where the <code>MultiKey</code>
+ * This method removes all the mappings where the {@code MultiKey}
* has three or more keys, and the first three match those specified.
*
* @param key1 the first key
@@ -789,7 +789,7 @@ public class MultiKeyMap<K, V> extends AbstractMapDecorator<MultiKey<? extends K
/**
* Removes all mappings where the first four keys are those specified.
* <p>
- * This method removes all the mappings where the <code>MultiKey</code>
+ * This method removes all the mappings where the {@code MultiKey}
* has four or more keys, and the first four match those specified.
*
* @param key1 the first key
diff --git a/src/main/java/org/apache/commons/collections4/map/MultiValueMap.java b/src/main/java/org/apache/commons/collections4/map/MultiValueMap.java
index 0b8c05c..c0aa64b 100644
--- a/src/main/java/org/apache/commons/collections4/map/MultiValueMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/MultiValueMap.java
@@ -42,7 +42,7 @@ import org.apache.commons.collections4.iterators.TransformIterator;
* A MultiValueMap decorates another map, allowing it to have
* more than one value for a key.
* <p>
- * A <code>MultiMap</code> is a Map with slightly different semantics.
+ * A {@code MultiMap} is a Map with slightly different semantics.
* Putting a value into the map will add the value to a Collection at that key.
* Getting a value will return a Collection, holding all the values put to that key.
* </p>
@@ -52,9 +52,9 @@ import org.apache.commons.collections4.iterators.TransformIterator;
* </p>
* <p>
* In addition, this implementation allows the type of collection used
- * for the values to be controlled. By default, an <code>ArrayList</code>
- * is used, however a <code>Class</code> to instantiate may be specified,
- * or a factory that returns a <code>Collection</code> instance.
+ * for the values to be controlled. By default, an {@code ArrayList}
+ * is used, however a {@code Class} to instantiate may be specified,
+ * or a factory that returns a {@code Collection} instance.
* </p>
* <p>
* <strong>Note that MultiValueMap is not synchronized and is not thread-safe.</strong>
@@ -95,8 +95,8 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
}
/**
- * Creates a map which decorates the given <code>map</code> and
- * maps keys to collections of type <code>collectionClass</code>.
+ * Creates a map which decorates the given {@code map} and
+ * maps keys to collections of type {@code collectionClass}.
*
* @param <K> the key type
* @param <V> the value type
@@ -112,8 +112,8 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
}
/**
- * Creates a map which decorates the given <code>map</code> and
- * creates the value collections using the supplied <code>collectionFactory</code>.
+ * Creates a map which decorates the given {@code map} and
+ * creates the value collections using the supplied {@code collectionFactory}.
*
* @param <K> the key type
* @param <V> the value type
@@ -130,8 +130,8 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
//-----------------------------------------------------------------------
/**
- * Creates a MultiValueMap based on a <code>HashMap</code> and
- * storing the multiple values in an <code>ArrayList</code>.
+ * Creates a MultiValueMap based on a {@code HashMap} and
+ * storing the multiple values in an {@code ArrayList}.
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public MultiValueMap() {
@@ -139,8 +139,8 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
}
/**
- * Creates a MultiValueMap which decorates the given <code>map</code> and
- * creates the value collections using the supplied <code>collectionFactory</code>.
+ * Creates a MultiValueMap which decorates the given {@code map} and
+ * creates the value collections using the supplied {@code collectionFactory}.
*
* @param <C> the collection class type
* @param map the map to decorate
@@ -206,8 +206,8 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
* The item is removed from the collection mapped to the specified key.
* Other values attached to that key are unaffected.
* <p>
- * If the last value for a key is removed, <code>null</code> will be returned
- * from a subsequent <code>get(key)</code>.
+ * If the last value for a key is removed, {@code null} will be returned
+ * from a subsequent {@code get(key)}.
*
* @param key the key to remove from
* @param value the value to remove
@@ -254,7 +254,7 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
/**
* Adds the value to the collection associated with the specified key.
* <p>
- * Unlike a normal <code>Map</code> the previous value is not replaced.
+ * Unlike a normal {@code Map} the previous value is not replaced.
* Instead the new value is added to the collection stored against the key.
*
* @param key the key to store against
@@ -285,9 +285,9 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
* correctly handled.
* <p>
* If you call this method with a normal map, each entry is
- * added using <code>put(Object,Object)</code>.
+ * added using {@code put(Object,Object)}.
* If you call this method with a multi map, each entry is
- * added using <code>putAll(Object,Collection)</code>.
+ * added using {@code putAll(Object,Collection)}.
*
* @param map the map to copy (either a normal or multi map)
*/
@@ -350,7 +350,7 @@ public class MultiValueMap<K, V> extends AbstractMapDecorator<K, Object> impleme
/**
* Gets the collection mapped to the specified key.
- * This method is a convenience method to typecast the result of <code>get(key)</code>.
+ * This method is a convenience method to typecast the result of {@code get(key)}.
*
* @param key the key to retrieve
* @return the collection mapped to the key, null if no mapping
diff --git a/src/main/java/org/apache/commons/collections4/map/PassiveExpiringMap.java b/src/main/java/org/apache/commons/collections4/map/PassiveExpiringMap.java
index ab91115..9dfbf1a 100644
--- a/src/main/java/org/apache/commons/collections4/map/PassiveExpiringMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/PassiveExpiringMap.java
@@ -29,7 +29,7 @@ import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
- * Decorates a <code>Map</code> to evict expired entries once their expiration
+ * Decorates a {@code Map} to evict expired entries once their expiration
* time has been reached.
* <p>
* When putting a key-value pair in the map this decorator uses a
@@ -40,7 +40,7 @@ import java.util.concurrent.TimeUnit;
* When accessing the mapped value for a key, its expiration time is checked,
* and if it is a negative value or if it is greater than the current time, the
* mapped value is returned. Otherwise, the key is removed from the decorated
- * map, and <code>null</code> is returned.
+ * map, and {@code null} is returned.
* </p>
* <p>
* When invoking methods that involve accessing the entire map contents (i.e
@@ -114,7 +114,7 @@ public class PassiveExpiringMap<K, V>
* before it expires. A negative value results in entries that
* NEVER expire. A zero value results in entries that ALWAYS
* expire.
- * @param timeUnit the unit of time for the <code>timeToLive</code>
+ * @param timeUnit the unit of time for the {@code timeToLive}
* parameter, must not be null.
* @throws NullPointerException if the time unit is null.
*/
@@ -186,7 +186,7 @@ public class PassiveExpiringMap<K, V>
* @param timeToLive the constant amount of time an entry is available
* before it expires. A negative value results in entries that NEVER
* expire. A zero value results in entries that ALWAYS expire.
- * @param timeUnit the unit of time for the <code>timeToLive</code>
+ * @param timeUnit the unit of time for the {@code timeToLive}
* parameter, must not be null.
* @throws NullPointerException if the time unit is null.
*/
@@ -281,7 +281,7 @@ public class PassiveExpiringMap<K, V>
* @param timeToLive the constant amount of time an entry is available
* before it expires. A negative value results in entries that NEVER
* expire. A zero value results in entries that ALWAYS expire.
- * @param timeUnit the unit of time for the <code>timeToLive</code>
+ * @param timeUnit the unit of time for the {@code timeToLive}
* parameter, must not be null.
* @throws NullPointerException if the time unit is null.
*/
@@ -300,7 +300,7 @@ public class PassiveExpiringMap<K, V>
* @param timeToLive the constant amount of time an entry is available
* before it expires. A negative value results in entries that NEVER
* expire. A zero value results in entries that ALWAYS expire.
- * @param timeUnit the unit of time for the <code>timeToLive</code>
+ * @param timeUnit the unit of time for the {@code timeToLive}
* parameter, must not be null.
* @param map the map to decorate, must not be null.
* @throws NullPointerException if the map or time unit is null.
@@ -384,15 +384,15 @@ public class PassiveExpiringMap<K, V>
}
/**
- * Determines if the given expiration time is less than <code>now</code>.
+ * Determines if the given expiration time is less than {@code now}.
*
* @param now the time in milliseconds used to compare against the
* expiration time.
* @param expirationTimeObject the expiration time value retrieved from
* {@link #expirationMap}, can be null.
- * @return <code>true</code> if <code>expirationTimeObject</code> is ≥ 0
- * and <code>expirationTimeObject</code> < <code>now</code>.
- * <code>false</code> otherwise.
+ * @return {@code true} if {@code expirationTimeObject} is ≥ 0
+ * and {@code expirationTimeObject} < {@code now}.
+ * {@code false} otherwise.
*/
private boolean isExpired(final long now, final Long expirationTimeObject) {
if (expirationTimeObject != null) {
@@ -457,7 +457,7 @@ public class PassiveExpiringMap<K, V>
/**
* Removes all entries in the map whose expiration time is less than
- * <code>now</code>. The exceptions are entries with negative expiration
+ * {@code now}. The exceptions are entries with negative expiration
* times; those entries are never removed.
*
* @see #isExpired(long, Long)
@@ -477,7 +477,7 @@ public class PassiveExpiringMap<K, V>
/**
* Removes the entry with the given key if the entry's expiration time is
- * less than <code>now</code>. If the entry has a negative expiration time,
+ * less than {@code now}. If the entry has a negative expiration time,
* the entry is never removed.
*/
private void removeIfExpired(final Object key, final long now) {
diff --git a/src/main/java/org/apache/commons/collections4/map/PredicatedMap.java b/src/main/java/org/apache/commons/collections4/map/PredicatedMap.java
index 7c1b69a..01e125e 100644
--- a/src/main/java/org/apache/commons/collections4/map/PredicatedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/PredicatedMap.java
@@ -26,7 +26,7 @@ import java.util.Map;
import org.apache.commons.collections4.Predicate;
/**
- * Decorates another <code>Map</code> to validate that additions
+ * Decorates another {@code Map} to validate that additions
* match a specified predicate.
* <p>
* This map exists to provide validation for the decorated map.
@@ -153,7 +153,7 @@ public class PredicatedMap<K, V>
}
/**
- * Override to validate an object set into the map via <code>setValue</code>.
+ * Override to validate an object set into the map via {@code setValue}.
*
* @param value the value to validate
* @return the value itself
diff --git a/src/main/java/org/apache/commons/collections4/map/PredicatedSortedMap.java b/src/main/java/org/apache/commons/collections4/map/PredicatedSortedMap.java
index 35d6805..94da315 100644
--- a/src/main/java/org/apache/commons/collections4/map/PredicatedSortedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/PredicatedSortedMap.java
@@ -22,7 +22,7 @@ import java.util.SortedMap;
import org.apache.commons.collections4.Predicate;
/**
- * Decorates another <code>SortedMap</code> to validate that additions
+ * Decorates another {@code SortedMap} to validate that additions
* match a specified predicate.
* <p>
* This map exists to provide validation for the decorated map.
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 63af713..a75a8a2 100644
--- a/src/main/java/org/apache/commons/collections4/map/ReferenceIdentityMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/ReferenceIdentityMap.java
@@ -23,11 +23,11 @@ import java.io.Serializable;
import java.lang.ref.Reference;
/**
- * A <code>Map</code> implementation that allows mappings to be
+ * A {@code Map} implementation that allows mappings to be
* removed by the garbage collector and matches keys and values based
- * on <code>==</code> not <code>equals()</code>.
+ * on {@code ==} not {@code equals()}.
* <p>
- * When you construct a <code>ReferenceIdentityMap</code>, you can specify what kind
+ * When you construct a {@code ReferenceIdentityMap}, you can specify what kind
* of references are used to store the map's keys and values.
* If non-hard references are used, then the garbage collector can remove
* mappings if a key or value becomes unreachable, or if the JVM's memory is
@@ -42,7 +42,7 @@ import java.lang.ref.Reference;
* <p>
* This map is similar to
* {@link org.apache.commons.collections4.map.ReferenceMap ReferenceMap}.
- * It differs in that keys and values in this class are compared using <code>==</code>.
+ * It differs in that keys and values in this class are compared using {@code ==}.
* </p>
* <p>
* This map will violate the detail of various Map and map view contracts.
@@ -50,17 +50,17 @@ import java.lang.ref.Reference;
* </p>
* <p>
* This {@link java.util.Map Map} implementation does <i>not</i> allow null elements.
- * Attempting to add a null key or value to the map will raise a <code>NullPointerException</code>.
+ * Attempting to add a null key or value to the map will raise a {@code NullPointerException}.
* </p>
* <p>
* This implementation is not synchronized.
* You can use {@link java.util.Collections#synchronizedMap} to
- * provide synchronized access to a <code>ReferenceIdentityMap</code>.
+ * provide synchronized access to a {@code ReferenceIdentityMap}.
* Remember that synchronization will not stop the garbage collector removing entries.
* </p>
* <p>
* All the available iterators can be reset back to the start by casting to
- * <code>ResettableIterator</code> and calling <code>reset()</code>.
+ * {@code ResettableIterator} and calling {@code reset()}.
* </p>
* <p>
* <strong>Note that ReferenceIdentityMap is not synchronized and is not thread-safe.</strong>
@@ -82,7 +82,7 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
private static final long serialVersionUID = -1266190134568365852L;
/**
- * Constructs a new <code>ReferenceIdentityMap</code> that will
+ * Constructs a new {@code ReferenceIdentityMap} that will
* use hard references to keys and soft references to values.
*/
public ReferenceIdentityMap() {
@@ -91,7 +91,7 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
}
/**
- * Constructs a new <code>ReferenceIdentityMap</code> that will
+ * Constructs a new {@code ReferenceIdentityMap} that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
@@ -108,7 +108,7 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
}
/**
- * Constructs a new <code>ReferenceIdentityMap</code> that will
+ * Constructs a new {@code ReferenceIdentityMap} that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
@@ -128,7 +128,7 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
}
/**
- * Constructs a new <code>ReferenceIdentityMap</code> with the
+ * Constructs a new {@code ReferenceIdentityMap} with the
* specified reference types, load factor and initial capacity.
*
* @param keyType the type of reference to use for keys;
@@ -148,7 +148,7 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
}
/**
- * Constructs a new <code>ReferenceIdentityMap</code> with the
+ * Constructs a new {@code ReferenceIdentityMap} with the
* specified reference types, load factor and initial capacity.
*
* @param keyType the type of reference to use for keys;
@@ -202,10 +202,10 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
* Compares two keys for equals.
* <p>
* This implementation converts the key from the entry to a real reference
- * before comparison and uses <code>==</code>.
+ * before comparison and uses {@code ==}.
*
* @param key1 the first key to compare passed in from outside
- * @param key2 the second key extracted from the entry via <code>entry.key</code>
+ * @param key2 the second key extracted from the entry via {@code entry.key}
* @return true if equal by identity
*/
@Override
@@ -217,10 +217,10 @@ public class ReferenceIdentityMap<K, V> extends AbstractReferenceMap<K, V> imple
/**
* Compares two values for equals.
* <p>
- * This implementation uses <code>==</code>.
+ * This implementation uses {@code ==}.
*
* @param value1 the first value to compare passed in from outside
- * @param value2 the second value extracted from the entry via <code>getValue()</code>
+ * @param value2 the second value extracted from the entry via {@code getValue()}
* @return true if equal by identity
*/
@Override
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 398db24..e19df74 100644
--- a/src/main/java/org/apache/commons/collections4/map/ReferenceMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/ReferenceMap.java
@@ -22,10 +22,10 @@ import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
- * A <code>Map</code> implementation that allows mappings to be
+ * A {@code Map} implementation that allows mappings to be
* removed by the garbage collector.
* <p>
- * When you construct a <code>ReferenceMap</code>, you can specify what kind
+ * When you construct a {@code ReferenceMap}, you can specify what kind
* of references are used to store the map's keys and values.
* If non-hard references are used, then the garbage collector can remove
* mappings if a key or value becomes unreachable, or if the JVM's memory is
@@ -37,28 +37,28 @@ import java.io.Serializable;
* The keys can be configured to be weak but the values hard,
* in which case this class will behave like a
* <a href="http://java.sun.com/j2se/1.4/docs/api/java/util/WeakHashMap.html">
- * <code>WeakHashMap</code></a>. However, you can also specify hard keys and
+ * {@code WeakHashMap}</a>. However, you can also specify hard keys and
* weak values, or any other combination. The default constructor uses
* hard keys and soft values, providing a memory-sensitive cache.
* </p>
* <p>
* This map is similar to
* {@link org.apache.commons.collections4.map.ReferenceIdentityMap ReferenceIdentityMap}.
- * It differs in that keys and values in this class are compared using <code>equals()</code>.
+ * 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.
- * Attempting to add a null key or value to the map will raise a <code>NullPointerException</code>.
+ * Attempting to add a null key or value to the map will raise a {@code NullPointerException}.
* </p>
* <p>
* This implementation is not synchronized.
* You can use {@link java.util.Collections#synchronizedMap} to
- * provide synchronized access to a <code>ReferenceMap</code>.
+ * provide synchronized access to a {@code ReferenceMap}.
* Remember that synchronization will not stop the garbage collector removing entries.
* </p>
* <p>
* All the available iterators can be reset back to the start by casting to
- * <code>ResettableIterator</code> and calling <code>reset()</code>.
+ * {@code ResettableIterator} and calling {@code reset()}.
* </p>
* <p>
* <strong>Note that ReferenceMap is not synchronized and is not thread-safe.</strong>
@@ -68,9 +68,9 @@ import java.io.Serializable;
* exceptions when accessed by concurrent threads without synchronization.
* </p>
* <p>
- * NOTE: As from Commons Collections 3.1 this map extends <code>AbstractReferenceMap</code>
+ * NOTE: As from Commons Collections 3.1 this map extends {@code AbstractReferenceMap}
* (previously it extended AbstractMap). As a result, the implementation is now
- * extensible and provides a <code>MapIterator</code>.
+ * extensible and provides a {@code MapIterator}.
* </p>
*
* @param <K> the type of the keys in the map
@@ -85,7 +85,7 @@ public class ReferenceMap<K, V> extends AbstractReferenceMap<K, V> implements Se
private static final long serialVersionUID = 1555089888138299607L;
/**
- * Constructs a new <code>ReferenceMap</code> that will
+ * Constructs a new {@code ReferenceMap} that will
* use hard references to keys and soft references to values.
*/
public ReferenceMap() {
@@ -94,7 +94,7 @@ public class ReferenceMap<K, V> extends AbstractReferenceMap<K, V> implements Se
}
/**
- * Constructs a new <code>ReferenceMap</code> that will
+ * Constructs a new {@code ReferenceMap} that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
@@ -111,7 +111,7 @@ public class ReferenceMap<K, V> extends AbstractReferenceMap<K, V> implements Se
}
/**
- * Constructs a new <code>ReferenceMap</code> that will
+ * Constructs a new {@code ReferenceMap} that will
* use the specified types of references.
*
* @param keyType the type of reference to use for keys;
@@ -130,7 +130,7 @@ public class ReferenceMap<K, V> extends AbstractReferenceMap<K, V> implements Se
}
/**
- * Constructs a new <code>ReferenceMap</code> with the
+ * Constructs a new {@code ReferenceMap} with the
* specified reference types, load factor and initial
* capacity.
*
@@ -151,7 +151,7 @@ public class ReferenceMap<K, V> extends AbstractReferenceMap<K, V> implements Se
}
/**
- * Constructs a new <code>ReferenceMap</code> with the
+ * Constructs a new {@code ReferenceMap} with the
* specified reference types, load factor and initial
* capacity.
*
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 753df2f..68d6be3 100644
--- a/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
@@ -34,11 +34,11 @@ import org.apache.commons.collections4.iterators.SingletonIterator;
import org.apache.commons.collections4.keyvalue.TiedMapEntry;
/**
- * A <code>Map</code> implementation that holds a single item and is fixed size.
+ * A {@code Map} implementation that holds a single item and is fixed size.
* <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</code> or <code>setValue</code> methods can <i>change</i>
+ * However, the {@code put} or {@code setValue} methods can <i>change</i>
* the value associated with the key.
* </p>
* <p>
@@ -52,8 +52,8 @@ import org.apache.commons.collections4.keyvalue.TiedMapEntry;
* </p>
* <ul>
* <li>normal Map methods and views
- * <li>the <code>MapIterator</code>, see {@link #mapIterator()}
- * <li>the <code>KeyValue</code> interface (just cast - no object creation)
+ * <li>the {@code MapIterator}, see {@link #mapIterator()}
+ * <li>the {@code KeyValue} interface (just cast - no object creation)
* </ul>
*
* @param <K> the type of the keys in this map
@@ -72,7 +72,7 @@ public class SingletonMap<K, V>
private V value;
/**
- * Constructor that creates a map of <code>null</code> to <code>null</code>.
+ * Constructor that creates a map of {@code null} to {@code null}.
*/
public SingletonMap() {
super();
@@ -92,7 +92,7 @@ public class SingletonMap<K, V>
}
/**
- * Constructor specifying the key and value as a <code>KeyValue</code>.
+ * Constructor specifying the key and value as a {@code KeyValue}.
*
* @param keyValue the key value pair to use
*/
@@ -103,7 +103,7 @@ public class SingletonMap<K, V>
}
/**
- * Constructor specifying the key and value as a <code>MapEntry</code>.
+ * Constructor specifying the key and value as a {@code MapEntry}.
*
* @param mapEntry the mapEntry to use
*/
@@ -315,7 +315,7 @@ public class SingletonMap<K, V>
//-----------------------------------------------------------------------
/**
* Gets the entrySet view of the map.
- * Changes made via <code>setValue</code> affect this map.
+ * Changes made via {@code setValue} affect this map.
* To simply iterate through the entries, use {@link #mapIterator()}.
*
* @return the entrySet view
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 cfc8192..ecd0a23 100644
--- a/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/StaticBucketMap.java
@@ -30,7 +30,7 @@ import org.apache.commons.collections4.KeyValue;
/**
* A StaticBucketMap is an efficient, thread-safe implementation of
- * <code>java.util.Map</code> that performs well in in a highly
+ * {@code java.util.Map} that performs well in in a highly
* thread-contentious environment. The map supports very efficient
* {@link #get(Object) get}, {@link #put(Object,Object) put},
* {@link #remove(Object) remove} and {@link #containsKey(Object) containsKey}
@@ -63,9 +63,9 @@ import org.apache.commons.collections4.KeyValue;
* </pre>
*
* then the results are generally random. Those two statement could cancel
- * each other out, leaving <code>staticBucketMapInstance</code> essentially
- * unchanged, or they could leave some random subset of <code>map</code> in
- * <code>staticBucketMapInstance</code>.<p>
+ * each other out, leaving {@code staticBucketMapInstance} essentially
+ * unchanged, or they could leave some random subset of {@code map} in
+ * {@code staticBucketMapInstance}.<p>
*
* Also, much like an encyclopedia, the results of {@link #size()} and
* {@link #isEmpty()} are out-of-date as soon as they are produced.<p>
diff --git a/src/main/java/org/apache/commons/collections4/map/TransformedMap.java b/src/main/java/org/apache/commons/collections4/map/TransformedMap.java
index e657ae2..c111eaa 100644
--- a/src/main/java/org/apache/commons/collections4/map/TransformedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/TransformedMap.java
@@ -25,7 +25,7 @@ import java.util.Map;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>Map</code> to transform objects that are added.
+ * Decorates another {@code Map} to transform objects that are added.
* <p>
* The Map put methods and Map.Entry setValue method are affected by this class.
* Thus objects must be removed or searched for using their transformed form.
@@ -211,7 +211,7 @@ public class TransformedMap<K, V>
}
/**
- * Override to transform the value when using <code>setValue</code>.
+ * Override to transform the value when using {@code setValue}.
*
* @param value the value to transform
* @return the transformed value
diff --git a/src/main/java/org/apache/commons/collections4/map/TransformedSortedMap.java b/src/main/java/org/apache/commons/collections4/map/TransformedSortedMap.java
index 4a8959f..5fb067e 100644
--- a/src/main/java/org/apache/commons/collections4/map/TransformedSortedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/TransformedSortedMap.java
@@ -23,7 +23,7 @@ import java.util.SortedMap;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>SortedMap </code> to transform objects that are added.
+ * Decorates another {@code SortedMap } to transform objects that are added.
* <p>
* The Map put methods and Map.Entry setValue method are affected by this class.
* Thus objects must be removed or searched for using their transformed form.
diff --git a/src/main/java/org/apache/commons/collections4/map/UnmodifiableEntrySet.java b/src/main/java/org/apache/commons/collections4/map/UnmodifiableEntrySet.java
index a2221bd..99966a8 100644
--- a/src/main/java/org/apache/commons/collections4/map/UnmodifiableEntrySet.java
+++ b/src/main/java/org/apache/commons/collections4/map/UnmodifiableEntrySet.java
@@ -29,7 +29,7 @@ import org.apache.commons.collections4.keyvalue.AbstractMapEntryDecorator;
import org.apache.commons.collections4.set.AbstractSetDecorator;
/**
- * Decorates a map entry <code>Set</code> to ensure it can't be altered.
+ * Decorates a map entry {@code Set} to ensure it can't be altered.
* <p>
* Attempts to modify it will result in an UnsupportedOperationException.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/map/UnmodifiableMap.java b/src/main/java/org/apache/commons/collections4/map/UnmodifiableMap.java
index 2d29245..ef21b8c 100644
--- a/src/main/java/org/apache/commons/collections4/map/UnmodifiableMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/UnmodifiableMap.java
@@ -33,7 +33,7 @@ import org.apache.commons.collections4.iterators.UnmodifiableMapIterator;
import org.apache.commons.collections4.set.UnmodifiableSet;
/**
- * Decorates another <code>Map</code> to ensure it can't be altered.
+ * Decorates another {@code Map} to ensure it can't be altered.
* <p>
* This class is Serializable from Commons Collections 3.1.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/map/UnmodifiableOrderedMap.java b/src/main/java/org/apache/commons/collections4/map/UnmodifiableOrderedMap.java
index 6ce6e76..3c876b0 100644
--- a/src/main/java/org/apache/commons/collections4/map/UnmodifiableOrderedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/UnmodifiableOrderedMap.java
@@ -32,7 +32,7 @@ import org.apache.commons.collections4.iterators.UnmodifiableOrderedMapIterator;
import org.apache.commons.collections4.set.UnmodifiableSet;
/**
- * Decorates another <code>OrderedMap</code> to ensure it can't be altered.
+ * Decorates another {@code OrderedMap} to ensure it can't be altered.
* <p>
* This class is Serializable from Commons Collections 3.1.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/map/UnmodifiableSortedMap.java b/src/main/java/org/apache/commons/collections4/map/UnmodifiableSortedMap.java
index 158e23f..2252d71 100644
--- a/src/main/java/org/apache/commons/collections4/map/UnmodifiableSortedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/UnmodifiableSortedMap.java
@@ -31,7 +31,7 @@ import org.apache.commons.collections4.collection.UnmodifiableCollection;
import org.apache.commons.collections4.set.UnmodifiableSet;
/**
- * Decorates another <code>SortedMap</code> to ensure it can't be altered.
+ * Decorates another {@code SortedMap} to ensure it can't be altered.
* <p>
* This class is Serializable from Commons Collections 3.1.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/multimap/AbstractListValuedMap.java b/src/main/java/org/apache/commons/collections4/multimap/AbstractListValuedMap.java
index 9ba272a..ca7bc2d 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractListValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractListValuedMap.java
@@ -92,10 +92,10 @@ public abstract class AbstractListValuedMap<K, V> extends AbstractMultiValuedMap
/**
* Removes all values associated with the specified key.
* <p>
- * A subsequent <code>get(Object)</code> would return an empty list.
+ * A subsequent {@code get(Object)} would return an empty list.
*
* @param key the key to remove values from
- * @return the <code>List</code> of values removed, will return an empty,
+ * @return the {@code List} of values removed, will return an empty,
* unmodifiable list for no mapping found.
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java b/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java
index 956a47c..d5414e3 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java
@@ -157,10 +157,10 @@ public abstract class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K,
/**
* Removes all values associated with the specified key.
* <p>
- * A subsequent <code>get(Object)</code> would return an empty collection.
+ * A subsequent {@code get(Object)} would return an empty collection.
*
* @param key the key to remove values from
- * @return the <code>Collection</code> of values removed, will return an
+ * @return the {@code Collection} of values removed, will return an
* empty, unmodifiable collection for no mapping found
*/
@Override
@@ -245,7 +245,7 @@ public abstract class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K,
/**
* Adds the value to the collection associated with the specified key.
* <p>
- * Unlike a normal <code>Map</code> the previous value is not replaced.
+ * Unlike a normal {@code Map} the previous value is not replaced.
* Instead the new value is added to the collection stored against the key.
*
* @param key the key to store against
diff --git a/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapDecorator.java b/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapDecorator.java
index f63236b..929b9af 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMapDecorator.java
@@ -28,10 +28,10 @@ import org.apache.commons.collections4.MultiSet;
import org.apache.commons.collections4.MultiValuedMap;
/**
- * Decorates another <code>MultiValuedMap</code> to provide additional behaviour.
+ * Decorates another {@code MultiValuedMap} to provide additional behaviour.
* <p>
- * Each method call made on this <code>MultiValuedMap</code> is forwarded to the
- * decorated <code>MultiValuedMap</code>. This class is used as a framework to build
+ * Each method call made on this {@code MultiValuedMap} is forwarded to the
+ * decorated {@code MultiValuedMap}. This class is used as a framework to build
* to extensions such as synchronized and unmodifiable behaviour.
* </p>
*
diff --git a/src/main/java/org/apache/commons/collections4/multimap/AbstractSetValuedMap.java b/src/main/java/org/apache/commons/collections4/multimap/AbstractSetValuedMap.java
index a7b6f6d..08e4316 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractSetValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractSetValuedMap.java
@@ -75,8 +75,8 @@ public abstract class AbstractSetValuedMap<K, V> extends AbstractMultiValuedMap<
* return an empty set in case the mapping is not present
*
* @param key the key to retrieve
- * @return the <code>Set</code> of values, will return an empty
- * <code>Set</code> for no mapping
+ * @return the {@code Set} of values, will return an empty
+ * {@code Set} for no mapping
*/
@Override
public Set<V> get(final K key) {
@@ -91,10 +91,10 @@ public abstract class AbstractSetValuedMap<K, V> extends AbstractMultiValuedMap<
/**
* Removes all values associated with the specified key.
* <p>
- * A subsequent <code>get(Object)</code> would return an empty set.
+ * A subsequent {@code get(Object)} would return an empty set.
*
* @param key the key to remove values from
- * @return the <code>Set</code> of values removed, will return an empty,
+ * @return the {@code Set} of values removed, will return an empty,
* unmodifiable set for no mapping found.
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedHashMap.java b/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedHashMap.java
index cdadb3d..bc0d1ec 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedHashMap.java
@@ -96,7 +96,7 @@ public class ArrayListValuedHashMap<K, V> extends AbstractListValuedMap<K, V>
/**
* Creates an ArrayListValuedHashMap copying all the mappings of the given map.
*
- * @param map a <code>MultiValuedMap</code> to copy into this map
+ * @param map a {@code MultiValuedMap} to copy into this map
*/
public ArrayListValuedHashMap(final MultiValuedMap<? extends K, ? extends V> map) {
this(map.size(), DEFAULT_INITIAL_LIST_CAPACITY);
@@ -106,7 +106,7 @@ public class ArrayListValuedHashMap<K, V> extends AbstractListValuedMap<K, V>
/**
* Creates an ArrayListValuedHashMap copying all the mappings of the given map.
*
- * @param map a <code>Map</code> to copy into this map
+ * @param map a {@code Map} to copy into this map
*/
public ArrayListValuedHashMap(final Map<? extends K, ? extends V> map) {
this(map.size(), DEFAULT_INITIAL_LIST_CAPACITY);
diff --git a/src/main/java/org/apache/commons/collections4/multimap/HashSetValuedHashMap.java b/src/main/java/org/apache/commons/collections4/multimap/HashSetValuedHashMap.java
index 3e230e3..d839b8e 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/HashSetValuedHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/HashSetValuedHashMap.java
@@ -95,7 +95,7 @@ public class HashSetValuedHashMap<K, V> extends AbstractSetValuedMap<K, V>
/**
* Creates an HashSetValuedHashMap copying all the mappings of the given map.
*
- * @param map a <code>MultiValuedMap</code> to copy into this map
+ * @param map a {@code MultiValuedMap} to copy into this map
*/
public HashSetValuedHashMap(final MultiValuedMap<? extends K, ? extends V> map) {
this(map.size(), DEFAULT_INITIAL_SET_CAPACITY);
@@ -105,7 +105,7 @@ public class HashSetValuedHashMap<K, V> extends AbstractSetValuedMap<K, V>
/**
* Creates an HashSetValuedHashMap copying all the mappings of the given map.
*
- * @param map a <code>Map</code> to copy into this map
+ * @param map a {@code Map} to copy into this map
*/
public HashSetValuedHashMap(final Map<? extends K, ? extends V> map) {
this(map.size(), DEFAULT_INITIAL_SET_CAPACITY);
diff --git a/src/main/java/org/apache/commons/collections4/multimap/TransformedMultiValuedMap.java b/src/main/java/org/apache/commons/collections4/multimap/TransformedMultiValuedMap.java
index a7723f0..c17c9cc 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/TransformedMultiValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/TransformedMultiValuedMap.java
@@ -26,7 +26,7 @@ import org.apache.commons.collections4.MultiValuedMap;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>MultiValuedMap</code> to transform objects that are added.
+ * Decorates another {@code MultiValuedMap} to transform objects that are added.
* <p>
* This class affects the MultiValuedMap put methods. Thus objects must be
* removed or searched for using their transformed form. For example, if the
diff --git a/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSetDecorator.java b/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSetDecorator.java
index 26097de..339ad2c 100644
--- a/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSetDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/multiset/AbstractMultiSetDecorator.java
@@ -22,7 +22,7 @@ import org.apache.commons.collections4.MultiSet;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
/**
- * Decorates another <code>MultSet</code> to provide additional behaviour.
+ * Decorates another {@code MultSet} to provide additional behaviour.
* <p>
* Methods are forwarded directly to the decorated multiset.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/overview.html b/src/main/java/org/apache/commons/collections4/overview.html
index 879bbde..ba9e932 100644
--- a/src/main/java/org/apache/commons/collections4/overview.html
+++ b/src/main/java/org/apache/commons/collections4/overview.html
@@ -25,7 +25,7 @@
come in the form of new interfaces, new implementations and utility classes.
</p>
<p>
- See also the <code>java.util</code> package for the standard Java collections.
+ See also the {@code java.util} package for the standard Java collections.
</p>
<h4>Main features</h4>
@@ -41,7 +41,7 @@
{@link org.apache.commons.collections.Bag}
</td>
<td valign="top">
- A new <code>Collection</code> subinterface that stores each object together
+ A new {@code Collection} subinterface that stores each object together
with the number of occurrences. Methods are provided to get the number of
occurrences, and to add and remove a certain number of that object.
</td>
@@ -51,7 +51,7 @@
{@link org.apache.commons.collections.Buffer}
</td>
<td valign="top">
- A new <code>Collection</code> subinterface that allows objects to be removed
+ A new {@code Collection} subinterface that allows objects to be removed
in some well-defined order. Methods enable the next item to be peeked and removed.
</td>
</tr>
@@ -60,7 +60,7 @@
{@link org.apache.commons.collections.BidiMap}
</td>
<td valign="top">
- A new <code>Map</code> subinterface that allows lookup from key to value and
+ A new {@code Map} subinterface that allows lookup from key to value and
from value to key with equal ease.
</td>
</tr>
@@ -69,7 +69,7 @@
{@link org.apache.commons.collections.OrderedMap}
</td>
<td valign="top">
- A new <code>Map</code> subinterface that is used when a map has an order, but is
+ A new {@code Map} subinterface that is used when a map has an order, but is
not sorted. Methods enable bidirectional iteration through the map.
</td>
</tr>
@@ -78,7 +78,7 @@
{@link org.apache.commons.collections.MapIterator}
</td>
<td valign="top">
- A new <code>Iterator</code> subinterface specially designed for maps. This iterator
+ A new {@code Iterator} subinterface specially designed for maps. This iterator
avoids the need for entrySet iteration of a map, and is simpler to use.
</td>
</tr>
@@ -87,7 +87,7 @@
{@link org.apache.commons.collections.ResettableIterator}
</td>
<td valign="top">
- A new <code>Iterator</code> subinterface that allows the iteration to be reset back
+ A new {@code Iterator} subinterface that allows the iteration to be reset back
to the start. Many iterators in this library have this functionality.
</td>
</tr>
diff --git a/src/main/java/org/apache/commons/collections4/sequence/DeleteCommand.java b/src/main/java/org/apache/commons/collections4/sequence/DeleteCommand.java
index f8a33e5..9af8ceb 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/DeleteCommand.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/DeleteCommand.java
@@ -43,7 +43,7 @@ public class DeleteCommand<T> extends EditCommand<T> {
}
/**
- * Accept a visitor. When a <code>DeleteCommand</code> accepts a visitor, it calls
+ * Accept a visitor. When a {@code DeleteCommand} accepts a visitor, it calls
* its {@link CommandVisitor#visitDeleteCommand visitDeleteCommand} method.
*
* @param visitor the visitor to be accepted
diff --git a/src/main/java/org/apache/commons/collections4/sequence/EditCommand.java b/src/main/java/org/apache/commons/collections4/sequence/EditCommand.java
index c06d61c..22f63c8 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/EditCommand.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/EditCommand.java
@@ -33,12 +33,12 @@ package org.apache.commons.collections4.sequence;
* inserted into the first sequence, {@link DeleteCommand DeleteCommand} which
* correspond to an object of the first sequence being removed and
* {@link KeepCommand KeepCommand} which correspond to an object of the first
- * sequence which <code>equals</code> an object in the second sequence. It is
+ * sequence which {@code equals} an object in the second sequence. It is
* guaranteed that comparison is always performed this way (i.e. the
- * <code>equals</code> method of the object from the first sequence is used and
+ * {@code equals} method of the object from the first sequence is used and
* the object passed as an argument comes from the second sequence) ; this can
* be important if subclassing is used for some elements in the first sequence
- * and the <code>equals</code> method is specialized.
+ * and the {@code equals} method is specialized.
* </p>
*
* @see SequencesComparator
diff --git a/src/main/java/org/apache/commons/collections4/sequence/EditScript.java b/src/main/java/org/apache/commons/collections4/sequence/EditScript.java
index 3bfbfcd..3a0f55e 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/EditScript.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/EditScript.java
@@ -33,7 +33,7 @@ import java.util.List;
* commands} come from the second sequence and that the objects embedded in
* either the {@link DeleteCommand delete commands} or {@link KeepCommand keep
* commands} come from the first sequence. This can be important if subclassing
- * is used for some elements in the first sequence and the <code>equals</code>
+ * is used for some elements in the first sequence and the {@code equals}
* method is specialized.
* </p>
*
diff --git a/src/main/java/org/apache/commons/collections4/sequence/InsertCommand.java b/src/main/java/org/apache/commons/collections4/sequence/InsertCommand.java
index a5efa3a..4afb30b 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/InsertCommand.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/InsertCommand.java
@@ -43,7 +43,7 @@ public class InsertCommand<T> extends EditCommand<T> {
}
/**
- * Accept a visitor. When an <code>InsertCommand</code> accepts a visitor,
+ * Accept a visitor. When an {@code InsertCommand} accepts a visitor,
* it calls its {@link CommandVisitor#visitInsertCommand visitInsertCommand}
* method.
*
diff --git a/src/main/java/org/apache/commons/collections4/sequence/KeepCommand.java b/src/main/java/org/apache/commons/collections4/sequence/KeepCommand.java
index cfd09e7..c259d0e 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/KeepCommand.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/KeepCommand.java
@@ -19,7 +19,7 @@ package org.apache.commons.collections4.sequence;
/**
* Command representing the keeping of one object present in both sequences.
* <p>
- * When one object of the first sequence <code>equals</code> another objects in
+ * When one object of the first sequence {@code equals} another objects in
* the second sequence at the right place, the {@link EditScript edit script}
* transforming the first sequence into the second sequence uses an instance of
* this class to represent the keeping of this object. The objects embedded in
@@ -45,7 +45,7 @@ public class KeepCommand<T> extends EditCommand<T> {
}
/**
- * Accept a visitor. When a <code>KeepCommand</code> accepts a visitor, it
+ * Accept a visitor. When a {@code KeepCommand} accepts a visitor, it
* calls its {@link CommandVisitor#visitKeepCommand visitKeepCommand} method.
*
* @param visitor the visitor to be accepted
diff --git a/src/main/java/org/apache/commons/collections4/sequence/ReplacementsHandler.java b/src/main/java/org/apache/commons/collections4/sequence/ReplacementsHandler.java
index 16c5418..318f179 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/ReplacementsHandler.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/ReplacementsHandler.java
@@ -37,8 +37,8 @@ public interface ReplacementsHandler<T> {
* equals (if they exist). This property also holds for the objects after
* the two sub-sequences.
* <p>
- * The replacement is defined as replacing the <code>from</code>
- * sub-sequence into the <code>to</code> sub-sequence.
+ * The replacement is defined as replacing the {@code from}
+ * sub-sequence into the {@code to} sub-sequence.
*
* @param skipped number of tokens skipped since the last call (i.e. number of
* tokens that were in both sequences), this number should be strictly positive
diff --git a/src/main/java/org/apache/commons/collections4/sequence/SequencesComparator.java b/src/main/java/org/apache/commons/collections4/sequence/SequencesComparator.java
index a486b86..b03e735 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/SequencesComparator.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/SequencesComparator.java
@@ -24,19 +24,19 @@ import org.apache.commons.collections4.functors.DefaultEquator;
/**
* This class allows to compare two objects sequences.
* <p>
- * The two sequences can hold any object type, as only the <code>equals</code>
+ * The two sequences can hold any object type, as only the {@code equals}
* method is used to compare the elements of the sequences. It is guaranteed
- * that the comparisons will always be done as <code>o1.equals(o2)</code> where
- * <code>o1</code> belongs to the first sequence and <code>o2</code> belongs to
+ * that the comparisons will always be done as {@code o1.equals(o2)} where
+ * {@code o1} belongs to the first sequence and {@code o2} belongs to
* the second sequence. This can be important if subclassing is used for some
- * elements in the first sequence and the <code>equals</code> method is
+ * elements in the first sequence and the {@code equals} method is
* specialized.
* </p>
* <p>
* Comparison can be seen from two points of view: either as giving the smallest
* modification allowing to transform the first sequence into the second one, or
* as giving the longest sequence which is a subsequence of both initial
- * sequences. The <code>equals</code> method is used to compare objects, so any
+ * sequences. The {@code equals} method is used to compare objects, so any
* object can be put into sequences. Modifications include deleting, inserting
* or keeping one object, starting from the beginning of the first sequence.
* </p>
@@ -79,10 +79,10 @@ public class SequencesComparator<T> {
* Creates a new instance of SequencesComparator using a {@link DefaultEquator}.
* <p>
* It is <em>guaranteed</em> that the comparisons will always be done as
- * <code>o1.equals(o2)</code> where <code>o1</code> belongs to the first
- * sequence and <code>o2</code> belongs to the second sequence. This can be
+ * {@code o1.equals(o2)} where {@code o1} belongs to the first
+ * sequence and {@code o2} belongs to the second sequence. This can be
* important if subclassing is used for some elements in the first sequence
- * and the <code>equals</code> method is specialized.
+ * and the {@code equals} method is specialized.
*
* @param sequence1 first sequence to be compared
* @param sequence2 second sequence to be compared
@@ -97,8 +97,8 @@ public class SequencesComparator<T> {
* Creates a new instance of SequencesComparator with a custom {@link Equator}.
* <p>
* It is <em>guaranteed</em> that the comparisons will always be done as
- * <code>Equator.equate(o1, o2)</code> where <code>o1</code> belongs to the first
- * sequence and <code>o2</code> belongs to the second sequence.
+ * {@code Equator.equate(o1, o2)} where {@code o1} belongs to the first
+ * sequence and {@code o2} belongs to the second sequence.
*
* @param sequence1 first sequence to be compared
* @param sequence2 second sequence to be compared
@@ -122,7 +122,7 @@ public class SequencesComparator<T> {
* embedded in either the {@link DeleteCommand delete commands} or
* {@link KeepCommand keep commands} come from the first sequence. This can
* be important if subclassing is used for some elements in the first
- * sequence and the <code>equals</code> method is specialized.
+ * sequence and the {@code equals} method is specialized.
*
* @return the edit script resulting from the comparison of the two
* sequences
diff --git a/src/main/java/org/apache/commons/collections4/sequence/package-info.java b/src/main/java/org/apache/commons/collections4/sequence/package-info.java
index 796298c..7902f79 100644
--- a/src/main/java/org/apache/commons/collections4/sequence/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/sequence/package-info.java
@@ -18,27 +18,27 @@
* This package provides classes to compare two sequences of objects.
* <p>
* The two sequences can hold any object type, as only the
- * <code>equals</code> method is used to compare the elements of the
+ * {@code equals} method is used to compare the elements of the
* sequences. It is guaranteed that the comparisons will always be done
- * as <code>o1.equals(o2)</code> where <code>o1</code> belongs to the
- * first sequence and <code>o2</code> belongs to the second
+ * as {@code o1.equals(o2)} where {@code o1} belongs to the
+ * first sequence and {@code o2} belongs to the second
* sequence. This can be important if subclassing is used for some
- * elements in the first sequence and the <code>equals</code> method is
+ * elements in the first sequence and the {@code equals} method is
* specialized.
* <p>
* Comparison can be seen from two points of view: either as giving the
* smallest modification allowing to transform the first sequence into
* the second one, or as giving the longest sequence which is a
- * subsequence of both initial sequences. The <code>equals</code> method
+ * subsequence of both initial sequences. The {@code equals} method
* is used to compare objects, so any object can be put into
* sequences. Modifications include deleting, inserting or keeping one
* object, starting from the beginning of the first sequence. Like most
* algorithms of the same type, objects transpositions are not
- * supported. This means that if a sequence <code>(A, B)</code> is
- * compared to <code>(B, A)</code>, the result will be either the
- * sequence of three commands <code>delete A</code>, <code>keep B</code>,
- * <code>insert A</code> or the sequence <code>insert B</code>,
- * <code>keep A</code>, <code>delete B</code>.
+ * supported. This means that if a sequence {@code (A, B)} is
+ * compared to {@code (B, A)}, the result will be either the
+ * sequence of three commands {@code delete A}, {@code keep B},
+ * {@code insert A} or the sequence {@code insert B},
+ * {@code keep A}, {@code delete B}.
* <p>
* The package uses a very efficient comparison algorithm designed by
* Eugene W. Myers and described in his paper: <a
@@ -62,7 +62,7 @@
* <p>
* Sometimes however, a more synthetic approach is needed. If the user
* prefers to see the differences between the two sequences as global
- * <code>replacement</code> operations acting on complete subsequences of
+ * {@code replacement} operations acting on complete subsequences of
* the original sequences, he will provide an object implementing the
* simple {@link org.apache.commons.collections4.sequence.ReplacementsHandler} interface,
* using an instance of the {@link org.apache.commons.collections4.sequence.ReplacementsFinder}
diff --git a/src/main/java/org/apache/commons/collections4/set/AbstractNavigableSetDecorator.java b/src/main/java/org/apache/commons/collections4/set/AbstractNavigableSetDecorator.java
index 00d6692..38c3f09 100644
--- a/src/main/java/org/apache/commons/collections4/set/AbstractNavigableSetDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/set/AbstractNavigableSetDecorator.java
@@ -20,7 +20,7 @@ import java.util.Iterator;
import java.util.NavigableSet;
/**
- * Decorates another <code>NavigableSet</code> to provide additional behaviour.
+ * Decorates another {@code NavigableSet} to provide additional behaviour.
* <p>
* Methods are forwarded directly to the decorated set.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/set/AbstractSetDecorator.java b/src/main/java/org/apache/commons/collections4/set/AbstractSetDecorator.java
index 86e69d6..a17c9f5 100644
--- a/src/main/java/org/apache/commons/collections4/set/AbstractSetDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/set/AbstractSetDecorator.java
@@ -21,7 +21,7 @@ import java.util.Set;
import org.apache.commons.collections4.collection.AbstractCollectionDecorator;
/**
- * Decorates another <code>Set</code> to provide additional behaviour.
+ * Decorates another {@code Set} to provide additional behaviour.
* <p>
* Methods are forwarded directly to the decorated set.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/set/AbstractSortedSetDecorator.java b/src/main/java/org/apache/commons/collections4/set/AbstractSortedSetDecorator.java
index 25c8f27..d4b26f0 100644
--- a/src/main/java/org/apache/commons/collections4/set/AbstractSortedSetDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/set/AbstractSortedSetDecorator.java
@@ -21,7 +21,7 @@ import java.util.Set;
import java.util.SortedSet;
/**
- * Decorates another <code>SortedSet</code> to provide additional behaviour.
+ * Decorates another {@code SortedSet} to provide additional behaviour.
* <p>
* Methods are forwarded directly to the decorated set.
* </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 70168b8..ebed422 100644
--- a/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/CompositeSet.java
@@ -69,7 +69,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
}
/**
- * Create a CompositeSet with just <code>set</code> composited.
+ * Create a CompositeSet with just {@code set} composited.
*
* @param set the initial set in the composite
*/
@@ -92,7 +92,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Gets the size of this composite set.
* <p>
- * This implementation calls <code>size()</code> on each set.
+ * This implementation calls {@code size()} on each set.
*
* @return total number of elements in all contained containers
*/
@@ -108,7 +108,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Checks whether this composite set is empty.
* <p>
- * This implementation calls <code>isEmpty()</code> on each set.
+ * This implementation calls {@code isEmpty()} on each set.
*
* @return true if all of the contained sets are empty
*/
@@ -125,7 +125,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Checks whether this composite set contains the object.
* <p>
- * This implementation calls <code>contains()</code> on each set.
+ * This implementation calls {@code contains()} on each set.
*
* @param obj the object to search for
* @return true if obj is contained in any of the contained sets
@@ -143,10 +143,10 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Gets an iterator over all the sets in this composite.
* <p>
- * This implementation uses an <code>IteratorChain</code>.
+ * This implementation uses an {@code IteratorChain}.
*
- * @return an <code>IteratorChain</code> instance which supports
- * <code>remove()</code>. Iteration occurs over contained collections in
+ * @return an {@code IteratorChain} instance which supports
+ * {@code remove()}. Iteration occurs over contained collections in
* the order they were added, but this behavior should not be relied upon.
* @see IteratorChain
*/
@@ -179,7 +179,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Returns an object array, populating the supplied array if possible.
- * See <code>Collection</code> interface for full details.
+ * See {@code Collection} interface for full details.
*
* @param <T> the type of the elements in the collection
* @param array the array to use, populating if possible
@@ -229,7 +229,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
}
/**
- * If a <code>CollectionMutator</code> is defined for this CompositeSet then this
+ * If a {@code CollectionMutator} is defined for this CompositeSet then this
* method will be called anyway.
*
* @param obj object to be removed
@@ -248,7 +248,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Checks whether this composite contains all the elements in the specified collection.
* <p>
- * This implementation calls <code>contains()</code> for each element in the
+ * This implementation calls {@code contains()} for each element in the
* specified collection.
*
* @param coll the collection to check for
@@ -305,7 +305,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Removes the elements in the specified collection from this composite set.
* <p>
- * This implementation calls <code>removeAll</code> on each collection.
+ * This implementation calls {@code removeAll} on each collection.
*
* @param coll the collection to remove
* @return true if the composite was modified
@@ -327,7 +327,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
* Retains all the elements in the specified collection in this composite set,
* removing all others.
* <p>
- * This implementation calls <code>retainAll()</code> on each collection.
+ * This implementation calls {@code retainAll()} on each collection.
*
* @param coll the collection to remove
* @return true if the composite was modified
@@ -345,7 +345,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
/**
* Removes all of the elements from this composite set.
* <p>
- * This implementation calls <code>clear()</code> on each set.
+ * This implementation calls {@code clear()} on each set.
*
* @throws UnsupportedOperationException if clear is unsupported
*/
@@ -521,7 +521,7 @@ public class CompositeSet<E> implements Set<E>, Serializable {
* Called when a Set is added to the CompositeSet and there is a
* collision between existing and added sets.
* <p>
- * If <code>added</code> and <code>existing</code> still have any intersects
+ * If {@code added} and {@code existing} still have any intersects
* after this method returns an IllegalArgumentException will be thrown.
*
* @param comp the CompositeSet being modified
diff --git a/src/main/java/org/apache/commons/collections4/set/ListOrderedSet.java b/src/main/java/org/apache/commons/collections4/set/ListOrderedSet.java
index 8282627..b64f58b 100644
--- a/src/main/java/org/apache/commons/collections4/set/ListOrderedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/ListOrderedSet.java
@@ -32,7 +32,7 @@ import org.apache.commons.collections4.iterators.AbstractIteratorDecorator;
import org.apache.commons.collections4.list.UnmodifiableList;
/**
- * Decorates another <code>Set</code> to ensure that the order of addition is
+ * Decorates another {@code Set} to ensure that the order of addition is
* retained and used by the iterator.
* <p>
* If an object is added to the set for a second time, it will remain in the
@@ -41,12 +41,12 @@ import org.apache.commons.collections4.list.UnmodifiableList;
* </p>
* <p>
* The ListOrderedSet also has various useful direct methods. These include many
- * from <code>List</code>, such as <code>get(int)</code>,
- * <code>remove(int)</code> and <code>indexOf(int)</code>. An unmodifiable
- * <code>List</code> view of the set can be obtained via <code>asList()</code>.
+ * from {@code List}, such as {@code get(int)},
+ * {@code remove(int)} and {@code indexOf(int)}. An unmodifiable
+ * {@code List} view of the set can be obtained via {@code asList()}.
* </p>
* <p>
- * This class cannot implement the <code>List</code> interface directly as
+ * This class cannot implement the {@code List} interface directly as
* various interface methods (notably equals/hashCode) are incompatible with a
* set.
* </p>
@@ -91,7 +91,7 @@ public class ListOrderedSet<E>
/**
* Factory method to create an ordered set.
* <p>
- * An <code>ArrayList</code> is used to retain order.
+ * An {@code ArrayList} is used to retain order.
*
* @param <E> the element type
* @param set the set to decorate, must not be null
@@ -106,7 +106,7 @@ public class ListOrderedSet<E>
/**
* Factory method to create an ordered set using the supplied list to retain order.
* <p>
- * A <code>HashSet</code> is used for the set behaviour.
+ * A {@code HashSet} is used for the set behaviour.
* <p>
* NOTE: If the list contains duplicates, the duplicates are removed,
* altering the specified list.
@@ -127,8 +127,8 @@ public class ListOrderedSet<E>
// -----------------------------------------------------------------------
/**
- * Constructs a new empty <code>ListOrderedSet</code> using a
- * <code>HashSet</code> and an <code>ArrayList</code> internally.
+ * Constructs a new empty {@code ListOrderedSet} using a
+ * {@code HashSet} and an {@code ArrayList} internally.
*
* @since 3.1
*/
@@ -240,9 +240,9 @@ public class ListOrderedSet<E>
* {@inheritDoc}
* <p>
* This implementation iterates over the elements of this set, checking
- * each element in turn to see if it's contained in <code>coll</code>.
+ * each element in turn to see if it's contained in {@code coll}.
* If it's not contained, it's removed from this set. As a consequence,
- * it is advised to use a collection type for <code>coll</code> that provides
+ * it is advised to use a collection type for {@code coll} that provides
* a fast (e.g. O(1)) implementation of {@link Collection#contains(Object)}.
*/
@Override
diff --git a/src/main/java/org/apache/commons/collections4/set/MapBackedSet.java b/src/main/java/org/apache/commons/collections4/set/MapBackedSet.java
index a15c341..748df14 100644
--- a/src/main/java/org/apache/commons/collections4/set/MapBackedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/MapBackedSet.java
@@ -25,15 +25,15 @@ import java.util.Set;
import java.util.function.Predicate;
/**
- * Decorates a <code>Map</code> to obtain <code>Set</code> behaviour.
+ * Decorates a {@code Map} to obtain {@code Set} behaviour.
* <p>
- * This class is used to create a <code>Set</code> with the same properties as
+ * This class is used to create a {@code Set} with the same properties as
* the key set of any map. Thus, a ReferenceSet can be created by wrapping a
- * <code>ReferenceMap</code> in an instance of this class.
+ * {@code ReferenceMap} in an instance of this class.
* </p>
* <p>
* Most map implementation can be used to create a set by passing in dummy values.
- * Exceptions include <code>BidiMap</code> implementations, as they require unique values.
+ * Exceptions include {@code BidiMap} implementations, as they require unique values.
* </p>
*
* @param <E> the type of the elements in this set
diff --git a/src/main/java/org/apache/commons/collections4/set/PredicatedNavigableSet.java b/src/main/java/org/apache/commons/collections4/set/PredicatedNavigableSet.java
index 23ca596..64fb88f 100644
--- a/src/main/java/org/apache/commons/collections4/set/PredicatedNavigableSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/PredicatedNavigableSet.java
@@ -22,7 +22,7 @@ import java.util.NavigableSet;
import org.apache.commons.collections4.Predicate;
/**
- * Decorates another <code>NavigableSet</code> to validate that all additions
+ * Decorates another {@code NavigableSet} to validate that all additions
* match a specified predicate.
* <p>
* This set exists to provide validation for the decorated set.
diff --git a/src/main/java/org/apache/commons/collections4/set/PredicatedSet.java b/src/main/java/org/apache/commons/collections4/set/PredicatedSet.java
index d63f0c2..f437bbc 100644
--- a/src/main/java/org/apache/commons/collections4/set/PredicatedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/PredicatedSet.java
@@ -22,7 +22,7 @@ import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.collection.PredicatedCollection;
/**
- * Decorates another <code>Set</code> to validate that all additions
+ * Decorates another {@code Set} to validate that all additions
* match a specified predicate.
* <p>
* This set exists to provide validation for the decorated set.
diff --git a/src/main/java/org/apache/commons/collections4/set/PredicatedSortedSet.java b/src/main/java/org/apache/commons/collections4/set/PredicatedSortedSet.java
index 0459efc..5d37bf1 100644
--- a/src/main/java/org/apache/commons/collections4/set/PredicatedSortedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/PredicatedSortedSet.java
@@ -22,7 +22,7 @@ import java.util.SortedSet;
import org.apache.commons.collections4.Predicate;
/**
- * Decorates another <code>SortedSet</code> to validate that all additions
+ * Decorates another {@code SortedSet} to validate that all additions
* match a specified predicate.
* <p>
* This set exists to provide validation for the decorated set.
diff --git a/src/main/java/org/apache/commons/collections4/set/TransformedNavigableSet.java b/src/main/java/org/apache/commons/collections4/set/TransformedNavigableSet.java
index 6963180..7e2cc26 100644
--- a/src/main/java/org/apache/commons/collections4/set/TransformedNavigableSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/TransformedNavigableSet.java
@@ -22,7 +22,7 @@ import java.util.NavigableSet;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>NavigableSet</code> to transform objects that are added.
+ * Decorates another {@code NavigableSet} to transform objects that are added.
* <p>
* The add methods are affected by this class.
* Thus objects must be removed or searched for using their transformed form.
diff --git a/src/main/java/org/apache/commons/collections4/set/TransformedSet.java b/src/main/java/org/apache/commons/collections4/set/TransformedSet.java
index 9e6cf57..85f1d92 100644
--- a/src/main/java/org/apache/commons/collections4/set/TransformedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/TransformedSet.java
@@ -22,7 +22,7 @@ import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.collection.TransformedCollection;
/**
- * Decorates another <code>Set</code> to transform objects that are added.
+ * Decorates another {@code Set} to transform objects that are added.
* <p>
* The add methods are affected by this class.
* Thus objects must be removed or searched for using their transformed form.
diff --git a/src/main/java/org/apache/commons/collections4/set/TransformedSortedSet.java b/src/main/java/org/apache/commons/collections4/set/TransformedSortedSet.java
index 6946a83..569854b 100644
--- a/src/main/java/org/apache/commons/collections4/set/TransformedSortedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/TransformedSortedSet.java
@@ -22,7 +22,7 @@ import java.util.SortedSet;
import org.apache.commons.collections4.Transformer;
/**
- * Decorates another <code>SortedSet</code> to transform objects that are added.
+ * Decorates another {@code SortedSet} to transform objects that are added.
* <p>
* The add methods are affected by this class.
* Thus objects must be removed or searched for using their transformed form.
diff --git a/src/main/java/org/apache/commons/collections4/set/UnmodifiableNavigableSet.java b/src/main/java/org/apache/commons/collections4/set/UnmodifiableNavigableSet.java
index e13507d..1441f26 100644
--- a/src/main/java/org/apache/commons/collections4/set/UnmodifiableNavigableSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/UnmodifiableNavigableSet.java
@@ -29,7 +29,7 @@ import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.iterators.UnmodifiableIterator;
/**
- * Decorates another <code>NavigableSet</code> to ensure it can't be altered.
+ * Decorates another {@code NavigableSet} to ensure it can't be altered.
* <p>
* Attempts to modify it will result in an UnsupportedOperationException.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/set/UnmodifiableSet.java b/src/main/java/org/apache/commons/collections4/set/UnmodifiableSet.java
index 6d8d43f..1a04b5f 100644
--- a/src/main/java/org/apache/commons/collections4/set/UnmodifiableSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/UnmodifiableSet.java
@@ -25,7 +25,7 @@ import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.iterators.UnmodifiableIterator;
/**
- * Decorates another <code>Set</code> to ensure it can't be altered.
+ * Decorates another {@code Set} to ensure it can't be altered.
* <p>
* This class is Serializable from Commons Collections 3.1.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/set/UnmodifiableSortedSet.java b/src/main/java/org/apache/commons/collections4/set/UnmodifiableSortedSet.java
index 50c7f7d..daf3107 100644
--- a/src/main/java/org/apache/commons/collections4/set/UnmodifiableSortedSet.java
+++ b/src/main/java/org/apache/commons/collections4/set/UnmodifiableSortedSet.java
@@ -28,7 +28,7 @@ import org.apache.commons.collections4.Unmodifiable;
import org.apache.commons.collections4.iterators.UnmodifiableIterator;
/**
- * Decorates another <code>SortedSet</code> to ensure it can't be altered.
+ * Decorates another {@code SortedSet} to ensure it can't be altered.
* <p>
* This class is Serializable from Commons Collections 3.1.
* </p>
diff --git a/src/main/java/org/apache/commons/collections4/splitmap/TransformedSplitMap.java b/src/main/java/org/apache/commons/collections4/splitmap/TransformedSplitMap.java
index 8ba6240..bf16282 100644
--- a/src/main/java/org/apache/commons/collections4/splitmap/TransformedSplitMap.java
+++ b/src/main/java/org/apache/commons/collections4/splitmap/TransformedSplitMap.java
@@ -48,7 +48,7 @@ import org.apache.commons.collections4.map.LinkedMap;
* contrast with {@link org.apache.commons.collections4.map.TransformedMap} which,
* by virtue of its implementing {@link Map}<K, V>, must be constructed in such
* a way that its read and write parameters are generalized to a common (super-)type.
- * In practice this would often mean <code>>Object, Object></code>, defeating
+ * In practice this would often mean {@code >Object, Object>}, defeating
* much of the usefulness of having parameterized types.
* </p>
* <p>
@@ -191,7 +191,7 @@ public class TransformedSplitMap<J, K, U, V> extends AbstractIterableGetMapDecor
}
/**
- * Override to transform the value when using <code>setValue</code>.
+ * Override to transform the value when using {@code setValue}.
*
* @param value the value to transform
* @return the transformed value