Lấy một đoạn của một mảng trong Java mà không tạo một mảng mới trên heap

Tôi đang tìm kiếm một phương thức trong Java sẽ trả về một phân đoạn của một mảng. Một ví dụ sẽ là lấy mảng byte chứa byte thứ 4 và thứ 5 của mảng byte. Tôi không muốn phải tạo một mảng byte mới trong bộ nhớ heap chỉ để làm điều đó. Ngay bây giờ tôi có mã sau đây:

doSomethingWithTwoBytes(byte[] twoByteArray);

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

Tôi muốn biết nếu có một cách để làm doSomething(bigArray.getSubArray(4, 2))trong đó 4 là phần bù và 2 là chiều dài chẳng hạn.

Tuyên bố miễn trừ trách nhiệm: Câu trả lời này không phù hợp với các ràng buộc của câu hỏi:

Tôi không muốn phải tạo một mảng byte mới trong bộ nhớ heap chỉ để làm điều đó.

( Thành thật mà nói, tôi cảm thấy câu trả lời của mình đáng bị xóa. Câu trả lời của @ unique72 là chính xác. Imma hãy để bản chỉnh sửa này ngồi một chút và sau đó tôi sẽ xóa câu trả lời này. )

Tôi không biết cách nào để thực hiện việc này trực tiếp với mảng mà không cần phân bổ heap bổ sung, nhưng các câu trả lời khác sử dụng trình bao bọc danh sách phụ chỉ có phân bổ bổ sung cho trình bao bọc - nhưng không phải là mảng - sẽ hữu ích trong trường hợp một mảng lớn.

Điều đó nói rằng, nếu một người đang tìm kiếm sự ngắn gọn, phương thức tiện ích Arrays.copyOfRange()đã được giới thiệu trong Java 6 (cuối năm 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)ủy quyền cho mới ArrayList(myArray), không sao chép mảng mà chỉ lưu trữ tham chiếu. Sử dụng List.subList(start, end)sau đó làm cho một SubListcái mà chỉ tham chiếu danh sách ban đầu (mà vẫn chỉ tham chiếu mảng). Không sao chép mảng hoặc nội dung của nó, chỉ tạo trình bao bọc và tất cả các danh sách liên quan đều được hỗ trợ bởi mảng ban đầu. (Tôi nghĩ nó sẽ nặng hơn.)

Nếu bạn đang tìm kiếm một cách tiếp cận bí danh kiểu con trỏ, do đó bạn thậm chí không cần phân bổ không gian và sao chép dữ liệu thì tôi tin rằng bạn đã hết may mắn.

System.arraycopy() sẽ sao chép từ nguồn của bạn đến đích và hiệu quả được yêu cầu cho tiện ích này. Bạn cần phân bổ mảng đích.

Một cách là bọc mảng trong java.nio.ByteBuffer , sử dụng các hàm put / get tuyệt đối và cắt bộ đệm để làm việc trên một phân đoạn.

Ví dụ:

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

Lưu ý rằng bạn phải gọi cả hai wrap()và slice(), vì wrap()chính nó chỉ ảnh hưởng đến các hàm put / get tương đối, chứ không phải các hàm tuyệt đối.

ByteBuffer có thể hơi khó hiểu, nhưng rất có thể được thực hiện một cách hiệu quả và rất đáng để học hỏi.

Sử dụng java.nio.Buffer. Đây là một trình bao bọc nhẹ dành cho bộ đệm thuộc nhiều kiểu nguyên thủy khác nhau và giúp quản lý việc cắt, vị trí, chuyển đổi, sắp xếp byte, v.v.

Nếu byte của bạn bắt nguồn từ Luồng, Bộ đệm NIO có thể sử dụng "chế độ trực tiếp" để tạo bộ đệm được hỗ trợ bởi tài nguyên bản địa. Điều này có thể cải thiện hiệu suất trong rất nhiều trường hợp.

Bạn có thể sử dụng ArrayUtils.subarray trong apache commons. Không hoàn hảo nhưng trực quan hơn một chút so với System.arraycopy. nhược điểm là nó giới thiệu một phụ thuộc khác vào mã của bạn.

Tôi thấy câu trả lời của SubList đã có ở đây, nhưng đây là đoạn mã chứng minh rằng đó là một danh sách con thực sự, không phải là một bản sao:

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

Tuy nhiên, tôi không tin rằng có một cách tốt để làm điều này trực tiếp với mảng.

List.subList(int startIndex, int endIndex)

Một tùy chọn sẽ là vượt qua toàn bộ mảng và các chỉ số bắt đầu và kết thúc, và lặp lại giữa các mảng thay vì lặp lại trên toàn bộ mảng được truyền.

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

Các Lists cho phép bạn sử dụng và làm việc với subListmột cái gì đó trong suốt. Mảng nguyên thủy sẽ yêu cầu bạn theo dõi một số loại giới hạn bù.ByteBuffers có các tùy chọn tương tự như tôi đã nghe.

Chỉnh sửa: Nếu bạn phụ trách phương thức hữu ích, bạn chỉ có thể định nghĩa nó bằng giới hạn (như được thực hiện trong nhiều phương thức liên quan đến mảng trong chính java:

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

Tuy nhiên, điều đó không rõ ràng nếu bạn tự làm việc với các phần tử mảng, ví dụ: bạn tính toán một cái gì đó và viết lại kết quả?

Các tham chiếu Java luôn trỏ đến một đối tượng. Đối tượng có một tiêu đề trong số những thứ khác xác định loại cụ thể (vì vậy phôi có thể thất bại vớiClassCastException ). Đối với các mảng, phần bắt đầu của đối tượng cũng bao gồm độ dài, dữ liệu sẽ xuất hiện ngay sau đó trong bộ nhớ (về mặt kỹ thuật, việc triển khai là tự do để làm những gì nó làm, nhưng nó sẽ không làm gì khác). Vì vậy, bạn không thể có một tham chiếu chỉ ra đâu đó thành một mảng.

Trong C con trỏ chỉ bất cứ nơi nào và bất cứ điều gì, và bạn có thể chỉ vào giữa một mảng. Nhưng bạn không thể sử dụng một cách an toàn hoặc tìm ra mảng dài bao nhiêu. Trong D, con trỏ chứa phần bù vào khối bộ nhớ và chiều dài (hoặc tương đương con trỏ đến cuối, tôi không thể nhớ việc thực hiện thực sự làm gì). Điều này cho phép D cắt các mảng. Trong C ++, bạn sẽ có hai vòng lặp trỏ đến điểm bắt đầu và kết thúc, nhưng C ++ hơi kỳ quặc như thế.

Vì vậy, quay trở lại Java, không có bạn không thể. Như đã đề cập, NIO ByteBuffercho phép bạn bọc một mảng và sau đó cắt nó, nhưng cung cấp một giao diện khó xử. Tất nhiên bạn có thể sao chép, có lẽ nhanh hơn rất nhiều so với bạn nghĩ. Bạn có thể giới thiệu sự Stringtrừu tượng giống như của riêng bạn , cho phép bạn cắt một mảng (triển khai Mặt trời hiện tại Stringcó char[]tham chiếu cộng với độ lệch bắt đầu và độ dài, thực hiện hiệu suất cao hơn chỉ có char[]). byte[]ở mức độ thấp, nhưng bất kỳ sự trừu tượng hóa dựa trên lớp nào mà bạn đưa vào sẽ tạo ra một mớ hỗn độn khủng khiếp của cú pháp, cho đến khi JDK7 (có lẽ).

@ unique72 trả lời dưới dạng một hàm hoặc dòng đơn giản, bạn có thể cần thay thế Object, với loại lớp tương ứng mà bạn muốn 'cắt'. Hai biến thể được đưa ra để phù hợp với nhu cầu khác nhau.

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

Làm thế nào về một Listbọc mỏng ?

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

(Chưa được kiểm tra)

Tôi cần lặp lại đến hết một mảng và không muốn sao chép mảng đó. Cách tiếp cận của tôi là tạo ra một Iterable trên mảng.

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

Đây là một chút nhẹ hơn Arrays.copyOfRange - không có phạm vi hoặc tiêu cực

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