Pegue um segmento de uma matriz em Java sem criar uma nova matriz na pilha

Estou procurando um método em Java que retornará um segmento de uma matriz. Um exemplo seria obter a matriz de bytes que contém os 4º e 5º bytes de uma matriz de bytes. Não quero ter que criar uma nova matriz de bytes na memória heap apenas para fazer isso. No momento, tenho o seguinte código:

doSomethingWithTwoBytes(byte[] twoByteArray);

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

Eu gostaria de saber se havia uma maneira de fazer apenas doSomething(bigArray.getSubArray(4, 2))onde 4 é o deslocamento e 2 é o comprimento, por exemplo.

Isenção de responsabilidade: Esta resposta não está de acordo com as restrições da pergunta:

Não quero ter que criar uma nova matriz de bytes na memória heap apenas para fazer isso.

( Sinceramente, acho que minha resposta merece ser excluída. A resposta de @ unique72 está correta. Vou deixar essa edição descansar um pouco e depois excluirei essa resposta. )

Não conheço uma maneira de fazer isso diretamente com matrizes sem alocação de heap adicional, mas as outras respostas usando um wrapper de sub-lista têm alocação adicional apenas para o wrapper - mas não o array - o que seria útil no caso de uma grande variedade.

Dito isto, se alguém procura concisão, o método utilitário Arrays.copyOfRange()foi introduzido no Java 6 (final de 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)delega para new ArrayList(myArray), que não copia a matriz, mas apenas armazena a referência. Usar List.subList(start, end)depois disso cria um SubListque apenas faz referência à lista original (que ainda apenas faz referência à matriz). Nenhuma cópia da matriz ou seu conteúdo, apenas a criação do wrapper e todas as listas envolvidas são apoiadas pela matriz original. (Eu pensei que seria mais pesado.)

Se você está procurando uma abordagem de alias no estilo de ponteiro, para que nem precise alocar espaço e copiar os dados, acredito que não tenha sorte.

System.arraycopy() será copiado da sua origem para o destino e a eficiência é reivindicada para este utilitário. Você precisa alocar a matriz de destino.

Uma maneira é envolver a matriz em java.nio.ByteBuffer , usar as funções absolutas de put / get e dividir o buffer para trabalhar em um subarray.

Por exemplo:

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());
}

Observe que você precisa chamar os dois wrap()e slice(), uma vez que, wrap()por si só, afeta as funções put / get relativas, não as absolutas.

ByteBuffer pode ser um pouco complicado de entender, mas provavelmente é implementado com eficiência e vale a pena aprender.

Use java.nio.Buffer. É um invólucro leve para buffers de vários tipos primitivos e ajuda a gerenciar fatias, posições, conversões, pedidos de bytes, etc.

Se seus bytes forem originários de um fluxo, os NIO Buffers poderão usar o "modo direto", que cria um buffer suportado por recursos nativos. Isso pode melhorar o desempenho em muitos casos.

Você pode usar o ArrayUtils.subarray no apache commons. Não é perfeito, mas um pouco mais intuitivo do que System.arraycopy. o lado negativo é que ele introduz outra dependência no seu código.

Vejo que a resposta subList já está aqui, mas aqui está o código que demonstra que é uma verdadeira sublist, não uma cópia:

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));
    }
}

Porém, não acredito que exista uma boa maneira de fazer isso diretamente com matrizes.

List.subList(int startIndex, int endIndex)

Eles Listpermitem que você use e trabalhe com subListalgo de forma transparente. Matrizes primitivas exigiriam que você acompanhasse algum tipo de limite de deslocamento. ByteBuffers têm opções semelhantes às que ouvi.

Edit: Se você é responsável pelo método útil, você pode defini-lo com limites (como feito em muitos métodos relacionados à matriz no próprio java:

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

Não está claro, no entanto, se você trabalha com os próprios elementos da matriz, por exemplo, calcula algo e escreve o resultado?

Uma opção seria passar toda a matriz e os índices de início e fim e iterar entre eles, em vez de iterar sobre toda a matriz passada.

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

As referências Java sempre apontam para um objeto. O objeto possui um cabeçalho que, entre outras coisas, identifica o tipo concreto (para que as transmissões possam falhar comClassCastException ). Para matrizes, o início do objeto também inclui o comprimento, os dados seguem imediatamente depois na memória (tecnicamente, uma implementação é livre para fazer o que bem entender, mas seria imprudente fazer qualquer outra coisa). Portanto, você não pode ter uma referência que aponte em algum lugar de uma matriz.

Em ponteiros C, aponte para qualquer lugar e para qualquer coisa, e você pode apontar para o meio de uma matriz. Mas você não pode transmitir ou descobrir com segurança quanto tempo a matriz é. Em D, o ponteiro contém um deslocamento no bloco e no comprimento da memória (ou um ponteiro equivalente ao final, não me lembro o que a implementação realmente faz). Isso permite que D divida matrizes. No C ++, você teria dois iteradores apontando para o início e o fim, mas o C ++ é um pouco estranho assim.

Então, voltando ao Java, não, você não pode. Como mencionado, o NIO ByteBufferpermite agrupar uma matriz e, em seguida, cortá-la, mas fornece uma interface estranha. É claro que você pode copiar, o que provavelmente é muito mais rápido do que você imagina. Você pode apresentar sua própria Stringabstração que permite dividir uma matriz (a implementação atual da Sun Stringtem uma char[]referência mais um deslocamento inicial e comprimento, a implementação de desempenho mais alto apenas possui a char[]). byte[]é de baixo nível, mas qualquer abstração baseada em classe que você colocar fará uma bagunça terrível da sintaxe, até o JDK7 (talvez).

@ unique72 responda como uma função ou linha simples, pode ser necessário substituir Object pelo tipo de classe que você deseja 'cortar'. Duas variantes são fornecidas para atender a várias necessidades.

/// 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 tal um Listinvólucro fino ?

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;
      }
   };
}

(Não testado)

Eu precisava percorrer o final de uma matriz e não queria copiar a matriz. Minha abordagem foi tornar um Iterable sobre a matriz.

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");
        }
      };
    }
  };
}

Isso é um pouco mais leve que Arrays.copyOfRange - sem intervalo ou negativo

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;
}