Add overloaded equals in Bytes

Author: patrickfav

CHANGELOG

@@ -4,6 +4,7 @@
 
 * add feature for gathering parts of the array as primitives (e.g. intAt(int position))
 * add to unsigned byte conversations
+* add overloaded equals
 
 ## v0.4.3
 

README.md

@@ -350,6 +350,15 @@ for (Byte aByte : bytesInstance) {
 }
 ```
 
+The `equals` method has overloaded versions for `byte[]`, `Byte[]` and `ByteBuffer` which can be used to directly
+compare the inner array:
+
+```java
+byte[] primitiveArray1 = ...
+byte[] primitiveArray2 = ...
+Bytes.wrap(primitiveArray1).equals(primitiveArray2); //compares primitiveArray1 with primitiveArray2
+```
+
 ### Validation
 
 A simple validation framework which can be used to check the internal byte array:

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

@@ -1002,7 +1002,7 @@ public int unsignedByteAt(int index) {
      */
     public char charAt(int index) {
         Util.checkIndexBounds(length(), index, 2, "char");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getChar();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getChar();
     }
 
     /**
@@ -1015,7 +1015,7 @@ public char charAt(int index) {
      */
     public short shortAt(int index) {
         Util.checkIndexBounds(length(), index, 2, "short");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getShort();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getShort();
     }
 
     /**
@@ -1028,7 +1028,7 @@ public short shortAt(int index) {
      */
     public int intAt(int index) {
         Util.checkIndexBounds(length(), index, 4, "int");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getInt();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getInt();
     }
 
     /**
@@ -1041,7 +1041,7 @@ public int intAt(int index) {
      */
     public long longAt(int index) {
         Util.checkIndexBounds(length(), index, 8, "long");
-        return ((ByteBuffer) ByteBuffer.wrap(internalArray()).order(byteOrder).position(index)).getLong();
+        return ByteBuffer.wrap(internalArray()).order(byteOrder).position(index).getLong();
     }
 
     /**
@@ -1478,6 +1478,12 @@ public int compareTo(Bytes o) {
         return internalBuffer().compareTo(o.internalBuffer());
     }
 
+    /**
+     * Checks if this instance is equal to given other instance o
+     *
+     * @param o other instance
+     * @return if the instance are equal
+     */
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
@@ -1489,6 +1495,37 @@ public boolean equals(Object o) {
         return byteOrder != null ? byteOrder.equals(bytes.byteOrder) : bytes.byteOrder == null;
     }
 
+    /**
+     * Compares the inner array with given array
+     *
+     * @param anotherArray to compare with
+     * @return true if {@link Arrays#equals(byte[], byte[])} returns true on given and internal array
+     */
+    public boolean equals(byte[] anotherArray) {
+        return anotherArray != null && Arrays.equals(internalArray(), anotherArray);
+    }
+
+    /**
+     * Compares the inner array with given array.
+     * Note: a <code>null</code> Byte will not be equal to a <code>0</code> byte
+     *
+     * @param anotherArray to compare with
+     * @return true if both array have same length and every byte element is the same
+     */
+    public boolean equals(Byte[] anotherArray) {
+        return Util.equals(internalArray(), anotherArray);
+    }
+
+    /**
+     * Compares the inner array with the inner array of given ByteBuffer
+     *
+     * @param buffer to compare with
+     * @return true if both array have same length and every byte element is the same
+     */
+    public boolean equals(ByteBuffer buffer) {
+        return buffer != null && Arrays.equals(internalArray(), buffer.array());
+    }
+
     /**
      * Checks only for internal array content
      *

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

@@ -426,6 +426,17 @@ static void checkExactLength(int length, int expectedLength, String type) {
         }
     }
 
+    static boolean equals(byte[] obj, Byte[] anotherArray) {
+        if (anotherArray == null) return false;
+        if (obj.length != anotherArray.length) return false;
+        for (int i = 0; i < obj.length; i++) {
+            if (anotherArray[i] == null || obj[i] != anotherArray[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /*
     =================================================================================================
      Copyright 2011 Twitter, Inc.

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

@@ -24,6 +24,7 @@
 import org.junit.Test;
 
 import java.math.BigInteger;
+import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.ReadOnlyBufferException;
 import java.util.NoSuchElementException;
@@ -69,6 +70,28 @@ public void testEquals() throws Exception {
         assertFalse(Bytes.wrap(example_bytes_eight).equals(Bytes.wrap(example2_bytes_seven)));
     }
 
+    @Test
+    public void testEqualsWithArray() throws Exception {
+        assertTrue(Bytes.allocate(4).equals(new byte[4]));
+        assertFalse(Bytes.allocate(4).equals(new byte[3]));
+        assertFalse(Bytes.random(16).equals(new byte[16]));
+    }
+
+    @Test
+    public void testEqualsWithObjectArray() throws Exception {
+        assertFalse(Bytes.allocate(4).equals(new Byte[4]));
+        assertTrue(Bytes.allocate(4).equals(new Byte[]{0, 0, 0, 0}));
+        assertFalse(Bytes.allocate(4).equals(new Byte[3]));
+        assertFalse(Bytes.random(16).equals(new Byte[16]));
+    }
+
+    @Test
+    public void testEqualsWithByteBuffer() throws Exception {
+        assertTrue(Bytes.allocate(4).equals(ByteBuffer.wrap(new byte[4])));
+        assertFalse(Bytes.allocate(4).equals(ByteBuffer.wrap(new byte[3])));
+        assertFalse(Bytes.random(16).equals(ByteBuffer.wrap(new byte[16])));
+    }
+
     @Test
     public void testEqualsContent() throws Exception {
         assertTrue(Bytes.wrap(new byte[0]).byteOrder(ByteOrder.BIG_ENDIAN).equalsContent(Bytes.wrap(new byte[0]).byteOrder(ByteOrder.LITTLE_ENDIAN)));