Raih segmen array di Java tanpa membuat array baru di heap

Saya mencari metode di Jawa yang akan mengembalikan segmen array. Contohnya adalah untuk mendapatkan array byte yang berisi byte 4 dan 5 byte array. Saya tidak ingin harus membuat array byte baru di memori tumpukan hanya untuk melakukan itu. Saat ini saya memiliki kode berikut:

doSomethingWithTwoBytes(byte[] twoByteArray);

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

Saya ingin tahu apakah ada cara untuk melakukan di doSomething(bigArray.getSubArray(4, 2))mana 4 adalah offset dan 2 adalah panjang, misalnya.

Penafian: Jawaban ini tidak sesuai dengan batasan pertanyaan:

Saya tidak ingin harus membuat array byte baru di memori tumpukan hanya untuk melakukan itu.

( Jujur, saya merasa jawaban saya layak dihapus. Jawaban oleh @ unique72 sudah benar. Imma membiarkan edit ini berlangsung sebentar dan kemudian saya akan menghapus jawaban ini. )

Saya tidak tahu cara untuk melakukan ini secara langsung dengan array tanpa alokasi tumpukan tambahan, tetapi jawaban lain menggunakan pembungkus sub-daftar memiliki alokasi tambahan hanya untuk pembungkus - tetapi tidak array - yang akan berguna dalam kasus array yang besar.

Yang mengatakan, jika seseorang mencari singkatnya, metode utilitas Arrays.copyOfRange()diperkenalkan di Java 6 (akhir 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)delegasi ke yang baru ArrayList(myArray), yang tidak menyalin array tetapi hanya menyimpan referensi. Menggunakan List.subList(start, end)setelah itu membuat SubListyang hanya mereferensikan daftar asli (yang masih hanya referensi array). Tidak ada salinan array atau isinya, hanya pembuatan wrapper, dan semua daftar yang terlibat didukung oleh array asli. (Saya pikir itu akan lebih berat.)

Jika Anda mencari pendekatan aliasing gaya pointer, sehingga Anda bahkan tidak perlu mengalokasikan ruang dan menyalin data maka saya yakin Anda kurang beruntung.

System.arraycopy() akan menyalin dari sumber Anda ke tujuan, dan efisiensi diklaim untuk utilitas ini. Anda perlu mengalokasikan array tujuan.

Salah satu caranya adalah dengan membungkus array java.nio.ByteBuffer, menggunakan fungsi put / get absolut, dan mengiris buffer untuk bekerja pada subarray.

Misalnya:

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

Perhatikan bahwa Anda harus memanggil keduanya wrap()dan slice(), karena wrap()dengan sendirinya hanya memengaruhi fungsi put / get relatif, bukan yang absolut.

ByteBuffer bisa agak sulit untuk dipahami, tetapi kemungkinan besar dilaksanakan secara efisien, dan layak untuk dipelajari.

Gunakan java.nio.Buffer's. Ini adalah pembungkus ringan untuk buffer dari berbagai jenis primitif dan membantu mengelola pengirisan, posisi, konversi, pemesanan byte, dll.

Jika byte Anda berasal dari Stream, NIO Buffer dapat menggunakan "mode langsung" yang menciptakan buffer yang didukung oleh sumber daya asli. Ini dapat meningkatkan kinerja dalam banyak kasus.

Anda bisa menggunakan ArrayUtils.subarray di apache commons. Tidak sempurna tetapi sedikit lebih intuitif daripada System.arraycopy. The downside adalah bahwa hal itu memperkenalkan ketergantungan lain ke dalam kode Anda.

Saya melihat jawaban subList sudah ada di sini, tetapi di sini kode yang menunjukkan bahwa itu adalah sublist yang benar, bukan salinan:

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

Saya tidak percaya ada cara yang baik untuk melakukan ini secara langsung dengan array.

List.subList(int startIndex, int endIndex)

The Lists memungkinkan Anda untuk menggunakan dan bekerja dengan subListsesuatu transparan. Array primitif akan mengharuskan Anda untuk melacak semacam batas offset. ByteBuffers memiliki opsi yang sama seperti yang saya dengar.

Sunting: Jika Anda bertanggung jawab atas metode yang berguna, Anda bisa mendefinisikannya dengan batas (seperti yang dilakukan dalam banyak metode terkait array di java itu sendiri:

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

Namun, tidak jelas apakah Anda mengerjakan sendiri elemen array, mis. Anda menghitung sesuatu dan menulis kembali hasilnya?

Salah satu opsi adalah untuk melewatkan seluruh array dan indeks awal dan akhir, dan beralih di antara mereka bukan iterasi atas seluruh array yang dilewati.

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

Referensi Java selalu menunjuk ke suatu objek. Objek memiliki header yang antara lain mengidentifikasi jenis beton (sehingga gips dapat gagalClassCastException ). Untuk array, awal objek juga termasuk panjang, data kemudian mengikuti segera setelah dalam memori (secara teknis implementasi bebas untuk melakukan apa yang diinginkan, tetapi akan sangat bodoh untuk melakukan hal lain). Jadi, Anda tidak bisa; t memiliki referensi yang menunjuk suatu tempat ke dalam array.

Dalam C pointer arahkan ke mana saja dan ke apa saja, dan Anda bisa menunjuk ke tengah array. Tetapi Anda tidak dapat dengan aman membuang atau mencari tahu berapa lama array itu. Dalam D pointer berisi offset ke blok memori dan panjang (atau setara dengan pointer ke ujung, saya tidak ingat apa implementasi sebenarnya). Ini memungkinkan D untuk mengiris array. Dalam C ++ Anda akan memiliki dua iterator yang menunjuk ke awal dan akhir, tetapi C ++ agak aneh seperti itu.

Jadi kembali ke Jawa, tidak, kamu tidak bisa. Seperti yang disebutkan, NIO ByteBuffermemungkinkan Anda untuk membungkus array dan kemudian mengirisnya, tetapi memberikan antarmuka yang canggung. Tentu saja Anda bisa menyalin, yang mungkin jauh lebih cepat daripada yang Anda bayangkan. Anda dapat memperkenalkan Stringabstraksi Anda sendiri- seperti yang memungkinkan Anda untuk mengiris array (implementasi Sun saat ini Stringmemiliki char[]referensi plus offset dan panjang mulai, implementasi kinerja yang lebih tinggi hanya memiliki char[]). byte[]tingkat rendah, tetapi abstraksi berbasis kelas apa pun yang Anda pakai yang akan membuat berantakan sintaks yang mengerikan, sampai JDK7 (mungkin).

@ unique72 menjawab sebagai fungsi atau garis sederhana, Anda mungkin perlu mengganti Object, dengan tipe kelas yang ingin Anda 'slice'. Dua varian diberikan sesuai dengan berbagai kebutuhan.

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

Bagaimana dengan Listbungkus tipis ?

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

(Belum dicoba)

Saya perlu mengulang melalui akhir array dan tidak ingin menyalin array. Pendekatan saya adalah membuat Iterable di atas array.

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

Ini sedikit lebih ringan daripada Array.copyOfRange - tidak ada rentang atau negatif

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