Add ArrayUtil.concat overloads for primitive types, re #61

Author: safris

src/main/java/org/libj/util/ArrayUtil.java

@@ -433,17 +433,17 @@ public static String getName(final String path) {
   }
 
   /**
-   * Returns the simple name of the file or directory denoted by the specified pathname. This is just the last name in the name
-   * sequence of {@code path}, with its dot-extension removed, if present. If the name sequence of {@code path} is empty, then the
-   * empty string is returned.
+   * Returns the last name in the {@code '/'}-delimited sequence of path segments of the given {@code path} with its dot-prefixed
+   * extension removed. The unmodified {@linkplain StringPaths#getName(String) name of the path} is returned if no dot-prefixed
+   * extension is present.
    *
    * @param path The path string.
-   * @return The simple name of the file or directory denoted by the specified pathname, or the empty string if the name sequence of
-   *         {@code path} is empty.
+   * @return The the last name in the {@code '/'}-delimited sequence of path segments of the given {@code path} with its dot-prefixed
+   *         extension removed.
    * @throws NullPointerException If {@code path} is null.
    * @throws IllegalArgumentException If {@code path} is an empty string.
    */
-  public static String getSimpleName(String path) {
+  public static String getNameWithoutExtension(String path) {
     if (path.length() == 0)
       throw new IllegalArgumentException("Empty path");
 

src/main/java/org/libj/util/CollectionUtil.java

@@ -22,6 +22,8 @@
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.ZoneId;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import java.time.temporal.ChronoUnit;
 import java.time.temporal.Temporal;
 import java.util.Comparator;
@@ -219,13 +221,42 @@ public static LocalDateTime toLocalDateTime(final Date date) {
    * Returns a new {@link LocalDateTime} of the instant specified by the {@code long} value representing milliseconds from the epoch,
    * in the default time-zone.
    *
-   * @param time Value representing milliseconds from the epoch.
+   * @param epochTimeMs Value representing milliseconds from the epoch.
    * @return A new {@link LocalDateTime} of the instant specified by the {@code long} value representing milliseconds from the epoch,
    *         in the default time-zone.
    * @throws DateTimeException If the result exceeds the supported range.
    */
-  public static LocalDateTime toLocalDateTime(final long time) {
-    return LocalDateTime.ofInstant(Instant.ofEpochMilli(time), ZoneId.systemDefault());
+  public static LocalDateTime toLocalDateTime(final long epochTimeMs) {
+    return LocalDateTime.ofInstant(Instant.ofEpochMilli(epochTimeMs), ZoneId.systemDefault());
+  }
+
+  /**
+   * Returns a new {@link ZonedDateTime} of the instant specified by the {@code long} value representing milliseconds from the epoch,
+   * in the provided {@link ZoneId}.
+   *
+   * @param epochTimeMs Value representing milliseconds from the epoch.
+   * @param zoneId The time zone.
+   * @return A new {@link ZonedDateTime} of the instant specified by the {@code long} value representing milliseconds from the epoch,
+   *         in the provided {@link ZoneId}.
+   * @throws DateTimeException If the result exceeds the supported range.
+   * @throws NullPointerException If {@code zoneId} is null.
+   */
+  public static ZonedDateTime toZonedDateTime(final long epochTimeMs, final ZoneId zoneId) {
+    return ZonedDateTime.ofInstant(Instant.ofEpochMilli(epochTimeMs), zoneId);
+  }
+
+  /**
+   * Returns a new {@link ZonedDateTime} of the instant specified by the {@code long} value representing milliseconds from the epoch,
+   * in the UTC time-zone.
+   *
+   * @param epochTimeMs Value representing milliseconds from the epoch.
+   * @return A new {@link ZonedDateTime} of the instant specified by the {@code long} value representing milliseconds from the epoch,
+   *         in the UTC time-zone.
+   * @throws DateTimeException If the result exceeds the supported range.
+   * @throws NullPointerException If {@code zoneId} is null.
+   */
+  public static ZonedDateTime toZonedDateTimeUTC(final long epochTimeMs) {
+    return ZonedDateTime.ofInstant(Instant.ofEpochMilli(epochTimeMs), ZoneOffset.UTC);
   }
 
   /**

src/main/java/org/libj/util/StringPaths.java

@@ -26,7 +26,7 @@
 import java.util.function.IntConsumer;
 
 import org.libj.lang.Throwables;
-import org.libj.lang.WrappedArrayList;
+import org.libj.lang.ToArrayList;
 import org.libj.util.function.ThrowingRunnable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -190,7 +190,7 @@ public Builder<E> clone() {
     }
   }
 
-  private static final ArrayList<Exception> testExceptions = new WrappedArrayList<>(new Exception());
+  private static final ArrayList<Exception> testExceptions = new ToArrayList<>(new Exception());
 
   private final int maxRetries;
   private final long maxDelayMs;

src/main/java/org/libj/util/Temporals.java

@@ -38,7 +38,7 @@ private static Object[] createRandomNestedArray() {
   public void testFlattenArrayRetainingReferences() {
     final Object[] array = {"a", "b", new Object[] {"c", "d"}, "e", new Object[] {"f", new Object[] {"g", "h"}}, "i"};
     final Object[] result = ArrayUtil.flatten(array);
-    assertEquals("[" + java.util.Arrays.deepToString(array).replace("[", "").replace("]", "") + "]", java.util.Arrays.deepToString(result));
+    assertEquals("[" + Arrays.deepToString(array).replace("[", "").replace("]", "") + "]", Arrays.deepToString(result));
 
     final Object[] expected = {array[0], array[1], array[2], ((Object[])array[2])[0], ((Object[])array[2])[1], array[3], array[4], ((Object[])array[4])[0], ((Object[])array[4])[1], ((Object[])((Object[])array[4])[1])[0], ((Object[])((Object[])array[4])[1])[1], array[5]};
     final Object[] resultRetainingReferences = ArrayUtil.flatten(array, true);
@@ -50,7 +50,7 @@ public void testFlattenArray() {
     for (int i = 0; i < 100; ++i) { // [N]
       final Object[] array = createRandomNestedArray();
       final Object[] result = ArrayUtil.flatten(array);
-      assertEquals("[" + java.util.Arrays.deepToString(array).replace("[", "").replace("]", "") + "]", java.util.Arrays.deepToString(result));
+      assertEquals("[" + Arrays.deepToString(array).replace("[", "").replace("]", "") + "]", Arrays.deepToString(result));
     }
   }
 
@@ -63,6 +63,8 @@ public void testBinaryClosestSearch() {
     catch (final NullPointerException e) {
     }
 
+    assertEquals(0, ArrayUtil.binaryClosestSearch(new int[0], 0));
+
     final int[] sorted = {1, 3, 5, 9, 19};
     try {
       ArrayUtil.binaryClosestSearch(sorted, 4, 3, -10);
@@ -99,6 +101,158 @@ public void testFilter() {
     assertArrayEquals(expected, filtered);
   }
 
+  @Test
+  public void testConcatBooleans() {
+    final boolean[] a0 = {true, false};
+    final boolean[] a1 = {false, true};
+    final boolean[] a2 = {false};
+    final boolean[] a3 = {};
+    final boolean[] a4 = {true};
+    final boolean[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new boolean[] {true, false, false, true, false, true}, concat);
+  }
+
+  @Test
+  public void testConcatBytes() {
+    final byte[] a0 = {'a', 'b'};
+    final byte[] a1 = {'c', 'd'};
+    final byte[] a2 = {'e'};
+    final byte[] a3 = {};
+    final byte[] a4 = {'f'};
+    final byte[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new byte[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatChars() {
+    final char[] a0 = {'a', 'b'};
+    final char[] a1 = {'c', 'd'};
+    final char[] a2 = {'e'};
+    final char[] a3 = {};
+    final char[] a4 = {'f'};
+    final char[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new char[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatShorts() {
+    final short[] a0 = {'a', 'b'};
+    final short[] a1 = {'c', 'd'};
+    final short[] a2 = {'e'};
+    final short[] a3 = {};
+    final short[] a4 = {'f'};
+    final short[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new short[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatInts() {
+    final int[] a0 = {'a', 'b'};
+    final int[] a1 = {'c', 'd'};
+    final int[] a2 = {'e'};
+    final int[] a3 = {};
+    final int[] a4 = {'f'};
+    final int[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new int[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatLongs() {
+    final long[] a0 = {'a', 'b'};
+    final long[] a1 = {'c', 'd'};
+    final long[] a2 = {'e'};
+    final long[] a3 = {};
+    final long[] a4 = {'f'};
+    final long[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new long[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatFloats() {
+    final float[] a0 = {'a', 'b'};
+    final float[] a1 = {'c', 'd'};
+    final float[] a2 = {'e'};
+    final float[] a3 = {};
+    final float[] a4 = {'f'};
+    final float[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new float[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat, 0);
+  }
+
+  @Test
+  public void testConcatDoubles() {
+    final double[] a0 = {'a', 'b'};
+    final double[] a1 = {'c', 'd'};
+    final double[] a2 = {'e'};
+    final double[] a3 = {};
+    final double[] a4 = {'f'};
+    final double[] concat = ArrayUtil.concat(a0, a1, a2, a3, a4);
+    assertArrayEquals(new double[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat, 0);
+  }
+
+  @Test
+  public void testConcatBoolean() {
+    final boolean[] one = {false, true, false};
+    final boolean[] two = {true, true, false};
+    final boolean[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new boolean[] {false, true, false, true, true, false}, concat);
+  }
+
+  @Test
+  public void testConcatByte() {
+    final byte[] one = {'a', 'b', 'c'};
+    final byte[] two = {'d', 'e', 'f'};
+    final byte[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new byte[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatChar() {
+    final char[] one = {'a', 'b', 'c'};
+    final char[] two = {'d', 'e', 'f'};
+    final char[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new char[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatShort() {
+    final short[] one = {'a', 'b', 'c'};
+    final short[] two = {'d', 'e', 'f'};
+    final short[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new short[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatInt() {
+    final int[] one = {'a', 'b', 'c'};
+    final int[] two = {'d', 'e', 'f'};
+    final int[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new int[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatLong() {
+    final long[] one = {'a', 'b', 'c'};
+    final long[] two = {'d', 'e', 'f'};
+    final long[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new long[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat);
+  }
+
+  @Test
+  public void testConcatFloat() {
+    final float[] one = {'a', 'b', 'c'};
+    final float[] two = {'d', 'e', 'f'};
+    final float[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new float[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat, 0);
+  }
+
+  @Test
+  public void testConcatDouble() {
+    final double[] one = {'a', 'b', 'c'};
+    final double[] two = {'d', 'e', 'f'};
+    final double[] concat = ArrayUtil.concat(one, two);
+    assertArrayEquals(new double[] {'a', 'b', 'c', 'd', 'e', 'f'}, concat, 0);
+  }
+
   @Test
   public void testConcat() {
     final String[] one = {"a", "b", "c"};

src/main/java/org/libj/util/retry/RetryPolicy.java

@@ -22,7 +22,7 @@
 import java.util.Collections;
 
 import org.junit.Test;
-import org.libj.lang.WrappedArrayList;
+import org.libj.lang.ToArrayList;
 import org.libj.util.primitive.IntComparator;
 
 public class PairedSortTest {
@@ -75,7 +75,7 @@ private static <T> void test(final ArrayList<T> data, final IntComparator c) {
   @Test
   public void testExceptions() {
     try {
-      test(new WrappedArrayList<>("a", "b", "c"), null);
+      test(new ToArrayList<>("a", "b", "c"), null);
       fail("Expected NullPointerException");
     }
     catch (final NullPointerException e) {
@@ -84,7 +84,7 @@ public void testExceptions() {
 
   @Test
   public void test26() {
-    test(new WrappedArrayList<>("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"));
+    test(new ToArrayList<>("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"));
   }
 
   private static void testN(final int n) {

src/test/java/org/libj/util/ArrayUtilTest.java

@@ -142,25 +142,25 @@ public void testGetName() {
   @Test
   public void testGetSimpleName() {
     try {
-      StringPaths.getSimpleName(null);
+      StringPaths.getNameWithoutExtension(null);
       fail("Expected NullPointerException");
     }
     catch (final NullPointerException e) {
     }
 
     try {
-      StringPaths.getSimpleName("");
+      StringPaths.getNameWithoutExtension("");
       fail("Expected IllegalArgumentException");
     }
     catch (final IllegalArgumentException e) {
     }
 
-    assertEquals("share", StringPaths.getSimpleName("file:///usr/share/../share.txt"));
-    assertEquals("lib", StringPaths.getSimpleName("file:///usr/share/../share/../lib"));
-    assertEquals("var", StringPaths.getSimpleName("/usr/share/../share/../lib/../../var.tar.old"));
-    assertEquals("var", StringPaths.getSimpleName("/usr/share/../share/../lib/../../var/"));
-    assertEquals("resolv", StringPaths.getSimpleName("/etc/resolv.conf"));
-    assertEquals("name", StringPaths.getSimpleName("name"));
+    assertEquals("share", StringPaths.getNameWithoutExtension("file:///usr/share/../share.txt"));
+    assertEquals("lib", StringPaths.getNameWithoutExtension("file:///usr/share/../share/../lib"));
+    assertEquals("var", StringPaths.getNameWithoutExtension("/usr/share/../share/../lib/../../var.tar.old"));
+    assertEquals("var", StringPaths.getNameWithoutExtension("/usr/share/../share/../lib/../../var/"));
+    assertEquals("resolv", StringPaths.getNameWithoutExtension("/etc/resolv.conf"));
+    assertEquals("name", StringPaths.getNameWithoutExtension("name"));
   }
 
   @Test