Conjunto de bytes de longitud desconocida en java

buffer

Question

Estoy construyendo una matriz de bytes en Java y no sé cuánto tiempo será la matriz.

Quiero una herramienta como StringBuffer de Java que pueda simplemente llamar a .append (byte b) o .append (byte [] buf) y hacer que almacene todos mis bytes y me devuelva una matriz de bytes cuando haya terminado. ¿Hay una clase que haga por bytes lo que StringBuffer hace por Strings? No parece que la clase ByteBuffer sea lo que estoy buscando.

Alguien tiene una buena solución?

Answer 1

Escribí uno que es realmente fácil de usar y evita una gran cantidad de copia de búfer de matriz de bytes.

Tiene un método llamado agregar.

Puede agregar cadenas, bytes, bytes, largo, int, doble, flotante, corto y caracteres.

La API es fácil de usar y algo no segura. No le permite copiar el búfer y no promueve tener dos lectores.

Tiene un modo de verificación de límites y un "SÉ QUE ESTOY HACIENDO MODO" sin verificación de límites.

El modo de verificación de límites crece automáticamente para que no haya problemas.

https://github.com/RichardHightower/boon/wiki/Auto-Growable-Byte-Buffer-like-a-ByteBuilder

Aquí hay una guía completa paso a paso sobre cómo usarlo. Está en github.

Java Boon - Auto Growable Byte Buffer como un ByteBuilder

¿Alguna vez ha deseado una matriz de búfer fácil de usar que crezca automáticamente y / o le puede dar un tamaño fijo y simplemente agregarle cosas? Yo tengo. Yo también escribí uno.

Mira ... puedo escribirle cadenas (los convierte a UTF-8).

    ByteBuf buf = new ByteBuf();
    buf.add(bytes("0123456789/n"));
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456END/n");

Luego, más tarde, puedo leer String fuera del buffer:

    String out = new String(buf.readAndReset(), 0, buf.len());
    assertEquals(66, buf.len());
    assertTrue(out.endsWith("END/n"));

Nunca tengo que establecer el tamaño de la matriz. Crecerá automáticamente según sea necesario de manera eficiente.

Si sé exactamente qué tan grande será mi información, puedo guardar la verificación de algunos límites usando createExact .

    ByteBuf buf = ByteBuf.createExact(66);
    buf.add(bytes("0123456789/n"));
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456END/n");
    assertEquals(66, buf.len());

Si uso create exact, entonces estoy diciendo ... hey ... sé exactamente lo grande que puede crecer y nunca pasará de este número y si lo hace ... puedes golpearme en la cabeza con un saco de rocas!

¡Lo siguiente te golpea en la cabeza con un saco de rocas! LANZA UNA EXCEPCIÓN !!!!

    ByteBuf buf = ByteBuf.createExact(22);
    buf.add(bytes("0123456789/n"));
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456789/n");
    buf.add("0123456END/n");

Funciona con dobles.

    ByteBuf buf = ByteBuf.createExact(8);

    //add the double
    buf.add(10.0000000000001);

    byte[] bytes = buf.readAndReset();
    boolean worked = true;

    worked |= idxDouble(bytes, 0) == 10.0000000000001 || die("Double worked");

Funciona con flotador.

    ByteBuf buf = ByteBuf.createExact(8);

    //add the float
    buf.add(10.001f);

    byte[] bytes = buf.readAndReset();
    boolean worked = true;

    worked |= buf.len() == 4 || die("Float worked");


    //read the float
    float flt = idxFloat(bytes, 0);

    worked |= flt == 10.001f || die("Float worked");

Funciona con int.

    ByteBuf buf = ByteBuf.createExact(8);

    //Add the int to the array
    buf.add(99);

    byte[] bytes = buf.readAndReset();
    boolean worked = true;


    //Read the int back
    int value = idxInt(bytes, 0);

    worked |= buf.len() == 4 || die("Int worked length = 4");
    worked |= value == 99 || die("Int worked value was 99");

Funciona con char.

    ByteBuf buf = ByteBuf.createExact(8);

    //Add the char to the array
    buf.add(''c'');

    byte[] bytes = buf.readAndReset();
    boolean worked = true;


    //Read the char back
    int value = idxChar(bytes, 0);

    worked |= buf.len() == 2 || die("char worked length = 4");
    worked |= value == ''c'' || die("char worked value was ''c''");

Funciona con corto.

    ByteBuf buf = ByteBuf.createExact(8);

    //Add the short to the array
    buf.add((short)77);

    byte[] bytes = buf.readAndReset();
    boolean worked = true;


    //Read the short back
    int value = idxShort(bytes, 0);

    worked |= buf.len() == 2 || die("short worked length = 2");
    worked |= value == 77 || die("short worked value was 77");

Incluso funciona con bytes.

    ByteBuf buf = ByteBuf.createExact(8);

    //Add the byte to the array
    buf.add( (byte)33 );

    byte[] bytes = buf.readAndReset();
    boolean worked = true;


    //Read the byte back
    int value = idx(bytes, 0);

    worked |= buf.len() == 1 || die("byte worked length = 1");
    worked |= value == 33 || die("byte worked value was 33");

Puede agregar todo tipo de primitivas a su matriz de bytes.

    boolean worked = true;
    ByteBuf buf = ByteBuf.create(1);

    //Add the various to the array
    buf.add( (byte)  1 );
    buf.add( (short) 2 );
    buf.add( (char)  3 );
    buf.add(         4 );
    buf.add( (float) 5 );
    buf.add( (long)  6 );
    buf.add( (double)7 );

    worked |= buf.len() == 29 || die("length = 29");


    byte[] bytes = buf.readAndReset();

    byte myByte;
    short myShort;
    char myChar;
    int myInt;
    float myFloat;
    long myLong;
    double myDouble;

Ahora solo comprobamos que podemos leer todo de vuelta.

    myByte    =   idx       ( bytes, 0 );
    myShort   =   idxShort  ( bytes, 1 );
    myChar    =   idxChar   ( bytes, 3 );
    myInt     =   idxInt    ( bytes, 5 );
    myFloat   =   idxFloat  ( bytes, 9 );
    myLong   =    idxLong   ( bytes, 13 );
    myDouble  =   idxDouble ( bytes, 21 );

    worked |= myByte   == 1 || die("value was 1");
    worked |= myShort  == 2 || die("value was 2");
    worked |= myChar   == 3 || die("value was 3");
    worked |= myInt    == 4 || die("value was 4");
    worked |= myFloat  == 5 || die("value was 5");
    worked |= myLong   == 6 || die("value was 6");
    worked |= myDouble == 7 || die("value was 7");

Una vez que llamas

 byte[] bytes = buf.readAndReset() 

¡entonces estás diciendo que has terminado con el ByteBuffer!

Una vez que solicite los bytes, se volverá inútil ya que establece el conjunto de bytes interno en nada.

Cuando llamas a readAndReset, te está dando su buffer. Aquí está mi estado interno, puedes tenerlo, pero voy a configurarlo para que nadie más lo use.

Está bien. Simplemente crea otro si estás seguro de que solo una instancia a la vez está usando el buffer (byte []).

Incluso puedes usar el buffer que estabas usando como en

ByteBuf buf2 = new ByteBuf.create(bytes); 

Esto se debe a que no se copia ningún búfer. ByteBuf escribe en el búfer que le das. Si desea que se le dé otra copia a ByteBuf, haga lo siguiente:

ByteBuf buf2 = new ByteBuf.create( copy(bytes) ); 

Esto es una bendición después de todo. :)

Ven y echa un vistazo bendición. Obtienes la clase de arriba e idx, y idxInt e idxLong gratis!

https://github.com/RichardHightower/boon/

Answer 2

Para ampliar la respuesta anterior, puede usar ByteArrayOutputStream y su método public void write(byte[] b, int off, int len) , donde los parámetros son:

b - los datos

off - el offset de inicio en los datos

len - la cantidad de bytes para escribir

Si desea usarlo como un "generador de bytes" e insertar byte por byte, puede usar esto:

byte byteToInsert = 100;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(new byte[]{byteToInsert}, 0, 1);

Luego puede usar el método baos.toString() para convertir la matriz en cadena. La ventaja es cuando necesitas configurar la codificación de entrada, simplemente puedes usar ie:

baos.toString("Windows-1250")

Answer 3

Veamos. Existe la clase ByteBuffer en Java.

http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html

Tiene métodos masivos que transfieren secuencias contiguas de bytes desde una matriz de bytes a los búferes de hardware. Haría el truco.

También tiene métodos get y put absolutos y relativos que leen y escriben byte [] sy otras primitivas en / para el buffer byte.

También tiene métodos para compactar, duplicar y cortar un búfer de bytes.

// Creates an empty ByteBuffer with a 1024 byte capacity
ByteBuffer buf = ByteBuffer.allocate(1024);

// Get the buffer''s capacity
int capacity = buf.capacity(); // 10

buf.put((byte)0xAA); // position=0

// Set the position
buf.position(500);

buf.put((byte)0xFF);

// Read the position 501
int pos = buf.position(); 

// Get remaining byte count
int remaining = buf.remaining(); (capacity - position)

También tiene una gran cantidad para poner una matriz, que está muy cerca del apéndice que pedías:

public final ByteBuffer put(byte[] src)

Ver: http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html#put (byte [])

Escribí mi propia pequeña lib para manipular matrices de bytes. :)

Puedes agregarlos así

byte [] a = ...
byte [] b = ...
byte [] c = ...

a = add(a, b);
a = add(a, c);

esto le daría todos los contenidos de b, y c después de los contenidos para a.

Si quisiera crecer un 21, podría hacer lo siguiente:

a = grow( letters,  21);

Si desea duplicar el tamaño de una, puede hacer lo siguiente:

a = grow( letters,  21);

Ver...

https://github.com/RichardHightower/boon/blob/master/src/main/java/org/boon/core/primitive/Byt.java

    byte[] letters =
            arrayOfByte(500);

    assertEquals(
            500,
            len(letters)
    );

Crear

    byte[] letters =
            array((byte)0, (byte)1, (byte)2, (byte)3);

    assertEquals(
            4,
            len(letters)
    );

Índice

    byte[] letters =
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'');

    assertEquals(
            ''a'',
            idx(letters, 0)
    );


    assertEquals(
            ''d'',
            idx(letters, -1)
    );


    assertEquals(
            ''d'',
            idx(letters, letters.length - 1)
    );


    idx(letters, 1, (byte)''z'');

    assertEquals(
            (byte)''z'',
            idx(letters, 1)
    );

Contiene

    byte[] letters =
            array((byte)''a'',(byte) ''b'', (byte)''c'', (byte)''d'');


    assertTrue(
            in((byte)''a'', letters)
    );

    assertFalse(
            in((byte)''z'', letters)
    );

Rebanada:

    byte[] letters =
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'');


    assertArrayEquals(
            array((byte)''a'', (byte)''b''),
            slc(letters, 0, 2)
    );

    assertArrayEquals(
            array((byte)''b'', (byte)''c''),
            slc(letters, 1, -1)
    );

    //>>> letters[2:]
    //[''c'', ''d'']
    //>>> letters[-2:]
    //[''c'', ''d'']

    assertArrayEquals(
            array((byte)''c'', (byte)''d''),
            slc(letters, -2)
    );


    assertArrayEquals(
            array((byte)''c'', (byte)''d''),
            slc(letters, 2)
    );


    //>>> letters[:-2]
    //     [''a'', ''b'']
    assertArrayEquals(
            array((byte)''a'', (byte)''b''),
            slcEnd(letters, -2)
    );


    //>>> letters[:-2]
    //     [''a'', ''b'']
    assertArrayEquals(
            array((byte)''a'',(byte) ''b''),
            slcEnd(letters, 2)
    );

Crecer

    byte[] letters =
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'');

    letters = grow( letters,  21);


    assertEquals(
            ''e'',
            idx(letters, 4)
    );


    assertEquals(
            ''a'',
            idx(letters, 0)
    );




    assertEquals(
            len(letters),
            26
    );


    assertEquals(
            ''/0'',
            idx(letters, 20)
    );

Encogimiento:

    letters =  shrink ( letters, 23 );

    assertArrayEquals(
            array((byte)''a'', (byte)''b'', (byte)''c''),
            letters

    );

Dupdo:

    assertArrayEquals(
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e''),
            copy(array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e''))

    );

Añadir:

    assertArrayEquals(
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''f''),
            add(array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e''), (byte)''f'') );

El complemento en realidad los agrega al usar System.arraycopy (considerando Inseguro, pero aún no).

Agregue una matriz a otra:

    assertArrayEquals(
            array(     (byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''f''),
            add( array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d''), array((byte)''e'', (byte)''f'') )

    );

Insertar:

    assertArrayEquals(
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''f'', (byte)''g''),
            insert( array((byte)''a'', (byte)''b'', (byte)''d'', (byte)''e'', (byte)''f'', (byte)''g''), 2, (byte)''c'' )

    );

    assertArrayEquals(
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''f'', (byte)''g''),
            insert( array((byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''f'', (byte)''g''), 0, (byte)''a'' )

    );

    assertArrayEquals(
            array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''f'', (byte)''g''),
            insert( array((byte)''a'', (byte)''b'', (byte)''c'', (byte)''d'', (byte)''e'', (byte)''g''), 5, (byte)''f'' )

    );

Aquí hay un vistazo a algunos de los métodos:

public static byte[] grow(byte [] array, final int size) {
    Objects.requireNonNull(array);

    byte [] newArray  = new byte[array.length + size];
    System.arraycopy(array, 0, newArray, 0, array.length);
    return newArray;
}



public static byte[] grow(byte [] array) {
    Objects.requireNonNull(array);

    byte [] newArray  = new byte[array.length *2];
    System.arraycopy(array, 0, newArray, 0, array.length);
    return newArray;
}


public static byte[] shrink(byte[] array, int size) {
    Objects.requireNonNull(array);

    byte[] newArray = new byte[array.length - size];

    System.arraycopy(array, 0, newArray, 0, array.length-size);
    return newArray;
}




public static byte[] copy(byte[] array) {
    Objects.requireNonNull(array);
    byte[] newArray = new byte[array.length];
    System.arraycopy(array, 0, newArray, 0, array.length);
    return newArray;
}


public static byte[] add(byte[] array, byte v) {
    Objects.requireNonNull(array);
    byte[] newArray = new byte[array.length + 1];
    System.arraycopy(array, 0, newArray, 0, array.length);
    newArray[array.length] = v;
    return newArray;
}

public static byte[] add(byte[] array, byte[] array2) {
    Objects.requireNonNull(array);
    byte[] newArray = new byte[array.length + array2.length];
    System.arraycopy(array, 0, newArray, 0, array.length);
    System.arraycopy(array2, 0, newArray, array.length, array2.length);
    return newArray;
}



public static byte[] insert(final byte[] array, final int idx, final byte v) {
    Objects.requireNonNull(array);

    if (idx >= array.length) {
        return add(array, v);
    }

    final int index = calculateIndex(array, idx);

    //Object newArray = Array.newInstance(array.getClass().getComponentType(), array.length+1);
    byte [] newArray = new byte[array.length+1];

    if (index != 0) {
        /* Copy up to the location in the array before the index. */
        /*                 src     sbegin  dst       dbegin   length of copy */
        System.arraycopy( array,   0,      newArray, 0,       index );
    }


    boolean lastIndex = index == array.length -1;
    int remainingIndex = array.length - index;

    if (lastIndex ) {
        /* Copy the area after the insert. Make sure we don''t write over the end. */
        /*                 src  sbegin   dst       dbegin     length of copy */
        System.arraycopy(array, index,   newArray, index + 1, remainingIndex );

    } else {
        /* Copy the area after the insert.  */
        /*                 src  sbegin   dst       dbegin     length of copy */
        System.arraycopy(array, index,   newArray, index + 1, remainingIndex );

    }

    newArray[index] = v;
    return  newArray;
}


public static byte[] insert(final byte[] array, final int fromIndex, final byte[] values) {
    Objects.requireNonNull(array);

    if (fromIndex >= array.length) {
        return add(array, values);
    }

    final int index = calculateIndex(array, fromIndex);

    //Object newArray = Array.newInstance(array.getClass().getComponentType(), array.length+1);
    byte [] newArray = new byte[array.length +  values.length];

    if (index != 0) {
        /* Copy up to the location in the array before the index. */
        /*                 src     sbegin  dst       dbegin   length of copy */
        System.arraycopy( array,   0,      newArray, 0,       index );
    }


    boolean lastIndex = index == array.length -1;

    int toIndex = index + values.length;
    int remainingIndex = newArray.length - toIndex;

    if (lastIndex ) {
        /* Copy the area after the insert. Make sure we don''t write over the end. */
        /*                 src  sbegin   dst       dbegin     length of copy */
        System.arraycopy(array, index,   newArray, index + values.length, remainingIndex );

    } else {
        /* Copy the area after the insert.  */
        /*                 src  sbegin   dst       dbegin     length of copy */
        System.arraycopy(array, index,   newArray, index + values.length, remainingIndex );

    }

    for (int i = index, j=0; i < toIndex; i++, j++) {
        newArray[ i ] = values[ j ];
    }
    return  newArray;
}

Más....

Answer 4

Pruebe ByteArrayOutputStream . Puede usar write( byte[] ) y crecerá según sea necesario.