array di byte di lunghezza sconosciuta in java
https://stackoverflow.com/questions/664389
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
sto costruendo un array di byte in Java e non so per quanto tempo la matrice sarà.
Voglio un po 'strumento come StringBuffer di Java che si può chiamare .Append (byte b) o .Append (byte [] buf) e lo hanno buffer di tutti i miei byte e tornare a me un array di byte quando ho finito. C'è una classe che fa per byte quello StringBuffer fa per archi? Non sembra come la classe ByteBuffer è quello che sto cercando.
Qualcuno ha una buona soluzione?
Soluzione
ByteArrayOutputStream . È possibile utilizzare write( byte[] ) e crescerà a seconda delle necessità.
Altri suggerimenti
Proprio per estendere la risposta precedente, è possibile utilizzare ByteArrayOutputStream ed è il metodo public void write(byte[] b, int off, int len), dove i parametri sono:
b - i dati
off - l'inizio di offset nei dati
len - il numero di byte da scrivere
Se si desidera utilizzarlo come un "costruttore di byte" e inserire byte per byte, è possibile utilizzare questo:
byte byteToInsert = 100;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(new byte[]{byteToInsert}, 0, 1);
Quindi è possibile utilizzare baos.toString() metodo per convertire la matrice di stringhe. Il vantaggio è quando è necessario impostare la codifica di ingresso, si può semplicemente utilizzare cioè:.
baos.toString("Windows-1250")
ho scritto uno che è veramente facile da usare ed evita un sacco di copie del buffer array di byte.
E 'un metodo chiamato add.
È possibile aggiungere stringhe, byte, byte, lungo, int, double, float, breve, e caratteri ad esso.
L'API è facile da usare e un po 'fail safe. Non permette di copiare il buffer intorno e non promuove avere due lettori.
Ha un modo di controllo limiti e so quello che sto facendo MODE senza il controllo dei limiti.
I limiti controllare le modalità auto-cresce quindi non c'è nessun problema.
https://github.com / RichardHightower / manna / wiki / Auto-growable-Byte-Buffer-like-a-ByteBuilder
Ecco un passo completo passo guida su come usarlo. E 'su GitHub.
Java Boon - Auto growable Byte Buffer come un ByteBuilder
Avete mai desiderato un facile da usare array di buffer che crescono in modo automatico e / o si può dare una dimensione fissa e basta aggiungere cose ad esso? Io ho. Ho scritto uno troppo.
Guarda .. posso scrivere stringhe ad esso (li converte in 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");
Poi dopo posso leggere la stringa di buffer:
String out = new String(buf.readAndReset(), 0, buf.len());
assertEquals(66, buf.len());
assertTrue(out.endsWith("END\n"));
Non ho mai per impostare la dimensione della matrice. Si auto-crescere come necessario in modo efficiente.
Se io so esattamente quanto sia grande il mio dati sta per essere quello che posso risparmiare qualche controllo dei limiti utilizzando 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 io uso creo esatto, allora io sto dicendo ... hey .. so esattamente quanto grande può crescere per e non potrà mai andare oltre questo numero e se lo fa ... mi si può colpire in testa con un sacco di rocce!
I seguenti ti colpisce sulla testa con un sacco di rocce! Genera un'eccezione !!!!
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");
Funziona con doppie.
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");
Funziona con galleggiante.
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");
Funziona 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");
Funziona con carattere.
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'");
Funziona con breve.
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");
Funziona anche con i byte.
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");
È possibile aggiungere tutti i tipi di primitive per l'array di byte.
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;
Ora dobbiamo solo verificare che possiamo leggere tutto di nuovo.
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 volta che si chiama
byte[] bytes = buf.readAndReset()
allora si sta dicendo che si è fatto con la ByteBuffer!
Una volta che si chiede per i byte, diventa inutile come si imposta l'array di byte interna a nulla.
Quando si chiama readAndReset, si ti dà il suo buffer. Qui è il mio stato interno, si può avere, ma ho intenzione di impostarlo su null in modo che nessuno altro lo usa.
E 'ok. Basta creare un altro se si è sicuri solo un'istanza alla volta sta usando il buffer (byte []).
È anche possibile utilizzare il buffer si stava solo usando come in
ByteBuf buf2 = new ByteBuf.create(bytes);
Questo è perché nessuno di buffer viene copiato. ByteBuf scrive il buffer si dà. Se si desidera un'altra copia da dare alla ByteBuf quindi fare questo:
ByteBuf buf2 = new ByteBuf.create( copy(bytes) );
Questa è manna, dopo tutto. :)
Vieni a controllare manna. È possibile ottenere la classe e IDX sopra, e idxInt e idxLong gratis!
Vediamo. C'è la classe ByteBuffer in Java.
http://docs.oracle.com/ JavaSE / 7 / docs / api / java / nio / ByteBuffer.html
Ha metodi rinfusa che trasferiscono le sequenze contigue di byte da una matrice di byte buffer hardware. Si farebbe il trucco.
Ha anche get assoluta e relativa e mettere metodi che leggono e scrivono byte [] s ed altre primitive da / per il buffer di byte.
Ha anche metodi per la compattazione, la duplicazione, e affettare un buffer di 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)
Essa ha anche un grosso messo a mettere un array, che è abbastanza vicino al accodamento che stavi chiedendo:
public final ByteBuffer put(byte[] src)
Vedi: http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html#put (byte [])
ho scritto il mio piccolo lib per la manipolazione di array di byte. :)
Si possono aggiungere in questo modo
byte [] a = ...
byte [] b = ...
byte [] c = ...
a = add(a, b);
a = add(a, c);
questo darebbe tutto il contenuto di B e C dopo che i contenuti per una.
Se si voleva far crescere una da 21, è possibile effettuare le seguenti operazioni:
a = grow( letters, 21);
Se si voleva raddoppiare le dimensioni di una, si potrebbe procedere come segue:
byte[] letters =
arrayOfByte(500);
assertEquals(
500,
len(letters)
);
Vedere ...
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)
);
Crea
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)
);
Indice
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)
);
Slice:
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'))
);
Copia:
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') );
Add:
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') )
);
Il componente aggiuntivo in realtà li somma utilizzando System.arraycopy (considerando non sicuro, ma non ancora).
Aggiungi un array ad un altro:
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' )
);
Inserisci:
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;
}
Ecco uno sguardo ad alcuni dei metodi:
<*>Più ....
