Comment diviser un tableau d'octets autour d'une séquence d'octets en Java?

Comment scinder une byte[] autour d'une séquence d'octets en Java? Quelque chose comme la byte[] version de String#split(regex).

Exemple

Prenons ce tableau d'octets:
[11 11 FF FF 22 22 22 FF FF 33 33 33 33]

et laissez-les choisir le délimiteur à être
[FF FF]

Puis la scission aura le résultat de ces trois parties:
[11 11]
[22 22 22]
[33 33 33 33]

EDIT:

Veuillez noter que vous ne pouvez pas convertir le byte[] à Stringde la diviser ensuite, puis de retour en raison de problèmes de codage. Lorsque vous effectuez la conversion sur les tableaux d'octets, la byte[] sera différent. Veuillez vous référer à ceci:
La Conversion de byte[] dans une Chaîne, puis de nouveau à un byte[]

source d'informationauteur Ori Popowski

java

6

Notez que vous pouvez convertir fiable de byte[] à la Chaîne et à l'arrière, avec un one-to-one mapping de caractères d'octets, si vous utilisez le codage "iso8859-1".

Cependant, il est toujours une vilaine solution.

Je pense que vous aurez besoin pour restaurer votre propre.

Je suggère de le résoudre en deux étapes:
1. Travailler sur la façon de trouver l'index de chaque occurrence d'un séparateur. Google pour "Knuth-Morris-Pratt" un algorithme efficace - bien que les plus naïfs algorithme sera bien pour les courts délimiteurs.
2. Chaque fois que vous trouvez un indice, utiliser des Tableaux.copyOfRange() pour obtenir la pièce dont vous avez besoin et l'ajouter à votre liste de sortie.
Ici, c'est à l'aide d'un naïfs algorithme de recherche de motif. KMP deviendrait-il la peine si les délimiteurs sont longues (parce qu'il enregistre les retours en arrière, mais ne manquez pas de délimiteurs si elles sont imbriquées dans la séquence de l'inadéquation à la fin).
```
public static boolean isMatch(byte[] pattern, byte[] input, int pos) {
    for(int i=0; i< pattern.length; i++) {
        if(pattern[i] != input[pos+i]) {
            return false;
        }
    }
    return true;
}

public static List<byte[]> split(byte[] pattern, byte[] input) {
    List<byte[]> l = new LinkedList<byte[]>();
    int blockStart = 0;
    for(int i=0; i<input.length; i++) {
       if(isMatch(pattern,input,i)) {
          l.add(Arrays.copyOfRange(input, blockStart, i));
          blockStart = i+pattern.length;
          i = blockStart;
       }
    }
    l.add(Arrays.copyOfRange(input, blockStart, input.length ));
    return l;
}
```

Voici une solution simple et efficace.

Contrairement à avgvstvs approche poignées de longueur arbitraire des délimiteurs. La réponse sommet est également bon, mais l'auteur n'a pas résolu le problème souligné par Eitan Perkal. Ce problème est évité ici à l'aide de l'approche Perkal suggère.

public static List<byte[]> tokens(byte[] array, byte[] delimiter) {
        List<byte[]> byteArrays = new LinkedList<>();
        if (delimiter.length == 0) {
            return byteArrays;
        }
        int begin = 0;

        outer:
        for (int i = 0; i < array.length - delimiter.length + 1; i++) {
            for (int j = 0; j < delimiter.length; j++) {
                if (array[i + j] != delimiter[j]) {
                    continue outer;
                }
            }
            byteArrays.add(Arrays.copyOfRange(array, begin, i));
            begin = i + delimiter.length;
        }
        byteArrays.add(Arrays.copyOfRange(array, begin, array.length));
        return byteArrays;
    }

J'ai modifié 'L. Blanc", la réponse à la poignée des délimiteurs au début et à la fin. En Plus je le renomme en "split".

private List<byte[]> split(byte[] array, byte[] delimiter)
{
   List<byte[]> byteArrays = new LinkedList<byte[]>();
   if (delimiter.length == 0)
   {
      return byteArrays;
   }
   int begin = 0;

   outer: for (int i = 0; i < array.length - delimiter.length + 1; i++)
   {
      for (int j = 0; j < delimiter.length; j++)
      {
         if (array[i + j] != delimiter[j])
         {
            continue outer;
         }
      }

      //If delimiter is at the beginning then there will not be any data.
      if (begin != i)
         byteArrays.add(Arrays.copyOfRange(array, begin, i));
      begin = i + delimiter.length;
   }

   //delimiter at the very end with no data following?
   if (begin != array.length)
      byteArrays.add(Arrays.copyOfRange(array, begin, array.length));

   return byteArrays;
}

0

Roulement de votre propre est la seule façon d'aller ici. La meilleure idée que je peux vous offrir, si vous êtes ouvert à des non-standard des bibliothèques, c'est cette classe d'Apache:

http://commons.apache.org/proper/commons-primitives/apidocs/org/apache/commons/collections/primitives/ArrayByteList.html

Knuth la solution est sans doute le meilleur, mais je traiterais le tableau comme une pile et faire quelque chose comme ceci:
```
List<ArrayByteList> targetList = new ArrayList<ArrayByteList>();
while(!stack.empty()){
  byte top = stack.pop();
  ArrayByteList tmp = new ArrayByteList();

  if( top == 0xff && stack.peek() == 0xff){
    stack.pop();
    continue;
  }else{
    while( top != 0xff ){
      tmp.add(stack.pop());
    }
    targetList.add(tmp);
  }
}
```
Je suis conscient que c'est assez rapide et sale, mais il devrait fournir de O(n) dans tous les cas.
0

Vous pouvez utiliser Tableaux.copyOfRange().

-3

Reportez-vous à Java Doc pour la Chaîne

Vous pouvez construire une String objet de byte tableau. Suppose que vous savez le reste.

public static byte[][] splitByteArray(byte[] bytes, byte[] regex, Charset charset) {
String str = new String(bytes, charset);
String[] split = str.split(new String(regex, charset));
byte[][] byteSplit = new byte[split.length][];
for (int i = 0; i < split.length; i++) {
byteSplit[i] = split[i].getBytes(charset);
}
return byteSplit;
}
public static void main(String[] args) {
Charset charset = Charset.forName("UTF-8");
byte[] bytes = {
'1', '1', ' ', '1', '1',
'F', 'F', ' ', 'F', 'F',
'2', '2', ' ', '2', '2', ' ', '2', '2',
'F', 'F', ' ', 'F', 'F',
'3', '3', ' ', '3', '3', ' ', '3', '3', ' ', '3', '3'
};
byte[] regex = {'F', 'F', ' ', 'F', 'F'};
byte[][] splitted = splitByteArray(bytes, regex, charset);
for (byte[] arr : splitted) {
System.out.print("[");
for (byte b : arr) {
System.out.print((char) b);
}
System.out.println("]");
}
}

Vous devez vous connecter pour publier un commentaire.