힙에 새 배열을 만들지 않고 Java에서 배열의 세그먼트를 가져옵니다.

Java에서 배열의 세그먼트를 반환하는 메소드를 찾고 있습니다. 예를 들어 바이트 배열의 4 번째 및 5 번째 바이트를 포함하는 바이트 배열을 얻는 것이 있습니다. 힙 메모리에 새로운 바이트 배열을 만들고 싶지는 않습니다. 현재 다음 코드가 있습니다.

doSomethingWithTwoBytes(byte[] twoByteArray);

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

doSomething(bigArray.getSubArray(4, 2))예를 들어 4가 오프셋이고 2가 길이 인 곳을 수행하는 방법이 있는지 알고 싶습니다 .

면책 조항 :이 답변은 질문의 제약 조건을 준수하지 않습니다 :

힙 메모리에 새로운 바이트 배열을 만들고 싶지는 않습니다.

( 솔직히, 내 대답은 삭제할 가치가 있다고 생각합니다. @ unique72의 대답은 정확합니다. Imma는이 편집 내용을 잠시 앉아서 다음 대답을 삭제합니다. )

추가 힙 할당없이 배열로 직접이 작업을 수행하는 방법을 모르지만 하위 목록 래퍼를 사용하는 다른 답변에는 래퍼에 대한 추가 할당이 있지만 배열은 아닙니다.이 경우에는 유용합니다. 큰 배열.

즉, 간결성을 찾고 있다면 유틸리티 방법 Arrays.copyOfRange()이 Java 6 (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)ArrayList(myArray)배열을 복사하지 않고 참조를 저장하는 new에 위임합니다 . List.subList(start, end)그 후에 사용 하면 a SubList는 원래 목록을 참조합니다 (아직도 배열을 참조합니다). 배열이나 그 내용을 복사하거나 래퍼를 만들지 않고 관련된 모든 목록은 원래 배열로 백업됩니다. (더 무겁다 고 생각했습니다.)

포인터 스타일의 앨리어싱 접근 방식을 찾고 있다면 공간을 할당하고 데이터를 복사 할 필요가 없으므로 운이 좋지 않다고 생각합니다.

System.arraycopy() 소스에서 대상으로 복사되며이 유틸리티의 효율성이 요구됩니다. 대상 배열을 할당해야합니다.

한 가지 방법은에서 배열을 래핑하고 java.nio.ByteBuffer절대 put / get 함수를 사용하고 하위 배열에서 작동하도록 버퍼를 슬라이스하는 것입니다.

예를 들어 :

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

참고이 모두를 호출해야한다는 wrap()하고 slice()있기 때문에, wrap()단지 상대 풋에 영향을 미치는 그 자체로 / 기능이 아닌 절대 사람을 얻는다.

ByteBuffer 이해하기가 약간 까다로울 수 있지만 대부분 효율적으로 구현되며 학습 가치가 있습니다.

java.nio.Buffer를 사용하십시오. 다양한 기본 유형의 버퍼를위한 경량 래퍼이며 슬라이싱, 위치, 변환, 바이트 순서 등을 관리하는 데 도움이됩니다.

바이트가 스트림에서 시작된 경우 NIO 버퍼는 "직접 모드"를 사용하여 기본 자원이 지원하는 버퍼를 만듭니다. 이것은 많은 경우에 성능을 향상시킬 수 있습니다.

ApacheUtils 에서 ArrayUtils.subarray 를 사용할 수 있습니다 . 완벽하지는 않지만 약간 직관적 인 System.arraycopy. 단점은 코드에 또 다른 의존성을 도입한다는 것입니다.

subList 답변이 이미 여기에 있지만 사본이 아닌 실제 하위 목록임을 보여주는 코드가 있습니다.

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

그러나 배열로 직접 이것을 수행하는 좋은 방법이 없다고 생각합니다.

List.subList(int startIndex, int endIndex)

하나의 옵션은 전체 배열과 시작 및 끝 인덱스를 전달하고 전달 된 전체 배열을 반복하는 대신 이들 사이를 반복하는 것입니다.

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

List들 당신이 작업을 사용할 수 있도록 subList투명하게 뭔가. 기본 배열은 어떤 종류의 오프셋-제한을 추적해야합니다. ByteBuffer들었던 것과 비슷한 옵션이 있습니다.

편집 : 유용한 메소드를 담당하는 경우 Java 자체의 많은 배열 관련 메소드에서와 같이 범위를 사용하여 정의 할 수 있습니다.

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

그러나 배열 요소 자체에서 작업하는 경우, 예를 들어 무언가를 계산하고 결과를 다시 쓰는 것이 확실하지 않습니까?

Java 참조는 항상 객체를 가리 킵니다. 객체에는 무엇보다도 콘크리트 유형을 식별하는 헤더가 있습니다 (따라서 캐스트가 실패 할 수 있음 ClassCastException). 배열의 경우 객체의 시작 부분에도 길이가 포함되며 데이터는 메모리에서 바로 뒤를 따릅니다 (기술적으로 구현은 원하는대로 자유롭게 수행 할 수 있지만 다른 일을하는 것은 멍청합니다). 따라서 어딘가에 배열을 가리키는 참조를 가질 수 없습니다.

C 포인터는 어느 곳에서나 가리킬 수 있으며 배열의 가운데를 가리킬 수 있습니다. 그러나 어레이의 길이를 안전하게 캐스팅하거나 확인할 수는 없습니다. D에서 포인터는 메모리 블록과 길이에 대한 오프셋을 포함합니다 (또는 끝에 대한 포인터와 마찬가지로 구현이 실제로 무엇을하는지 기억할 수 없습니다). 이를 통해 D는 배열을 슬라이스 할 수 있습니다. C ++에서는 시작과 끝을 가리키는 두 개의 반복자가 있지만 C ++은 약간 이상합니다.

Java로 돌아 가면 할 수 없습니다. 언급했듯이 NIO를 ByteBuffer사용하면 배열을 래핑 한 다음 슬라이스 할 수 있지만 어색한 인터페이스를 제공합니다. 물론 복사 할 수도 있는데, 생각보다 훨씬 빠릅니다. String배열을 슬라이스 할 수있는 고유 한 추상화를 도입 할 수 있습니다 (현재 Sun 구현 String에는 char[]참조와 시작 오프셋 및 길이가 있고 고성능 구현에는 char[]) 만 있습니다 . byte[]저수준이지만 클래스 기반 추상화는 JDK7 (아마)까지 구문을 엉망으로 만듭니다.

@ unique72는 간단한 함수 또는 라인으로 응답하므로 Object를 '슬라이스'하려는 각 클래스 유형으로 바꿔야 할 수도 있습니다. 다양한 요구에 맞게 두 가지 변형이 제공됩니다.

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

얇은 List포장지는 어떻습니까?

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

(테스트되지 않은)

배열 끝까지 반복해야했고 배열을 복사하고 싶지 않았습니다. 내 접근 방식은 배열 위에 Iterable을 만드는 것입니다.

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

이것은 Arrays.copyOfRange보다 약간 가벼우 며 범위가 없거나 음수입니다.

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