Add from() constructor for float[] and double[]

Author: patrickfav

CHANGELOG

@@ -1,5 +1,10 @@
 # Releases
 
+## v1.4.0
+
+* add `from()` constructor from `float[]`
+* add `from()` constructor from `double[]`
+
 ## v1.3.0
 * improve hex encoder performance by factor 5
 

README.md

@@ -137,6 +137,8 @@ Creating byte arrays from **primitive integer** types and arrays:
 Bytes.from(8);  //00000000 00000000 00000000 00001000
 Bytes.from(1897621543227L);
 Bytes.from(1634, 88903, 77263);
+Bytes.from(0.7336f, -87263.0f);
+Bytes.from(0.8160183296, 3984639846.0);
 ```
 
 Initializing **empty arrays** of arbitrary length:

src/main/java/at/favre/lib/bytes/Bytes.java

@@ -108,7 +108,7 @@ public static Bytes empty() {
      * @return new instance
      */
     public static Bytes wrap(Bytes bytes) {
-        return wrap(bytes.internalArray(), bytes.byteOrder);
+        return wrap(Objects.requireNonNull(bytes, "passed Byte instance must not be null").internalArray(), bytes.byteOrder);
     }
 
     /**
@@ -346,6 +346,16 @@ public static Bytes from(float float4byte) {
         return wrap(ByteBuffer.allocate(4).putFloat(float4byte).array());
     }
 
+    /**
+     * Creates a new instance from given float array.
+     *
+     * @param floatArray to create from
+     * @return new instance
+     */
+    public static Bytes from(float... floatArray) {
+        return wrap(Util.Converter.toByteArray(Objects.requireNonNull(floatArray, "must provide at least a single float")));
+    }
+
     /**
      * Creates a new instance from given 8 byte floating point number (double).
      *
@@ -356,6 +366,16 @@ public static Bytes from(double double8Byte) {
         return wrap(ByteBuffer.allocate(8).putDouble(double8Byte).array());
     }
 
+    /**
+     * Creates a new instance from given double array.
+     *
+     * @param doubleArray to create from
+     * @return new instance
+     */
+    public static Bytes from(double... doubleArray) {
+        return wrap(Util.Converter.toByteArray(Objects.requireNonNull(doubleArray, "must provide at least a single double")));
+    }
+
     /**
      * Creates a new instance from given {@link ByteBuffer}.
      * Will use the same backing byte array and honour the buffer's byte order.
@@ -2043,7 +2063,7 @@ public char[] toCharArray(Charset charset) {
      * Pairs of {@code byte} elements are compared as if by invoking
      * {@link Byte#compare(byte, byte)}.
      * <p>
-     * Uses {@link ByteBuffer#compareTo(Object)} internally.
+     * Uses {@link ByteBuffer#compareTo(ByteBuffer)} internally.
      *
      * @return A negative integer, zero, or a positive integer as this buffer
      * is less than, equal to, or greater than the given buffer

src/main/java/at/favre/lib/bytes/Util.java

@@ -560,6 +560,33 @@ static byte[] toByteArray(int[] intArray) {
             return primitivesArray;
         }
 
+        /**
+         * Creates a byte array from given float array.
+         * The resulting byte array will have length floatArray * 4.
+         *
+         * <p>
+         * <strong>Analysis</strong>
+         * <ul>
+         * <li>Time Complexity: <code>O(n)</code></li>
+         * <li>Space Complexity: <code>O(n)</code></li>
+         * <li>Alters Parameters: <code>false</code></li>
+         * </ul>
+         * </p>
+         *
+         * @param floatArray to convert
+         * @return resulting byte array
+         */
+        static byte[] toByteArray(float[] floatArray) {
+            byte[] primitivesArray = new byte[floatArray.length * 4];
+            ByteBuffer buffer = ByteBuffer.allocate(4);
+            for (int i = 0; i < floatArray.length; i++) {
+                buffer.clear();
+                byte[] floatBytes = buffer.putFloat(floatArray[i]).array();
+                System.arraycopy(floatBytes, 0, primitivesArray, (i * 4), floatBytes.length);
+            }
+            return primitivesArray;
+        }
+
         /**
          * Creates a byte array from given long array.
          * The resulting byte array will have length longArray * 8
@@ -587,6 +614,33 @@ static byte[] toByteArray(long[] longArray) {
             return primitivesArray;
         }
 
+        /**
+         * Creates a byte array from given double array.
+         * The resulting byte array will have length doubleArray * 8.
+         *
+         * <p>
+         * <strong>Analysis</strong>
+         * <ul>
+         * <li>Time Complexity: <code>O(n)</code></li>
+         * <li>Space Complexity: <code>O(n)</code></li>
+         * <li>Alters Parameters: <code>false</code></li>
+         * </ul>
+         * </p>
+         *
+         * @param doubleArray to convert
+         * @return resulting byte array
+         */
+        static byte[] toByteArray(double[] doubleArray) {
+            byte[] primitivesArray = new byte[doubleArray.length * 8];
+            ByteBuffer buffer = ByteBuffer.allocate(8);
+            for (int i = 0; i < doubleArray.length; i++) {
+                buffer.clear();
+                byte[] doubleBytes = buffer.putDouble(doubleArray[i]).array();
+                System.arraycopy(doubleBytes, 0, primitivesArray, (i * 8), doubleBytes.length);
+            }
+            return primitivesArray;
+        }
+
         /**
          * Converts a char array to a byte array with given charset and range
          *

src/test/java/at/favre/lib/bytes/BytesConstructorTests.java

@@ -67,14 +67,19 @@ public void wrapTest() {
         assertEquals(0, bNullSafe1.length());
     }
 
+    @Test(expected = NullPointerException.class)
+    public void wrapByteNull_shouldThrow() {
+        Bytes.wrap((Bytes) null);
+    }
+
     @Test(expected = NullPointerException.class)
     public void wrapTestNullExpected() {
         Bytes.wrap((byte[]) null);
     }
 
     @Test
     public void wrapTestNullSafe() {
-        Bytes.wrapNullSafe(null);
+        assertSame(Bytes.empty(), Bytes.wrapNullSafe(null));
     }
 
     @Test
@@ -183,6 +188,11 @@ public void fromInt() {
         assertEquals(test, Bytes.from(test).toInt());
     }
 
+    @Test(expected = NullPointerException.class)
+    public void fromIntArray_empty_shouldThrow() {
+        Bytes.from((int[]) null);
+    }
+
     @Test
     public void fromIntArray() {
         assertArrayEquals(new byte[]{0, 0, 0, 1, 0, 0, 0, 2}, Bytes.from(1, 2).array());
@@ -207,6 +217,11 @@ public void fromLong() {
         assertEquals(test, Bytes.from(test).toLong());
     }
 
+    @Test(expected = NullPointerException.class)
+    public void fromLongArray_empty_shouldThrow() {
+        Bytes.from((long[]) null);
+    }
+
     @Test
     public void fromLongArray() {
         assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2}, Bytes.from(new long[]{1, 2}).array());
@@ -224,6 +239,22 @@ public void fromFloat() {
         assertEquals(test, Bytes.from(test).toFloat(), 0.01);
     }
 
+    @Test(expected = NullPointerException.class)
+    public void fromFloatArray_empty_shouldThrow() {
+        Bytes.from((float[]) null);
+    }
+
+    @Test
+    public void fromFloatArray() {
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 0}, Bytes.from(0f, 0f).array());
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 63, -128, 0, 0}, Bytes.from(0f, 1f).array());
+        assertArrayEquals(new byte[]{0, 0, 0, 0, -65, -128, 0, 0}, Bytes.from(0f, -1f).array());
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, Bytes.from(0f, 0f, 0f).array());
+        assertArrayEquals(new byte[]{66, -105, 0, 0, 71, 119, 46, 31}, Bytes.from(75.5f, 63278.123f).array());
+        assertArrayEquals(Bytes.from(Bytes.from(78239.934978f), Bytes.from(-82736.65178f), Bytes.from(0.12879316287461f)).array(),
+                Bytes.from(78239.934978f, -82736.65178f, 0.12879316287461f).array());
+    }
+
     @Test
     public void fromDouble() {
         double test = 3423423.8923423974123;
@@ -233,6 +264,21 @@ public void fromDouble() {
         assertEquals(test, Bytes.from(test).toDouble(), 0.01);
     }
 
+    @Test(expected = NullPointerException.class)
+    public void fromDoubleArray_empty_shouldThrow() {
+        Bytes.from((double[]) null);
+    }
+
+    @Test
+    public void fromDoubleArray() {
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, Bytes.from(0.0, 0.0).array());
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 63, -16, 0, 0, 0, 0, 0, 0}, Bytes.from(0.0, 1.0).array());
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, -65, -16, 0, 0, 0, 0, 0, 0}, Bytes.from(0.0, -1.0).array());
+        assertArrayEquals(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, Bytes.from(0, 0, 0).array());
+        assertArrayEquals(Bytes.from(Bytes.from(78239.934978), Bytes.from(-82736.65178), Bytes.from(0.12879316287461)).array(),
+                Bytes.from(78239.934978, -82736.65178, 0.12879316287461).array());
+    }
+
     @Test
     public void fromByteBuffer() {
         checkByteBuffer(example_bytes_empty);
@@ -325,6 +371,11 @@ public void toCharArrayShouldThroughNullPointer() {
         Bytes.allocate(4).toCharArray(null);
     }
 
+    @Test(expected = NullPointerException.class)
+    public void fromMultipleBytes_empty_shouldThrow() {
+        Bytes.from((Bytes[]) null);
+    }
+
     @Test
     public void fromMultipleBytes() {
         assertArrayEquals(new byte[]{0x01, 0x02, 0x03}, Bytes.from(Bytes.from((byte) 0x01), Bytes.from((byte) 0x02), Bytes.from((byte) 0x03)).array());
@@ -446,6 +497,21 @@ public void fromVariousBytes() {
         assertArrayEquals(example_bytes_sixteen, Bytes.fromNullSafe(example_bytes_sixteen).array());
     }
 
+    @Test(expected = NullPointerException.class)
+    public void fromArray_empty_shouldThrow() {
+        Bytes.from((byte[]) null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void wrapArrayByteOrder_empty_shouldThrow() {
+        Bytes.wrap(null, ByteOrder.BIG_ENDIAN);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void fromPartByte_empty_shouldThrow() {
+        Bytes.from((byte[]) null, 0, 1);
+    }
+
     @Test
     public void fromPartByte() {
         assertArrayEquals(new byte[]{example_bytes_four[1]}, Bytes.from(example_bytes_four, 1, 1).array());