Byte-Array mit unbekannter Länge in Java
https://stackoverflow.com/questions/664389
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
ich ein Array von Bytes in Java am Bau und ich weiß nicht, wie lange das Array sein wird.
Ich möchte ein Programm wie Java String, die Sie gerade anrufen .append können (byte b) oder .append (byte [] buf) und haben es alle meine Bytes Puffer und mir ein Byte-Array zurück, wenn ich fertig bin. Gibt es eine Klasse, die für Bytes tut, was String tut für Strings? Es sieht nicht so aus wie die ByteBuffer Klasse ist das, was ich suche.
Wer eine gute Lösung?
Lösung
Versuchen Sie ByteArrayOutputStream . Sie können write( byte[] ) verwenden und es wird je nach Bedarf wachsen.
Andere Tipps
Sie einfach die vorherige Antwort zu erweitern, können Sie ByteArrayOutputStream und es ist Methode public void write(byte[] b, int off, int len), wo Parameter sind:
b - die Daten
- die Start-Offset in den Daten
len - die Anzahl von Bytes schreiben
Wenn Sie es als ein „Byte-Builder“ verwenden möchten, und legen Sie Byte für Byte, können Sie diese verwenden:
byte byteToInsert = 100;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(new byte[]{byteToInsert}, 0, 1);
Dann können Sie baos.toString() Methode verwenden, um das Array String zu konvertieren. Der Vorteil ist, wenn Sie Codierung von Eingangs einrichten müssen, können Sie einfach das heißt benutzen.
baos.toString("Windows-1250")
Ich schrieb eine, die einfach zu bedienen ist und eine Menge von Byte-Array-Puffer Kopieren vermeidet.
Es hat eine Methode namens add.
Sie können hinzufügen Strings, Bytes, Byte, lang, int, double, float, kurz, und Zeichen zu.
Die API ist einfach zu bedienen und etwas ausfallsicher. Es erlaubt Ihnen nicht, den Puffer um zu kopieren und zu fördern, nicht zwei Leser mit.
Es hat eine Grenze Prüfmodus und ein Ich weiß, was ich MODE mache mit keine Grenzen gesetzt zu überprüfen.
Die Grenzen Prüfmodus es automatisch wächst so keine Probleme gibt.
https://github.com / RichardHightower / Segen / wiki / Auto-Growable-Byte-Buffer-like-a-ByteBuilder
Hier ist ein kompletter Schritt für Schritt Anleitung, wie man es benutzt. Es ist auf Github.
Java Boon - Auto Growable Byte Buffer wie ein ByteBuilder
Haben Sie überhaupt eine einfache wollte Puffer-Array verwenden, die automatisch wachsen und / oder Sie können es ein Update Größe geben und nur Sachen, um es hinzuzufügen? Ich habe. Ich schrieb auch einen.
Schauen .. Ich kann Strings es schreiben (es wandelt sie 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");
Dann später kann ich den String aus dem Puffer lesen:
String out = new String(buf.readAndReset(), 0, buf.len());
assertEquals(66, buf.len());
assertTrue(out.endsWith("END\n"));
Ich habe nie die Größe des Arrays gesetzt. Es wird automatisch wachsen, wie in einer effizienten Weise benötigt.
Wenn ich weiß genau, wie groß meine Daten sein werden, als ich unter Verwendung createExact einige Grenzen Überprüfung speichern.
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());
Wenn ich genau erstellen, dann sage ich ... hey .. Ich weiß genau, wie groß es wachsen und es wird nie über diese Nummer gehen und wenn ja ... Sie können mir über den Kopf getroffen mit einem Sack rock!
Die folgenden Treffer erhalten Sie über den Kopf mit einem Sack Felsen! Löst eine Ausnahme !!!!
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");
Es arbeitet mit Doppelzimmer.
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");
Es funktioniert mit Schwimmer.
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");
Es funktioniert mit 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");
Es funktioniert mit Saibling.
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'");
Es funktioniert mit kurz.
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");
Es funktioniert sogar mit 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");
Sie können alle Arten von Primitiven auf Ihren Byte-Array hinzuzufügen.
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;
Jetzt prüfen wir gerade, dass wir alles wieder lesen kann.
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");
Wenn Sie anrufen
byte[] bytes = buf.readAndReset()
dann sagen Sie, dass Sie mit dem ByteBuffer fertig sind!
Wenn Sie für das Bytes fragen, wird es nutzlos, da sie die interne Byte-Array nichts setzen.
Wenn Sie readAndReset nennen, es gibt Ihnen seinen Puffer. Hier ist mein innerer Zustand, man kann es, aber ich werde es auf null gesetzt, damit niemand sonst verwendet es.
Es ist in Ordnung. Nur ein weiteres erstellen, wenn Sie nur eine Instanz zu einem Zeitpunkt sicher sind, wird mit dem Puffer (byte []).
Sie können sogar die Puffer verwenden Sie wurden ebenso wie in mit
ByteBuf buf2 = new ByteBuf.create(bytes);
Das ist, weil kein Puffer kopiert wird. ByteBuf schreibt in den Puffer geben Sie es. Wenn Sie eine weitere Kopie zu erhalten, um ByteBuf dann tun dies wollen:
ByteBuf buf2 = new ByteBuf.create( copy(bytes) );
Dies ist Segen, nachdem alle. :)
Kommen Sie in Segen. Sie erhalten die oben Klasse und idx und idxInt und idxLong kostenlos!
Lassen Sie uns sehen. Es gibt die ByteBuffer Klasse in Java.
http://docs.oracle.com/ JavaSE / 7 / docs / api / java / NiO / ByteBuffer.html
Es hat bulk Methoden, die zusammenhängenden Sequenzen von Bytes von Byte-Array von Hardware-Puffern zu übertragen. Es würde den Trick tun.
Es hat auch absolute und relative get und Methoden setzen, die byte [] s und andere Primitive / für die Byte-Puffer lesen und schreiben.
Es hat auch Methoden zum Verdichten, Duplizieren und einen Byte Puffer schneiden.
// 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)
Es hat auch eine Masse setzte eine Reihe zu setzen, die das Anfügen ziemlich nahe ist du fragst:
public final ByteBuffer put(byte[] src)
Siehe auch: http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html#put (byte [])
schrieb ich meine eigene kleine lib für die Manipulation von Byte-Arrays. :)
Sie können sie wie so hinzufügen
byte [] a = ...
byte [] b = ...
byte [] c = ...
a = add(a, b);
a = add(a, c);
Dies würde Ihnen der gesamte Inhalt von b und c, nachdem die Inhalte für a.
Wenn Sie mit 21 ein wachsen wollten, könnten Sie wie folgt vor:
a = grow( letters, 21);
Wenn Sie die Größe eines verdoppeln wollen, könnten Sie Folgendes tun:
a = grow( letters, 21);
Siehe ...
https: //github.com/RichardHightower/boon/blob/master/src/main/java/org/boon/core/primitive/Byt.java
byte[] letters =
arrayOfByte(500);
assertEquals(
500,
len(letters)
);
Erstellen
byte[] letters =
array((byte)0, (byte)1, (byte)2, (byte)3);
assertEquals(
4,
len(letters)
);
Index
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)
);
Enthält
byte[] letters =
array((byte)'a',(byte) 'b', (byte)'c', (byte)'d');
assertTrue(
in((byte)'a', letters)
);
assertFalse(
in((byte)'z', letters)
);
Scheibe:
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)
);
Shrink:
letters = shrink ( letters, 23 );
assertArrayEquals(
array((byte)'a', (byte)'b', (byte)'c'),
letters
);
Kopieren:
assertArrayEquals(
array((byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'),
copy(array((byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e'))
);
Anzahl:
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') );
Das Add sie tatsächlich zusammen addiert durch System.arraycopy mit (unter Berücksichtigung Unsafe, aber noch nicht).
ein Array zu einem anderen hinzufügen:
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') )
);
Einfügen:
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' )
);
Hier ist ein Blick auf einige der Methoden:
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;
}
Mehr ....
