Перетворити рядкове представлення шістнадцяткового дампа в байтовий масив за допомогою Java?


372

Я шукаю спосіб перетворити довгий рядок (з дампа), який представляє шістнадцяткові значення в байтовий масив.

Я не міг би сформулювати це краще, ніж людина, яка поставила тут те саме запитання .

Але щоб зберегти його оригінальним, я сформулюю це по-своєму: припустимо, у мене є рядок, "00A0BF"який я хотів би інтерпретувати як

byte[] {0x00,0xA0,0xBf}

що я повинен зробити?

Я початківець Java і в кінцевому підсумку використовую BigIntegerі стежу за провідними шестигранними нулями. Але я думаю, що це некрасиво, і я впевнений, що мені не вистачає чогось простого.


Дивіться також stackoverflow.com/questions/9655181 / ... .
flow2k

Я BigInteger тут приручив .
Джон Макклайн

FWIW String.getBytes()не працюватиме так, як ви думаєте, що може. Довелося навчитися цьому важким шляхом. if ("FF".getBytes() != "ff".getBytes()) { System.out.println("Try again"); }
tir38

Відповіді:


636

Ось рішення, яке, на мою думку, є кращим за будь-який розміщений досі:

public static byte[] hexStringToByteArray(String s) {
    int len = s.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                             + Character.digit(s.charAt(i+1), 16));
    }
    return data;
}

Причини, чому це поліпшення:

  • Безпечно з провідними нулями (на відміну від BigInteger) та з негативними значеннями байтів (на відміну від Byte.parseByte)

  • Не перетворює String в a char[], або створює об'єкти StringBuilder і String для кожного байта.

  • Немає залежностей від бібліотеки, які можуть бути недоступними

Не соромтеся додавати перевірку аргументів через assertабо виключення, якщо аргумент, як відомо, не є безпечним.


2
Чи можете ви навести приклад, який неправильно розшифровується, або пояснити, як це неправильно?
Дейв Л.

5
Це не працює для рядка "0". Це кидає java.lang.StringIndexOutOfBoundsException
ovdsrn

49
"0" - недійсний ввід. У байтах потрібні дві шістнадцяткові цифри кожен. Як зазначається у відповіді, "Не соромтеся додавати перевірку аргументів ... якщо аргумент, як відомо, не є безпечним".
Дейв Л.

12
javax.xml.bind.DatatypeConverter.parseHexBinary (hexString) у моїх мікротестах здається приблизно на 20% швидшим, ніж вищенаведене рішення (за все, що вони варті), а також правильно викидати винятки з недійсного введення даних (наприклад, "gg" не є дійсним hexString, але поверне -77 за допомогою запропонованого рішення).
Тревор Фріман

6
@DaedalusAlpha Це залежить від вашого контексту, але зазвичай я вважаю, що краще швидко і голосно провалюватися з такими речами, щоб ви могли виправити свої припущення, а не мовчки повертати невірні дані.
Дейв Л.

331

Одноколісні:

import javax.xml.bind.DatatypeConverter;

public static String toHexString(byte[] array) {
    return DatatypeConverter.printHexBinary(array);
}

public static byte[] toByteArray(String s) {
    return DatatypeConverter.parseHexBinary(s);
}

Попередження :

  • в Java 9 Jigsaw це більше не є частиною корінного набору java.se (за замовчуванням), тому це призведе до ClassNotFoundException, якщо не вказати --add-модулі java.se.ee (завдяки @ eckes)
  • Недоступно на Android (спасибі на Fabianте, що зауважили), але ви можете просто взяти вихідний код, якщо вашій системі бракує javax.xmlякихось причин. Завдяки @ Bert Regelinkдля вилучення джерела.

14
ІМХО, це має бути прийнятою / головною відповіддю, оскільки вона коротка і чистота (на відміну від відповіді @ DaveL) і не потребує зовнішніх лайків (як відповідь скафмана). Крім того, <Введіть виснажений анекдот про винахід велосипеда> .
Priidu Neemre

9
клас данихtypeconverter недоступний, наприклад, для Android.
Фабіан

4
Попередження: у Jigsaw Jigsaw 9 це вже не частина java.seкореневого набору (за замовчуванням) , тому це призведе до, ClassNotFoundExceptionякщо ви не вкажете--add-modules java.se.ee
eckes

2
@dantebarba Я думаю, що javax.xml.bind.DatatypeConverterвже передбачений метод кодування / декодування даних Base64. Дивіться parseBase64Binary()і printBase64Binary().
DragShot

2
Щоб додати до проблем із DataTypeConverter, Java SE 11 повністю видалила API JAXB і тепер включена лише у Java EE. Ви також можете додати його в якості залежно Maven, як запропоновано тут: stackoverflow.com/a/43574427/7347751
Девід Mordigal

79

Клас Hex у commons-codec повинен зробити це для вас.

http://commons.apache.org/codec/

import org.apache.commons.codec.binary.Hex;
...
byte[] decoded = Hex.decodeHex("00A0BF");
// 0x00 0xA0 0xBF

6
Це також добре виглядає. Дивіться org.apache.commons.codec.binary.Hex.decodeHex ()
Дейв Л.

Це було цікаво. Але мені було важко слідувати їхньому рішенню. Чи є якісь переваги перед запропонованим вами пропозицією (крім перевірки на рівну кількість символів)?
rafraf

38

Тепер ви можете використовувати BaseEncoding в guavaдля досягнення цієї мети .

BaseEncoding.base16().decode(string);

Для зворотного використання використовуйте

BaseEncoding.base16().encode(bytes);

27

Насправді, я думаю, що рішення BigInteger дуже приємне:

new BigInteger("00A0BF", 16).toByteArray();

Редагувати: Не безпечно для провідних нулів , як зазначає афіша


Я теж так думав спочатку. І дякую, що задокументували це - я просто думав, що треба ... це зробив деякі дивні речі, хоча я насправді не зрозумів - як опустити кілька ведучих 0x00, а також змішати порядок 1 байт у рядку 156 байт I грався з.
rafraf

2
Це хороший момент щодо ведучих 0. Я не впевнений, я вважаю, що це може змішати порядок байтів, і мені було б дуже цікаво, щоб це було продемонстровано.
Дейв Л.

1
так, як тільки я це сказав, я не повірив і мені :) Я запустив порівняння байтового масиву від BigInteger з mmyers'fromHexString і (без 0x00) проти рядку-образи - вони були однакові. "Змішання" все-таки відбулося, але, можливо, це було щось інше. Я буду дивитись ближче завтра
rafraf

3
Проблема з BigInteger полягає в тому, що повинен бути "бітовий знак". Якщо у ведучого байта встановлено високий біт, то отриманий байтовий масив має додаткові 0 у 1-й позиції. Але все одно +1.
Сірий

25

Одноколісні:

import javax.xml.bind.DatatypeConverter;

public static String toHexString(byte[] array) {
    return DatatypeConverter.printHexBinary(array);
}

public static byte[] toByteArray(String s) {
    return DatatypeConverter.parseHexBinary(s);
}

Для тих, хто цікавиться фактичним кодом, що стоїть за однолінійками від FractalizeR (мені це потрібно було, оскільки javax.xml.bind недоступний для Android (за замовчуванням)), це походить від com.sun.xml.internal.bind. DatatypeConverterImpl.java :

public byte[] parseHexBinary(String s) {
    final int len = s.length();

    // "111" is not a valid hex encoding.
    if( len%2 != 0 )
        throw new IllegalArgumentException("hexBinary needs to be even-length: "+s);

    byte[] out = new byte[len/2];

    for( int i=0; i<len; i+=2 ) {
        int h = hexToBin(s.charAt(i  ));
        int l = hexToBin(s.charAt(i+1));
        if( h==-1 || l==-1 )
            throw new IllegalArgumentException("contains illegal character for hexBinary: "+s);

        out[i/2] = (byte)(h*16+l);
    }

    return out;
}

private static int hexToBin( char ch ) {
    if( '0'<=ch && ch<='9' )    return ch-'0';
    if( 'A'<=ch && ch<='F' )    return ch-'A'+10;
    if( 'a'<=ch && ch<='f' )    return ch-'a'+10;
    return -1;
}

private static final char[] hexCode = "0123456789ABCDEF".toCharArray();

public String printHexBinary(byte[] data) {
    StringBuilder r = new StringBuilder(data.length*2);
    for ( byte b : data) {
        r.append(hexCode[(b >> 4) & 0xF]);
        r.append(hexCode[(b & 0xF)]);
    }
    return r.toString();
}

3
DatatypeConverter також недоступний у Java 9 за замовчуванням. Небезпечна річ - це використання коду, який буде компілюватися під Java 1.8 або раніше (Java 9 із початковими налаштуваннями раніше), але отримає виключення під час виконання Java під Java 9 без "--add-модулів java.se.ee".
Стівен М -на страйк-

24

HexBinaryAdapterНадає можливість маршала і розпакувати між Stringі byte[].

import javax.xml.bind.annotation.adapters.HexBinaryAdapter;

public byte[] hexToBytes(String hexString) {
     HexBinaryAdapter adapter = new HexBinaryAdapter();
     byte[] bytes = adapter.unmarshal(hexString);
     return bytes;
}

Це лише приклад, який я набрав ... Я насправді просто використовую його таким, який є, і не потрібно робити окремий метод його використання.


5
Він працює лише в тому випадку, якщо вхідний рядок (hexString) має парну кількість символів. В іншому випадку: Виняток у потоці "main" java.lang.IllegalArgumentException: hexBinary має бути рівного розміру:
ovdsrn

3
О, дякую, що вказали на це. Користувач дійсно не повинен мати непарну кількість символів, тому що байтовий масив представлений як {0x00,0xA0,0xBf}. Кожен байт має дві шістнадцяткові цифри чи нібелі. Тому будь-яка кількість байтів завжди повинна мати парну кількість символів. Дякуємо, що згадали про це.
GrkEngineer

8
Ви можете використовувати java.xml.bind.DatatypeConverter.parseHexBinary (hexString) безпосередньо замість використання HexBinaryAdapter (який у свою чергу називає DatatypeConverter). Таким чином, вам не потрібно створювати об'єкт примірника адаптера (оскільки методи DatatypeConverter є статичними).
Тревор Фріман

javax.xml.bind. * більше не доступний на Java 9. Небезпечна річ - це код, який за допомогою нього збиратиметься під Java 1.8 або раніше (Java 9 із початковими налаштуваннями раніше), але отримуватиметься виняток під час роботи під Java 9.
Stephen M - страйк -

15

Ось метод, який фактично працює (заснований на кількох попередніх напівправильних відповідях):

private static byte[] fromHexString(final String encoded) {
    if ((encoded.length() % 2) != 0)
        throw new IllegalArgumentException("Input string must contain an even number of characters");

    final byte result[] = new byte[encoded.length()/2];
    final char enc[] = encoded.toCharArray();
    for (int i = 0; i < enc.length; i += 2) {
        StringBuilder curr = new StringBuilder(2);
        curr.append(enc[i]).append(enc[i + 1]);
        result[i/2] = (byte) Integer.parseInt(curr.toString(), 16);
    }
    return result;
}

Єдине можливе питання, яке я бачу, - якщо рядок введення надзвичайно довгий; виклик toCharArray () робить копію внутрішнього масиву рядка.

EDIT: О, і, до речі, бати підписані на Java, тому ваш вхідний рядок перетворюється на [0, -96, -65] замість [0, 160, 191]. Але ви, мабуть, це вже знали.


1
Спасибі Майкл - ти рятувальник життя! Працюючи над проектом BlackBerry і намагаюся перетворити рядкове байт назад у байт ..., використовуючи метод "Byte.parseByte (byteString, 16)" RIM. Тримали викидання NumberFormatExcpetion. Провели години, намагаючись зрозуміти, чому. Ваша пропозиція "Integer.praseInt ()" зробила трюк. Знову дякую!!
BonanzaDriver

12

В android, якщо ви працюєте з hex, ви можете спробувати okio .

просте використання:

byte[] bytes = ByteString.decodeHex("c000060000").toByteArray();

і результат буде

[-64, 0, 6, 0, 0]

Я перевірив багато різних методів, але цей принаймні вдвічі швидший!
побі

5

BigInteger()Метод від java.math дуже повільно і не рекомендуємо.

Integer.parseInt(HEXString, 16)

може спричинити проблеми з деякими символами, не перетворюючись на Digit / Integer

a Спосіб роботи:

Integer.decode("0xXX") .byteValue()

Функція:

public static byte[] HexStringToByteArray(String s) {
    byte data[] = new byte[s.length()/2];
    for(int i=0;i < s.length();i+=2) {
        data[i/2] = (Integer.decode("0x"+s.charAt(i)+s.charAt(i+1))).byteValue();
    }
    return data;
}

Веселіться, удачі


4

EDIT: як вказував @mmyers, цей метод не працює на вході, який містить підрядки, відповідні байтам з високим набором бітів ("80" - "FF"). Пояснення вказано за ідентифікатором помилки: 6259307 Byte.parseByte не працює, як рекламується в Документації SDK .

public static final byte[] fromHexString(final String s) {
    byte[] arr = new byte[s.length()/2];
    for ( int start = 0; start < s.length(); start += 2 )
    {
        String thisByte = s.substring(start, start+2);
        arr[start/2] = Byte.parseByte(thisByte, 16);
    }
    return arr;
}

1
Закрити, але цей спосіб не вдається на заданому вході "00A0BBF". Див. Bugs.sun.com/bugdatabase/view_bug.do?bug_id=6259307 .
Майкл Майерс

1
Також дивним чином він не має
стосунку

1
@mmyers: whoa. Це не добре. Вибачте за плутанину. @ravigad: 9C має ту саму проблему, оскільки в цьому випадку встановлюється високий біт.
Блер Конрад

(байт) Short.parseShort (thisByte, 16) вирішує цю проблему
Джеймі Хікс

3

Для чого варто, ось ще одна версія, яка підтримує рядки непарної довжини, не вдаючись до конкатенації рядків.

public static byte[] hexStringToByteArray(String input) {
    int len = input.length();

    if (len == 0) {
        return new byte[] {};
    }

    byte[] data;
    int startIdx;
    if (len % 2 != 0) {
        data = new byte[(len / 2) + 1];
        data[0] = (byte) Character.digit(input.charAt(0), 16);
        startIdx = 1;
    } else {
        data = new byte[len / 2];
        startIdx = 0;
    }

    for (int i = startIdx; i < len; i += 2) {
        data[(i + 1) / 2] = (byte) ((Character.digit(input.charAt(i), 16) << 4)
                + Character.digit(input.charAt(i+1), 16));
    }
    return data;
}

2

Я завжди використовував такий метод

public static final byte[] fromHexString(final String s) {
    String[] v = s.split(" ");
    byte[] arr = new byte[v.length];
    int i = 0;
    for(String val: v) {
        arr[i++] =  Integer.decode("0x" + val).byteValue();

    }
    return arr;
}

цей метод розбивається на шістнадцяткові значення, обмежені простором, але не важко буде змусити його розділити рядок за будь-якими іншими критеріями, наприклад, на групування з двох символів.


З'єднання рядків не є зайвим. Просто використовуйте Integer.valueOf (val, 16).
Майкл Майерс

Я раніше намагався використовувати подібні конверсії, і я мав неоднозначні результати
pfranza,

спасибі - як не дивно, він добре працює з цим рядком: "9C001C" або "001C21" і не вдається з цим: "9C001C21" Виняток у потоці "main" java.lang.NumberFormatException: Для рядка введення: "9C001C21" у java.lang. NumberFormatException.forInputString (Невідоме джерело)
rafraf

(Це не дивно, ніж у Byte/ byteвипадку: найвищий біт встановлений без провідних -)
сіра борода

2

Мені подобається рішення Character.digit, але ось як я його вирішив

public byte[] hex2ByteArray( String hexString ) {
    String hexVal = "0123456789ABCDEF";
    byte[] out = new byte[hexString.length() / 2];

    int n = hexString.length();

    for( int i = 0; i < n; i += 2 ) {
        //make a bit representation in an int of the hex value 
        int hn = hexVal.indexOf( hexString.charAt( i ) );
        int ln = hexVal.indexOf( hexString.charAt( i + 1 ) );

        //now just shift the high order nibble and add them together
        out[i/2] = (byte)( ( hn << 4 ) | ln );
    }

    return out;
}

2

Кодекс, представлений Бертом Регелінк, просто не працює. Спробуйте наступне:

import javax.xml.bind.DatatypeConverter;
import java.io.*;

public class Test
{  
    @Test
    public void testObjectStreams( ) throws IOException, ClassNotFoundException
    {     
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);

            String stringTest = "TEST";
            oos.writeObject( stringTest );

            oos.close();
            baos.close();

            byte[] bytes = baos.toByteArray();
            String hexString = DatatypeConverter.printHexBinary( bytes);
            byte[] reconvertedBytes = DatatypeConverter.parseHexBinary(hexString);

            assertArrayEquals( bytes, reconvertedBytes );

            ByteArrayInputStream bais = new ByteArrayInputStream(reconvertedBytes);
            ObjectInputStream ois = new ObjectInputStream(bais);

            String readString = (String) ois.readObject();

            assertEquals( stringTest, readString);
        }
    }

2
Це справді інша проблема, і, ймовірно, належить до іншої теми.
Шон Коффі

1

Я виявив, що Кернел Панік є рішенням, яке мені найбільше корисне, але зіткнувся з проблемами, якщо шістнадцятковий рядок був непарним числом. вирішили це таким чином:

boolean isOdd(int value)
{
    return (value & 0x01) !=0;
}

private int hexToByte(byte[] out, int value)
{
    String hexVal = "0123456789ABCDEF"; 
    String hexValL = "0123456789abcdef";
    String st = Integer.toHexString(value);
    int len = st.length();
    if (isOdd(len))
        {
        len+=1; // need length to be an even number.
        st = ("0" + st);  // make it an even number of chars
        }
    out[0]=(byte)(len/2);
    for (int i =0;i<len;i+=2)
    {
        int hh = hexVal.indexOf(st.charAt(i));
            if (hh == -1)  hh = hexValL.indexOf(st.charAt(i));
        int lh = hexVal.indexOf(st.charAt(i+1));
            if (lh == -1)  lh = hexValL.indexOf(st.charAt(i+1));
        out[(i/2)+1] = (byte)((hh << 4)|lh);
    }
    return (len/2)+1;
}

Я додаю до масиву декілька шістнадцяткових чисел, тому я передаю посилання на масив, який я використовую, і int мені потрібно перетворити і повернути відносне положення наступного шістнадцяткового числа. Отже, кінцевий байтовий масив має [0] кількість шістнадцяткових пар, [1 ...] шістнадцяткових пар, то кількість пар ...


1

Виходячи з прийнятого рішення, наступне повинно бути трохи ефективнішим:

  public static byte [] hexStringToByteArray (final String s) {
    if (s == null || (s.length () % 2) == 1)
      throw new IllegalArgumentException ();
    final char [] chars = s.toCharArray ();
    final int len = chars.length;
    final byte [] data = new byte [len / 2];
    for (int i = 0; i < len; i += 2) {
      data[i / 2] = (byte) ((Character.digit (chars[i], 16) << 4) + Character.digit (chars[i + 1], 16));
    }
    return data;
  }

Тому що: початкове перетворення в масив char заряджає перевірки довжини в charAt


1

Якщо ви віддаєте перевагу потокам Java 8 як своєму стилю кодування, то цього можна досягти, використовуючи лише примітиви JDK.

String hex = "0001027f80fdfeff";

byte[] converted = IntStream.range(0, hex.length() / 2)
    .map(i -> Character.digit(hex.charAt(i * 2), 16) << 4 | Character.digit(hex.charAt((i * 2) + 1), 16))
    .collect(ByteArrayOutputStream::new,
             ByteArrayOutputStream::write,
             (s1, s2) -> s1.write(s2.toByteArray(), 0, s2.size()))
    .toByteArray();

В , 0, s2.size()параметрах функції колектора конкатенації можуть бути опущені , якщо ви не проти лову IOException.


0
public static byte[] hex2ba(String sHex) throws Hex2baException {
    if (1==sHex.length()%2) {
        throw(new Hex2baException("Hex string need even number of chars"));
    }

    byte[] ba = new byte[sHex.length()/2];
    for (int i=0;i<sHex.length()/2;i++) {
        ba[i] = (Integer.decode(
                "0x"+sHex.substring(i*2, (i+1)*2))).byteValue();
    }
    return ba;
}

0

Моє формальне рішення:

/**
 * Decodes a hexadecimally encoded binary string.
 * <p>
 * Note that this function does <em>NOT</em> convert a hexadecimal number to a
 * binary number.
 *
 * @param hex Hexadecimal representation of data.
 * @return The byte[] representation of the given data.
 * @throws NumberFormatException If the hexadecimal input string is of odd
 * length or invalid hexadecimal string.
 */
public static byte[] hex2bin(String hex) throws NumberFormatException {
    if (hex.length() % 2 > 0) {
        throw new NumberFormatException("Hexadecimal input string must have an even length.");
    }
    byte[] r = new byte[hex.length() / 2];
    for (int i = hex.length(); i > 0;) {
        r[i / 2 - 1] = (byte) (digit(hex.charAt(--i)) | (digit(hex.charAt(--i)) << 4));
    }
    return r;
}

private static int digit(char ch) {
    int r = Character.digit(ch, 16);
    if (r < 0) {
        throw new NumberFormatException("Invalid hexadecimal string: " + ch);
    }
    return r;
}

Це як функція PHP hex2bin (), але в стилі Java.

Приклад:

String data = new String(hex2bin("6578616d706c65206865782064617461"));
// data value: "example hex data"

0

Пізно до вечірки, але я відповів вищевказаною відповіддю DaveL в клас із зворотною дією - про всяк випадок, коли це допоможе.

public final class HexString {
    private static final char[] digits = "0123456789ABCDEF".toCharArray();

    private HexString() {}

    public static final String fromBytes(final byte[] bytes) {
        final StringBuilder buf = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            buf.append(HexString.digits[(bytes[i] >> 4) & 0x0f]);
            buf.append(HexString.digits[bytes[i] & 0x0f]);
        }
        return buf.toString();
    }

    public static final byte[] toByteArray(final String hexString) {
        if ((hexString.length() % 2) != 0) {
            throw new IllegalArgumentException("Input string must contain an even number of characters");
        }
        final int len = hexString.length();
        final byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
                    + Character.digit(hexString.charAt(i + 1), 16));
        }
        return data;
    }
}

І тестовий клас JUnit:

public class TestHexString {

    @Test
    public void test() {
        String[] tests = {"0FA1056D73", "", "00", "0123456789ABCDEF", "FFFFFFFF"};

        for (int i = 0; i < tests.length; i++) {
            String in = tests[i];
            byte[] bytes = HexString.toByteArray(in);
            String out = HexString.fromBytes(bytes);
            System.out.println(in); //DEBUG
            System.out.println(out); //DEBUG
            Assert.assertEquals(in, out);

        }

    }

}

0

Я знаю, що це дуже стара нитка, але все ж люблю додати мою копійку варто.

Якщо мені дійсно потрібно кодувати просту шістнадцяткову рядок до двійкового перетворювача, я хотів би зробити це наступним чином.

public static byte[] hexToBinary(String s){

  /*
   * skipped any input validation code
   */

  byte[] data = new byte[s.length()/2];

  for( int i=0, j=0; 
       i<s.length() && j<data.length; 
       i+=2, j++)
  {
     data[j] = (byte)Integer.parseInt(s.substring(i, i+2), 16);
  }

  return data;
}

0

На сьогоднішній день не найчистішим рішенням. Але це працює для мене і добре відформатовано:

private String createHexDump(byte[] msg, String description) {
    System.out.println();
    String result = "\n" + description;
    int currentIndex = 0;
    int printedIndex = 0;
    for(int i=0 ; i<msg.length ; i++){
        currentIndex++;
        if(i == 0){
            result += String.format("\n  %04x ", i);
        }
        if(i % 16 == 0 && i != 0){
            result += " | ";
            for(int j=(i-16) ; j<msg.length && j<i ; j++) {
                char characterToAdd = (char) msg[j];
                if (characterToAdd == '\n') {
                    characterToAdd = ' ';
                }
                result += characterToAdd;
                printedIndex++;
            }

            result += String.format("\n  %04x ", i);
        }

        result += String.format("%02x ", msg[i]);
    }

    if(currentIndex - printedIndex > 0){
        int leftOvers = currentIndex - printedIndex;
        for(int i=0 ; i<16-leftOvers ; i++){
            result += "   ";
        }

        result += " | ";

        for(int i=msg.length-leftOvers ; i<msg.length ; i++){
            char characterToAdd = (char) msg[i];
            if (characterToAdd == '\n') {
                characterToAdd = ' ';
            }
            result += characterToAdd;
        }
    }

    result += "\n";

    return result;
}

Вихід:

  S -> C
    0000 0b 00 2e 06 4d 6f 72 69 74 7a 53 6f 6d 65 20 54  |  .Heyyy Some T
    0010 43 50 20 73 74 75 66 66 20 49 20 63 61 70 74 75  | CP stuff I captu
    0020 72 65 64 2e 2e 77 65 6c 6c 20 66 6f 72 6d 61 74  | red..well format
    0030 3f                                               | ?

-2

Я думаю, це зробить за тебе. Я зв'язав це разом із аналогічною функцією, яка повертала дані як рядок:

private static byte[] decode(String encoded) {
    byte result[] = new byte[encoded/2];
    char enc[] = encoded.toUpperCase().toCharArray();
    StringBuffer curr;
    for (int i = 0; i < enc.length; i += 2) {
        curr = new StringBuffer("");
        curr.append(String.valueOf(enc[i]));
        curr.append(String.valueOf(enc[i + 1]));
        result[i] = (byte) Integer.parseInt(curr.toString(), 16);
    }
    return result;
}

По-перше, вам не потрібно буде перетворювати рядок у великі регістри. По-друге, можна додавати символи безпосередньо до StringBuffer, що має бути набагато ефективнішим.
Майкл Майєрс

-2

Для мене це було рішення, HEX = "FF01" потім розділився на FF (255) і 01 (01)

private static byte[] BytesEncode(String encoded) {
    //System.out.println(encoded.length());
    byte result[] = new byte[encoded.length() / 2];
    char enc[] = encoded.toUpperCase().toCharArray();
    String curr = "";
    for (int i = 0; i < encoded.length(); i=i+2) {
        curr = encoded.substring(i,i+2);
        System.out.println(curr);
        if(i==0){
            result[i]=((byte) Integer.parseInt(curr, 16));
        }else{
            result[i/2]=((byte) Integer.parseInt(curr, 16));
        }

    }
    return result;
}

На це запитання давали відповідь деякий час і є кілька хороших альтернатив; на жаль, на цей момент ваша відповідь не дає суттєво покращеного значення.
rfornal
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.