Merge pull request #6 from andrei-cristea/master

refactor: Improve performance for methods "formatByte" and "fromString"

Author: devnied

src/main/java/fr/devnied/bitlib/BytesUtils.java

@@ -1,13 +1,12 @@
 package fr.devnied.bitlib;
 
 import java.math.BigInteger;
-import java.util.Locale;
 
 /**
  * Class used to manage String/byte/int converter
- * 
+ *
  * @author Millau Julien
- * 
+ *
  */
 public final class BytesUtils {
 
@@ -22,22 +21,45 @@ public final class BytesUtils {
 	private static final int HEXA = 16;
 
 	/**
-	 * No space format
+	 * Byte left mask
 	 */
-	private static final String FORMAT_NOSPACE = "%02x";
+	private static final int LEFT_MASK = 0xF0;
+
+	/**
+	 * Byte right mask
+	 */
+	private static final int RIGHT_MASK = 0xF;
+
+	/**
+	 * Char digit 0 (0x30) :<br>
+	 * <ul>
+	 * <li>char 0 = 0x30 + 0x0
+	 * <li>char 1 = 0x30 + 0x1
+	 * <li>...
+	 * <li>char 9 = 0x30 + 0x9
+	 * </ul>
+	 */
+	private static final int CHAR_DIGIT_ZERO = 0x30;
+
 	/**
-	 * Space format
+	 * Char digit 7 (0x37) :<br>
+	 * <ul>
+	 * <li>char A = 0x37 + 0xA
+	 * <li>char B = 0x37 + 0xB
+	 * <li>...
+	 * <li>char F = 0x37 + 0xF
+	 * </ul>
 	 */
-	private static final String FORMAT_SPACE = "%02x ";
+	private static final int CHAR_DIGIT_SEVEN = 0x37;
 
 	/**
-	 * Default mask
+	 * Char space
 	 */
-	private static final int DEFAULT_MASK = 0xFF;
+	private static final char CHAR_SPACE = (char) 0x20;
 
 	/**
 	 * Method used to convert byte array to int
-	 * 
+	 *
 	 * @param byteArray
 	 *            byte array to convert
 	 * @return int value
@@ -51,7 +73,7 @@ public static int byteArrayToInt(final byte[] byteArray) {
 
 	/**
 	 * Method used to convert byte array to int
-	 * 
+	 *
 	 * @param byteArray
 	 *            byte array to convert
 	 * @param startPos
@@ -79,95 +101,112 @@ public static int byteArrayToInt(final byte[] byteArray, final int startPos, fin
 
 	/**
 	 * Method to convert bytes to string with space between bytes
-	 * 
+	 *
 	 * @param pBytes
-	 * 			Bytes to convert
-	 * 
+	 *            Bytes to convert
+	 *
 	 * @return a string
 	 */
 	public static String bytesToString(final byte[] pBytes) {
-		return formatByte(pBytes, FORMAT_SPACE, false);
+		return formatByte(pBytes, true, false);
 	}
 
 	/**
 	 * Method to convert bytes to string with space between bytes
-	 * 
+	 *
 	 * bytes to convert
+	 *
 	 * @param pBytes
-	 * 			Bytes to convert
+	 *            Bytes to convert
 	 * @param pTruncate
 	 *            true to remove 0 left byte value
 	 * @return a string
 	 */
 	public static String bytesToString(final byte[] pBytes, final boolean pTruncate) {
-		return formatByte(pBytes, FORMAT_SPACE, pTruncate);
+		return formatByte(pBytes, true, pTruncate);
 	}
 
 	/**
 	 * Method to convert byte to string without space between byte
-	 * 
+	 *
 	 * @param pByte
 	 *            byte to convert
 	 * @return a string
 	 */
 	public static String bytesToStringNoSpace(final byte pByte) {
-		return formatByte(new byte[] { pByte }, FORMAT_NOSPACE, false);
+		return formatByte(new byte[] { pByte }, false, false);
 	}
 
 	/**
 	 * Method to convert bytes to string without space between bytes
-	 * 
+	 *
 	 * @param pBytes
 	 *            bytes to convert
 	 * @return a string
 	 */
 	public static String bytesToStringNoSpace(final byte[] pBytes) {
-		return formatByte(pBytes, FORMAT_NOSPACE, false);
+		return formatByte(pBytes, false, false);
 	}
 
 	/**
 	 * Method to convert bytes to string without space between bytes
-	 * 
+	 *
 	 * @param pBytes
 	 *            bytes to convert
 	 * @param pTruncate
 	 *            true to remove 0 left byte value
 	 * @return a string
 	 */
 	public static String bytesToStringNoSpace(final byte[] pBytes, final boolean pTruncate) {
-		return formatByte(pBytes, FORMAT_NOSPACE, pTruncate);
+		return formatByte(pBytes, false, pTruncate);
 	}
 
 	/**
-	 * Private method to format byte to hexa string
-	 * 
+	 * Private method to format bytes to hexa string
+	 *
 	 * @param pByte
-	 *            the byte to format
-	 * @param pFormat
-	 *            the format
+	 *            the bytes to format
+	 * @param pSpace
+	 *            true if add spaces between bytes
 	 * @param pTruncate
-	 *            true to remove 0 left byte value
+	 *            true to remove 0 left bytes value
 	 * @return a string containing the requested string
 	 */
-	private static String formatByte(final byte[] pByte, final String pFormat, final boolean pTruncate) {
-		StringBuffer sb = new StringBuffer();
+	private static String formatByte(final byte[] pByte, final boolean pSpace, final boolean pTruncate) {
+		String result;
 		if (pByte == null) {
-			sb.append("");
+			result = "";
 		} else {
-			boolean t = false;
-			for (byte b : pByte) {
-				if (b != 0 || !pTruncate || t) {
-					t = true;
-					sb.append(String.format(pFormat, b & DEFAULT_MASK));
+			int i = 0;
+			if (pTruncate) {
+				while (i < pByte.length && pByte[i] == 0) {
+					i++;
+				}
+			}
+			if (i < pByte.length) {
+				int sizeMultiplier = pSpace ? 3 : 2;
+				char[] c = new char[(pByte.length - i) * sizeMultiplier];
+				byte b;
+				for (int j = 0; i < pByte.length; i++, j++) {
+					b = (byte) ((pByte[i] & LEFT_MASK) >> 4);
+					c[j] = (char) (b > 9 ? b + CHAR_DIGIT_SEVEN : b + CHAR_DIGIT_ZERO);
+					b = (byte) (pByte[i] & RIGHT_MASK);
+					c[++j] = (char) (b > 9 ? b + CHAR_DIGIT_SEVEN : b + CHAR_DIGIT_ZERO);
+					if (pSpace) {
+						c[++j] = CHAR_SPACE;
+					}
 				}
+				result = pSpace ? new String(c, 0, c.length - 1) : new String(c);
+			} else {
+				result = "";
 			}
 		}
-		return sb.toString().toUpperCase(Locale.getDefault()).trim();
+		return result;
 	}
 
 	/**
 	 * Method to get bytes form string
-	 * 
+	 *
 	 * @param pData
 	 *            String to parse
 	 * @return a table of string
@@ -176,22 +215,28 @@ public static byte[] fromString(final String pData) {
 		if (pData == null) {
 			throw new IllegalArgumentException("Argument can't be null");
 		}
-		String text = pData.replace(" ", "");
-		if (text.length() % 2 != 0) {
+		StringBuilder sb = new StringBuilder(pData);
+		int j = 0;
+		for (int i = 0; i < sb.length(); i++) {
+			if (!Character.isWhitespace(sb.charAt(i))) {
+				sb.setCharAt(j++, sb.charAt(i));
+			}
+		}
+		sb.delete(j, sb.length());
+		if (sb.length() % 2 != 0) {
 			throw new IllegalArgumentException("Hex binary needs to be even-length :" + pData);
 		}
-		byte[] commandByte = new byte[Math.round(text.length() / (float) 2.0)];
-		int j = 0;
-		for (int i = 0; i < text.length(); i += 2) {
-			Integer val = Integer.parseInt(text.substring(i, i + 2), HEXA);
-			commandByte[j++] = val.byteValue();
+		byte[] result = new byte[sb.length() / 2];
+		j = 0;
+		for (int i = 0; i < sb.length(); i += 2) {
+			result[j++] = (byte) ((Character.digit(sb.charAt(i), 16) << 4) + Character.digit(sb.charAt(i + 1), 16));
 		}
-		return commandByte;
+		return result;
 	}
 
 	/**
 	 * Test if bit at given index of given value is = 1.
-	 * 
+	 *
 	 * @param pVal
 	 *            value to test
 	 * @param pBitIndex
@@ -200,14 +245,15 @@ public static byte[] fromString(final String pData) {
 	 */
 	public static boolean matchBitByBitIndex(final int pVal, final int pBitIndex) {
 		if (pBitIndex < 0 || pBitIndex > MAX_BIT_INTEGER) {
-			throw new IllegalArgumentException("parameter 'pBitIndex' must be between 0 and 31. pBitIndex=" + pBitIndex);
+			throw new IllegalArgumentException(
+					"parameter 'pBitIndex' must be between 0 and 31. pBitIndex=" + pBitIndex);
 		}
 		return (pVal & 1 << pBitIndex) != 0;
 	}
 
 	/**
 	 * Method used to set a bit index to 1 or 0.
-	 * 
+	 *
 	 * @param pData
 	 *            data to modify
 	 * @param pBitIndex
@@ -231,7 +277,7 @@ public static byte setBit(final byte pData, final int pBitIndex, final boolean p
 
 	/**
 	 * Convert byte array to binary String
-	 * 
+	 *
 	 * @param pBytes
 	 *            byte array to convert
 	 * @return a binary representation of the byte array
@@ -252,14 +298,14 @@ public static String toBinary(final byte[] pBytes) {
 
 	/**
 	 * Method used to convert integer to byet array
-	 * 
+	 *
 	 * @param value
 	 *            the value to convert
 	 * @return a byte array
 	 */
 	public static byte[] toByteArray(final int value) {
 		return new byte[] { //
-		(byte) (value >> 24), //
+				(byte) (value >> 24), //
 				(byte) (value >> 16), //
 				(byte) (value >> 8), //
 				(byte) value //