Change remove to its previous implementation, use JDK's copyOf for removeFrom

Author: mr-bat

src/main/java/btree4j/BTree.java

@@ -39,21 +39,15 @@
 import btree4j.utils.io.FastMultiByteArrayOutputStream;
 import btree4j.utils.lang.ArrayUtils;
 import btree4j.utils.lang.Primitives;
-
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-
-import javax.annotation.CheckForNull;
-
 import com.google.common.annotations.Beta;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
+import javax.annotation.CheckForNull;
+import java.io.*;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
 /**
  * BTree represents a Variable Magnitude Simple-Prefix B+Tree File.
  */
@@ -669,20 +663,20 @@ void removeFrom(Value searchKey) throws BTreeException {
                     getChildNode(leftIdx).removeFrom(searchKey);
 
                     if (leftIdx < keys.length && leftIdx + 1 < ptrs.length)
-                        set(ArrayUtils.removeFrom(keys, leftIdx), ArrayUtils.removeFrom(ptrs, leftIdx + 1));
+                        set(ArrayUtils.copyOf(keys, leftIdx), ArrayUtils.copyOf(ptrs, leftIdx + 1));
                     break;
                 case LEAF:
                     leftIdx = (leftIdx < 0) ? -(leftIdx + 1) : leftIdx;
                     if (leftIdx < keys.length && leftIdx < ptrs.length)
-                        set(ArrayUtils.removeFrom(keys, leftIdx), ArrayUtils.removeFrom(ptrs, leftIdx));
+                        set(ArrayUtils.copyOf(keys, leftIdx), ArrayUtils.copyOf(ptrs, leftIdx));
                     this._next = -1;
                     break;
                 default:
                     throw new BTreeCorruptException(
                             "Invalid page type '" + ph.getStatus() + "' in removeValue");
             }
 
-            if (getParent() == null)
+            if (getParent() == null) 
                 while (_rootNode.ptrs.length == 1) {
                     _rootNode = _rootNode.getChildNode(0);
                 }

src/main/java/btree4j/utils/lang/ArrayUtils.java

@@ -301,29 +301,21 @@ public static int[] append(final int[] left, final int[] right) {
      * @throws IndexOutOfBoundsException if the index is out of range (index < 0 || index >=
      *         array.length), or if the array is <code>null</code>.
      * @since 2.1
-     * @implNote Its dependance on removeFrom may slow down the function.
      */
     @SuppressWarnings("unchecked")
     public static <T> T[] remove(final T[] array, final int index) {
-        int length = getLength(array);
-        Object result = Arrays.copyOf(removeFrom(array, index), length - 1);
-        if (index < length - 1) {
-            System.arraycopy(array, index + 1, result, index, length - index - 1);
-        }
-        return (T[]) result;
-    }
-
-    public static <T> T[] removeFrom(final T[] array, final int index) {
         int length = getLength(array);
         if (index < 0 || index >= length) {
             throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
         }
-        Object result = Array.newInstance(array.getClass().getComponentType(), index);
+        Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
         System.arraycopy(array, 0, result, 0, index);
+        if (index < length - 1) {
+            System.arraycopy(array, index + 1, result, index, length - index - 1);
+        }
         return (T[]) result;
     }
 
-
     @SuppressWarnings("unchecked")
     public static <T> T[] remove(final T[] array, final int from, final int to) {
         assert (to >= from) : to + " - " + from;
@@ -341,22 +333,14 @@ public static <T> T[] remove(final T[] array, final int from, final int to) {
         return (T[]) result;
     }
 
-    /**
-     * @implNote Its dependance on removeFrom may slow down the function.
-     */
     public static long[] remove(final long[] vals, final int idx) {
-        long[] newVals = Arrays.copyOf(removeFrom(vals, idx), vals.length - 1);
-        if (idx < newVals.length) {
-            System.arraycopy(vals, idx + 1, newVals, idx, newVals.length - idx);
-        }
-        return newVals;
-    }
-
-    public static long[] removeFrom(final long[] vals, final int idx) {
-        long[] newVals = new long[idx];
+        long[] newVals = new long[vals.length - 1];
         if (idx > 0) {
             System.arraycopy(vals, 0, newVals, 0, idx);
         }
+        if (idx < newVals.length) {
+            System.arraycopy(vals, idx + 1, newVals, idx, newVals.length - idx);
+        }
         return newVals;
     }
 
@@ -482,6 +466,11 @@ public static int[] copyOf(final int[] original, final int newLength) {
         return copy;
     }
 
+    public static long[] copyOf(final long[] vals, final int idx) {
+        return Arrays.copyOf(vals, idx);
+
+    }
+
     public static char[] copyOf(final char[] original, final int newLength) {
         final char[] copy = new char[newLength];
         System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));

src/test/java/btree4j/ArrayUtilsTest.java

@@ -4,8 +4,6 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-import java.util.ArrayList;
-
 public class ArrayUtilsTest {
     // --------------- remove
     @Test
@@ -50,46 +48,46 @@ public void shouldRemoveMiddleValuePrimitive() {
         Assert.assertArrayEquals(new long[]{1, 3}, a);
     }
 
-    // --------------- removeFrom
+    // --------------- copyOf
     @Test
     public void shouldRemoveFromFirstValue() {
         Integer[] a = {1, 2, 3};
-        a = ArrayUtils.removeFrom(a, 0);
+        a = ArrayUtils.copyOf(a, 0);
         Assert.assertArrayEquals(new Integer[]{}, a);
     }
 
     @Test
     public void shouldRemoveFromLastValue() {
         Integer[] a = {1, 2, 3};
-        a = ArrayUtils.removeFrom(a, 2);
+        a = ArrayUtils.copyOf(a, 2);
         Assert.assertArrayEquals(new Integer[]{1, 2}, a);
     }
 
     @Test
     public void shouldRemoveFromMiddleValue() {
         Integer[] a = {1, 2, 3};
-        a = ArrayUtils.removeFrom(a, 1);
+        a = ArrayUtils.copyOf(a, 1);
         Assert.assertArrayEquals(new Integer[]{1}, a);
     }
 
     @Test
     public void shouldRemoveFromFirstValuePrimitive() {
         long[] a = {1, 2, 3};
-        a = ArrayUtils.removeFrom(a, 0);
+        a = ArrayUtils.copyOf(a, 0);
         Assert.assertArrayEquals(new long[]{}, a);
     }
 
     @Test
     public void shouldRemoveFromLastValuePrimitive() {
         long[] a = {1, 2, 3};
-        a = ArrayUtils.removeFrom(a, 2);
+        a = ArrayUtils.copyOf(a, 2);
         Assert.assertArrayEquals(new long[]{1, 2}, a);
     }
 
     @Test
     public void shouldRemoveFromMiddleValuePrimitive() {
         long[] a = {1, 2, 3};
-        a = ArrayUtils.removeFrom(a, 1);
+        a = ArrayUtils.copyOf(a, 1);
         Assert.assertArrayEquals(new long[]{1}, a);
     }
 }