Octet tableau de longueur inconnue en java
https://stackoverflow.com/questions/664389
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je construis un tableau d'octets en java et je ne sais pas combien de temps le tableau sera.
Je veux un certain outil comme StringBuffer de Java que vous pouvez simplement appeler .append (octet b) ou .append (octet [] BUF) et avoir tampon tous mes octets et revenez me voir un tableau d'octets quand je suis fait. Y at-il une classe qui fait pour octets ce StringBuffer fait pour cordes? Il ne ressemble pas à la classe ByteBuffer est ce que je cherche.
Quelqu'un at-il une bonne solution?
Autres conseils
Juste pour prolonger la réponse précédente, vous pouvez utiliser ByteArrayOutputStream et c'est la méthode public void write(byte[] b, int off, int len), où les paramètres sont:
b - les données
off - le décalage de début dans les données
len - le nombre d'octets à écrire
Si vous voulez l'utiliser comme un « bâtisseur d'octets » et insérez octet par octet, vous pouvez utiliser ceci:
byte byteToInsert = 100;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
baos.write(new byte[]{byteToInsert}, 0, 1);
Ensuite, vous pouvez utiliser la méthode pour convertir le baos.toString() tableau à chaîne. L'avantage est lorsque vous devez configurer l'encodage d'entrée, vous pouvez simplement utiliser i.e.:.
baos.toString("Windows-1250")
J'ai écrit un qui est vraiment facile à utiliser et évite beaucoup de copie de mémoire tampon de tableau d'octets.
Il a une méthode appelée add.
Vous pouvez ajouter des chaînes, octets, octet, long, int, double, flotteur, court, et les caractères à elle.
L'API est facile à utiliser et un peu fail safe. Il ne vous permet pas de copier le tampon autour et ne favorise pas avoir deux lecteurs.
Il a un mode de vérification des limites et je sais ce que je FAIS MODE sans vérification de limites.
Les limites vérifiez le mode d'auto-pousse donc il n'y a pas de problème.
Voici une étape complète par étape sur la façon de l'utiliser. Il est sur GitHub.
Java Boon - Auto Growable octet tampon comme un ByteBuilder
Avez-vous déjà voulu un outil facile à utiliser le tableau qui se développent automatiquement et / ou vous pouvez donner un tampon de taille fixe et simplement ajouter des choses à elle? J'ai. J'ai écrit aussi.
Regardez .. Je peux écrire des chaînes à (il les convertit en 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");
Alors je peux lire plus tard, la chaîne de la mémoire tampon:
String out = new String(buf.readAndReset(), 0, buf.len());
assertEquals(66, buf.len());
assertTrue(out.endsWith("END\n"));
Je ne dois définir la taille du tableau. Il auto-croissance, au besoin de manière efficace.
Si je sais exactement comment grand mes données va être que je peux sauver des limites de contrôle en utilisant 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 je crée exactement, je veux dire ... hey .. Je sais exactement comment grand il peut atteindre et il ne sera jamais plus ce nombre et si elle le fait ... vous pouvez me frapper sur la tête avec un sac de roches!
Les coups suivants vous sur la tête avec un sac de roches! EXCEPTIONNELLEMENT !!!! LANCERS
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");
Il fonctionne avec des doubles.
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");
Il fonctionne avec flotteur.
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");
Il fonctionne avec 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");
Il fonctionne avec ombles.
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'");
Il fonctionne avec peu.
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");
Il fonctionne même avec des octets.
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");
Vous pouvez ajouter toutes sortes de primitives à votre tableau d'octets.
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;
Maintenant, nous vérifions simplement que nous pouvons lire tout retour.
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");
Une fois que vous appelez
byte[] bytes = buf.readAndReset()
vous dites que vous avez terminé avec le ByteBuffer!
Une fois que vous demandez les octets, il devient inutile car il définit le tableau d'octets interne à rien.
Lorsque vous appelez readAndReset, il vous donne son tampon. Voici mon état interne, vous pouvez l'avoir, mais je vais le mettre à null si personne d'autre ne l'utilise.
Il est ok. Il suffit de créer un autre si vous êtes sûr qu'une seule instance à la fois utilise la mémoire tampon (octet []).
Vous pouvez même utiliser le tampon que vous utilisez juste comme dans
ByteBuf buf2 = new ByteBuf.create(bytes);
En effet, aucun tampon est copié. ByteBuf écrit dans le tampon que vous lui donnez. Si vous voulez une autre copie à donner à ByteBuf puis faire ceci:
ByteBuf buf2 = new ByteBuf.create( copy(bytes) );
Ceci est aubaine après tout. :)
Venez vérifier aubaine. Vous obtenez la classe ci-dessus et IDX, et idxInt et idxLong gratuitement!
Voyons voir. Il y a la classe ByteBuffer en Java.
http://docs.oracle.com/ JavaSE / 7 / docs / api / java / NiO / ByteBuffer.html
Il a des méthodes en vrac qui transfèrent des séquences contiguës d'octets à partir d'un tableau d'octets de tampons matériels. Il ferait l'affaire.
Il a également obtenir absolue et relative et de mettre les méthodes qui lisent et écrivent byte [] s et d'autres primitives à / pour le tampon d'octets.
Il a également des procédés pour le compactage, la duplication, et découper un tampon d'octets.
// 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)
Il a également mis en vrac pour mettre un tableau, ce qui est assez proche de la append que vous demandiez:
public final ByteBuffer put(byte[] src)
Voir: http://docs.oracle.com/javase/7/docs/api/java/nio/ByteBuffer.html#put (byte [])
J'ai écrit mon propre petit lib pour manipuler des tableaux d'octets. :)
Vous pouvez les ajouter comme si
byte [] a = ...
byte [] b = ...
byte [] c = ...
a = add(a, b);
a = add(a, c);
cela vous donne tout le contenu de b, et c après que le contenu d'un.
Si vous voulez pousser un par 21, vous pouvez faire ce qui suit:
a = grow( letters, 21);
Si vous voulez doubler la taille d'un, vous pouvez faire ce qui suit:
byte[] letters =
arrayOfByte(500);
assertEquals(
500,
len(letters)
);
Voir ...
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)
);
Créer
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)
);
Index
byte[] letters =
array((byte)'a',(byte) 'b', (byte)'c', (byte)'d');
assertTrue(
in((byte)'a', letters)
);
assertFalse(
in((byte)'z', letters)
);
Contient
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)
);
Tranche:
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)
);
Cultivez
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'))
);
Copie:
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') );
Ajouter:
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') )
);
Ajoutez-les ajoute en fait ensemble en utilisant System.arraycopy (considérant Unsafe, mais pas encore).
Ajouter un tableau à un autre:
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' )
);
Insérer:
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;
}
Voici un coup d'oeil à quelques-unes des méthodes:
<*>En savoir plus ....
