From 949c59fc1efa2bf7cabc7afd28121c47a7a40667 Mon Sep 17 00:00:00 2001
From: ZhouXY108 <luquanlion@outlook.com>
Date: Mon, 14 Oct 2024 16:36:01 +0800
Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=20ArrayTools#fill=20?=
 =?UTF-8?q?=E6=96=B9=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../plusone/commons/util/ArrayTools.java      | 160 ++++++++++++++++++
 1 file changed, 160 insertions(+)

diff --git a/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java b/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java
index 2808125..559582f 100644
--- a/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java
@@ -26,6 +26,13 @@ import javax.annotation.Nullable;
 
 public class ArrayTools {
 
+    // empty arrays
+    public static final char[] EMPTY_CHAR_ARRAY = {};
+    public static final int[] EMPTY_INTEGER_ARRAY = {};
+    public static final long[] EMPTY_LONG_ARRAY = {};
+    public static final float[] EMPTY_FLOAT_ARRAY = {};
+    public static final double[] EMPTY_DOUBLE_ARRAY = {};
+
     // isNullOrEmpty
 
     /**
@@ -315,6 +322,159 @@ public class ArrayTools {
         return result;
     }
 
+    // fill - char
+
+    public static void fill(char[] a, char... values) {
+        fill(a, 0, a.length, values);
+    }
+
+    public static void fill(char[] a, String values) {
+        fill(a, 0, a.length, values != null ? values.toCharArray() : EMPTY_CHAR_ARRAY);
+    }
+
+    public static void fill(char[] a, int fromIndex, int toIndex, char... values) {
+        AssertTools.checkArgumentNotNull(a);
+        if (values.length == 0) {
+            return;
+        }
+        final int start = Integer.max(fromIndex, 0);
+        final int end = Integer.min(toIndex, a.length);
+        if (start >= end) {
+            return;
+        }
+        for (int i = start; i < end; i += values.length) {
+            for (int j = 0; j < values.length; j++) {
+                final int k = (i + j);
+                if (k < end) {
+                    a[k] = values[j];
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+
+    // fill - long
+
+    public static void fill(long[] a, long... values) {
+        fill(a, 0, a.length, values);
+    }
+
+    public static void fill(long[] a, int fromIndex, int toIndex, long... values) {
+        AssertTools.checkArgumentNotNull(a);
+        if (values.length == 0) {
+            return;
+        }
+        final int start = Integer.max(fromIndex, 0);
+        final int end = Integer.min(toIndex, a.length);
+        if (start >= end) {
+            return;
+        }
+        for (int i = start; i < end; i += values.length) {
+            for (int j = 0; j < values.length; j++) {
+                final int k = (i + j);
+                if (k < end) {
+                    a[k] = values[j];
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+
+    // fill - float
+
+    public static void fill(float[] a, float... values) {
+        fill(a, 0, a.length, values);
+    }
+
+    public static void fill(float[] a, int fromIndex, int toIndex, float... values) {
+        AssertTools.checkArgumentNotNull(a);
+        if (values.length == 0) {
+            return;
+        }
+        final int start = Integer.max(fromIndex, 0);
+        final int end = Integer.min(toIndex, a.length);
+        if (start >= end) {
+            return;
+        }
+        for (int i = start; i < end; i += values.length) {
+            for (int j = 0; j < values.length; j++) {
+                final int k = (i + j);
+                if (k < end) {
+                    a[k] = values[j];
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+
+    // fill - double
+
+    public static void fill(double[] a, double... values) {
+        fill(a, 0, a.length, values);
+    }
+
+    public static void fill(double[] a, int fromIndex, int toIndex, double... values) {
+        AssertTools.checkArgumentNotNull(a);
+        if (values.length == 0) {
+            return;
+        }
+        final int start = Integer.max(fromIndex, 0);
+        final int end = Integer.min(toIndex, a.length);
+        if (start >= end) {
+            return;
+        }
+        for (int i = start; i < end; i += values.length) {
+            for (int j = 0; j < values.length; j++) {
+                final int k = (i + j);
+                if (k < end) {
+                    a[k] = values[j];
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+
+    // fill - T
+
+    public static <T> void fill(@Nonnull T[] a, T[] values) {
+        fillInternal(a, 0, a.length, values);
+    }
+
+    public static <T> void fill(@Nonnull T[] a, int fromIndex, int toIndex, T[] values) {
+        fillInternal(a, fromIndex, toIndex, values);
+    }
+    
+    private static <T> void fillInternal(@Nonnull T[] a, int fromIndex, int toIndex, @Nullable T[] values) {
+        AssertTools.checkArgumentNotNull(a);
+        if (values == null || values.length == 0) {
+            return;
+        }
+        final int start = Integer.max(fromIndex, 0);
+        final int end = Integer.min(toIndex, a.length);
+        if (start >= end) {
+            return;
+        }
+        for (int i = start; i < end; i += values.length) {
+            for (int j = 0; j < values.length; j++) {
+                final int k = (i + j);
+                if (k < end) {
+                    a[k] = values[j];
+                }
+                else {
+                    break;
+                }
+            }
+        }
+    }
+
     private ArrayTools() {
         throw new IllegalStateException("Utility class");
     }