Use the more modern, compact, and flexible Javadoc "{@code ...}" instead of the HTML "<tt>...</tt>".

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/collections/trunk@1612021 13f79535-47bb-0310-9956-ffa450edef68

src/main/java/org/apache/commons/collections4/BidiMap.java

@@ -131,12 +131,12 @@ public interface BidiMap<K, V> extends IterableMap<K, V> {
      * 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 (except through the iterator's own
-     * <tt>remove</tt> operation), the results of the iteration are undefined.
+     * {@code remove} operation), the results of the iteration are undefined.
      * The set supports element removal, which removes the corresponding
-     * mapping from the map, via the <tt>Iterator.remove</tt>,
+     * mapping from the map, via the {@code Iterator.remove},
-     * <tt>Collection.remove</tt>, <tt>removeAll</tt>,
+     * {@code Collection.remove}, {@code removeAll},
-     * <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not
+     * {@code retainAll} and {@code clear} operations.  It does not
-     * support the <tt>add</tt> or <tt>addAll</tt> operations.
+     * support the {@code add} or {@code addAll} operations.
      *
      * @return a set view of the values contained in this map
      */

src/main/java/org/apache/commons/collections4/CollectionUtils.java

@@ -270,9 +270,9 @@ public class CollectionUtils {
      * cardinality(<i>e</i>,<i>b</i>))</tt>.
      * <p>
      * This is equivalent to
-     * <tt>{@link #subtract subtract}({@link #union union(a,b)},{@link #intersection intersection(a,b)})</tt>
+     * {@code {@link #subtract subtract}({@link #union union(a,b)},{@link #intersection intersection(a,b)})}
      * or
-     * <tt>{@link #union union}({@link #subtract subtract(a,b)},{@link #subtract subtract(b,a)})</tt>.
+     * {@code {@link #union union}({@link #subtract subtract(a,b)},{@link #subtract subtract(b,a)})}.
 
      * @param a the first collection, must not be null
      * @param b the second collection, must not be null
@@ -289,7 +289,7 @@ public class CollectionUtils {
     }
 
     /**
-     * Returns a new {@link Collection} containing <tt><i>a</i> - <i>b</i></tt>.
+     * Returns a new {@link Collection} containing {@code <i>a</i> - <i>b</i>}.
      * The cardinality of each element <i>e</i> in the returned {@link Collection}
      * will be the cardinality of <i>e</i> in <i>a</i> minus the cardinality
      * of <i>e</i> in <i>b</i>, or zero, whichever is greater.
@@ -453,7 +453,7 @@ public class CollectionUtils {
     }
 
     /**
-     * Returns <tt>true</tt> iff <i>a</i> is a sub-collection of <i>b</i>,
+     * Returns {@code true} iff <i>a</i> is a sub-collection of <i>b</i>,
      * that is, iff the cardinality of <i>e</i> in <i>a</i> is less than or
      * equal to the cardinality of <i>e</i> in <i>b</i>, for each element <i>e</i>
      * in <i>a</i>.
@@ -475,7 +475,7 @@ public class CollectionUtils {
     }
 
     /**
-     * Returns <tt>true</tt> iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>,
+     * Returns {@code true} iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>,
      * that is, iff the cardinality of <i>e</i> in <i>a</i> is less
      * than or equal to the cardinality of <i>e</i> in <i>b</i>,
      * for each element <i>e</i> in <i>a</i>, and there is at least one
@@ -500,7 +500,7 @@ public class CollectionUtils {
     }
 
     /**
-     * Returns <tt>true</tt> iff the given {@link Collection}s contain
+     * Returns {@code true} iff the given {@link Collection}s contain
      * exactly the same elements with exactly the same cardinalities.
      * <p>
      * That is, iff the cardinality of <i>e</i> in <i>a</i> is
@@ -528,7 +528,7 @@ public class CollectionUtils {
     }
 
     /**
-     * Returns <tt>true</tt> iff the given {@link Collection}s contain
+     * Returns {@code true} iff the given {@link Collection}s contain
      * exactly the same elements with exactly the same cardinalities.
      * <p>
      * That is, iff the cardinality of <i>e</i> in <i>a</i> is

src/main/java/org/apache/commons/collections4/ListUtils.java

@@ -223,14 +223,14 @@ public class ListUtils {
      * The relevant text (slightly paraphrased as this is a static method) is:
      * <blockquote>
      * Compares the two list objects for equality.  Returns
-     * <tt>true</tt> if and only if both
+     * {@code true} if and only if both
      * lists have the same size, and all corresponding pairs of elements in
-     * the two lists are <i>equal</i>.  (Two elements <tt>e1</tt> and
+     * the two lists are <i>equal</i>.  (Two elements {@code e1} and
-     * <tt>e2</tt> are <i>equal</i> if <tt>(e1==null ? e2==null :
+     * {@code e2} are <i>equal</i> if <tt>(e1==null ? e2==null :
      * e1.equals(e2))</tt>.)  In other words, two lists are defined to be
      * equal if they contain the same elements in the same order.  This
      * definition ensures that the equals method works properly across
-     * different implementations of the <tt>List</tt> interface.
+     * different implementations of the {@code List} interface.
      * </blockquote>
      *
      * <b>Note:</b> The behaviour of this method is undefined if the lists are

src/main/java/org/apache/commons/collections4/MultiValuedMap.java

@@ -59,21 +59,21 @@ public interface MultiValuedMap<K, V> {
     int size();
 
     /**
-     * Returns <tt>true</tt> if this map contains no key-value mappings.
+     * Returns {@code true} if this map contains no key-value mappings.
      *
-     * @return <tt>true</tt> if this map contains no key-value mappings
+     * @return {@code true} if this map contains no key-value mappings
      */
     boolean isEmpty();
 
     /**
-     * Returns <tt>true</tt> if this map contains a mapping for the specified
+     * Returns {@code true} if this map contains a mapping for the specified
-     * key. More formally, returns <tt>true</tt> if and only if this map
+     * key. More formally, returns {@code true} if and only if this map
-     * contains a mapping for a key <tt>k</tt> such that
+     * contains a mapping for a key {@code k} such that
-     * <tt>(key==null ? k==null : key.equals(k))</tt>. (There can be at most one
+     * {@code (key==null ? k==null : key.equals(k))}. (There can be at most one
      * such mapping.)
      *
      * @param key key whose presence in this map is to be tested
-     * @return <tt>true</tt> if this map contains a mapping for the specified key
+     * @return {@code true} if this map contains a mapping for the specified key
      * @throws ClassCastException if the key is of an inappropriate type for this map (optional)
      * @throws NullPointerException if the specified key is null and this map
      *        does not permit null keys (optional)
@@ -159,13 +159,13 @@ public interface MultiValuedMap<K, V> {
      * <p>
      * The effect of this call is equivalent to that of calling
      * {@link #put(Object,Object) put(k, v)} on this map once for each mapping
-     * from key <tt>k</tt> to value <tt>v</tt> in the specified map.
+     * from key {@code k} to value {@code v} in the specified map.
      * <p>
      * The behavior of this operation is undefined if the specified map is modified
      * while the operation is in progress.
      *
      * @param m mappings to be stored in this map
-     * @throws UnsupportedOperationException if the <tt>putAll</tt> operation is
+     * @throws UnsupportedOperationException if the {@code putAll} operation is
      *        not supported by this map
      * @throws ClassCastException if the class of a key or value in the
      *        specified map prevents it from being stored in this map (optional)
@@ -182,13 +182,13 @@ public interface MultiValuedMap<K, V> {
      * <p>
      * The effect of this call is equivalent to that of
      * calling {@link #put(Object,Object) put(k, v)} on this map once for each
-     * mapping from key <tt>k</tt> to value <tt>v</tt> in the specified map.
+     * mapping from key {@code k} to value {@code v} in the specified map.
      * <p>
      * The behavior of this operation is undefined if the specified map is modified
      * while the operation is in progress.
      *
      * @param m mappings to be stored in this map
-     * @throws UnsupportedOperationException if the <tt>putAll</tt> operation is
+     * @throws UnsupportedOperationException if the {@code putAll} operation is
      *        not supported by this map
      * @throws ClassCastException if the class of a key or value in the
      *        specified map prevents it from being stored in this map (optional)
@@ -273,12 +273,12 @@ public interface MultiValuedMap<K, V> {
      * in the set, and vice-versa.
      * <p>
      * If the map is modified while an iteration over the set is in
-     * progress (except through the iterator's own <tt>remove</tt> operation),
+     * progress (except through the iterator's own {@code remove} operation),
      * the result of the iteration is undefined. The set supports element
      * removal, which removes the corresponding mapping from the map, via the
-     * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, <tt>removeAll</tt>,
+     * {@code Iterator.remove}, {@code Set.remove}, {@code removeAll},
-     * <tt>retainAll</tt>, and <tt>clear</tt> operations. It does not support
+     * {@code retainAll}, and {@code clear} operations. It does not support
-     * the <tt>add</tt> or <tt>addAll</tt> operations.
+     * the {@code add} or {@code addAll} operations.
      *
      * @return a set view of the keys contained in this map
      */

src/main/java/org/apache/commons/collections4/SetUtils.java

@@ -97,15 +97,15 @@ public class SetUtils {
      * <blockquote>
      * <p>Two sets are considered equal if they have
      * the same size, and every member of the first set is contained in
-     * the second. This ensures that the <tt>equals</tt> method works
+     * the second. This ensures that the {@code equals} method works
-     * properly across different implementations of the <tt>Set</tt>
+     * properly across different implementations of the {@code Set}
      * interface.</p>
      *
      * <p>
      * This implementation first checks if the two sets are the same object:
-     * if so it returns <tt>true</tt>.  Then, it checks if the two sets are
+     * if so it returns {@code true}.  Then, it checks if the two sets are
      * identical in size; if not, it returns false. If so, it returns
-     * <tt>a.containsAll((Collection) b)</tt>.</p>
+     * {@code a.containsAll((Collection) b)}.</p>
      * </blockquote>
      *
      * @see java.util.Set

src/main/java/org/apache/commons/collections4/iterators/CollatingIterator.java

@@ -308,7 +308,7 @@ public class CollatingIterator<E> implements Iterator<E> {
      * <i>i</i>, or clear them if the <i>i</i><sup>th</sup> iterator has no next
      * value.
      *
-     * @return <tt>false</tt> iff there was no value to set
+     * @return {@code false} iff there was no value to set
      */
     private boolean set(final int i) {
         final Iterator<? extends E> it = iterators.get(i);

src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java

@@ -95,9 +95,9 @@ public class SingletonIterator<E>
     /**
      * Remove the object from this iterator.
      *
-     * @throws IllegalStateException if the <tt>next</tt> method has not
+     * @throws IllegalStateException if the {@code next} method has not
-     *        yet been called, or the <tt>remove</tt> method has already
+     *        yet been called, or the {@code remove} method has already
-     *        been called after the last call to the <tt>next</tt>
+     *        been called after the last call to the {@code next}
      *        method.
      * @throws UnsupportedOperationException if remove is not supported
      */

src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java

@@ -68,7 +68,7 @@ public class SingletonListIterator<E> implements ResettableListIterator<E> {
 
     /**
      * Returns the index of the element that would be returned by a subsequent
-     * call to <tt>next</tt>.
+     * call to {@code next}.
      *
      * @return 0 or 1 depending on current state.
      */
@@ -78,7 +78,7 @@ public class SingletonListIterator<E> implements ResettableListIterator<E> {
 
     /**
      * Returns the index of the element that would be returned by a subsequent
-     * call to <tt>previous</tt>. A return value of -1 indicates that the iterator is currently at
+     * call to {@code previous}. A return value of -1 indicates that the iterator is currently at
      * the start.
      *
      * @return 0 or -1 depending on current state.
@@ -124,10 +124,10 @@ public class SingletonListIterator<E> implements ResettableListIterator<E> {
 
     /**
      * Remove the object from this iterator.
-     * @throws IllegalStateException if the <tt>next</tt> or <tt>previous</tt>
+     * @throws IllegalStateException if the {@code next} or {@code previous}
-     *        method has not yet been called, or the <tt>remove</tt> method
+     *        method has not yet been called, or the {@code remove} method
-     *        has already been called after the last call to <tt>next</tt>
+     *        has already been called after the last call to {@code next}
-     *        or <tt>previous</tt>.
+     *        or {@code previous}.
      */
     public void remove() {
         if(!nextCalled || removed) {
@@ -151,7 +151,7 @@ public class SingletonListIterator<E> implements ResettableListIterator<E> {
      * Set sets the value of the singleton.
      *
      * @param obj  the object to set
-     * @throws IllegalStateException if <tt>next</tt> has not been called
+     * @throws IllegalStateException if {@code next} has not been called
      *          or the object has been removed
      */
     public void set(final E obj) {

src/main/java/org/apache/commons/collections4/map/CompositeMap.java

@@ -180,20 +180,20 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
     }
 
     /**
-     * Returns <tt>true</tt> if this map contains a mapping for the specified
+     * Returns {@code true} if this map contains a mapping for the specified
-     * key.  More formally, returns <tt>true</tt> if and only if
+     * key.  More formally, returns {@code true} if and only if
-     * this map contains at a mapping for a key <tt>k</tt> such that
+     * this map contains at a mapping for a key {@code k} such that
-     * <tt>(key==null ? k==null : key.equals(k))</tt>.  (There can be
+     * {@code (key==null ? k==null : key.equals(k))}.  (There can be
      * at most one such mapping.)
      *
      * @param key  key whose presence in this map is to be tested.
-     * @return <tt>true</tt> if this map contains a mapping for the specified
+     * @return {@code true} if this map contains a mapping for the specified
      *         key.
      *
      * @throws ClassCastException if the key is of an inappropriate type for
      *         this map (optional).
-     * @throws NullPointerException if the key is <tt>null</tt> and this map
+     * @throws NullPointerException if the key is {@code null} and this map
-     *            does not not permit <tt>null</tt> keys (optional).
+     *            does not not permit {@code null} keys (optional).
      */
     public boolean containsKey(final Object key) {
         for (int i = this.composite.length - 1; i >= 0; --i) {
@@ -205,20 +205,20 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
     }
 
     /**
-     * Returns <tt>true</tt> if this map maps one or more keys to the
+     * Returns {@code true} if this map maps one or more keys to the
-     * specified value.  More formally, returns <tt>true</tt> if and only if
+     * specified value.  More formally, returns {@code true} if and only if
-     * this map contains at least one mapping to a value <tt>v</tt> such that
+     * this map contains at least one mapping to a value {@code v} such that
-     * <tt>(value==null ? v==null : value.equals(v))</tt>.  This operation
+     * {@code (value==null ? v==null : value.equals(v))}.  This operation
      * will probably require time linear in the map size for most
-     * implementations of the <tt>Map</tt> interface.
+     * implementations of the {@code Map} interface.
      *
      * @param value value whose presence in this map is to be tested.
-     * @return <tt>true</tt> 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.
      * @throws ClassCastException if the value is of an inappropriate type for
      *         this map (optional).
-     * @throws NullPointerException if the value is <tt>null</tt> and this map
+     * @throws NullPointerException if the value is {@code null} and this map
-     *            does not not permit <tt>null</tt> values (optional).
+     *            does not not permit {@code null} values (optional).
      */
     public boolean containsValue(final Object value) {
         for (int i = this.composite.length - 1; i >= 0; --i) {
@@ -236,9 +236,9 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
      * 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
      * removal, which removes the corresponding mapping from the map, via the
-     * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, <tt>removeAll</tt>,
+     * {@code Iterator.remove}, {@code Set.remove}, {@code removeAll},
-     * <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not support
+     * {@code retainAll} and {@code clear} operations.  It does not support
-     * the <tt>add</tt> or <tt>addAll</tt> operations.
+     * the {@code add} or {@code addAll} operations.
      * <p>
      * This implementation returns a <code>CompositeSet</code> which
      * composites the entry sets from all of the composited maps.
@@ -256,25 +256,25 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
 
     /**
      * Returns the value to which this map maps the specified key.  Returns
-     * <tt>null</tt> if the map contains no mapping for this key.  A return
+     * {@code null} if the map contains no mapping for this key.  A return
-     * value of <tt>null</tt> does not <i>necessarily</i> indicate that the
+     * value of {@code null} does not <i>necessarily</i> indicate that the
      * map contains no mapping for the key; it's also possible that the map
-     * explicitly maps the key to <tt>null</tt>.  The <tt>containsKey</tt>
+     * explicitly maps the key to {@code null}.  The {@code containsKey}
      * operation may be used to distinguish these two cases.
      *
      * <p>More formally, if this map contains a mapping from a key
-     * <tt>k</tt> to a value <tt>v</tt> such that <tt>(key==null ? k==null :
+     * {@code k} to a value {@code v} such that <tt>(key==null ? k==null :
-     * key.equals(k))</tt>, then this method returns <tt>v</tt>; otherwise
+     * key.equals(k))</tt>, then this method returns {@code v}; otherwise
-     * it returns <tt>null</tt>.  (There can be at most one such mapping.)
+     * it returns {@code null}.  (There can be at most one such mapping.)
      *
      * @param key key whose associated value is to be returned.
      * @return the value to which this map maps the specified key, or
-     *         <tt>null</tt> if the map contains no mapping for this key.
+     *         {@code null} if the map contains no mapping for this key.
      *
      * @throws ClassCastException if the key is of an inappropriate type for
      *         this map (optional).
-     * @throws NullPointerException key is <tt>null</tt> and this map does not
+     * @throws NullPointerException key is {@code null} and this map does not
-     *         not permit <tt>null</tt> keys (optional).
+     *         not permit {@code null} keys (optional).
      *
      * @see #containsKey(Object)
      */
@@ -288,9 +288,9 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
     }
 
     /**
-     * Returns <tt>true</tt> if this map contains no key-value mappings.
+     * Returns {@code true} if this map contains no key-value mappings.
      *
-     * @return <tt>true</tt> if this map contains no key-value mappings.
+     * @return {@code true} if this map contains no key-value mappings.
      */
     public boolean isEmpty() {
         for (int i = this.composite.length - 1; i >= 0; --i) {
@@ -307,9 +307,9 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
      * 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 removal, which removes the corresponding mapping from
-     * the map, via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
+     * the map, via the {@code Iterator.remove}, {@code Set.remove},
-     * <tt>removeAll</tt> <tt>retainAll</tt>, and <tt>clear</tt> operations.
+     * {@code removeAll} {@code retainAll}, and {@code clear} operations.
-     * It does not support the add or <tt>addAll</tt> operations.
+     * It does not support the add or {@code addAll} operations.
      * <p>
      * This implementation returns a <code>CompositeSet</code> which
      * composites the key sets from all of the composited maps.
@@ -328,26 +328,26 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
      * Associates the specified value with the specified key in this map
      * (optional operation).  If the map previously contained a mapping for
      * this key, the old value is replaced by the specified value.  (A map
-     * <tt>m</tt> is said to contain a mapping for a key <tt>k</tt> if and only
+     * {@code m} is said to contain a mapping for a key {@code k} if and only
      * if {@link #containsKey(Object) m.containsKey(k)} would return
-     * <tt>true</tt>.))
+     * {@code true}.))
      *
      * @param key key with which the specified value is to be associated.
      * @param value value to be associated with the specified key.
-     * @return previous value associated with specified key, or <tt>null</tt>
+     * @return previous value associated with specified key, or {@code null}
-     *         if there was no mapping for key.  A <tt>null</tt> return can
+     *         if there was no mapping for key.  A {@code null} return can
-     *         also indicate that the map previously associated <tt>null</tt>
+     *         also indicate that the map previously associated {@code null}
      *         with the specified key, if the implementation supports
-     *         <tt>null</tt> values.
+     *         {@code null} values.
      *
      * @throws UnsupportedOperationException if no MapMutator has been specified
      * @throws ClassCastException if the class of the specified key or value
      *            prevents it from being stored in this map.
      * @throws IllegalArgumentException if some aspect of this key or value
      *            prevents it from being stored in this map.
-     * @throws NullPointerException this map does not permit <tt>null</tt>
+     * @throws NullPointerException this map does not permit {@code null}
      *            keys or values, and the specified key or value is
-     *            <tt>null</tt>.
+     *            {@code null}.
      */
     public V put(final K key, final V value) {
         if (this.mutator == null) {
@@ -360,13 +360,13 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
      * Copies all of the mappings from the specified map to this map
      * (optional operation).  The effect of this call is equivalent to that
      * of calling {@link #put(Object,Object) put(k, v)} on this map once
-     * for each mapping from key <tt>k</tt> to value <tt>v</tt> in the
+     * for each mapping from key {@code k} to value {@code v} in the
      * specified map.  The behavior of this operation is unspecified if the
      * specified map is modified while the operation is in progress.
      *
      * @param map Mappings to be stored in this map.
      *
-     * @throws UnsupportedOperationException if the <tt>putAll</tt> method is
+     * @throws UnsupportedOperationException if the {@code putAll} method is
      *         not supported by this map.
      *
      * @throws ClassCastException if the class of a key or value in the
@@ -374,9 +374,9 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
      *
      * @throws IllegalArgumentException some aspect of a key or value in the
      *         specified map prevents it from being stored in this map.
-     * @throws NullPointerException the specified map is <tt>null</tt>, or if
+     * @throws NullPointerException the specified map is {@code null}, or if
-     *         this map does not permit <tt>null</tt> keys or values, and the
+     *         this map does not permit {@code null} keys or values, and the
-     *         specified map contains <tt>null</tt> keys or values.
+     *         specified map contains {@code null} keys or values.
      */
     public void putAll(final Map<? extends K, ? extends V> map) {
         if (this.mutator == null) {
@@ -388,26 +388,26 @@ 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 <tt>k</tt> to value <tt>v</tt> such that
+     * from key {@code k} to value {@code v} such that
      * <code>(key==null ?  k==null : key.equals(k))</code>, 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
-     * <tt>null</tt> if the map contained no mapping for this key.  (A
+     * {@code null} if the map contained no mapping for this key.  (A
-     * <tt>null</tt> return can also indicate that the map previously
+     * {@code null} return can also indicate that the map previously
-     * associated <tt>null</tt> with the specified key if the implementation
+     * associated {@code null} with the specified key if the implementation
-     * supports <tt>null</tt> values.)  The map will not contain a mapping for
+     * supports {@code null} values.)  The map will not contain a mapping for
      * the specified  key once the call returns.
      *
      * @param key key whose mapping is to be removed from the map.
-     * @return previous value associated with specified key, or <tt>null</tt>
+     * @return previous value associated with specified key, or {@code null}
      *         if there was no mapping for key.
      *
      * @throws ClassCastException if the key is of an inappropriate type for
      *         the composited map (optional).
-     * @throws NullPointerException if the key is <tt>null</tt> and the composited map
+     * @throws NullPointerException if the key is {@code null} and the composited map
-     *            does not not permit <tt>null</tt> keys (optional).
+     *            does not not permit {@code null} keys (optional).
-     * @throws UnsupportedOperationException if the <tt>remove</tt> method is
+     * @throws UnsupportedOperationException if the {@code remove} method is
      *         not supported by the composited map containing the key
      */
     public V remove(final Object key) {
@@ -421,8 +421,8 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
 
     /**
      * Returns the number of key-value mappings in this map.  If the
-     * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
+     * map contains more than {@code Integer.MAX_VALUE} elements, returns
-     * <tt>Integer.MAX_VALUE</tt>.
+     * {@code Integer.MAX_VALUE}.
      *
      * @return the number of key-value mappings in this map.
      */
@@ -441,9 +441,9 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
      * iteration over the collection is in progress, the results of the
      * iteration are undefined.  The collection supports element removal,
      * which removes the corresponding mapping from the map, via the
-     * <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>,
+     * {@code Iterator.remove}, {@code Collection.remove},
-     * <tt>removeAll</tt>, <tt>retainAll</tt> and <tt>clear</tt> operations.
+     * {@code removeAll}, {@code retainAll} and {@code clear} operations.
-     * It does not support the add or <tt>addAll</tt> operations.
+     * It does not support the add or {@code addAll} operations.
      *
      * @return a collection view of the values contained in this map.
      */
@@ -509,20 +509,20 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
          * @param composited  array of Maps in the CompositeMap being modified
          * @param key  key with which the specified value is to be associated.
          * @param value  value to be associated with the specified key.
-         * @return previous value associated with specified key, or <tt>null</tt>
+         * @return previous value associated with specified key, or {@code null}
-         *         if there was no mapping for key.  A <tt>null</tt> return can
+         *         if there was no mapping for key.  A {@code null} return can
-         *         also indicate that the map previously associated <tt>null</tt>
+         *         also indicate that the map previously associated {@code null}
          *         with the specified key, if the implementation supports
-         *         <tt>null</tt> values.
+         *         {@code null} values.
          *
          * @throws UnsupportedOperationException if not defined
          * @throws ClassCastException if the class of the specified key or value
          *            prevents it from being stored in this map.
          * @throws IllegalArgumentException if some aspect of this key or value
          *            prevents it from being stored in this map.
-         * @throws NullPointerException this map does not permit <tt>null</tt>
+         * @throws NullPointerException this map does not permit {@code null}
          *            keys or values, and the specified key or value is
-         *            <tt>null</tt>.
+         *            {@code null}.
          */
         V put(CompositeMap<K, V> map, Map<K, V>[] composited, K key, V value);
 
@@ -538,9 +538,9 @@ public class CompositeMap<K, V> extends AbstractIterableMap<K, V> implements Ser
          *            prevents it from being stored in this map.
          * @throws IllegalArgumentException if some aspect of this key or value
          *            prevents it from being stored in this map.
-         * @throws NullPointerException this map does not permit <tt>null</tt>
+         * @throws NullPointerException this map does not permit {@code null}
          *            keys or values, and the specified key or value is
-         *            <tt>null</tt>.
+         *            {@code null}.
          */
         void putAll(CompositeMap<K, V> map, Map<K, V>[] composited,
                 Map<? extends K, ? extends V> mapToAdd);

src/main/java/org/apache/commons/collections4/multimap/AbstractMultiValuedMap.java

@@ -292,8 +292,8 @@ public class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K, V>, Seria
     /**
      * Copies all of the mappings from the specified map to this map. The effect
      * of this call is equivalent to that of calling {@link #put(Object,Object)
-     * put(k, v)} on this map once for each mapping from key <tt>k</tt> to value
+     * put(k, v)} on this map once for each mapping from key {@code k} to value
-     * <tt>v</tt> in the specified map. The behavior of this operation is
+     * {@code v} in the specified map. The behavior of this operation is
      * undefined if the specified map is modified while the operation is in
      * progress.
      *
@@ -311,7 +311,7 @@ public class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K, V>, Seria
      * Copies all of the mappings from the specified MultiValuedMap to this map.
      * The effect of this call is equivalent to that of calling
      * {@link #put(Object,Object) put(k, v)} on this map once for each mapping
-     * from key <tt>k</tt> to value <tt>v</tt> in the specified map. The
+     * from key {@code k} to value {@code v} in the specified map. The
      * behavior of this operation is undefined if the specified map is modified
      * while the operation is in progress.
      *
@@ -331,8 +331,8 @@ public class AbstractMultiValuedMap<K, V> implements MultiValuedMap<K, V>, Seria
      * <p>
      * Returns a Bag of keys with its values count as the count of the Bag. This
      * bag is backed by the map, so any changes in the map is reflected here.
-     * Any method which modifies this bag like <tt>add</tt>, <tt>remove</tt>,
+     * Any method which modifies this bag like {@code add}, {@code remove},
-     * <tt>Iterator.remove</tt> etc throws
+     * {@code Iterator.remove} etc throws
      * <code>UnsupportedOperationException</code>
      *
      * @return a bag view of the key mapping contained in this map