diff --git a/src/main/java/org/apache/commons/lang3/ArrayUtils.java b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
index c318a8a6b..c7eec43cd 100644
--- a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
+++ b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
@@ -3284,8 +3284,8 @@ public class ArrayUtils {
      * Multi-dimensional primitive arrays are also handled correctly by this method.
      * </p>
      *
-     * @param array1  the left-hand array to compare, may be {@code null}
-     * @param array2  the right-hand array to compare, may be {@code null}
+     * @param array1  the left-hand side array to compare, may be {@code null}
+     * @param array2  the right-hand side array to compare, may be {@code null}
      * @return {@code true} if the arrays are equal
      * @deprecated this method has been replaced by {@code java.util.Objects.deepEquals(Object, Object)} and will be
      * removed from future releases.
diff --git a/src/main/java/org/apache/commons/lang3/Range.java b/src/main/java/org/apache/commons/lang3/Range.java
index 66cb5ddf4..ab0c67a5f 100644
--- a/src/main/java/org/apache/commons/lang3/Range.java
+++ b/src/main/java/org/apache/commons/lang3/Range.java
@@ -40,8 +40,8 @@ public class Range<T> implements Serializable {
         /**
          * Comparable based compare implementation.
          *
-         * @param obj1 left-hand side of comparison
-         * @param obj2 right-hand side of comparison
+         * @param obj1 left-hand side side of comparison
+         * @param obj2 right-hand side side of comparison
          * @return negative, 0, positive comparison value
          */
         @Override
diff --git a/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java b/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
index 2c241c5e1..e8f7020e2 100644
--- a/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
+++ b/src/main/java/org/apache/commons/lang3/builder/CompareToBuilder.java
@@ -100,8 +100,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to {@code builder} the comparison of {@code lhs}
      * to {@code rhs} using the fields defined in {@code clazz}.
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @param clazz  {@link Class} that defines fields to be compared
      * @param builder  {@link CompareToBuilder} to append to
      * @param useTransients  whether to compare transient fields
@@ -147,8 +147,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>If both {@code lhs} and {@code rhs} are {@code null},
      * they are considered equal.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @return a negative integer, zero, or a positive integer as {@code lhs}
      *  is less than, equal to, or greater than {@code rhs}
      * @throws NullPointerException  if either (but not both) parameters are
@@ -178,8 +178,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>If both {@code lhs} and {@code rhs} are {@code null},
      * they are considered equal.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @param compareTransients  whether to compare transient fields
      * @return a negative integer, zero, or a positive integer as {@code lhs}
      *  is less than, equal to, or greater than {@code rhs}
@@ -211,8 +211,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>If both {@code lhs} and {@code rhs} are {@code null},
      * they are considered equal.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @param compareTransients  whether to compare transient fields
      * @param reflectUpToClass  last superclass for which fields are compared
      * @param excludeFields  fields to exclude
@@ -268,8 +268,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>If both {@code lhs} and {@code rhs} are {@code null},
      * they are considered equal.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @param excludeFields  Collection of String fields to exclude
      * @return a negative integer, zero, or a positive integer as {@code lhs}
      *  is less than, equal to, or greater than {@code rhs}
@@ -301,8 +301,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>If both {@code lhs} and {@code rhs} are {@code null},
      * they are considered equal.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @param excludeFields  array of fields to exclude
      * @return a negative integer, zero, or a positive integer as {@code lhs}
      *  is less than, equal to, or greater than {@code rhs}
@@ -336,8 +336,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to the {@code builder} the comparison of
      * two {@code booleans}s.
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
       */
     public CompareToBuilder append(final boolean lhs, final boolean rhs) {
@@ -366,8 +366,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(boolean, boolean)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final boolean[] lhs, final boolean[] rhs) {
@@ -399,8 +399,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to the {@code builder} the comparison of
      * two {@code byte}s.
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final byte lhs, final byte rhs) {
@@ -422,8 +422,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(byte, byte)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final byte[] lhs, final byte[] rhs) {
@@ -455,8 +455,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to the {@code builder} the comparison of
      * two {@code char}s.
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final char lhs, final char rhs) {
@@ -478,8 +478,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(char, char)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final char[] lhs, final char[] rhs) {
@@ -516,8 +516,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>It is compatible with the hash code generated by
      * {@link HashCodeBuilder}.</p>
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final double lhs, final double rhs) {
@@ -539,8 +539,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(double, double)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final double[] lhs, final double[] rhs) {
@@ -577,8 +577,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>It is compatible with the hash code generated by
      * {@link HashCodeBuilder}.</p>
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final float lhs, final float rhs) {
@@ -600,8 +600,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(float, float)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final float[] lhs, final float[] rhs) {
@@ -633,8 +633,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to the {@code builder} the comparison of
      * two {@code int}s.
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final int lhs, final int rhs) {
@@ -656,8 +656,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(int, int)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final int[] lhs, final int[] rhs) {
@@ -689,8 +689,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to the {@code builder} the comparison of
      * two {@code long}s.
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final long lhs, final long rhs) {
@@ -712,8 +712,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(long, long)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final long[] lhs, final long[] rhs) {
@@ -754,8 +754,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *
      * <p>{@code lhs} must either be an array or implement {@link Comparable}.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @return this
      * @throws ClassCastException  if {@code rhs} is not assignment-compatible
      *  with {@code lhs}
@@ -780,8 +780,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * If {@code comparator} is {@code null}, {@code lhs} must
      * implement {@link Comparable} instead.</p>
      *
-     * @param lhs  left-hand object
-     * @param rhs  right-hand object
+     * @param lhs  left-hand side object
+     * @param rhs  right-hand side object
      * @param comparator  {@link Comparator} used to compare the objects,
      *  {@code null} means treat lhs as {@link Comparable}
      * @return this
@@ -834,8 +834,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>This method will also will be called for the top level of multi-dimensional,
      * ragged, and multi-typed arrays.</p>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      * @throws ClassCastException  if {@code rhs} is not assignment-compatible
      *  with {@code lhs}
@@ -858,8 +858,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * <p>This method will also will be called for the top level of multi-dimensional,
      * ragged, and multi-typed arrays.</p>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @param comparator  {@link Comparator} to use to compare the array elements,
      *  {@code null} means to treat {@code lhs} elements as {@link Comparable}.
      * @return this
@@ -896,8 +896,8 @@ public class CompareToBuilder implements Builder<Integer> {
      * Appends to the {@code builder} the comparison of
      * two {@code short}s.
      *
-     * @param lhs  left-hand value
-     * @param rhs  right-hand value
+     * @param lhs  left-hand side value
+     * @param rhs  right-hand side value
      * @return this
      */
     public CompareToBuilder append(final short lhs, final short rhs) {
@@ -919,8 +919,8 @@ public class CompareToBuilder implements Builder<Integer> {
      *  <li>Check array contents element by element using {@link #append(short, short)}</li>
      * </ol>
      *
-     * @param lhs  left-hand array
-     * @param rhs  right-hand array
+     * @param lhs  left-hand side array
+     * @param rhs  right-hand side array
      * @return this
      */
     public CompareToBuilder append(final short[] lhs, final short[] rhs) {
diff --git a/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java b/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
index b0e6c3aa3..678be99d8 100644
--- a/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
+++ b/src/main/java/org/apache/commons/lang3/builder/DiffBuilder.java
@@ -149,9 +149,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code boolean}
+     *            the left-hand side {@code boolean}
      * @param rhs
-     *            the right-hand {@code boolean}
+     *            the right-hand side {@code boolean}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -186,9 +186,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code boolean[]}
+     *            the left-hand side {@code boolean[]}
      * @param rhs
-     *            the right-hand {@code boolean[]}
+     *            the right-hand side {@code boolean[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -222,9 +222,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code byte}
+     *            the left-hand side {@code byte}
      * @param rhs
-     *            the right-hand {@code byte}
+     *            the right-hand side {@code byte}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -258,9 +258,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code byte[]}
+     *            the left-hand side {@code byte[]}
      * @param rhs
-     *            the right-hand {@code byte[]}
+     *            the right-hand side {@code byte[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -295,9 +295,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code char}
+     *            the left-hand side {@code char}
      * @param rhs
-     *            the right-hand {@code char}
+     *            the right-hand side {@code char}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -332,9 +332,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code char[]}
+     *            the left-hand side {@code char[]}
      * @param rhs
-     *            the right-hand {@code char[]}
+     *            the right-hand side {@code char[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -412,9 +412,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code double}
+     *            the left-hand side {@code double}
      * @param rhs
-     *            the right-hand {@code double}
+     *            the right-hand side {@code double}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -449,9 +449,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code double[]}
+     *            the left-hand side {@code double[]}
      * @param rhs
-     *            the right-hand {@code double[]}
+     *            the right-hand side {@code double[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -486,9 +486,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code float}
+     *            the left-hand side {@code float}
      * @param rhs
-     *            the right-hand {@code float}
+     *            the right-hand side {@code float}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -524,9 +524,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code float[]}
+     *            the left-hand side {@code float[]}
      * @param rhs
-     *            the right-hand {@code float[]}
+     *            the right-hand side {@code float[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -561,9 +561,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code int}
+     *            the left-hand side {@code int}
      * @param rhs
-     *            the right-hand {@code int}
+     *            the right-hand side {@code int}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -598,9 +598,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code int[]}
+     *            the left-hand side {@code int[]}
      * @param rhs
-     *            the right-hand {@code int[]}
+     *            the right-hand side {@code int[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -635,9 +635,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code long}
+     *            the left-hand side {@code long}
      * @param rhs
-     *            the right-hand {@code long}
+     *            the right-hand side {@code long}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -672,9 +672,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code long[]}
+     *            the left-hand side {@code long[]}
      * @param rhs
-     *            the right-hand {@code long[]}
+     *            the right-hand side {@code long[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -709,9 +709,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@link Object}
+     *            the left-hand side {@link Object}
      * @param rhs
-     *            the right-hand {@link Object}
+     *            the right-hand side {@link Object}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -790,9 +790,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code Object[]}
+     *            the left-hand side {@code Object[]}
      * @param rhs
-     *            the right-hand {@code Object[]}
+     *            the right-hand side {@code Object[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -828,9 +828,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code short}
+     *            the left-hand side {@code short}
      * @param rhs
-     *            the right-hand {@code short}
+     *            the right-hand side {@code short}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
@@ -865,9 +865,9 @@ public class DiffBuilder<T> implements Builder<DiffResult<T>> {
      * @param fieldName
      *            the field name
      * @param lhs
-     *            the left-hand {@code short[]}
+     *            the left-hand side {@code short[]}
      * @param rhs
-     *            the right-hand {@code short[]}
+     *            the right-hand side {@code short[]}
      * @return this
      * @throws NullPointerException
      *             if field name is {@code null}
diff --git a/src/main/java/org/apache/commons/lang3/builder/DiffResult.java b/src/main/java/org/apache/commons/lang3/builder/DiffResult.java
index 28c30a6f2..3cd2699ca 100644
--- a/src/main/java/org/apache/commons/lang3/builder/DiffResult.java
+++ b/src/main/java/org/apache/commons/lang3/builder/DiffResult.java
@@ -55,9 +55,9 @@ public class DiffResult<T> implements Iterable<Diff<?>> {
      * objects.
      *
      * @param lhs
-     *            the left-hand object
+     *            the left-hand side object
      * @param rhs
-     *            the right-hand object
+     *            the right-hand side object
      * @param diffList
      *            the list of differences, may be empty
      * @param style
diff --git a/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java b/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
index 2291de491..ff5276b04 100644
--- a/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
+++ b/src/main/java/org/apache/commons/lang3/builder/EqualsBuilder.java
@@ -387,8 +387,8 @@ public class EqualsBuilder implements Builder<Boolean> {
     /**
      * Test if two {@code booleans}s are equal.
      *
-     * @param lhs  the left-hand {@code boolean}
-     * @param rhs  the right-hand {@code boolean}
+     * @param lhs  the left-hand side {@code boolean}
+     * @param rhs  the right-hand side {@code boolean}
      * @return this
       */
     public EqualsBuilder append(final boolean lhs, final boolean rhs) {
@@ -405,8 +405,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(boolean, boolean)} is used.</p>
      *
-     * @param lhs  the left-hand {@code boolean[]}
-     * @param rhs  the right-hand {@code boolean[]}
+     * @param lhs  the left-hand side {@code boolean[]}
+     * @param rhs  the right-hand side {@code boolean[]}
      * @return this
      */
     public EqualsBuilder append(final boolean[] lhs, final boolean[] rhs) {
@@ -433,8 +433,8 @@ public class EqualsBuilder implements Builder<Boolean> {
     /**
      * Test if two {@code byte}s are equal.
      *
-     * @param lhs  the left-hand {@code byte}
-     * @param rhs  the right-hand {@code byte}
+     * @param lhs  the left-hand side {@code byte}
+     * @param rhs  the right-hand side {@code byte}
      * @return this
      */
     public EqualsBuilder append(final byte lhs, final byte rhs) {
@@ -451,8 +451,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(byte, byte)} is used.</p>
      *
-     * @param lhs  the left-hand {@code byte[]}
-     * @param rhs  the right-hand {@code byte[]}
+     * @param lhs  the left-hand side {@code byte[]}
+     * @param rhs  the right-hand side {@code byte[]}
      * @return this
      */
     public EqualsBuilder append(final byte[] lhs, final byte[] rhs) {
@@ -479,8 +479,8 @@ public class EqualsBuilder implements Builder<Boolean> {
     /**
      * Test if two {@code char}s are equal.
      *
-     * @param lhs  the left-hand {@code char}
-     * @param rhs  the right-hand {@code char}
+     * @param lhs  the left-hand side {@code char}
+     * @param rhs  the right-hand side {@code char}
      * @return this
      */
     public EqualsBuilder append(final char lhs, final char rhs) {
@@ -497,8 +497,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(char, char)} is used.</p>
      *
-     * @param lhs  the left-hand {@code char[]}
-     * @param rhs  the right-hand {@code char[]}
+     * @param lhs  the left-hand side {@code char[]}
+     * @param rhs  the right-hand side {@code char[]}
      * @return this
      */
     public EqualsBuilder append(final char[] lhs, final char[] rhs) {
@@ -531,8 +531,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      * <p>It is compatible with the hash code generated by
      * {@link HashCodeBuilder}.</p>
      *
-     * @param lhs  the left-hand {@code double}
-     * @param rhs  the right-hand {@code double}
+     * @param lhs  the left-hand side {@code double}
+     * @param rhs  the right-hand side {@code double}
      * @return this
      */
     public EqualsBuilder append(final double lhs, final double rhs) {
@@ -548,8 +548,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(double, double)} is used.</p>
      *
-     * @param lhs  the left-hand {@code double[]}
-     * @param rhs  the right-hand {@code double[]}
+     * @param lhs  the left-hand side {@code double[]}
+     * @param rhs  the right-hand side {@code double[]}
      * @return this
      */
     public EqualsBuilder append(final double[] lhs, final double[] rhs) {
@@ -582,8 +582,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      * <p>It is compatible with the hash code generated by
      * {@link HashCodeBuilder}.</p>
      *
-     * @param lhs  the left-hand {@code float}
-     * @param rhs  the right-hand {@code float}
+     * @param lhs  the left-hand side {@code float}
+     * @param rhs  the right-hand side {@code float}
      * @return this
      */
     public EqualsBuilder append(final float lhs, final float rhs) {
@@ -599,8 +599,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(float, float)} is used.</p>
      *
-     * @param lhs  the left-hand {@code float[]}
-     * @param rhs  the right-hand {@code float[]}
+     * @param lhs  the left-hand side {@code float[]}
+     * @param rhs  the right-hand side {@code float[]}
      * @return this
      */
     public EqualsBuilder append(final float[] lhs, final float[] rhs) {
@@ -627,8 +627,8 @@ public class EqualsBuilder implements Builder<Boolean> {
     /**
      * Test if two {@code int}s are equal.
      *
-     * @param lhs  the left-hand {@code int}
-     * @param rhs  the right-hand {@code int}
+     * @param lhs  the left-hand side {@code int}
+     * @param rhs  the right-hand side {@code int}
      * @return this
      */
     public EqualsBuilder append(final int lhs, final int rhs) {
@@ -645,8 +645,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(int, int)} is used.</p>
      *
-     * @param lhs  the left-hand {@code int[]}
-     * @param rhs  the right-hand {@code int[]}
+     * @param lhs  the left-hand side {@code int[]}
+     * @param rhs  the right-hand side {@code int[]}
      * @return this
      */
     public EqualsBuilder append(final int[] lhs, final int[] rhs) {
@@ -674,9 +674,9 @@ public class EqualsBuilder implements Builder<Boolean> {
      * Test if two {@code long} s are equal.
      *
      * @param lhs
-     *                  the left-hand {@code long}
+     *                  the left-hand side {@code long}
      * @param rhs
-     *                  the right-hand {@code long}
+     *                  the right-hand side {@code long}
      * @return this
      */
     public EqualsBuilder append(final long lhs, final long rhs) {
@@ -693,8 +693,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(long, long)} is used.</p>
      *
-     * @param lhs  the left-hand {@code long[]}
-     * @param rhs  the right-hand {@code long[]}
+     * @param lhs  the left-hand side {@code long[]}
+     * @param rhs  the right-hand side {@code long[]}
      * @return this
      */
     public EqualsBuilder append(final long[] lhs, final long[] rhs) {
@@ -725,8 +725,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      * is set to {@code false}. Otherwise, using their
      * {@code equals} method.
      *
-     * @param lhs  the left-hand object
-     * @param rhs  the right-hand object
+     * @param lhs  the left-hand side object
+     * @param rhs  the right-hand side object
      * @return this
      */
     public EqualsBuilder append(final Object lhs, final Object rhs) {
@@ -763,8 +763,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      * <p>Note that this method does not compare the type of the arrays; it only
      * compares the contents.</p>
      *
-     * @param lhs  the left-hand {@code Object[]}
-     * @param rhs  the right-hand {@code Object[]}
+     * @param lhs  the left-hand side {@code Object[]}
+     * @param rhs  the right-hand side {@code Object[]}
      * @return this
      */
     public EqualsBuilder append(final Object[] lhs, final Object[] rhs) {
@@ -791,8 +791,8 @@ public class EqualsBuilder implements Builder<Boolean> {
     /**
      * Test if two {@code short}s are equal.
      *
-     * @param lhs  the left-hand {@code short}
-     * @param rhs  the right-hand {@code short}
+     * @param lhs  the left-hand side {@code short}
+     * @param rhs  the right-hand side {@code short}
      * @return this
      */
     public EqualsBuilder append(final short lhs, final short rhs) {
@@ -809,8 +809,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>The method {@link #append(short, short)} is used.</p>
      *
-     * @param lhs  the left-hand {@code short[]}
-     * @param rhs  the right-hand {@code short[]}
+     * @param lhs  the left-hand side {@code short[]}
+     * @param rhs  the right-hand side {@code short[]}
      * @return this
      */
     public EqualsBuilder append(final short[] lhs, final short[] rhs) {
@@ -837,8 +837,8 @@ public class EqualsBuilder implements Builder<Boolean> {
     /**
      * Test if an {@link Object} is equal to an array.
      *
-     * @param lhs  the left-hand object, an array
-     * @param rhs  the right-hand object
+     * @param lhs  the left-hand side object, an array
+     * @param rhs  the right-hand side object
      */
     private void appendArray(final Object lhs, final Object rhs) {
         // First we compare different dimensions, for example: a boolean[][] to a boolean[]
@@ -928,10 +928,10 @@ public class EqualsBuilder implements Builder<Boolean> {
      *
      * <p>If either class of the compared objects is contained in
      * {@code bypassReflectionClasses}, both objects are compared by calling
-     * the equals method of the left-hand object with the right-hand object as an argument.</p>
+     * the equals method of the left-hand side object with the right-hand side object as an argument.</p>
      *
-     * @param lhs  the left-hand object
-     * @param rhs  the right-hand object
+     * @param lhs  the left-hand side object
+     * @param rhs  the right-hand side object
      * @return this
      */
     public EqualsBuilder reflectionAppend(final Object lhs, final Object rhs) {
@@ -1000,8 +1000,8 @@ public class EqualsBuilder implements Builder<Boolean> {
      * Appends the fields and values defined by the given object of the
      * given Class.
      *
-     * @param lhs  the left-hand object
-     * @param rhs  the right-hand object
+     * @param lhs  the left-hand side object
+     * @param rhs  the right-hand side object
      * @param clazz  the class to append details of
      */
     private void reflectionAppend(
diff --git a/src/main/java/org/apache/commons/lang3/text/StrBuilder.java b/src/main/java/org/apache/commons/lang3/text/StrBuilder.java
index 1a7f2da52..6cef484a8 100644
--- a/src/main/java/org/apache/commons/lang3/text/StrBuilder.java
+++ b/src/main/java/org/apache/commons/lang3/text/StrBuilder.java
@@ -829,7 +829,7 @@ public class StrBuilder implements CharSequence, Appendable, Serializable, Build
     /**
      * Appends an object to the builder padding on the left to a fixed width.
      * The {@code String.valueOf} of the {@code int} value is used.
-     * If the formatted value is larger than the length, the left-hand side is lost.
+     * If the formatted value is larger than the length, the left-hand side side is lost.
      *
      * @param value  the value to append
      * @param width  the fixed field width, zero or negative has no effect
@@ -843,7 +843,7 @@ public class StrBuilder implements CharSequence, Appendable, Serializable, Build
     /**
      * Appends an object to the builder padding on the left to a fixed width.
      * The {@code toString} of the object is used.
-     * If the object is larger than the length, the left-hand side is lost.
+     * If the object is larger than the length, the left-hand side side is lost.
      * If the object is null, the null text value is used.
      *
      * @param obj  the object to append, null uses null text
@@ -876,7 +876,7 @@ public class StrBuilder implements CharSequence, Appendable, Serializable, Build
     /**
      * Appends an object to the builder padding on the right to a fixed length.
      * The {@code String.valueOf} of the {@code int} value is used.
-     * If the object is larger than the length, the right-hand side is lost.
+     * If the object is larger than the length, the right-hand side side is lost.
      *
      * @param value  the value to append
      * @param width  the fixed field width, zero or negative has no effect
@@ -890,7 +890,7 @@ public class StrBuilder implements CharSequence, Appendable, Serializable, Build
     /**
      * Appends an object to the builder padding on the right to a fixed length.
      * The {@code toString} of the object is used.
-     * If the object is larger than the length, the right-hand side is lost.
+     * If the object is larger than the length, the right-hand side side is lost.
      * If the object is null, null text value is used.
      *
      * @param obj  the object to append, null uses null text
diff --git a/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java b/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java
index b1b8b60a6..e77c4bb93 100644
--- a/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java
+++ b/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java
@@ -337,14 +337,14 @@ public class DurationFormatUtils {
 
     /**
      * Formats the time gap as a string, using the specified format.
-     * Padding the left-hand side of numbers with zeroes is optional.
+     * Padding the left-hand side side of numbers with zeroes is optional.
      *
      * <p>This method formats durations using the days and lower fields of the
      * format pattern. Months and larger are not used.</p>
      *
      * @param durationMillis  the duration to format
      * @param format  the way in which to format the duration, not null
-     * @param padWithZeros  whether to pad the left-hand side of numbers with 0's
+     * @param padWithZeros  whether to pad the left-hand side side of numbers with 0's
      * @return the formatted duration, not null
      * @throws IllegalArgumentException if durationMillis is negative
      */
@@ -469,7 +469,7 @@ public class DurationFormatUtils {
     }
     /**
      * Formats the time gap as a string, using the specified format.
-     * Padding the left-hand side of numbers with zeroes is optional.
+     * Padding the left-hand side side of numbers with zeroes is optional.
      *
      * @param startMillis  the start of the duration
      * @param endMillis  the end of the duration
@@ -482,7 +482,7 @@ public class DurationFormatUtils {
     }
     /**
      * <p>Formats the time gap as a string, using the specified format.
-     * Padding the left-hand side of numbers with zeroes is optional and
+     * Padding the left-hand side side of numbers with zeroes is optional and
      * the time zone may be specified.
      *
      * <p>When calculating the difference between months/days, it chooses to
@@ -499,7 +499,7 @@ public class DurationFormatUtils {
      * @param startMillis  the start of the duration
      * @param endMillis  the end of the duration
      * @param format  the way in which to format the duration, not null
-     * @param padWithZeros  whether to pad the left-hand side of numbers with 0's
+     * @param padWithZeros  whether to pad the left-hand side side of numbers with 0's
      * @param timezone  the millis are defined in
      * @return the formatted duration, not null
      * @throws IllegalArgumentException if startMillis is greater than endMillis
diff --git a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
index 4f2b21450..7614377de 100644
--- a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
@@ -1168,7 +1168,7 @@ public class EqualsBuilderTest extends AbstractLangTest {
      *
      * @param to             a TestObject
      * @param toBis          a TestObject, equal to to and toTer
-     * @param toTer          left-hand side, equal to to and toBis
+     * @param toTer          left-hand side side, equal to to and toBis
      * @param to2            a different TestObject
      * @param oToChange      a TestObject that will be changed
      * @param testTransients whether to test transient instance variables