matriz de bytes de comprimento desconhecido em java
https://stackoverflow.com/questions/664389
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu estou construindo uma matriz de bytes em java e eu não sei por quanto tempo a matriz será.
Eu quero alguma ferramenta como StringBuffer de Java que você pode apenas chamar .append (byte b) ou .append (byte [] buf) e tê-lo tampão todos os meus bytes e retorno para mim um array de bytes quando eu terminar. Existe uma classe que faz para bytes que StringBuffer faz para Cordas? Ele não se parece com a classe ByteBuffer é o que eu estou procurando.
Alguém tem uma boa solução?
Solução
Tente ByteArrayOutputStream . Você pode usar write( byte[] ) e ela vai crescer conforme necessário.
Outras dicas
Apenas para estender a resposta anterior, você pode usar ByteArrayOutputStream e é public void write(byte[] b, int off, int len) método, onde os parâmetros são:
b - os dados
off - o início compensados ??nos dados
len - o número de bytes para escrever
Se você quiser usá-lo como um "construtor de byte" e inserção byte por byte, você pode usar isto:
byte byteToInsert = 100;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(new byte[]{byteToInsert}, 0, 1);
Em seguida, você pode usar o método baos.toString() para converter a matriz para string. A vantagem é quando você precisa configurar codificação de entrada, você pode simplesmente usar ou seja:.
baos.toString("Windows-1250")
Eu escrevi um que é realmente fácil de usar e evita um monte de matriz de bytes tampão copiar.
Ele tem um método chamado add.
Você pode adicionar strings, bytes, bytes, longo, int, double, float, curto, e caracteres a ela.
A API é fácil de usar e um pouco à prova de falhas. Ele não permite que você copie o tampão ao redor e não promove a ter dois leitores.
Tem um barrancos modo e uma FAZENDO MODO Eu sei o que estou sem verificação de limites verificar.
Os limites verificar o modo de auto-cresce, por isso não há problemas.
Aqui está um passo completo guia passo sobre como usá-lo. É no github.
Java Boon - Auto growable Byte buffer como um ByteBuilder
Você sempre quis um fácil de usar matriz de buffer que crescem automaticamente e / ou você pode dar-lhe um tamanho de correção e apenas adicionar coisas a ele? Eu tenho. Eu escrevi um também.
Olha .. eu posso escrever cordas para ele (ele converte-los para 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");
Então, mais tarde eu posso ler a cadeia fora do buffer:
String out = new String(buf.readAndReset(), 0, buf.len());
assertEquals(66, buf.len());
assertTrue(out.endsWith("END\n"));
Eu nunca tem que definir o tamanho da matriz. Vai auto-crescer conforme necessário de uma maneira eficiente.
Se eu sei exatamente como grande meus dados vai ser do que eu posso salvar alguns verificação de limites 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());
Se eu usar criar exata, então eu estou dizendo ... hey .. Eu sei exatamente o quão grande ele pode crescer para e isso nunca vai passar por cima este número e se isso acontecer ... você pode me atingido na cabeça com um saco de pedras!
Os seguintes bate em você na cabeça com um saco de pedras! Lança uma exceção !!!!
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");
Ele funciona com duplos.
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");
Ele funciona com float.
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");
Ele funciona com 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");
Ele funciona com carvão.
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'");
Ele funciona com curta.
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");
Ele ainda trabalha com 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");
Você pode adicionar todos os tipos de primitivas para a sua 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;
Agora só verificar que pode ler tudo de volta.
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");
Uma vez que você chamar
byte[] bytes = buf.readAndReset()
então você está dizendo que você é feito com o ByteBuffer!
Uma vez que você pedir para os bytes, torna-se inútil como ele define a matriz de bytes interno para nada.
Quando você chama readAndReset, é dando-lhe o seu buffer. Aqui é o meu estado interno, você pode tê-lo, mas estou indo para defini-lo como nulo por isso ninguém usa mais ele.
É ok. Basta criar outra se tiver certeza de apenas uma instância de cada vez está usando o buffer (byte []).
Você ainda pode usar o buffer você estava apenas usando como em
ByteBuf buf2 = new ByteBuf.create(bytes);
Isso ocorre porque nenhum buffer é copiado. ByteBuf gravações para o buffer de você lhe dá. Se você quiser outra cópia a ser dada ao ByteBuf em seguida, faça o seguinte:
ByteBuf buf2 = new ByteBuf.create( copy(bytes) );
Esta é benção, afinal. :)
Venha conferir benção. Você fica com a classe acima e idx e idxInt e idxLong gratuitamente!
Vamos ver. Não é a classe ByteBuffer em Java.
http://docs.oracle.com/ JavaSE / 7 / docs / api / java / nio / ByteBuffer.html
Tem métodos granel que transferem sequências contíguas de bytes a partir de uma matriz de bytes para buffers de hardware. Ele faria o truque.
Ele também tem get absoluta e relativa e métodos colocam que ler e escrever byte [] s e outras primitivas de / para o buffer de bytes.
Tem também métodos para a compactação, a duplicação, e corta um tampão de byte.
// 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)
Ele também tem uma opção de venda a granel para colocar um array, que é bastante próximo ao acrescentar-lhe pediam:
public final ByteBuffer put(byte[] src)
Veja: http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html#put (byte [])
Eu escrevi o meu próprio pequeno lib para manipular matrizes de bytes. :)
Você pode adicioná-los como assim
byte [] a = ...
byte [] b = ...
byte [] c = ...
a = add(a, b);
a = add(a, c);
este iria dar-lhe todo o conteúdo de b e c após o conteúdo para um.
Se você queria crescer um por 21, você pode fazer o seguinte:
a = grow( letters, 21);
Se você quiser dobrar o tamanho de um, você pode fazer o seguinte:
a = grow( letters, 21);
Veja ...
https: //github.com/RichardHightower/boon/blob/master/src/main/java/org/boon/core/primitive/Byt.java
byte[] letters =
arrayOfByte(500);
assertEquals(
500,
len(letters)
);
Criar
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)
);
Contém
byte[] letters =
array((byte)'a',(byte) 'b', (byte)'c', (byte)'d');
assertTrue(
in((byte)'a', letters)
);
assertFalse(
in((byte)'z', letters)
);
Slice:
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)
);
Grow
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)
);
Encolher:
letters = shrink ( letters, 23 );
assertArrayEquals(
array((byte)'a', (byte)'b', (byte)'c'),
letters
);
Copiar:
assertArrayEquals(
array((byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'),
copy(array((byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'))
);
Adicionar:
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') );
O add realmente acrescenta-los juntos usando System.arraycopy (considerando inseguro, mas não ainda).
Adicionar um array para outro:
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') )
);
Inserir:
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' )
);
Aqui está uma olhada em alguns dos 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;
}
Mais ....
