Захватите сегмент массива в 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 правильный. Имма, пусть это изменение займет некоторое время, а затем я удалю этот ответ. )

Я не знаю способа сделать это напрямую с массивами без дополнительного выделения кучи, но другие ответы, использующие оболочку подсписка, имеют дополнительное выделение только для оболочки - но не для массива - что было бы полезно в случае большой массив.

Тем не менее, если кто-то ищет краткость, 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)делегирует new ArrayList(myArray), который не копирует массив, а просто хранит ссылку. Использование List.subList(start, end)после этого делает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()само по себе влияет только на относительные функции put / get, а не на абсолютные.

ByteBuffer может быть немного сложным для понимания, но, скорее всего, эффективно реализовано и заслуживает изучения.

Используйте java.nio.Buffer's. Это облегченная оболочка для буферов различных примитивных типов, которая помогает управлять нарезкой, позицией, преобразованием, упорядочением байтов и т. Д.

Если ваши байты происходят из потока, буферы NIO могут использовать «прямой режим», который создает буфер, поддерживаемый собственными ресурсами. Это может улучшить производительность во многих случаях.

Вы можете использовать ArrayUtils.subarray в Apache Commons. Не идеальный, но немного более интуитивный, чем System.arraycopy. недостаток в том, что он вводит другую зависимость в ваш код.

Я вижу, что ответ подсписка уже здесь, но вот код, который демонстрирует, что это настоящий подсписок, а не копия:

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)

Они Listпозволяют вам использовать и работать с subListчем-то прозрачным. Примитивные массивы требуют, чтобы вы отслеживали какой-то предел смещения. ByteBufferУ меня есть похожие варианты, как я слышал.

Редактировать: если вы отвечаете за полезный метод, вы можете просто определить его с помощью границ (как это делается во многих связанных с массивом методах в самой java:

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

Однако не ясно, работаете ли вы над самими элементами массива, например, что-то вычисляете и записываете результат?

Одним из вариантов будет передача всего массива и индексов начала и конца и итерация между ними вместо перебора всего переданного массива.

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

Ссылки 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;
}