You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2023/12/11 14:33:28 UTC
(commons-lang) 02/02: Javadoc
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 29c94abc083e7de44c1fdb83679ed32181d9884e
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Mon Dec 11 09:33:21 2023 -0500
Javadoc
- "left-hand" -> "left-hand side"
- "right-hand" -> "right-hand side"
---
.../java/org/apache/commons/lang3/ArrayUtils.java | 4 +-
src/main/java/org/apache/commons/lang3/Range.java | 4 +-
.../commons/lang3/builder/CompareToBuilder.java | 104 ++++++++++-----------
.../apache/commons/lang3/builder/DiffBuilder.java | 72 +++++++-------
.../apache/commons/lang3/builder/DiffResult.java | 4 +-
.../commons/lang3/builder/EqualsBuilder.java | 86 ++++++++---------
.../org/apache/commons/lang3/text/StrBuilder.java | 8 +-
.../commons/lang3/time/DurationFormatUtils.java | 10 +-
.../commons/lang3/builder/EqualsBuilderTest.java | 2 +-
9 files changed, 147 insertions(+), 147 deletions(-)
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