Test: Move out Range from the visitor params

java/algorithm/src/main/java/org/apache/arrow/algorithm/deduplicate/DeduplicationUtils.java

@@ -22,7 +22,7 @@
 import org.apache.arrow.vector.BitVectorHelper;
 import org.apache.arrow.vector.IntVector;
 import org.apache.arrow.vector.ValueVector;
-import org.apache.arrow.vector.compare.RangeEqualsParameter;
+import org.apache.arrow.vector.compare.Range;
 import org.apache.arrow.vector.compare.RangeEqualsVisitor;
 
 import io.netty.buffer.ArrowBuf;
@@ -44,15 +44,11 @@ public static <V extends ValueVector> void populateRunStartIndicators(V vector,
     runStarts.setZero(0, bufSize);
 
     BitVectorHelper.setValidityBitToOne(runStarts, 0);
-    RangeEqualsVisitor visitor = new RangeEqualsVisitor();
-    RangeEqualsParameter param = new RangeEqualsParameter()
-            .setRight(vector)
-            .setLeft(vector)
-            .setLength(1)
-            .setTypeCheckNeeded(false);
+    RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector, vector, false);
+    Range range = new Range(0, 0, 1);
     for (int i = 1; i < vector.getValueCount(); i++) {
-      param.setLeftStart(i).setRightStart(i - 1);
-      if (!visitor.rangeEquals(param)) {
+      range.setLeftStart(i).setRightStart(i - 1);
+      if (!visitor.rangeEquals(range)) {
         BitVectorHelper.setValidityBitToOne(runStarts, i);
       }
     }

java/vector/src/main/java/org/apache/arrow/vector/compare/ApproxEqualsVisitor.java

@@ -20,6 +20,7 @@
 import org.apache.arrow.vector.BaseFixedWidthVector;
 import org.apache.arrow.vector.Float4Vector;
 import org.apache.arrow.vector.Float8Vector;
+import org.apache.arrow.vector.ValueVector;
 
 /**
  * Visitor to compare floating point.
@@ -40,7 +41,16 @@ public class ApproxEqualsVisitor extends RangeEqualsVisitor {
   private DiffFunction<Double> doubleDiffFunction =
       (Double value1, Double value2) -> Math.abs(value1 - value2);
 
-  public ApproxEqualsVisitor(float floatEpsilon, double doubleEpsilon) {
+  /**
+   * Constructs a new instance.
+   *
+   * @param left left vector
+   * @param right right vector
+   * @param floatEpsilon difference for float values
+   * @param doubleEpsilon difference for double values
+   */
+  public ApproxEqualsVisitor(ValueVector left, ValueVector right, float floatEpsilon, double doubleEpsilon) {
+    super(left, right, true);
     this.floatEpsilon = floatEpsilon;
     this.doubleEpsilon = doubleEpsilon;
   }
@@ -54,29 +64,28 @@ public void setDoubleDiffFunction(DiffFunction<Double> doubleDiffFunction) {
   }
 
   @Override
-  public Boolean visit(BaseFixedWidthVector left, RangeEqualsParameter parameter) {
-    parameter.setLeft(left);
+  public Boolean visit(BaseFixedWidthVector left, Range range) {
     if (left instanceof Float4Vector) {
-      return parameter.validate() && float4ApproxEquals(parameter);
+      return float4ApproxEquals(range);
     } else if (left instanceof Float8Vector) {
-      return parameter.validate() && float8ApproxEquals(parameter);
+      return float8ApproxEquals(range);
     } else {
-      return super.visit(left, parameter);
+      return super.visit(left, range);
     }
   }
 
   @Override
-  protected ApproxEqualsVisitor createInnerVisitor() {
-    return new ApproxEqualsVisitor(floatEpsilon, doubleEpsilon);
+  protected ApproxEqualsVisitor createInnerVisitor(ValueVector left, ValueVector right) {
+    return new ApproxEqualsVisitor(left, right, floatEpsilon, doubleEpsilon);
   }
 
-  private boolean float4ApproxEquals(RangeEqualsParameter parameter) {
-    Float4Vector leftVector  = (Float4Vector) parameter.getLeft();
-    Float4Vector rightVector  = (Float4Vector) parameter.getRight();
+  private boolean float4ApproxEquals(Range range) {
+    Float4Vector leftVector  = (Float4Vector) getLeft();
+    Float4Vector rightVector  = (Float4Vector) getRight();
 
-    for (int i = 0; i < parameter.getLength(); i++) {
-      int leftIndex = parameter.getLeftStart() + i;
-      int rightIndex = parameter.getRightStart() + i;
+    for (int i = 0; i < range.getLength(); i++) {
+      int leftIndex = range.getLeftStart() + i;
+      int rightIndex = range.getRightStart() + i;
 
       boolean isNull = leftVector.isNull(leftIndex);
 
@@ -101,13 +110,13 @@ private boolean float4ApproxEquals(RangeEqualsParameter parameter) {
     return true;
   }
 
-  private boolean float8ApproxEquals(RangeEqualsParameter parameter) {
-    Float8Vector leftVector  = (Float8Vector) parameter.getLeft();
-    Float8Vector rightVector  = (Float8Vector) parameter.getRight();
+  private boolean float8ApproxEquals(Range range) {
+    Float8Vector leftVector  = (Float8Vector) getLeft();
+    Float8Vector rightVector  = (Float8Vector) getRight();
 
-    for (int i = 0; i < parameter.getLength(); i++) {
-      int leftIndex = parameter.getLeftStart() + i;
-      int rightIndex = parameter.getRightStart() + i;
+    for (int i = 0; i < range.getLength(); i++) {
+      int leftIndex = range.getLeftStart() + i;
+      int rightIndex = range.getRightStart() + i;
 
       boolean isNull = leftVector.isNull(leftIndex);
 

java/vector/src/main/java/org/apache/arrow/vector/compare/Range.java

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.arrow.vector.compare;
+
+/**
+ * Wrapper for the parameters of comparing a range of values in two vectors.
+ */
+public class Range {
+
+  /**
+   * Start position in the left vector.
+   */
+  private int leftStart = -1;
+
+  /**
+   * Start position in the right vector.
+   */
+  private int rightStart = -1;
+
+  /**
+   * Length of the range.
+   */
+  private int length = -1;
+
+
+  /**
+   * Constructs a new instance.
+   */
+  public Range() {}
+
+  /**
+   * Constructs a new instance.
+   *
+   * @param leftStart start index in left vector
+   * @param rightStart start index in right vector
+   * @param length length of range
+   */
+  public Range(int leftStart, int rightStart, int length) {
+    this.leftStart = leftStart;
+    this.rightStart = rightStart;
+    this.length = length;
+  }
+
+  public int getLeftStart() {
+    return leftStart;
+  }
+
+  public int getRightStart() {
+    return rightStart;
+  }
+
+  public int getLength() {
+    return length;
+  }
+
+  public Range setLeftStart(int leftStart) {
+    this.leftStart = leftStart;
+    return this;
+  }
+
+  public Range setRightStart(int rightStart) {
+    this.rightStart = rightStart;
+    return this;
+  }
+
+  public Range setLength(int length) {
+    this.length = length;
+    return this;
+  }
+}