Récupérer un segment d'un tableau en Java sans créer un nouveau tableau sur le tas

Je recherche une méthode en Java qui retournera un segment d'un tableau. Un exemple serait d'obtenir le tableau d'octets contenant les 4e et 5e octets d'un tableau d'octets. Je ne veux pas avoir à créer un nouveau tableau d'octets dans la mémoire du tas juste pour le faire. En ce moment, j'ai le code suivant:

doSomethingWithTwoBytes(byte[] twoByteArray);

void someMethod(byte[] bigArray)
{
      byte[] x = {bigArray[4], bigArray[5]};
      doSomethingWithTwoBytes(x);
}

J'aimerais savoir s'il y avait un moyen de faire simplement doSomething(bigArray.getSubArray(4, 2))où 4 est le décalage et 2 est la longueur, par exemple.

Avertissement: Cette réponse n'est pas conforme aux contraintes de la question:

Je ne veux pas avoir à créer un nouveau tableau d'octets dans la mémoire du tas juste pour le faire.

( Honnêtement, je pense que ma réponse mérite d'être supprimée. La réponse de @ unique72 est correcte. Je vais laisser cette modification reposer un peu, puis je supprimerai cette réponse. )

Je ne connais pas de moyen de le faire directement avec des tableaux sans allocation de tas supplémentaire, mais les autres réponses utilisant un wrapper de sous-liste ont une allocation supplémentaire pour le wrapper uniquement - mais pas le tableau - ce qui serait utile dans le cas de un large éventail.

Cela dit, si l'on recherche la brièveté, la méthode utilitaire a Arrays.copyOfRange()été introduite dans Java 6 (fin 2006?):

byte [] a = new byte [] {0, 1, 2, 3, 4, 5, 6, 7};

// get a[4], a[5]

byte [] subArray = Arrays.copyOfRange(a, 4, 6);

Arrays.asList(myArray)délègue à new ArrayList(myArray), qui ne copie pas le tableau mais stocke simplement la référence. Utiliser List.subList(start, end)après cela fait un SubListqui fait simplement référence à la liste d'origine (qui fait toujours référence au tableau). Pas de copie du tableau ou de son contenu, il suffit de créer un wrapper et toutes les listes impliquées sont sauvegardées par le tableau d'origine. (Je pensais que ce serait plus lourd.)

Si vous recherchez une approche d'alias de style pointeur, de sorte que vous n'ayez même pas besoin d'allouer de l'espace et de copier les données, je pense que vous n'avez pas de chance.

System.arraycopy() copiera de votre source à destination, et l'efficacité est réclamée pour cet utilitaire. Vous devez allouer le tableau de destination.

Une façon consiste à envelopper le tableau dans java.nio.ByteBuffer , d'utiliser les fonctions put / get absolues et de découper le tampon pour qu'il fonctionne sur un sous-tableau.

Par exemple:

doSomething(ByteBuffer twoBytes) {
    byte b1 = twoBytes.get(0);
    byte b2 = twoBytes.get(1);
    ...
}

void someMethod(byte[] bigArray) {
      int offset = 4;
      int length = 2;
      doSomething(ByteBuffer.wrap(bigArray, offset, length).slice());
}

Notez que vous devez appeler les deux wrap()et slice(), puisque wrap()par lui-même n'affecte que les fonctions put / get relatives, pas les fonctions absolues.

ByteBuffer peut être un peu difficile à comprendre, mais il est très probablement mis en œuvre efficacement et mérite d'être appris.

Utilisez java.nio.Buffer. C'est un wrapper léger pour les tampons de divers types primitifs et aide à gérer le découpage, la position, la conversion, l'ordre des octets, etc.

Si vos octets proviennent d'un Stream, les tampons NIO peuvent utiliser le "mode direct" qui crée un tampon sauvegardé par des ressources natives. Cela peut améliorer les performances dans de nombreux cas.

Vous pouvez utiliser ArrayUtils.subarray dans apache commons. Pas parfait mais un peu plus intuitif que System.arraycopy. l'inconvénient est qu'il introduit une autre dépendance dans votre code.

Je vois que la réponse à la sous-liste est déjà là, mais voici le code qui démontre que c'est une vraie sous-liste, pas une copie:

public class SubListTest extends TestCase {
    public void testSubarray() throws Exception {
        Integer[] array = {1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(array);
        List<Integer> subList = list.subList(2, 4);
        assertEquals(2, subList.size());
        assertEquals((Integer) 3, subList.get(0));
        list.set(2, 7);
        assertEquals((Integer) 7, subList.get(0));
    }
}

Cependant, je ne pense pas qu'il existe un bon moyen de le faire directement avec des tableaux.

List.subList(int startIndex, int endIndex)

Les Lists vous permettent d'utiliser et de travailler avec subListquelque chose de manière transparente. Les tableaux primitifs vous obligeraient à suivre une sorte de limite de décalage. ByteBuffers ont des options similaires à celles que j'ai entendues.

Edit: Si vous êtes en charge de la méthode utile, vous pouvez simplement la définir avec des limites (comme cela est fait dans de nombreuses méthodes liées aux tableaux dans Java lui-même:

doUseful(byte[] arr, int start, int len) {
    // implementation here
}
doUseful(byte[] arr) {
    doUseful(arr, 0, arr.length);
}

Ce n'est pas clair, cependant, si vous travaillez sur les éléments du tableau eux-mêmes, par exemple si vous calculez quelque chose et écrivez le résultat?

Une option serait de passer le tableau entier et les index de début et de fin, et de faire une itération entre ceux-ci au lieu d'itérer sur tout le tableau passé.

void method1(byte[] array) {
    method2(array,4,5);
}
void method2(byte[] smallarray,int start,int end) {
    for ( int i = start; i <= end; i++ ) {
        ....
    }
}

Les références Java pointent toujours vers un objet. L'objet a un en-tête qui, entre autres, identifie le type de béton (les casts peuvent donc échouer avecClassCastException ). Pour les tableaux, le début de l'objet inclut également la longueur, les données suivent alors immédiatement après en mémoire (techniquement une implémentation est libre de faire ce qu'elle veut, mais il serait stupide de faire autre chose). Donc, vous pouvez; t avoir une référence qui pointe quelque part dans un tableau.

En C, les pointeurs pointent n'importe où et vers n'importe quoi, et vous pouvez pointer vers le milieu d'un tableau. Mais vous ne pouvez pas lancer en toute sécurité ou découvrir la longueur de la matrice. En D, le pointeur contient un décalage dans le bloc de mémoire et la longueur (ou de manière équivalente un pointeur vers la fin, je ne me souviens pas de ce que fait réellement l'implémentation). Cela permet à D de découper des tableaux. En C ++, vous auriez deux itérateurs pointant vers le début et la fin, mais C ++ est un peu étrange comme ça.

Donc, pour revenir à Java, non, vous ne pouvez pas. Comme mentionné, NIO ByteBuffervous permet d'envelopper un tableau puis de le découper, mais donne une interface peu pratique. Vous pouvez bien sûr copier, ce qui est probablement beaucoup plus rapide que vous ne le pensez. Vous pouvez introduire votre propre Stringabstraction qui vous permet de découper un tableau (l'implémentation Sun actuelle de Stringa une char[]référence plus un décalage de début et une longueur, une implémentation plus performante a juste le char[]). byte[]est de bas niveau, mais toute abstraction basée sur les classes que vous mettez sur qui va faire un terrible désordre de la syntaxe, jusqu'à JDK7 (peut-être).

@ unique72 answer comme une simple fonction ou ligne, vous devrez peut-être remplacer Object, par le type de classe respectif que vous souhaitez «découper». Deux variantes sont proposées pour répondre à divers besoins.

/// Extract out array from starting position onwards
public static Object[] sliceArray( Object[] inArr, int startPos ) {
    return Arrays.asList(inArr).subList(startPos, inArr.length).toArray();
}

/// Extract out array from starting position to ending position
public static Object[] sliceArray( Object[] inArr, int startPos, int endPos ) {
    return Arrays.asList(inArr).subList(startPos, endPos).toArray();
}

Que diriez-vous d'un Listemballage fin ?

List<Byte> getSubArrayList(byte[] array, int offset, int size) {
   return new AbstractList<Byte>() {
      Byte get(int index) {
         if (index < 0 || index >= size) 
           throw new IndexOutOfBoundsException();
         return array[offset+index];
      }
      int size() {
         return size;
      }
   };
}

(Non testé)

J'avais besoin d'itérer jusqu'à la fin d'un tableau et je ne voulais pas copier le tableau. Mon approche était de créer un Iterable sur le tableau.

public static Iterable<String> sliceArray(final String[] array, 
                                          final int start) {
  return new Iterable<String>() {
    String[] values = array;
    int posn = start;

    @Override
    public Iterator<String> iterator() {
      return new Iterator<String>() {
        @Override
        public boolean hasNext() {
          return posn < values.length;
        }

        @Override
        public String next() {
          return values[posn++];
        }

        @Override
        public void remove() {
          throw new UnsupportedOperationException("No remove");
        }
      };
    }
  };
}

C'est un peu plus léger que Arrays.copyOfRange - pas de plage ou négatif

public static final byte[] copy(byte[] data, int pos, int length )
{
    byte[] transplant = new byte[length];

    System.arraycopy(data, pos, transplant, 0, length);

    return transplant;
}