A CellExtractor that outputs the mapping [(1,2),(2,3),(3,1)] can be created from many combinations + *

A CellExtractor that outputs the mapping [(1, 2),(2, 3),(3, 1)] can be created from many combinations * of indices including:

      * [1, 1, 2, 2, 2, 3]
@@ -84,6 +85,7 @@ interface CellPredicate {
      */
     static CellExtractor from(final IndexExtractor indexExtractor) {
         return new CellExtractor() {
+
             /**
              * Class to track cell values in the TreeMap.
              */
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/CountingBloomFilter.java b/src/main/java/org/apache/commons/collections4/bloomfilter/CountingBloomFilter.java
index cdad5286e6..0a1dbed676 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/CountingBloomFilter.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/CountingBloomFilter.java
@@ -234,6 +234,7 @@ default boolean merge(final Hasher hasher) {
      * to a CellExtractor and add that.
      * 
Implementations should throw {@code IllegalArgumentException} and no other exception on bad input.
      * 
+     *
      * @param indexExtractor the IndexExtractor
      * @return {@code true} if the removal was successful and the state is valid
      * @see #isValid()
@@ -348,6 +349,7 @@ default boolean remove(final IndexExtractor indexExtractor) {
 
     /**
      * The default implementation is a no-op since the counting bloom filter returns an unique IndexExtractor by default.
+     *
      * @return this counting Bloom filter.
      */
     @Override
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/IndexFilter.java b/src/main/java/org/apache/commons/collections4/bloomfilter/IndexFilter.java
index a494ee9aa2..646093f298 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/IndexFilter.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/IndexFilter.java
@@ -32,6 +32,7 @@ public final class IndexFilter {
     /**
      * An IndexTracker implementation that uses an array of integers to track whether or not a
      * number has been seen. Suitable for Shapes that have few hash functions.
+     *
      * @since 4.5.0
      */
     static class ArrayTracker implements IntPredicate {
@@ -40,6 +41,7 @@ static class ArrayTracker implements IntPredicate {
 
         /**
          * Constructs the tracker based on the shape.
+         *
          * @param shape the shape to build the tracker for.
          */
         ArrayTracker(final Shape shape) {
@@ -70,6 +72,7 @@ static class BitMapTracker implements IntPredicate {
 
         /**
          * Constructs a bit map based tracker for the specified shape.
+         *
          * @param shape The shape that is being generated.
          */
         BitMapTracker(final Shape shape) {
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/LayerManager.java b/src/main/java/org/apache/commons/collections4/bloomfilter/LayerManager.java
index 1cb64ded8f..7aa9b1c590 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/LayerManager.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/LayerManager.java
@@ -138,7 +138,7 @@ public static > Consumer> noCleanup() {
         }
 
         /**
-         * Removes the earliest filters in the list when the the number of filters
+         * Removes the earliest filters in the list when the number of filters
          * exceeds maxSize.
          *
          * @param  Type of BloomFilter.
@@ -292,7 +292,7 @@ public static > Builder builder() {
     /**
      * Constructs a new instance.
      *
-     * @param filterSupplier the non-null supplier of new Bloom filters to add the the list
+     * @param filterSupplier the non-null supplier of new Bloom filters to add the list
      *                       when necessary.
      * @param extendCheck    The non-null predicate that checks if a new filter should be
      *                       added to the list.
@@ -361,6 +361,7 @@ public LayerManager copy() {
     /**
      * Gets the Bloom filter from the first layer.
      * No extension check is performed during this call.
+     *
      * @return The Bloom filter from the first layer.
      * @see #getTarget()
      */
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/LayeredBloomFilter.java b/src/main/java/org/apache/commons/collections4/bloomfilter/LayeredBloomFilter.java
index b47b9a462c..5d0531c50e 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/LayeredBloomFilter.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/LayeredBloomFilter.java
@@ -45,7 +45,7 @@
  * 

  * 
Level 0 is the oldest layer and the highest level is the newest.
  * 
There is always at least one enclosed filter.
- * 
The newest filter is the {@code target} into which merges are performed.
+ * 
The newest filter is the {@code target} into which merges are performed.
  * 
Whenever the target is retrieved, or a {@code merge} operation is performed the code checks if any older layers should be removed, and if so removes
  * them. It also checks it a new layer should be added, and if so adds it and sets the {@code target} before the operation.
  * 
diff --git a/src/main/java/org/apache/commons/collections4/bloomfilter/LongBiPredicate.java b/src/main/java/org/apache/commons/collections4/bloomfilter/LongBiPredicate.java
index ff2f3b49d7..9d36ed692c 100644
--- a/src/main/java/org/apache/commons/collections4/bloomfilter/LongBiPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/bloomfilter/LongBiPredicate.java
@@ -20,7 +20,7 @@
  * Represents a function that accepts a two long-valued argument and produces a binary result.
  * This is the long-consuming primitive specialization for {@code BiPredicate}.
  * 

- * This is a functional interface whose functional method is {@code test(long,long)}.
+ * This is a functional interface whose functional method is {@code test(long, long)}.
  * 
  *
  * @since 4.5.0-M1
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 34ce3d3d70..e764eb5566 100644
--- a/src/main/java/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/collection/AbstractCollectionDecorator.java
@@ -67,6 +67,7 @@ public abstract class AbstractCollectionDecorator
 
     /**
      * Constructor only used in deserialization, do not use otherwise.
+     *
      * @since 3.1
      */
     protected AbstractCollectionDecorator() {
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 1b21ab3332..d89db8d669 100644
--- a/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
+++ b/src/main/java/org/apache/commons/collections4/collection/CompositeCollection.java
@@ -37,6 +37,7 @@
  * Add and remove operations require the use of a pluggable strategy. If no
  * strategy is provided then add and remove are unsupported.
  * 

+ *
  * @param  the type of the elements in the collection
  * @since 3.0
  */
@@ -228,6 +229,7 @@ public void addComposited(final Collection compositeCollection1,
      * 

      * This implementation calls {@code clear()} on each collection.
      * 
+     *
      * @throws UnsupportedOperationException if clear is unsupported
      */
     @Override
@@ -242,6 +244,7 @@ public void clear() {
      * 

      * This implementation calls {@code contains()} on each collection.
      * 
+     *
      * @param obj  the object to search for
      * @return true if obj is contained in any of the contained collections
      */
@@ -261,6 +264,7 @@ public boolean contains(final Object obj) {
      * This implementation calls {@code contains()} for each element in the
      * specified collection.
      * 

+     *
      * @param coll  the collection to check for
      * @return true if all elements contained
      */
@@ -288,6 +292,7 @@ public List> getCollections() {
 
     /**
      * Gets the collection mutator to be used for this CompositeCollection.
+     *
      * @return CollectionMutator<E>
      */
     protected CollectionMutator getMutator() {
@@ -299,6 +304,7 @@ protected CollectionMutator getMutator() {
      * 

      * This implementation calls {@code isEmpty()} on each collection.
      * 
+     *
      * @return true if all of the contained collections are empty
      */
     @Override
@@ -316,6 +322,7 @@ public boolean isEmpty() {
      * 

      * This implementation uses an {@code IteratorChain}.
      * 
+     *
      * @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.
@@ -356,6 +363,7 @@ public boolean remove(final Object obj) {
      * 

      * This implementation calls {@code removeAll} on each collection.
      * 
+     *
      * @param coll  the collection to remove
      * @return true if the collection was modified
      * @throws UnsupportedOperationException if removeAll is unsupported
@@ -386,6 +394,7 @@ public void removeComposited(final Collection coll) {
      * 

      * This implementation calls {@code removeIf} on each collection.
      * 
+     *
      * @param filter  a predicate which returns true for elements to be removed
      * @return true if the collection was modified
      * @throws UnsupportedOperationException if removeIf is unsupported
@@ -409,6 +418,7 @@ public boolean removeIf(final Predicate filter) {
      * 

      * This implementation calls {@code retainAll()} on each collection.
      * 
+     *
      * @param coll  the collection to remove
      * @return true if the collection was modified
      * @throws UnsupportedOperationException if retainAll is unsupported
@@ -438,6 +448,7 @@ public void setMutator(final CollectionMutator mutator) {
      * 

      * This implementation calls {@code size()} on each collection.
      * 
+     *
      * @return total number of elements in all contained containers
      */
     @Override
diff --git a/src/main/java/org/apache/commons/collections4/collection/SynchronizedCollection.java b/src/main/java/org/apache/commons/collections4/collection/SynchronizedCollection.java
index 820727fed5..dbe9d50d9f 100644
--- a/src/main/java/org/apache/commons/collections4/collection/SynchronizedCollection.java
+++ b/src/main/java/org/apache/commons/collections4/collection/SynchronizedCollection.java
@@ -58,6 +58,7 @@ public class SynchronizedCollection implements Collection, Serializable {
     public static  SynchronizedCollection synchronizedCollection(final Collection coll) {
         return new SynchronizedCollection<>(coll);
     }
+
     /** The collection to decorate */
     private final Collection collection;
 
diff --git a/src/main/java/org/apache/commons/collections4/collection/package-info.java b/src/main/java/org/apache/commons/collections4/collection/package-info.java
index 912a520b1b..6958e97e23 100644
--- a/src/main/java/org/apache/commons/collections4/collection/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/collection/package-info.java
@@ -20,16 +20,19 @@
  * {@link java.util.Collection Collection} interface.
  * 

  * The following implementations are provided in the package:
+ * 
  * 

- *   
CompositeCollection - a collection that combines multiple collections into one
+ *   
CompositeCollection - a collection that combines multiple collections into one
  * 
+ * 

  * The following decorators are provided in the package:
+ * 
  * 

- *   
Synchronized - synchronizes method access for multithreaded environments
- *   
Unmodifiable - ensures the collection cannot be altered
- *   
Predicated - ensures that only elements that are valid according to a predicate can be added
- *   
Transformed - transforms elements as they are added
- *   
Indexed - provides a map-like view onto another collection
+ *   
Synchronized - synchronizes method access for multithreaded environments
+ *   
Unmodifiable - ensures the collection cannot be altered
+ *   
Predicated - ensures that only elements that are valid according to a predicate can be added
+ *   
Transformed - transforms elements as they are added
+ *   
Indexed - provides a map-like view onto another collection
  * 
  */
 package org.apache.commons.collections4.collection;
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 aca9fe7bb6..429c1af745 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/BooleanComparator.java
@@ -176,7 +176,7 @@ public int hashCode() {
      * 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)}
+     * {@link #compare(Boolean,Boolean) compare(Boolean.FALSE, Boolean.TRUE)}
      * returns a positive value.
      *
      * @return the trueFirst flag
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 05fa8acabd..253ddce5b3 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/ComparatorChain.java
@@ -58,15 +58,17 @@ public class ComparatorChain implements Comparator, Serializable {
 
     /** The list of comparators in the chain. */
     private final List> comparatorChain;
+
     /** Order - false (clear) = ascend; true (set) = descend. */
     private final BitSet orderingBits;
-   /** Whether the chain has been "locked". */
+
+    /** Whether the chain has been "locked". */
     private boolean isLocked;
 
     /**
      * Constructs a ComparatorChain with no Comparators.
      * You must add at least one Comparator before calling
-     * the compare(Object,Object) method, or an
+     * the compare(Object, Object) method, or an
      * UnsupportedOperationException is thrown
      */
     public ComparatorChain() {
@@ -182,7 +184,7 @@ private void checkLocked() {
 
     /**
      * Perform comparisons on the Objects as per
-     * Comparator.compare(o1,o2).
+     * Comparator.compare(o1, o2).
      *
      * @param o1  the first object to compare
      * @param o2  the second object to compare
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 42490a70f0..fa9b3a25a6 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/FixedOrderComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/FixedOrderComparator.java
@@ -90,7 +90,6 @@ public enum UnknownObjectBehavior {
     /** The behavior in the case of an unknown object */
     private UnknownObjectBehavior unknownObjectBehavior = UnknownObjectBehavior.EXCEPTION;
 
-    // Constructors
     /**
      * Constructs an empty FixedOrderComparator.
      */
@@ -127,7 +126,6 @@ public FixedOrderComparator(final T... items) {
         }
     }
 
-    // Methods for adding items
     /**
      * Adds an item, which compares as after all items known to the Comparator.
      * If the item is already known to the Comparator, its old position is
@@ -178,7 +176,6 @@ protected void checkLocked() {
         }
     }
 
-    // Comparator methods
     /**
      * Compares two objects according to the order of this Comparator.
      * 

@@ -245,7 +242,6 @@ public int hashCode() {
         return Objects.hash(counter, isLocked, map, unknownObjectBehavior);
     }
 
-    // Bean methods / state querying methods
     /**
      * Returns true if modifications cannot be made to the FixedOrderComparator.
      * FixedOrderComparators cannot be modified once they have performed a comparison.
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 882fc9fc50..b38c6203b1 100644
--- a/src/main/java/org/apache/commons/collections4/comparators/NullComparator.java
+++ b/src/main/java/org/apache/commons/collections4/comparators/NullComparator.java
@@ -35,99 +35,96 @@ public class NullComparator implements Comparator, Serializable {
     private static final long serialVersionUID = -5820772575483504339L;
 
     /**
-     *  The comparator to use when comparing two non-{@code null} objects.
-     **/
+     * The comparator to use when comparing two non-{@code null} objects.
+     */
     private final Comparator nonNullComparator;
 
     /**
-     *  Specifies whether a {@code null} are compared as higher than
-     *  non-{@code null} 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} higher than any
-     *  non-{@code null} object it is compared with. When comparing two
-     *  non-{@code null} objects, the {@link ComparableComparator} is
-     *  used.
-     **/
+     * 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() {
         this(ComparatorUtils.NATURAL_COMPARATOR, true);
     }
 
     /**
-     *  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.
+     * 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} 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.
-     **/
+     * @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} higher than any
-     *  non-{@code null} object it is compared with.  When comparing two
-     *  non-{@code null} objects, the specified {@link Comparator} is
-     *  used.
+     * 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} objects.  This argument cannot be
-     *  {@code null}
-     *
-     *  @throws NullPointerException if {@code nonNullComparator} is
-     *  {@code null}
-     **/
+     * @param nonNullComparator the comparator to use when comparing two
+     * non-{@code null} objects.  This argument cannot be
+     * {@code null}
+     * @throws NullPointerException if {@code nonNullComparator} is
+     * {@code null}
+     */
     public NullComparator(final Comparator nonNullComparator) {
         this(nonNullComparator, true);
     }
 
     /**
-     *  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} objects. This argument cannot be
-     *  {@code null}
+     * 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 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} is
-     *  {@code null}
-     **/
+     * @param nonNullComparator the comparator to use when comparing two
+     * non-{@code null} objects. This argument cannot be
+     * {@code null}
+     * @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} is
+     * {@code null}
+     */
     public NullComparator(final Comparator nonNullComparator, final boolean nullsAreHigh) {
         this.nonNullComparator = Objects.requireNonNull(nonNullComparator, "nonNullComparator");
         this.nullsAreHigh = nullsAreHigh;
     }
 
     /**
-     *  Perform a comparison between two objects.  If both objects are
-     *  {@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}, an
-     *  underlying comparator specified in the constructor (or the default) is
-     *  used to compare the non-{@code null} objects.
+     * Perform a comparison between two objects.  If both objects are
+     * {@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}, an
+     * underlying comparator specified in the constructor (or the default) is
+     * 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} 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.
-     **/
+     * @param o1  the first object to compare
+     * @param o2  the object to compare it to.
+     * @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) {
         if (o1 == o2) {
@@ -143,16 +140,15 @@ public int compare(final E o1, final E o2) {
     }
 
     /**
-     *  Determines whether the specified object represents a comparator that is
-     *  equal to this comparator.
-     *
-     *  @param obj  the object to compare this comparator with.
+     * Determines whether the specified object represents a comparator that is
+     * equal to this comparator.
      *
-     *  @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.
-     **/
+     * @param obj  the object to compare this comparator with.
+     * @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) {
         if (obj == null) {
@@ -172,11 +168,11 @@ public boolean equals(final Object obj) {
     }
 
     /**
-     *  Implement a hash code for this comparator that is consistent with
-     *  {@link #equals(Object)}.
+     * Implement a hash code for this comparator that is consistent with
+     * {@link #equals(Object)}.
      *
-     *  @return a hash code for this comparator.
-     **/
+     * @return a hash code for this comparator.
+     */
     @Override
     public int hashCode() {
         return (nullsAreHigh ? -1 : 1) * nonNullComparator.hashCode();
diff --git a/src/main/java/org/apache/commons/collections4/functors/AbstractPredicate.java b/src/main/java/org/apache/commons/collections4/functors/AbstractPredicate.java
index 5b7e409173..d091bd6321 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AbstractPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AbstractPredicate.java
@@ -19,7 +19,7 @@
 import org.apache.commons.collections4.Predicate;
 
 /**
- * Abstract base class for predicates.
+ * Abstract class for predicates.
  *
  * @param  the type of the input to the predicate.
  * @since 4.5.0-M3
diff --git a/src/main/java/org/apache/commons/collections4/functors/AbstractQuantifierPredicate.java b/src/main/java/org/apache/commons/collections4/functors/AbstractQuantifierPredicate.java
index c8b902aa04..062799ddfb 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AbstractQuantifierPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AbstractQuantifierPredicate.java
@@ -21,7 +21,7 @@
 import org.apache.commons.collections4.Predicate;
 
 /**
- * Abstract base class for quantification predicates, for example All, Any, None.
+ * Abstract class for quantification predicates, for example All, Any, None.
  *
  * @param  the type of the input to the predicate.
  * @since 4.0
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 40d8896ef9..5c21374510 100644
--- a/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/AndPredicate.java
@@ -46,6 +46,7 @@ public static  Predicate andPredicate(final Predicate predicate
         return new AndPredicate<>(Objects.requireNonNull(predicate1, "predicate1"),
                 Objects.requireNonNull(predicate2, "predicate2"));
     }
+
     /** The array of predicates to call */
     private final Predicate iPredicate1;
 
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 67eb9d0aa8..8fc4f58011 100644
--- a/src/main/java/org/apache/commons/collections4/functors/ForClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/ForClosure.java
@@ -53,6 +53,7 @@ public static  Closure forClosure(final int count, final Closure(count, closure);
     }
+
     /** The number of times to loop */
     private final int iCount;
 
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 964f16d900..54072b79bc 100644
--- a/src/main/java/org/apache/commons/collections4/functors/IfClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/IfClosure.java
@@ -50,6 +50,7 @@ public class IfClosure implements Closure, Serializable {
     public static  Closure ifClosure(final Predicate predicate, final Closure trueClosure) {
         return IfClosure.ifClosure(predicate, trueClosure, NOPClosure.nopClosure());
     }
+
     /**
      * Factory method that performs validation.
      *
@@ -67,6 +68,7 @@ public static  Closure ifClosure(final Predicate predicate,
                 Objects.requireNonNull(trueClosure, "trueClosure"),
                 Objects.requireNonNull(falseClosure, "falseClosure"));
     }
+
     /** The test */
     private final Predicate iPredicate;
 
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 97e0c21716..7743c5337a 100644
--- a/src/main/java/org/apache/commons/collections4/functors/IfTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/IfTransformer.java
@@ -53,6 +53,7 @@ public static  Transformer ifTransformer(final Predicate
                 Objects.requireNonNull(trueTransformer, "trueTransformer"),
                 Objects.requireNonNull(falseTransformer, "falseTransformer"));
     }
+
     /**
      * Factory method that performs validation.
      * 

@@ -71,6 +72,7 @@ public static  Transformer ifTransformer(
         return new IfTransformer<>(Objects.requireNonNull(predicate, "predicate"),
                 Objects.requireNonNull(trueTransformer, "trueTransformer"), NOPTransformer.nopTransformer());
     }
+
     /** The test */
     private final Predicate iPredicate;
 
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 cb263f6f15..e8f2d22756 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InstantiateFactory.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InstantiateFactory.java
@@ -63,10 +63,13 @@ public static  Factory instantiateFactory(final Class classToInstantiat
         }
         return new InstantiateFactory<>(classToInstantiate, paramTypes, args);
     }
+
     /** The class to create */
     private final Class iClassToInstantiate;
+
     /** The constructor parameter types */
     private final Class[] iParamTypes;
+
     /** The constructor arguments */
     private final Object[] iArgs;
 
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 e1c3f09869..18361e5c19 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InstantiateTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InstantiateTransformer.java
@@ -49,6 +49,7 @@ public class InstantiateTransformer implements Transformer
     public static  Transformer, T> instantiateTransformer() {
         return NO_ARG_INSTANCE;
     }
+
     /**
      * Transformer method that performs validation.
      *
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 f24cea644e..263a306d09 100644
--- a/src/main/java/org/apache/commons/collections4/functors/InvokerTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/InvokerTransformer.java
@@ -51,6 +51,7 @@ public class InvokerTransformer implements Transformer {
     public static  Transformer invokerTransformer(final String methodName) {
         return new InvokerTransformer<>(Objects.requireNonNull(methodName, "methodName"));
     }
+
     /**
      * Gets an instance of this transformer calling a specific method with specific values.
      *
@@ -76,6 +77,7 @@ public static  Transformer invokerTransformer(final String methodNam
         }
         return new InvokerTransformer<>(methodName, paramTypes, args);
     }
+
     /** The method name to call */
     private final String iMethodName;
 
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 4576cc85bb..92572a5831 100644
--- a/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
+++ b/src/main/java/org/apache/commons/collections4/functors/OrPredicate.java
@@ -46,6 +46,7 @@ public static  Predicate orPredicate(final Predicate predicate1
         return new OrPredicate<>(Objects.requireNonNull(predicate1, "predicate1"),
                 Objects.requireNonNull(predicate2, "predicate2"));
     }
+
     /** The array of predicates to call */
     private final Predicate iPredicate1;
 
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 5333dbec44..5c1fada974 100644
--- a/src/main/java/org/apache/commons/collections4/functors/PrototypeFactory.java
+++ b/src/main/java/org/apache/commons/collections4/functors/PrototypeFactory.java
@@ -51,6 +51,7 @@ static class PrototypeCloneFactory implements Factory {
 
         /** The object to clone each time */
         private final T iPrototype;
+
         /** The method used to clone */
         private transient Method iCloneMethod;
 
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 a63c67c225..2d20c1ad15 100644
--- a/src/main/java/org/apache/commons/collections4/functors/SwitchClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/SwitchClosure.java
@@ -72,6 +72,7 @@ public static  Closure switchClosure(final Map, Closure> p
         }
         return new SwitchClosure<>(false, preds, closures, defaultClosure);
     }
+
     /**
      * Factory method that performs validation and copies the parameter arrays.
      *
@@ -98,6 +99,7 @@ public static  Closure switchClosure(final Predicate[] predicat
         }
         return new SwitchClosure<>(predicates, closures, defaultClosure);
     }
+
     /** The tests to consider */
     private final Predicate[] iPredicates;
 
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 a73a7fe4f0..213d1d5b95 100644
--- a/src/main/java/org/apache/commons/collections4/functors/SwitchTransformer.java
+++ b/src/main/java/org/apache/commons/collections4/functors/SwitchTransformer.java
@@ -81,6 +81,7 @@ public static  Transformer switchTransformer(
         }
         return new SwitchTransformer<>(false, preds, transformers, defaultTransformer);
     }
+
     /**
      * Factory method that performs validation and copies the parameter arrays.
      *
@@ -109,6 +110,7 @@ public static  Transformer switchTransformer(final Predicate(predicates, transformers, defaultTransformer);
     }
+
     /** The tests to consider */
     private final Predicate[] iPredicates;
 
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 84b235f3b0..cd9f984f58 100644
--- a/src/main/java/org/apache/commons/collections4/functors/WhileClosure.java
+++ b/src/main/java/org/apache/commons/collections4/functors/WhileClosure.java
@@ -51,8 +51,10 @@ public static  Closure whileClosure(final Predicate predicate,
         return new WhileClosure<>(Objects.requireNonNull(predicate, "predicate"),
                 Objects.requireNonNull(closure, "closure"), doLoop);
     }
+
     /** The test condition */
     private final Predicate iPredicate;
+
     /** The closure to call */
     private final Closure iClosure;
 
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 f972cdf27a..b19a8ec53c 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ArrayIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ArrayIterator.java
@@ -41,10 +41,13 @@ public class ArrayIterator implements ResettableIterator {
 
     /** The array to iterate over */
     final Object array;
+
     /** The start index to loop from */
     final int startIndex;
+
     /** The end index to loop to */
     final int endIndex;
+
     /** The current iterator index */
     int index;
 
diff --git a/src/main/java/org/apache/commons/collections4/iterators/BoundedIterator.java b/src/main/java/org/apache/commons/collections4/iterators/BoundedIterator.java
index 73d3b2f316..300910b442 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/BoundedIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/BoundedIterator.java
@@ -82,6 +82,7 @@ public BoundedIterator(final Iterator iterator, final long offset,
 
     /**
      * Checks whether the iterator is still within its bounded range.
+     *
      * @return {@code true} if the iterator is within its bounds, {@code false} otherwise
      */
     private boolean checkBounds() {
diff --git a/src/main/java/org/apache/commons/collections4/iterators/EmptyMapIterator.java b/src/main/java/org/apache/commons/collections4/iterators/EmptyMapIterator.java
index 52265fec20..1aac23f18b 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EmptyMapIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EmptyMapIterator.java
@@ -30,6 +30,7 @@ public class EmptyMapIterator extends AbstractEmptyMapIterator imple
 
     /**
      * Singleton instance of the iterator.
+     *
      * @since 3.1
      */
     @SuppressWarnings("rawtypes")
@@ -37,6 +38,7 @@ public class EmptyMapIterator extends AbstractEmptyMapIterator imple
 
     /**
      * Gets a typed instance of the iterator.
+     *
      * @param  the key type
      * @param  the value type
      * @return {@link MapIterator}<K, V>
diff --git a/src/main/java/org/apache/commons/collections4/iterators/EmptyOrderedMapIterator.java b/src/main/java/org/apache/commons/collections4/iterators/EmptyOrderedMapIterator.java
index 0ee07de620..b3e0fb4de7 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EmptyOrderedMapIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EmptyOrderedMapIterator.java
@@ -30,6 +30,7 @@ public class EmptyOrderedMapIterator extends AbstractEmptyMapIterator extends AbstractEmptyMapIterator the key type
      * @param  the value type
      * @return {@link OrderedMapIterator}<K, V>
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 95333b4078..9a83e7ebfc 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/EnumerationIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/EnumerationIterator.java
@@ -31,12 +31,13 @@ public class EnumerationIterator implements Iterator {
 
     /** The collection to remove elements from */
     private final Collection collection;
+
     /** The enumeration being converted */
     private Enumeration enumeration;
+
     /** The last object retrieved */
     private E last;
 
-    // Constructors
     /**
      * Constructs a new {@code EnumerationIterator} that will not
      * function until {@link #setEnumeration(Enumeration)} is called.
@@ -77,7 +78,6 @@ public Enumeration getEnumeration() {
         return enumeration;
     }
 
-    // Iterator interface
     /**
      * Returns true if the underlying enumeration has more elements.
      *
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 7a2e88b72b..67fb422c49 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/FilterListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/FilterListIterator.java
@@ -109,6 +109,7 @@ public FilterListIterator(final Predicate predicate) {
 
     /**
      * Not supported.
+     *
      * @param o the element to insert
      */
     @Override
@@ -194,6 +195,7 @@ public void remove() {
 
     /**
      * Not supported.
+     *
      * @param ignored the element with which to replace the last element returned by
      *          {@code next} or {@code previous}
      */
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 433f60d46b..031fb650c0 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/IteratorChain.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/IteratorChain.java
@@ -69,7 +69,7 @@ public class IteratorChain implements Iterator {
     private Iterator lastUsedIterator;
 
     /**
-     * ComparatorChain is "locked" after the first time compare(Object,Object)
+     * ComparatorChain is "locked" after the first time compare(Object, Object)
      * is called
      */
     private boolean isLocked;
@@ -175,7 +175,7 @@ public void addIterator(final Iterator iterator) {
                 // in case it is an IteratorChain, wrap every underlying iterators as unmodifiable
                 // multiple rechainings would otherwise lead to exponential growing number of function calls
                 // when the iteratorChain gets used.
-                for (Iterator nestedIterator : ((IteratorChain) underlyingIterator).iteratorQueue) {
+                for (final Iterator nestedIterator : ((IteratorChain) underlyingIterator).iteratorQueue) {
                     iteratorQueue.add(UnmodifiableIterator.unmodifiableIterator(nestedIterator));
                 }
             } else {
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 3d227940a8..dbba4b722f 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ListIteratorWrapper.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ListIteratorWrapper.java
@@ -60,13 +60,16 @@ public class ListIteratorWrapper implements ResettableListIterator {
 
     /** The underlying iterator being decorated. */
     private final Iterator iterator;
+
     /** The list being used to cache the iterator. */
     private final List list = new ArrayList<>();
 
     /** The current index of this iterator. */
     private int currentIndex;
+
     /** The current index of the wrapped iterator. */
     private int wrappedIteratorIndex;
+
     /** Recall whether the wrapped iterator's "cursor" is in such a state as to allow remove() to be called */
     private boolean removeState;
 
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 31fb99dc6c..0bcdea5ee6 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/LoopingIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/LoopingIterator.java
@@ -42,6 +42,7 @@ public class LoopingIterator implements ResettableIterator {
 
     /** The collection to base the iterator on */
     private final Collection collection;
+
     /** The current iterator */
     private Iterator iterator;
 
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 0c47deecc9..1f76ddf046 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/LoopingListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/LoopingListIterator.java
@@ -44,6 +44,7 @@ public class LoopingListIterator implements ResettableListIterator {
 
     /** The list to base the iterator on */
     private final List list;
+
     /** The current list iterator */
     private ListIterator iterator;
 
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 82f4682d9d..916eeab927 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/NodeListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/NodeListIterator.java
@@ -37,6 +37,7 @@ public class NodeListIterator implements Iterator {
 
     /** The original NodeList instance */
     private final NodeList nodeList;
+
     /** The current iterator index */
     private int index;
 
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 c45909d942..2c0d82631f 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ObjectArrayIterator.java
@@ -38,10 +38,13 @@ public class ObjectArrayIterator implements ResettableIterator {
 
     /** The array */
     final E[] array;
+
     /** The start index to loop from */
     final int startIndex;
+
     /** The end index to loop to */
     final int endIndex;
+
     /** The current iterator index */
     int index;
 
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 2cc1f1a195..daae6e426a 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ObjectGraphIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ObjectGraphIterator.java
@@ -84,17 +84,22 @@ public class ObjectGraphIterator implements Iterator {
 
     /** The stack of iterators */
     private final Deque> stack = new ArrayDeque<>(8);
+
     /** The root object in the tree */
     private E root;
+
     /** The transformer to use */
     private final Transformer transformer;
 
     /** Whether there is another element in the iteration */
     private boolean hasNext;
+
     /** The current iterator */
     private Iterator currentIterator;
+
     /** The current value */
     private E currentValue;
+
     /** The last used iterator, needed for remove() */
     private Iterator lastUsedIterator;
 
diff --git a/src/main/java/org/apache/commons/collections4/iterators/PermutationIterator.java b/src/main/java/org/apache/commons/collections4/iterators/PermutationIterator.java
index 542cdae0d0..6aace66579 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/PermutationIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/PermutationIterator.java
@@ -71,6 +71,7 @@ public class PermutationIterator implements Iterator> {
 
     /**
      * Standard constructor for this class.
+     *
      * @param collection  the collection to generate permutations for
      * @throws NullPointerException if coll is null
      */
@@ -91,6 +92,7 @@ public PermutationIterator(final Collection collection) {
 
     /**
      * Indicates if there are more permutation available.
+     *
      * @return true if there are more permutations, otherwise false
      */
     @Override
@@ -100,6 +102,7 @@ public boolean hasNext() {
 
     /**
      * Returns the next permutation of the input collection.
+     *
      * @return a list of the permutator's elements representing a permutation
      * @throws NoSuchElementException if there are no more permutations
      */
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 287bdf5b7f..921c66f09a 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/ReverseListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/ReverseListIterator.java
@@ -42,8 +42,10 @@ public class ReverseListIterator implements ResettableListIterator {
 
     /** The list being wrapped. */
     private final List list;
+
     /** The list iterator being wrapped. */
     private ListIterator iterator;
+
     /** Flag to indicate if updating is possible at the moment. */
     private boolean validForUpdate = true;
 
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 87dd8d19d2..49b4fb6872 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/SingletonIterator.java
@@ -32,10 +32,13 @@ public class SingletonIterator
 
     /** Whether remove is allowed */
     private final boolean removeAllowed;
+
     /** Is the cursor before the first element */
     private boolean beforeFirst = true;
+
     /** Has the element been removed */
     private boolean removed;
+
     /** The object */
     private E object;
 
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 6496e41a79..53529a98b2 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/SingletonListIterator.java
@@ -140,6 +140,7 @@ public int previousIndex() {
 
     /**
      * Remove the object from this iterator.
+     *
      * @throws IllegalStateException if the {@code next} or {@code previous}
      *        method has not yet been called, or the {@code remove} method
      *        has already been called after the last call to {@code next}
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 36dc0b9f1c..f7b4113fd7 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/TransformIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/TransformIterator.java
@@ -31,6 +31,7 @@ public class TransformIterator implements Iterator {
 
     /** The iterator being used */
     private Iterator iterator;
+
     /** The transformer being used */
     private Transformer transformer;
 
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 88eadd41ca..7370b1bd57 100644
--- a/src/main/java/org/apache/commons/collections4/iterators/UniqueFilterIterator.java
+++ b/src/main/java/org/apache/commons/collections4/iterators/UniqueFilterIterator.java
@@ -31,9 +31,9 @@
 public class UniqueFilterIterator extends FilterIterator {
 
     /**
-     *  Constructs a new {@code UniqueFilterIterator}.
+     * Constructs a new {@code UniqueFilterIterator}.
      *
-     *  @param iterator  the iterator to use
+     * @param iterator  the iterator to use
      */
     public UniqueFilterIterator(final Iterator iterator) {
         super(iterator, UniquePredicate.uniquePredicate());
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 24bdd55675..4a602681a4 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/AbstractKeyValue.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/AbstractKeyValue.java
@@ -30,6 +30,7 @@ public abstract class AbstractKeyValue implements KeyValue {
 
     /** The key */
     private K key;
+
     /** The value */
     private V value;
 
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 4515372d23..dcc621eb3b 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/MultiKey.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/MultiKey.java
@@ -233,6 +233,7 @@ public MultiKey(final K[] keys, final boolean makeClone) {
 
     /**
      * Calculate the hash code of the instance using the provided keys.
+     *
      * @param keys the keys to calculate the hash code for
      */
     private void calculateHashCode(final Object[] keys) {
@@ -316,6 +317,7 @@ public int hashCode() {
      * Recalculate the hash code after deserialization. The hash code of some
      * keys might have change (hash codes based on the system hash code are
      * only stable for the same process).
+     *
      * @return the instance with recalculated hash code
      */
     protected Object readResolve() {
diff --git a/src/main/java/org/apache/commons/collections4/keyvalue/package-info.java b/src/main/java/org/apache/commons/collections4/keyvalue/package-info.java
index f6f305feb6..4a1b204464 100644
--- a/src/main/java/org/apache/commons/collections4/keyvalue/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/keyvalue/package-info.java
@@ -20,10 +20,11 @@
  * These are usually used in maps, however they can be used as data holders in any collection.
  * 

  * The following key/value designs are included:
+ * 
  * 

- *   
Map Entry - various map entry implementations
- *   
KeyValue - a key and value pair, without map entry semantics
- *   
MultiKey - a holder of multiple keys tied together
+ *   
Map Entry - various map entry implementations
+ *   
KeyValue - a key and value pair, without map entry semantics
+ *   
MultiKey - a holder of multiple keys tied together
  * 
  */
 package org.apache.commons.collections4.keyvalue;
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 ab18d7b032..fe9e30ea2f 100644
--- a/src/main/java/org/apache/commons/collections4/list/AbstractLinkedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/AbstractLinkedList.java
@@ -438,8 +438,10 @@ protected static class Node {
 
         /** A pointer to the node before this node */
         protected Node previous;
+
         /** A pointer to the node after this node */
         protected Node next;
+
         /** The object contained within this node */
         protected E value;
 
diff --git a/src/main/java/org/apache/commons/collections4/list/AbstractLinkedListJava21.java b/src/main/java/org/apache/commons/collections4/list/AbstractLinkedListJava21.java
index e2a7c52e2a..7a79d4dc3f 100644
--- a/src/main/java/org/apache/commons/collections4/list/AbstractLinkedListJava21.java
+++ b/src/main/java/org/apache/commons/collections4/list/AbstractLinkedListJava21.java
@@ -229,12 +229,16 @@ public void set(final E obj) {
      * @param  the type of elements in this list.
      */
     protected static class LinkedSubList extends AbstractList {
+
         /** The main list */
         AbstractLinkedListJava21 parent;
+
         /** Offset from the main list */
         int offset;
+
         /** Sublist size */
         int size;
+
         /** Sublist modCount */
         int expectedModCount;
 
@@ -437,8 +441,10 @@ protected static class Node {
 
         /** A pointer to the node before this node */
         protected Node previous;
+
         /** A pointer to the node after this node */
         protected Node next;
+
         /** The object contained within this node */
         protected E value;
 
diff --git a/src/main/java/org/apache/commons/collections4/list/AbstractListDecorator.java b/src/main/java/org/apache/commons/collections4/list/AbstractListDecorator.java
index 25ecf62669..ee85167de5 100644
--- a/src/main/java/org/apache/commons/collections4/list/AbstractListDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/list/AbstractListDecorator.java
@@ -38,6 +38,7 @@ public abstract class AbstractListDecorator extends AbstractCollectionDecorat
 
     /**
      * Constructor only used in deserialization, do not use otherwise.
+     *
      * @since 3.1
      */
     protected AbstractListDecorator() {
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 df080a21e5..c8e231b4c4 100644
--- a/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
+++ b/src/main/java/org/apache/commons/collections4/list/CursorableLinkedList.java
@@ -70,10 +70,13 @@ public class CursorableLinkedList extends AbstractLinkedList implements Se
      * @param  the type of elements in this cursor.
      */
     public static class Cursor extends AbstractLinkedList.LinkedListIterator {
+
         /** Is the cursor valid (not closed) */
         boolean valid = true;
+
         /** Is the next index valid */
         boolean nextIndexValid = true;
+
         /** Flag to indicate if the current element was removed by another object. */
         boolean currentRemovedByAnother;
 
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 5bedb5cd1b..57c15b24ef 100644
--- a/src/main/java/org/apache/commons/collections4/list/TreeList.java
+++ b/src/main/java/org/apache/commons/collections4/list/TreeList.java
@@ -33,7 +33,7 @@
  * A {@code List} implementation that is optimized for fast insertions and
  * removals at any index in the list.
  * 

- * This list implementation utilises a tree structure internally to ensure that
+ * This list implementation utilizes 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} and a {@code LinkedList} where elements
  * are inserted and removed repeatedly from anywhere in the list.
@@ -76,23 +76,32 @@ public class TreeList extends AbstractList {
      * The nodes don't know the index of the object they are holding.  They
      * do know however their position relative to their parent node.
      * This allows to calculate the index of a node while traversing the tree.
+     * 
      * 

      * The Faedelung calculation stores a flag for both the left and right child
      * to indicate if they are a child (false) or a link as in linked list (true).
+     * 
      */
     static class AVLNode {
+
         /** The left child node or the predecessor if {@link #leftIsPrevious}.*/
         private AVLNode left;
+
         /** Flag indicating that left reference is not a subtree but the predecessor. */
         private boolean leftIsPrevious;
+
         /** The right child node or the successor if {@link #rightIsNext}. */
         private AVLNode right;
+
         /** Flag indicating that right reference is not a subtree but the successor. */
         private boolean rightIsNext;
+
         /** How many levels of left/right are below this one. */
         private int height;
+
         /** The relative position, root holds absolute position. */
         private int relativePosition;
+
         /** The stored element. */
         private E value;
 
@@ -132,6 +141,7 @@ private AVLNode(final int relativePosition, final E obj,
          * to this method will construct the subtree for elements {@code start}
          * through {@code end} of the collection, assuming the iterator
          * {@code e} already points at element {@code start}.
+         * 

          *
          * @param iterator  an iterator over the collection, which should already point
          *          to the element at index {@code start} within the collection
@@ -754,25 +764,31 @@ public String toString() {
      * A list iterator over the linked list.
      */
     static class TreeListIterator implements ListIterator, OrderedIterator {
+
         /** The parent list */
         private final TreeList parent;
+
         /**
          * Cache of the next node that will be returned by {@link #next()}.
          */
         private AVLNode next;
+
         /**
          * The index of the next node to be returned.
          */
         private int nextIndex;
+
         /**
          * Cache of the last node that was returned by {@link #next()}
          * or {@link #previous()}.
          */
         private AVLNode current;
+
         /**
          * The index of the last node that was returned.
          */
         private int currentIndex;
+
         /**
          * The modification count that the list is expected to have. If the list
          * doesn't have this count, then a
@@ -788,6 +804,7 @@ static class TreeListIterator implements ListIterator, OrderedIterator
          * @param fromIndex  the index to start at
          */
         protected TreeListIterator(final TreeList parent, final int fromIndex) {
+            checkInterval(fromIndex, 0, parent.size(), parent.size());
             this.parent = parent;
             this.expectedModCount = parent.modCount;
             this.next = parent.root == null ? null : parent.root.get(fromIndex);
@@ -900,6 +917,21 @@ public void set(final E obj) {
         }
     }
 
+    /**
+     * Checks whether the index is valid.
+     *
+     * @param index  the index to check.
+     * @param startIndex  the first allowed index.
+     * @param endIndex  the last allowed index.
+     * @param endIndex  the size.
+     * @throws IndexOutOfBoundsException if the index is invalid
+     */
+    private static void checkInterval(final int index, final int startIndex, final int endIndex, final int size) {
+        if (index < startIndex || index > endIndex) {
+            throw new IndexOutOfBoundsException("Invalid index:" + index + ", size=" + size);
+        }
+    }
+
     /** The root node in the AVL tree */
     private AVLNode root;
 
@@ -949,6 +981,7 @@ public void add(final int index, final E obj) {
      * 

      * This method runs in O(n + log m) time, where m is
      * the size of this list and n is the size of {@code c}.
+     * 
      *
      * @param c  the collection to be added to this list
      * @return {@code true} if this list changed as a result of the call
@@ -977,9 +1010,7 @@ public boolean addAll(final Collection c) {
      * @throws IndexOutOfBoundsException if the index is invalid
      */
     private void checkInterval(final int index, final int startIndex, final int endIndex) {
-        if (index < startIndex || index > endIndex) {
-            throw new IndexOutOfBoundsException("Invalid index:" + index + ", size=" + size());
-        }
+        checkInterval(index, startIndex, endIndex, size());
     }
 
     /**
@@ -1055,14 +1086,13 @@ public ListIterator listIterator() {
     /**
      * Gets a ListIterator over the list.
      *
-     * @param fromIndex  the index to start from
-     * @return the new iterator
+     * @param fromIndex  the index to start from.
+     * @return the new iterator.
      */
     @Override
     public ListIterator listIterator(final int fromIndex) {
         // override to go 75% faster
         // cannot use EmptyIterator as iterator.add() must work
-        checkInterval(fromIndex, 0, size());
         return new TreeListIterator<>(this, fromIndex);
     }
 
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 683072cc82..aee103d8b7 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractHashedMap.java
@@ -235,6 +235,7 @@ public String toString() {
             return new StringBuilder().append(getKey()).append('=').append(getValue()).toString();
         }
     }
+
     /**
      * Base Iterator.
      *
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 4473831a57..4f17657fba 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractLinkedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractLinkedMap.java
@@ -140,8 +140,10 @@ public K previous() {
      * @param  the value type.
      */
     protected static class LinkEntry extends HashEntry {
+
         /** The entry before this one in the order */
         protected LinkEntry before;
+
         /** The entry after this one in the order */
         protected LinkEntry after;
 
diff --git a/src/main/java/org/apache/commons/collections4/map/AbstractMapDecorator.java b/src/main/java/org/apache/commons/collections4/map/AbstractMapDecorator.java
index 5047b1ac76..ffcae5ee29 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractMapDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractMapDecorator.java
@@ -47,6 +47,7 @@ public abstract class AbstractMapDecorator extends AbstractIterableMap extends AbstractMapDecor
 
     /**
      * Constructor only used in deserialization, do not use otherwise.
+     *
      * @since 3.1
      */
     protected AbstractOrderedMapDecorator() {
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 3b08521555..42f84c2942 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractReferenceMap.java
@@ -94,6 +94,7 @@ public abstract class AbstractReferenceMap extends AbstractHashedMap
      * Base iterator class.
      */
     static class ReferenceBaseIterator {
+
         /** The parent map */
         final AbstractReferenceMap parent;
 
@@ -197,6 +198,7 @@ public void remove() {
      * @since 3.1
      */
     protected static class ReferenceEntry extends HashEntry {
+
         /** The parent map */
         private final AbstractReferenceMap parent;
 
@@ -309,6 +311,7 @@ protected void onPurge() {
 
         /**
          * Purges the specified reference
+         *
          * @param ref  the reference to purge
          * @return true or false
          */
@@ -517,6 +520,7 @@ public enum ReferenceStrength {
 
         /**
          * Resolve enum from int.
+         *
          * @param value  the int value
          * @return ReferenceType
          * @throws IllegalArgumentException if the specified value is invalid.
@@ -586,6 +590,7 @@ public V next() {
      * A soft reference holder.
      */
     static class SoftRef extends SoftReference {
+
         /** The hashCode of the key (even if the reference points to a value) */
         private final int hash;
 
@@ -619,6 +624,7 @@ public int hashCode() {
      * A weak reference holder.
      */
     static class WeakRef extends WeakReference {
+
         /** The hashCode of the key (even if the reference points to a value) */
         private final int hash;
 
diff --git a/src/main/java/org/apache/commons/collections4/map/AbstractSortedMapDecorator.java b/src/main/java/org/apache/commons/collections4/map/AbstractSortedMapDecorator.java
index 78a49ef6a1..75a6d7dca3 100644
--- a/src/main/java/org/apache/commons/collections4/map/AbstractSortedMapDecorator.java
+++ b/src/main/java/org/apache/commons/collections4/map/AbstractSortedMapDecorator.java
@@ -59,6 +59,7 @@ protected static class SortedMapIterator extends EntrySetToMapIteratorAdap
 
         /**
          * Create a new AbstractSortedMapDecorator.SortedMapIterator.
+         *
          * @param entrySet  the entrySet to iterate
          */
         protected SortedMapIterator(final Set> entrySet) {
@@ -94,6 +95,7 @@ public synchronized void reset() {
 
     /**
      * Constructor only used in deserialization, do not use otherwise.
+     *
      * @since 3.1
      */
     protected AbstractSortedMapDecorator() {
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 9c26db3f33..8161d6cb1f 100644
--- a/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/CompositeMap.java
@@ -56,6 +56,7 @@ public class CompositeMap extends AbstractIterableMap implements Ser
      * @param  the type of the values in the map
      */
     public interface MapMutator extends Serializable {
+
         /**
          * Called when the CompositeMap.put() method is invoked.
          *
diff --git a/src/main/java/org/apache/commons/collections4/map/ConcurrentReferenceHashMap.java b/src/main/java/org/apache/commons/collections4/map/ConcurrentReferenceHashMap.java
index 979c15c230..c7cdea3950 100644
--- a/src/main/java/org/apache/commons/collections4/map/ConcurrentReferenceHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/ConcurrentReferenceHashMap.java
@@ -400,9 +400,9 @@ public int size() {
     /**
      * ConcurrentReferenceHashMap list entry. Note that this is never exported out as a user-visible Map.Entry.
      * 

-     * Because the value field is volatile, not final, it is legal wrt the Java Memory Model for an unsynchronized reader to see null instead of initial value
-     * when read via a data race. Although a reordering leading to this is not likely to ever actually occur, the Segment.readValueUnderLock method is used as a
-     * backup in case a null (pre-initialized) value is ever seen in an unsynchronized access method.
+     * Because the value field is volatile, not final, it is legal with respect to the Java Memory Model for an unsynchronized reader to see null instead of
+     * initial value when read via a data race. Although a reordering leading to this is not likely to ever actually occur, the Segment.readValueUnderLock
+     * method is used as a backup in case a null (pre-initialized) value is ever seen in an unsynchronized access method.
      * 
      */
     private static final class HashEntry {
@@ -622,9 +622,10 @@ public int size() {
     }
 
     /**
-     * Behavior-changing configuration options for the map
+     * Enumerates eehavior-changing configuration options for the map.
      */
     public enum Option {
+
         /**
          * Indicates that referential-equality (== instead of .equals()) should be used when locating keys. This offers similar behavior to
          * {@link IdentityHashMap}
@@ -633,17 +634,20 @@ public enum Option {
     }
 
     /**
-     * An option specifying which Java reference type should be used to refer to a key and/or value.
+     * Enumerates which Java reference type should be used to refer to a key and/or value.
      */
     public enum ReferenceType {
+
         /**
          * Indicates a normal Java strong reference should be used
          */
         STRONG,
+
         /**
          * Indicates a {@link WeakReference} should be used
          */
         WEAK,
+
         /**
          * Indicates a {@link SoftReference} should be used
          */
diff --git a/src/main/java/org/apache/commons/collections4/map/EntrySetToMapIteratorAdapter.java b/src/main/java/org/apache/commons/collections4/map/EntrySetToMapIteratorAdapter.java
index 3f9d57ee3d..636e14d9e6 100644
--- a/src/main/java/org/apache/commons/collections4/map/EntrySetToMapIteratorAdapter.java
+++ b/src/main/java/org/apache/commons/collections4/map/EntrySetToMapIteratorAdapter.java
@@ -43,6 +43,7 @@ public class EntrySetToMapIteratorAdapter implements MapIterator, Re
 
     /**
      * Create a new EntrySetToMapIteratorAdapter.
+     *
      * @param entrySet  the entrySet to adapt
      */
     public EntrySetToMapIteratorAdapter(final Set> entrySet) {
@@ -52,6 +53,7 @@ public EntrySetToMapIteratorAdapter(final Set> entrySet) {
 
     /**
      * Gets the currently active entry.
+     *
      * @return Map.Entry<K, V>
      */
     protected synchronized Map.Entry current() {
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 f9d7dbaec8..1d68fe033a 100644
--- a/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
+++ b/src/main/java/org/apache/commons/collections4/map/Flat3Map.java
@@ -44,11 +44,11 @@
  * It also has good garbage collection characteristics.
  * 

  * 

- * 
Optimized for operation at size 3 or less.
- * 
Still works well once size 3 exceeded.
- * 
Gets at size 3 or less are about 0-10% faster than HashMap,
- * 
Puts at size 3 or less are over 4 times faster than HashMap.
- * 
Performance 5% slower than HashMap once size 3 exceeded once.
+ * 
Optimized for operation at size 3 or less.
+ * 
Still works well once size 3 exceeded.
+ * 
Gets at size 3 or less are about 0-10% faster than HashMap,
+ * 
Puts at size 3 or less are over 4 times faster than HashMap.
+ * 
Performance 5% slower than HashMap once size 3 exceeded once.
  * 
  * 

  * The design uses two distinct modes of operation - flat and delegate.
@@ -161,6 +161,7 @@ public int size() {
             return parent.size();
         }
     }
+
     /**
      * EntrySetIterator and MapEntry
      */
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 73ae5c539f..feecbe44c8 100644
--- a/src/main/java/org/apache/commons/collections4/map/LRUMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/LRUMap.java
@@ -68,11 +68,13 @@ public class LRUMap
 
     /** Serialization version */
     private static final long serialVersionUID = -612114643488955218L;
+
     /** Default maximum size */
     protected static final int DEFAULT_MAX_SIZE = 100;
 
     /** Maximum size */
     private transient int maxSize;
+
     /** Scan behavior */
     private final boolean scanUntilRemovable;
 
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 7bb9e50f89..0882943fdb 100644
--- a/src/main/java/org/apache/commons/collections4/map/MultiKeyMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/MultiKeyMap.java
@@ -50,9 +50,9 @@
  * enables extra behavior to be added easily.
  * 
  * 

- * 
{@code MultiKeyMap.decorate(new LinkedMap())} creates an ordered map.
- * 
{@code MultiKeyMap.decorate(new LRUMap())} creates an least recently used map.
- * 
{@code MultiKeyMap.decorate(new ReferenceMap())} creates a garbage collector sensitive map.
+ * 
{@code MultiKeyMap.decorate(new LinkedMap())} creates an ordered map.
+ * 
{@code MultiKeyMap.decorate(new LRUMap())} creates an least recently used map.
+ * 
{@code MultiKeyMap.decorate(new ReferenceMap())} creates a garbage collector sensitive map.
  * 
  * 

  * Note that {@code IdentityMap} and {@code ReferenceIdentityMap} are unsuitable
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 995977da53..7d3cd3c8d2 100644
--- a/src/main/java/org/apache/commons/collections4/map/MultiValueMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/MultiValueMap.java
@@ -66,7 +66,7 @@
  * @param  the type of the keys in this map
  * @param  the type of the values in this map
  * @since 3.2
- * @deprecated since 4.1, use {@link org.apache.commons.collections4.MultiValuedMap MultiValuedMap} instead
+ * @deprecated Since 4.1, use {@link org.apache.commons.collections4.MultiValuedMap MultiValuedMap} instead
  */
 @Deprecated
 public class MultiValueMap extends AbstractMapDecorator implements MultiMap, Serializable {
@@ -135,6 +135,7 @@ public int size() {
             return totalSize();
         }
     }
+
     /**
      * Inner class that provides the values iterator.
      */
@@ -471,9 +472,9 @@ public boolean putAll(final K key, final Collection values) {
      * correctly handled.
      * 

      * If you call this method with a normal map, each entry is
-     * added using {@code put(Object,Object)}.
+     * added using {@code put(Object, Object)}.
      * If you call this method with a multi map, each entry is
-     * added using {@code putAll(Object,Collection)}.
+     * added using {@code putAll(Object, Collection)}.
      * 
      *
      * @param map  the map to copy (either a normal or multi map)
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 dff5a199b5..a9f3fc8fbd 100644
--- a/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/SingletonMap.java
@@ -52,9 +52,9 @@
  * The key and value can be obtained by:
  * 

  * 

- * 
normal Map methods and views
- * 
the {@code MapIterator}, see {@link #mapIterator()}
- * 
the {@code KeyValue} interface (just cast - no object creation)
+ * 
normal Map methods and views
+ * 
the {@code MapIterator}, see {@link #mapIterator()}
+ * 
the {@code KeyValue} interface (just cast - no object creation)
  * 
  *
  * @param  the type of the keys in this map
@@ -183,6 +183,7 @@ public int size() {
             return 1;
         }
     }
+
     /** Serialization version */
     private static final long serialVersionUID = -8931271118676803261L;
 
@@ -336,7 +337,6 @@ public K firstKey() {
         return getKey();
     }
 
-    // Map
     /**
      * Gets the value mapped to the key specified.
      *
@@ -351,7 +351,6 @@ public V get(final Object key) {
         return null;
     }
 
-    // KeyValue
     /**
      * Gets the key.
      *
@@ -413,7 +412,6 @@ protected boolean isEqualValue(final Object value) {
         return Objects.equals(value, getValue());
     }
 
-    // BoundedMap
     /**
      * Is the map currently full, always true.
      *
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 d358f29539..6dcd47d879 100644
--- a/src/main/java/org/apache/commons/collections4/map/TransformedMap.java
+++ b/src/main/java/org/apache/commons/collections4/map/TransformedMap.java
@@ -84,6 +84,7 @@ public static  TransformedMap transformedMap(final Map map,
         }
         return decorated;
     }
+
     /**
      * Factory method to create a transforming map.
      * 

diff --git a/src/main/java/org/apache/commons/collections4/map/package-info.java b/src/main/java/org/apache/commons/collections4/map/package-info.java
index 84364141c3..c70baf0915 100644
--- a/src/main/java/org/apache/commons/collections4/map/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/map/package-info.java
@@ -25,29 +25,31 @@
  * simple iteration of map keys and values.
  * 

  * The following implementations are provided:
+ * 
  * 

- *   
CaseInsensitiveMap - map that compares keys in a case insensitive way
- *   
CompositeMap - map that combines multiple maps into a single view
- *   
HashedMap - general purpose HashMap replacement supporting MapIterator
- *   
Flat3Map - designed for good performance at size 3 or less
- *   
LinkedMap - a hash map that maintains insertion order, supporting OrderedMapIterator
- *   
LRUMap - a hash map that maintains a maximum size by removing the least recently used entries
- *   
MultiKeyMap - map that provides special methods for using more than one key to access the value
- *   
ReferenceMap - allows the garbage collector to collect keys and values using equals() for comparison
- *   
ReferenceIdentityMap - allows the garbage collector to collect keys and values using == for comparison
- *   
SingletonMap - a fully featured map to hold one key-value pair
- *   
StaticBucketMap - internally synchronized and designed for thread-contentious environments
+ *   
CaseInsensitiveMap - map that compares keys in a case insensitive way
+ *   
CompositeMap - map that combines multiple maps into a single view
+ *   
HashedMap - general purpose HashMap replacement supporting MapIterator
+ *   
Flat3Map - designed for good performance at size 3 or less
+ *   
LinkedMap - a hash map that maintains insertion order, supporting OrderedMapIterator
+ *   
LRUMap - a hash map that maintains a maximum size by removing the least recently used entries
+ *   
MultiKeyMap - map that provides special methods for using more than one key to access the value
+ *   
ReferenceMap - allows the garbage collector to collect keys and values using equals() for comparison
+ *   
ReferenceIdentityMap - allows the garbage collector to collect keys and values using == for comparison
+ *   
SingletonMap - a fully featured map to hold one key-value pair
+ *   
StaticBucketMap - internally synchronized and designed for thread-contentious environments
  * 
  * 

  * The following decorators are provided:
+ * 
  * 

- *   
Unmodifiable - ensures the collection cannot be altered
- *   
Predicated - ensures that only elements that are valid according to a predicate can be added
- *   
Transformed - transforms each element added
- *   
FixedSize - ensures that the size of the map cannot change
- *   
Defaulted - provides default values for non-existing keys
- *   
Lazy - creates objects in the map on demand
- *   
ListOrdered - ensures that insertion order is retained
+ *   
Unmodifiable - ensures the collection cannot be altered
+ *   
Predicated - ensures that only elements that are valid according to a predicate can be added
+ *   
Transformed - transforms each element added
+ *   
FixedSize - ensures that the size of the map cannot change
+ *   
Defaulted - provides default values for non-existing keys
+ *   
Lazy - creates objects in the map on demand
+ *   
ListOrdered - ensures that insertion order is retained
  * 
  */
 package org.apache.commons.collections4.map;
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 f14371f9bc..de34ee31bb 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractListValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractListValuedMap.java
@@ -242,6 +242,7 @@ protected AbstractListValuedMap(final Map> map) {
 
     /**
      * Creates a new value collection using the provided factory.
+     *
      * @return a new list
      */
     @Override
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 5f3b940cf4..ff98ea2b75 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/AbstractSetValuedMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/AbstractSetValuedMap.java
@@ -87,6 +87,7 @@ protected AbstractSetValuedMap(final Map> map) {
 
     /**
      * Creates a new value collection using the provided factory.
+     *
      * @return a new set
      */
     @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 a9d2a11537..47586dc631 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedHashMap.java
@@ -25,6 +25,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import org.apache.commons.collections4.MultiMapUtils;
 import org.apache.commons.collections4.MultiValuedMap;
 
 /**
@@ -118,6 +119,11 @@ protected ArrayList createCollection() {
         return new ArrayList<>(initialListCapacity);
     }
 
+    @Override
+    public ArrayListValuedHashMap inverted() {
+        return MultiMapUtils.invert(this, new ArrayListValuedHashMap());
+    }
+
     /**
      * Deserializes an instance from an ObjectInputStream.
      *
diff --git a/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedLinkedHashMap.java b/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedLinkedHashMap.java
index f1b797b532..2556ab3f74 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedLinkedHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/ArrayListValuedLinkedHashMap.java
@@ -25,6 +25,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 
+import org.apache.commons.collections4.MultiMapUtils;
 import org.apache.commons.collections4.MultiValuedMap;
 
 /**
@@ -118,6 +119,11 @@ protected ArrayList createCollection() {
         return new ArrayList<>(initialListCapacity);
     }
 
+    @Override
+    public ArrayListValuedLinkedHashMap inverted() {
+        return MultiMapUtils.invert(this, new ArrayListValuedLinkedHashMap<>());
+    }
+
     /**
      * Deserializes an instance from an ObjectInputStream.
      *
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 b122e2c410..184730cbfb 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/HashSetValuedHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/HashSetValuedHashMap.java
@@ -24,6 +24,7 @@
 import java.util.HashSet;
 import java.util.Map;
 
+import org.apache.commons.collections4.MultiMapUtils;
 import org.apache.commons.collections4.MultiValuedMap;
 
 /**
@@ -117,6 +118,11 @@ protected HashSet createCollection() {
         return new HashSet<>(initialSetCapacity);
     }
 
+    @Override
+    public HashSetValuedHashMap inverted() {
+        return MultiMapUtils.invert(this, new HashSetValuedHashMap());
+    }
+
     /**
      * Deserializes an instance from an ObjectInputStream.
      *
diff --git a/src/main/java/org/apache/commons/collections4/multimap/LinkedHashSetValuedLinkedHashMap.java b/src/main/java/org/apache/commons/collections4/multimap/LinkedHashSetValuedLinkedHashMap.java
index c8be8751dc..c381893b6a 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/LinkedHashSetValuedLinkedHashMap.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/LinkedHashSetValuedLinkedHashMap.java
@@ -24,6 +24,7 @@
 import java.util.LinkedHashSet;
 import java.util.Map;
 
+import org.apache.commons.collections4.MultiMapUtils;
 import org.apache.commons.collections4.MultiValuedMap;
 
 /**
@@ -117,6 +118,11 @@ protected LinkedHashSet createCollection() {
         return new LinkedHashSet<>(initialSetCapacity);
     }
 
+    @Override
+    public LinkedHashSetValuedLinkedHashMap inverted() {
+        return MultiMapUtils.invert(this, new LinkedHashSetValuedLinkedHashMap());
+    }
+
     /**
      * Deserializes an instance from an ObjectInputStream.
      *
diff --git a/src/main/java/org/apache/commons/collections4/multimap/package-info.java b/src/main/java/org/apache/commons/collections4/multimap/package-info.java
index 85cb3686c9..4936635078 100644
--- a/src/main/java/org/apache/commons/collections4/multimap/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/multimap/package-info.java
@@ -20,15 +20,17 @@
  * A MultiValuedMap holds a collection of values against each key.
  * 

  * The following implementations are provided in the package:
+ * 
  * 

- *   
ArrayListValuedHashMap - ListValuedMap implementation using a HashMap/ArrayList
- *   
HashSetValuedHashMap   - SetValuedMap implementation using a HashMap/HashSet
+ *   
ArrayListValuedHashMap - ListValuedMap implementation using a HashMap/ArrayList
+ *   
HashSetValuedHashMap   - SetValuedMap implementation using a HashMap/HashSet
  * 
  * 

  * The following decorators are provided in the package:
+ * 
  * 

- *   
Transformed - transforms elements added to the MultiValuedMap
- *   
Unmodifiable - ensures the collection cannot be altered
+ *   
Transformed - transforms elements added to the MultiValuedMap
+ *   
Unmodifiable - ensures the collection cannot be altered
  * 
  */
 package org.apache.commons.collections4.multimap;
diff --git a/src/main/java/org/apache/commons/collections4/multiset/AbstractMapMultiSet.java b/src/main/java/org/apache/commons/collections4/multiset/AbstractMapMultiSet.java
index 19e7f620c3..0e24a6e167 100644
--- a/src/main/java/org/apache/commons/collections4/multiset/AbstractMapMultiSet.java
+++ b/src/main/java/org/apache/commons/collections4/multiset/AbstractMapMultiSet.java
@@ -64,6 +64,7 @@ protected static class EntrySetIterator implements Iterator> {
 
         /**
          * Constructs a new instance.
+         *
          * @param decorated  the iterator to decorate
          * @param parent  the parent multiset
          */
@@ -95,6 +96,7 @@ public void remove() {
             canRemove = false;
         }
     }
+
     /**
      * Inner class iterator for the MultiSet.
      */
@@ -174,6 +176,7 @@ protected static class MultiSetEntry extends AbstractEntry {
 
         /**
          * Constructs a new instance.
+         *
          * @param parentEntry  the entry to decorate
          */
         protected MultiSetEntry(final Map.Entry parentEntry) {
@@ -195,11 +198,13 @@ public E getElement() {
      * Mutable integer class for storing the data.
      */
     protected static class MutableInteger {
+
         /** The value of this mutable. */
         protected int value;
 
         /**
          * Constructs a new instance.
+         *
          * @param value the initial value
          */
         MutableInteger(final int value) {
@@ -238,6 +243,7 @@ protected static class UniqueSetIterator extends AbstractIteratorDecorator
 
         /**
          * Constructs a new instance.
+         *
          * @param iterator  the iterator to decorate
          * @param parent  the parent multiset
          */
diff --git a/src/main/java/org/apache/commons/collections4/multiset/SynchronizedMultiSet.java b/src/main/java/org/apache/commons/collections4/multiset/SynchronizedMultiSet.java
index 426ad6438e..ccffd0946d 100644
--- a/src/main/java/org/apache/commons/collections4/multiset/SynchronizedMultiSet.java
+++ b/src/main/java/org/apache/commons/collections4/multiset/SynchronizedMultiSet.java
@@ -40,11 +40,13 @@ public class SynchronizedMultiSet extends SynchronizedCollection implement
      * @param  the type held in this Set.
      */
     static class SynchronizedSet extends SynchronizedCollection implements Set {
+
         /** Serialization version */
         private static final long serialVersionUID = 20150629L;
 
         /**
          * Constructs a new instance.
+         *
          * @param set  the set to decorate
          * @param lock  the lock to use, shared with the multiset
          */
diff --git a/src/main/java/org/apache/commons/collections4/multiset/package-info.java b/src/main/java/org/apache/commons/collections4/multiset/package-info.java
index 58c1b4cd6c..5b8486f549 100644
--- a/src/main/java/org/apache/commons/collections4/multiset/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/multiset/package-info.java
@@ -21,15 +21,17 @@
  * A multiset stores an object and a count of the number of occurrences of the object.
  * 

  * The following implementations are provided in the package:
+ * 
  * 

- *   
HashMultiSet - implementation that uses a HashMap to store the data
+ *   
HashMultiSet - implementation that uses a HashMap to store the data
  * 
  * 

  * The following decorators are provided in the package:
+ * 
  * 

- *   
Predicated   - ensures that only elements that are valid according to a predicate can be added
- *   
Synchronized - synchronizes method access for multithreaded environments
- *   
Unmodifiable - ensures the multiset cannot be altered
+ *   
Predicated   - ensures that only elements that are valid according to a predicate can be added
+ *   
Synchronized - synchronizes method access for multithreaded environments
+ *   
Unmodifiable - ensures the multiset cannot be altered
  * 
  */
 package org.apache.commons.collections4.multiset;
diff --git a/src/main/java/org/apache/commons/collections4/package-info.java b/src/main/java/org/apache/commons/collections4/package-info.java
index ef1e29105e..7e45d23606 100644
--- a/src/main/java/org/apache/commons/collections4/package-info.java
+++ b/src/main/java/org/apache/commons/collections4/package-info.java
@@ -21,7 +21,7 @@
  * The following collection implementations are provided in the package:
  * 

  * 

- *   
ArrayStack - a non synchronized Stack that follows the same API as {@code java.util Stack}
+ *   
ArrayStack - a non synchronized Stack that follows the same API as {@code java.util Stack}
  * 
  */
 package org.apache.commons.collections4;
diff --git a/src/main/java/org/apache/commons/collections4/properties/OrderedProperties.java b/src/main/java/org/apache/commons/collections4/properties/OrderedProperties.java
index fb39e749d1..3252b61f78 100644
--- a/src/main/java/org/apache/commons/collections4/properties/OrderedProperties.java
+++ b/src/main/java/org/apache/commons/collections4/properties/OrderedProperties.java
@@ -84,6 +84,26 @@ public Set> entrySet() {
         return orderedKeys.stream().map(k -> new SimpleEntry<>(k, get(k))).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
+    /**
+     * Enumerates all key/value pairs in the specified LinkedHashSet and omits the property if the key or value is not a string.
+     *
+     * @param result The result set to populate.
+     * @return The given set.
+     */
+    private synchronized LinkedHashSet enumerateStringProperties(final LinkedHashSet result) {
+        if (defaults != null) {
+            result.addAll(defaults.stringPropertyNames());
+        }
+        for (final Enumeration e = keys(); e.hasMoreElements();) {
+            final Object k = e.nextElement();
+            final Object v = get(k);
+            if (k instanceof String && v instanceof String) {
+                result.add((String) k);
+            }
+        }
+        return result;
+    }
+
     @Override
     public synchronized void forEach(final BiConsumer action) {
         Objects.requireNonNull(action);
@@ -109,7 +129,7 @@ public synchronized Object merge(final Object key, final Object value,
 
     @Override
     public Enumeration propertyNames() {
-        return Collections.enumeration(orderedKeys);
+        return Collections.enumeration(stringPropertyNames());
     }
 
     @Override
@@ -154,6 +174,11 @@ public synchronized boolean remove(final Object key, final Object value) {
         return remove;
     }
 
+    @Override
+    public Set stringPropertyNames() {
+        return enumerateStringProperties(new LinkedHashSet<>());
+    }
+
     @Override
     public synchronized String toString() {
         // Must override for Java 17 to maintain order since the implementation is based on a map
diff --git a/src/main/java/org/apache/commons/collections4/properties/SortedProperties.java b/src/main/java/org/apache/commons/collections4/properties/SortedProperties.java
index fd950e8e1f..7363949329 100644
--- a/src/main/java/org/apache/commons/collections4/properties/SortedProperties.java
+++ b/src/main/java/org/apache/commons/collections4/properties/SortedProperties.java
@@ -18,17 +18,17 @@
 package org.apache.commons.collections4.properties;
 
 import java.util.AbstractMap;
-import java.util.AbstractMap.SimpleEntry;
+import java.util.Collections;
 import java.util.Enumeration;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import org.apache.commons.collections4.iterators.IteratorEnumeration;
-
 /**
  * A drop-in replacement for {@link Properties} for sorting keys.
  * 

@@ -51,16 +51,55 @@ public SortedProperties() {
 
     @Override
     public Set> entrySet() {
-        final Stream> stream = sortedKeys().map(k -> new AbstractMap.SimpleEntry<>(k, getProperty(k)));
-        return stream.collect(Collectors.toCollection(LinkedHashSet::new));
+        return keyStream().map(k -> new AbstractMap.SimpleEntry<>(k, get(k))).collect(Collectors.toCollection(LinkedHashSet::new));
+    }
+
+    /**
+     * Enumerates all key/value pairs in the specified TreeSet and omits the property if the key or value is not a string.
+     *
+     * @param result The result set to populate.
+     * @return The given set.
+     */
+    private synchronized TreeSet enumerateStringProperties(final TreeSet result) {
+        if (defaults != null) {
+            result.addAll(defaults.stringPropertyNames());
+        }
+        for (final Enumeration e = keys(); e.hasMoreElements();) {
+            final Object k = e.nextElement();
+            final Object v = get(k);
+            if (k instanceof String && v instanceof String) {
+                result.add((String) k);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public synchronized void forEach(final BiConsumer action) {
+        keyStream().forEach(k -> action.accept(k, get(k)));
     }
 
     @Override
     public synchronized Enumeration