Use ArrayUtil#copyOfSubArray to simplify manual array copy patterns (#15826)

easyice · easyice · commit 8f78d79dd6d8 · 2026-03-16T15:43:11.000+08:00
* Use ArrayUtil#copyOfSubArray to simplify manual array copy patterns
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
@@ -85,6 +85,8 @@ Other
 
 * GITHUB#15799: Exclude JNA Cleaner from thread leak detection by LuceneTestCase. (Alan Woodward)
 
+* GITHUB#15826: Use ArrayUtil#copyOfSubArray to simplify manual array copy patterns. (Zhang Chao)
+
 ======================= Lucene 10.4.0 =======================
 
 API Changes
diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java b/lucene/codecs/src/java/org/apache/lucene/codecs/blocktreeords/OrdsBlockTreeTermsWriter.java
@@ -263,8 +263,7 @@ private static final class PendingTerm extends PendingEntry {
 
     public PendingTerm(BytesRef term, BlockTermState state) {
       super(true);
-      this.termBytes = new byte[term.length];
-      System.arraycopy(term.bytes, term.offset, termBytes, 0, term.length);
+      this.termBytes = ArrayUtil.copyOfSubArray(term.bytes, term.offset, term.offset + term.length);
       this.state = state;
     }
 
diff --git a/lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java b/lucene/codecs/src/java/org/apache/lucene/codecs/memory/DirectPostingsFormat.java
@@ -277,8 +277,7 @@ public void add(int value) {
       }
 
       public int[] get() {
-        final int[] arr = new int[upto];
-        System.arraycopy(ints, 0, arr, 0, upto);
+        final int[] arr = ArrayUtil.copyOfSubArray(ints, 0, upto);
         upto = 0;
         return arr;
       }
@@ -444,10 +443,9 @@ public DirectField(
                   if (hasPayloads) {
                     BytesRef payload = docsAndPositionsEnum.getPayload();
                     if (payload != null) {
-                      byte[] payloadBytes = new byte[payload.length];
-                      System.arraycopy(
-                          payload.bytes, payload.offset, payloadBytes, 0, payload.length);
-                      payloads[upto][pos] = payloadBytes;
+                      payloads[upto][pos] =
+                          ArrayUtil.copyOfSubArray(
+                              payload.bytes, payload.offset, payload.offset + payload.length);
                     }
                   }
                   posUpto++;
@@ -477,8 +475,7 @@ public DirectField(
 
       // System.out.println(skipCount + " skips: " + field);
 
-      this.termBytes = new byte[termOffset];
-      System.arraycopy(termBytes, 0, this.termBytes, 0, termOffset);
+      this.termBytes = ArrayUtil.copyOfSubArray(termBytes, 0, termOffset);
 
       // Pack skips:
       this.skips = new int[skipCount];
diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene103/blocktree/Lucene103BlockTreeTermsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene103/blocktree/Lucene103BlockTreeTermsWriter.java
@@ -414,8 +414,7 @@ private static final class PendingTerm extends PendingEntry {
 
     public PendingTerm(BytesRef term, BlockTermState state) {
       super(true);
-      this.termBytes = new byte[term.length];
-      System.arraycopy(term.bytes, term.offset, termBytes, 0, term.length);
+      this.termBytes = ArrayUtil.copyOfSubArray(term.bytes, term.offset, term.offset + term.length);
       this.state = state;
     }
 
diff --git a/lucene/core/src/java/org/apache/lucene/document/InetAddressRange.java b/lucene/core/src/java/org/apache/lucene/document/InetAddressRange.java
@@ -20,6 +20,7 @@
 import java.util.Arrays;
 import org.apache.lucene.document.RangeFieldQuery.QueryType;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.util.ArrayUtil;
 import org.apache.lucene.util.BytesRef;
 
 /**
@@ -182,10 +183,8 @@ protected String toString(byte[] ranges, int dimension) {
    * @return The string representation for the range at the provided dimension
    */
   private static String toString(byte[] ranges, int dimension) {
-    byte[] min = new byte[BYTES];
-    System.arraycopy(ranges, 0, min, 0, BYTES);
-    byte[] max = new byte[BYTES];
-    System.arraycopy(ranges, BYTES, max, 0, BYTES);
+    byte[] min = ArrayUtil.copyOfSubArray(ranges, 0, BYTES);
+    byte[] max = ArrayUtil.copyOfSubArray(ranges, BYTES, BYTES + BYTES);
     return "[" + InetAddressPoint.decode(min) + " : " + InetAddressPoint.decode(max) + "]";
   }
 }
diff --git a/lucene/core/src/java/org/apache/lucene/index/IndexingChain.java b/lucene/core/src/java/org/apache/lucene/index/IndexingChain.java
@@ -1299,9 +1299,9 @@ private void invertTokenStream(int docID, IndexableField field, boolean first)
           try {
             termsHashPerField.add(invertState.termAttribute.getBytesRef(), docID);
           } catch (MaxBytesLengthExceededException e) {
-            byte[] prefix = new byte[30];
             BytesRef bigTerm = invertState.termAttribute.getBytesRef();
-            System.arraycopy(bigTerm.bytes, bigTerm.offset, prefix, 0, 30);
+            byte[] prefix =
+                ArrayUtil.copyOfSubArray(bigTerm.bytes, bigTerm.offset, bigTerm.offset + 30);
             String msg =
                 "Document contains at least one immense term in field=\""
                     + fieldInfo.name
@@ -1372,8 +1372,9 @@ private void invertTerm(int docID, IndexableField field, boolean first) throws I
       try {
         termsHashPerField.add(binaryValue, docID);
       } catch (MaxBytesLengthExceededException e) {
-        byte[] prefix = new byte[30];
-        System.arraycopy(binaryValue.bytes, binaryValue.offset, prefix, 0, 30);
+        byte[] prefix =
+            ArrayUtil.copyOfSubArray(
+                binaryValue.bytes, binaryValue.offset, binaryValue.offset + 30);
         String msg =
             "Document contains at least one immense term in field=\""
                 + fieldInfo.name
diff --git a/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSourceRescorer.java b/lucene/core/src/java/org/apache/lucene/search/DoubleValuesSourceRescorer.java
@@ -78,9 +78,7 @@ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int top
 
     if (topN < hits.length) {
       ArrayUtil.select(hits, 0, hits.length, topN, ScoreDoc.COMPARATOR);
-      ScoreDoc[] subset = new ScoreDoc[topN];
-      System.arraycopy(hits, 0, subset, 0, topN);
-      hits = subset;
+      hits = ArrayUtil.copyOfSubArray(hits, 0, topN);
     }
     Arrays.sort(hits, ScoreDoc.COMPARATOR);
 
diff --git a/lucene/core/src/java/org/apache/lucene/search/QueryRescorer.java b/lucene/core/src/java/org/apache/lucene/search/QueryRescorer.java
@@ -119,9 +119,7 @@ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int top
 
     if (topN < hits.length) {
       ArrayUtil.select(hits, 0, hits.length, topN, sortDocComparator);
-      ScoreDoc[] subset = new ScoreDoc[topN];
-      System.arraycopy(hits, 0, subset, 0, topN);
-      hits = subset;
+      hits = ArrayUtil.copyOfSubArray(hits, 0, topN);
     }
 
     Arrays.sort(hits, sortDocComparator);
diff --git a/lucene/core/src/java/org/apache/lucene/util/NumericUtils.java b/lucene/core/src/java/org/apache/lucene/util/NumericUtils.java
@@ -256,8 +256,7 @@ assert sortableBytesToBigInt(result, offset, bigIntSize).equals(bigInt)
    * @see #bigIntToSortableBytes(BigInteger, int, byte[], int)
    */
   public static BigInteger sortableBytesToBigInt(byte[] encoded, int offset, int length) {
-    byte[] bigIntBytes = new byte[length];
-    System.arraycopy(encoded, offset, bigIntBytes, 0, length);
+    byte[] bigIntBytes = ArrayUtil.copyOfSubArray(encoded, offset, offset + length);
     // Flip the sign bit back to the original
     bigIntBytes[0] ^= 0x80;
     return new BigInteger(bigIntBytes);
diff --git a/lucene/core/src/java/org/apache/lucene/util/PagedBytes.java b/lucene/core/src/java/org/apache/lucene/util/PagedBytes.java
@@ -226,9 +226,7 @@ public Reader freeze(boolean trim) {
       throw new IllegalStateException("cannot freeze when copy(BytesRef, BytesRef) was used");
     }
     if (trim && upto < blockSize) {
-      final byte[] newBlock = new byte[upto];
-      System.arraycopy(currentBlock, 0, newBlock, 0, upto);
-      currentBlock = newBlock;
+      currentBlock = ArrayUtil.copyOfSubArray(currentBlock, 0, upto);
     }
     if (currentBlock == null) {
       currentBlock = EMPTY_BYTES;
diff --git a/lucene/core/src/java/org/apache/lucene/util/automaton/Operations.java b/lucene/core/src/java/org/apache/lucene/util/automaton/Operations.java
@@ -1390,9 +1390,7 @@ public static int[] topoSortStates(Automaton a) {
 
     if (upto < states.length) {
       // There were dead states
-      int[] newStates = new int[upto];
-      System.arraycopy(states, 0, newStates, 0, upto);
-      states = newStates;
+      states = ArrayUtil.copyOfSubArray(states, 0, upto);
     }
 
     // Reverse the order:
diff --git a/lucene/core/src/java/org/apache/lucene/util/hnsw/FloatHeap.java b/lucene/core/src/java/org/apache/lucene/util/hnsw/FloatHeap.java
@@ -17,6 +17,8 @@
 
 package org.apache.lucene.util.hnsw;
 
+import org.apache.lucene.util.ArrayUtil;
+
 /**
  * A bounded min heap that stores floats. The top element is the lowest value of the heap.
  *
@@ -59,9 +61,7 @@ public boolean offer(float value) {
   }
 
   public float[] getHeap() {
-    float[] result = new float[size];
-    System.arraycopy(this.heap, 1, result, 0, size);
-    return result;
+    return ArrayUtil.copyOfSubArray(this.heap, 1, 1 + size);
   }
 
   /**

Original file line number	Diff line number	Diff line change
`@@ -263,8 +263,7 @@ private static final class PendingTerm extends PendingEntry {`
`263`	`263`
`264`	`264`	`public PendingTerm(BytesRef term, BlockTermState state) {`
`265`	`265`	`super(true);`
`266`		`- this.termBytes = new byte[term.length];`
`267`		`- System.arraycopy(term.bytes, term.offset, termBytes, 0, term.length);`
	`266`	`+ this.termBytes = ArrayUtil.copyOfSubArray(term.bytes, term.offset, term.offset + term.length);`
`268`	`267`	`this.state = state;`
`269`	`268`	`}`
`270`	`269`
Original file line number	Diff line number	Diff line change
`@@ -414,8 +414,7 @@ private static final class PendingTerm extends PendingEntry {`
`414`	`414`
`415`	`415`	`public PendingTerm(BytesRef term, BlockTermState state) {`
`416`	`416`	`super(true);`
`417`		`- this.termBytes = new byte[term.length];`
`418`		`- System.arraycopy(term.bytes, term.offset, termBytes, 0, term.length);`
	`417`	`+ this.termBytes = ArrayUtil.copyOfSubArray(term.bytes, term.offset, term.offset + term.length);`
`419`	`418`	`this.state = state;`
`420`	`419`	`}`
`421`	`420`
Original file line number	Diff line number	Diff line change
`@@ -78,9 +78,7 @@ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int top`
`78`	`78`
`79`	`79`	`if (topN < hits.length) {`
`80`	`80`	`ArrayUtil.select(hits, 0, hits.length, topN, ScoreDoc.COMPARATOR);`
`81`		`- ScoreDoc[] subset = new ScoreDoc[topN];`
`82`		`- System.arraycopy(hits, 0, subset, 0, topN);`
`83`		`- hits = subset;`
	`81`	`+ hits = ArrayUtil.copyOfSubArray(hits, 0, topN);`
`84`	`82`	`}`
`85`	`83`	`Arrays.sort(hits, ScoreDoc.COMPARATOR);`
`86`	`84`
Original file line number	Diff line number	Diff line change
`@@ -119,9 +119,7 @@ public TopDocs rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int top`
`119`	`119`
`120`	`120`	`if (topN < hits.length) {`
`121`	`121`	`ArrayUtil.select(hits, 0, hits.length, topN, sortDocComparator);`
`122`		`- ScoreDoc[] subset = new ScoreDoc[topN];`
`123`		`- System.arraycopy(hits, 0, subset, 0, topN);`
`124`		`- hits = subset;`
	`122`	`+ hits = ArrayUtil.copyOfSubArray(hits, 0, topN);`
`125`	`123`	`}`
`126`	`124`
`127`	`125`	`Arrays.sort(hits, sortDocComparator);`
Original file line number	Diff line number	Diff line change
`@@ -226,9 +226,7 @@ public Reader freeze(boolean trim) {`
`226`	`226`	`throw new IllegalStateException("cannot freeze when copy(BytesRef, BytesRef) was used");`
`227`	`227`	`}`
`228`	`228`	`if (trim && upto < blockSize) {`
`229`		`- final byte[] newBlock = new byte[upto];`
`230`		`- System.arraycopy(currentBlock, 0, newBlock, 0, upto);`
`231`		`- currentBlock = newBlock;`
	`229`	`+ currentBlock = ArrayUtil.copyOfSubArray(currentBlock, 0, upto);`
`232`	`230`	`}`
`233`	`231`	`if (currentBlock == null) {`
`234`	`232`	`currentBlock = EMPTY_BYTES;`