Matriz de bytes de longitud desconocida en java
https://stackoverflow.com/questions/664389
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Yo soy la construcción de una matriz de bytes de java y no sé por cuánto tiempo la matriz será.
Quiero algunas herramientas como Java del StringBuffer que usted puede llamar .append(byte b) o .append(byte[] buf) y se han búfer de todos mis bytes y el retorno a mí una matriz de bytes cuando estoy hecho.Hay una clase que hace de bytes lo StringBuffer para las Cadenas?No se ve como el ByteBuffer clase es lo que estoy buscando.
Alguien tiene una buena solución?
Solución
Trate de ByteArrayOutputStream.Puede utilizar write( byte[] ) y va a crecer tanto como sea necesario.
Otros consejos
Sólo para extender la respuesta anterior, puede utilizar ByteArrayOutputStream y su método de public void write(byte[] b, int off, int len), donde los parámetros son:
b - los datos
off - el desplazamiento inicial de los datos
len - el número de bytes a escribir
Si desea utilizarlo como un "constructor de bytes" e insertar byte a byte, puede utilizar lo siguiente:
byte byteToInsert = 100;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(new byte[]{byteToInsert}, 0, 1);
A continuación, puede utilizar baos.toString() método para convertir la matriz de cadena. La ventaja es cuando se necesita configurar la codificación de entrada, puede simplemente usar es decir:.
baos.toString("Windows-1250")
escribí uno que es muy fácil de usar y evita un montón de copia búfer matriz de bytes.
Se ha añadido un método llamado.
Puede agregar cadenas, bytes, bytes, de largo, int, double, float, corta y caracteres a la misma.
La API es fácil de usar y algo a prueba de fallos. No se permite copiar el búfer de alrededor y no promueve que tiene dos lectores.
Tiene un modo de comprobación de límites y un SÉ lo que estoy haciendo MODO con la comprobación de límites.
Los comprobación de límites modo de auto-crece, por lo que no hay problemas.
Aquí está un paso a paso guía completa sobre cómo usarlo. Es en github.
Java Boon - Auto ampliable Byte Buffer como un ByteBuilder
¿Alguna vez has querido un fácil utilizar la matriz del separador que crecen de forma automática y / o puede darle un tamaño fijo y sólo tiene que añadir cosas a ella? Yo tengo. Escribí uno también.
Mira .. Puedo escribir cadenas a él (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");
A continuación, después puedo leer la cadena de la memoria intermedia:
String out = new String(buf.readAndReset(), 0, buf.len());
assertEquals(66, buf.len());
assertTrue(out.endsWith("END\n"));
Nunca tengo que ajustar el tamaño de la matriz. Será crecimiento automático según sea necesario de una manera eficiente.
Si sé exactamente qué tan grande mis datos va a ser de lo que puede ahorrar algo de comprobación de límites mediante el uso de 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 utilizo crear exacta, entonces yo estoy diciendo ... hey .. Sé exactamente lo grande que puede llegar a medir y nunca pasa este número y si lo hace ... se puede me golpeó en la cabeza con un saco de piedras!
Los siguientes te golpea en la cabeza con un saco de piedras! Emite 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 carbón.
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 trabaja 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");
Puedes añadir 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 que acabamos de verificar que podemos leer todo de nuevo.
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 se llama a
byte[] bytes = buf.readAndReset()
A continuación, usted está diciendo que haya terminado con el ByteBuffer!
Una vez que solicita los bytes, se vuelve inútil, ya que establece la matriz de bytes interno para nada.
Cuando se llama a readAndReset, le está dando a su memoria intermedia. Aquí está mi estado interno, se puede tener, pero voy a ponerlo en null para que nadie más lo usa.
Esta bien. Basta con crear otra si está seguro de una sola instancia en un momento está usando el buffer (byte []).
Usted puede incluso utilizar el buffer que estaba utilizando como en
ByteBuf buf2 = new ByteBuf.create(bytes);
Esto se debe a ninguna memoria intermedia se copia. ByteBuf escribe en el buffer que le des. Si desea otra copia que se dará a continuación ByteBuf hacer esto:
ByteBuf buf2 = new ByteBuf.create( copy(bytes) );
Esto es de gran ayuda después de todo. :)
Ven echa un vistazo a favor. Se obtiene la clase y idx arriba, y idxInt y idxLong gratis!
Vamos a ver. No es la clase ByteBuffer en Java.
http://docs.oracle.com/ JavaSE / 7 / docs / api / java / nio / ByteBuffer.html
Tiene métodos granel que transfieren secuencias contiguas de bytes a partir de una matriz de bytes en tampones de hardware. Sería hacer el truco.
También tiene get absoluta y relativa y poner métodos que leen y escriben bytes s [] y otras primitivas a / de la memoria intermedia de bytes.
También tiene métodos para la compactación, la duplicación, y cortar una memoria intermedia 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 mayor puesto que poner una matriz, que es bastante cerca de la append que pedían para:
public final ByteBuffer put(byte[] src)
Ver: http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html#put (byte [])
escribí mi propio pequeño lib para la manipulación de matrices de bytes. :)
Puedes añadirlas al igual que
byte [] a = ...
byte [] b = ...
byte [] c = ...
a = add(a, b);
a = add(a, c);
Esto le daría a todos los contenidos de B y C después de que los contenidos de.
Si usted quiere hacer crecer un 21 por, puede hacer lo siguiente:
a = grow( letters, 21);
Si desea duplicar el tamaño de una, se puede hacer lo siguiente:
byte[] letters =
arrayOfByte(500);
assertEquals(
500,
len(letters)
);
Vea ...
https: //github.com/RichardHightower/boon/blob/master/src/main/java/org/boon/core/primitive/Byt.java
byte[] letters =
array((byte)0, (byte)1, (byte)2, (byte)3);
assertEquals(
4,
len(letters)
);
Crear
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)
);
Índice
byte[] letters =
array((byte)'a',(byte) 'b', (byte)'c', (byte)'d');
assertTrue(
in((byte)'a', letters)
);
assertFalse(
in((byte)'z', letters)
);
Contiene
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)
);
División:
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)
);
Grow
letters = shrink ( letters, 23 );
assertArrayEquals(
array((byte)'a', (byte)'b', (byte)'c'),
letters
);
Shrink:
assertArrayEquals(
array((byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'),
copy(array((byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'))
);
Copiar:
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') );
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'), array((byte)'e', (byte)'f') )
);
El complemento realidad las suma mediante el uso de System.arraycopy (considerando inseguro, pero no todavía).
Añadir una matriz a otra:
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' )
);
Insertar:
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;
}
Aquí es un vistazo a algunos de los métodos:
<*>Más ....
