Смещение массива

Question

Я вижу этот код в книге, что его задача - смещение массива.

public void arrayshift(int count) { 
    synchronized (array) { 
     System.arraycopy(array, count, array, 0, array.length - count); 
    } 
} 

Теперь я запускаю этот код, как показано ниже, но результат неправильный!

public class t2 { 

static byte array[] = new byte[]{1, 2, 3, 4, 5, 6}; 

public void arrayshift(int count) { 
    synchronized (array) { 
     System.arraycopy(array, count, array, 0, array.length - count); 
    } 
} 

public static void main(String[] args) { 
    System.out.println("First array: " + Arrays.toString(array)); 
    new t2().arrayshift(2); 
    System.out.println("After two shift is: " + Arrays.toString(array)); 
    } 
} 

Результат:

First array: [1, 2, 3, 4, 5, 6] 
After two shift is: [3, 4, 5, 6, 5, 6] 

Answer 1

Чтобы действительно повернуть есть альтернативный способ, с помощью Collections.rotate()

В вашем случае, вы можете конвертировать byte[] в Byte[], создать список Bytes и вращать с помощью Collections.rotate()

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

Ваш измененный код:

static byte array[] = new byte[] { 1, 2, 3, 4, 5, 6 }; 
    static List<Byte> list = new ArrayList<Byte>(); 

    public static void main(String[] args) { 
     System.out.println("First array: " + Arrays.toString(array)); 
     new Rotate().arrayshift(2); 
     System.out.println("After two shift is: "); 
     for (Byte b : list.toArray(new Byte[list.size()])) 
      System.out.print(b.byteValue() + ", "); 
    } 

    public void arrayshift(int count) { 
     synchronized (array) { 
      Byte[] byteObjects = new Byte[array.length]; 
      int i = 0; 
      for (byte b : array) 
       byteObjects[i++] = b; 
      list = Arrays.asList(byteObjects); 
      Collections.rotate(list, count); 
     } 
    } 

Выход:

First array: [1, 2, 3, 4, 5, 6] 
After two shift is: 
5, 6, 1, 2, 3, 4, 

Answer 2

Результаты являются правильными.

System.arraycopy(array, count, array, 0, array.length - count);

Параметры функции являются:

Object src, 
int srcPos, 
Object dest, 
int destPos, 
int length 

Таким образом, вы принимаете из массива [2] вперед (так 3, 4, 5, 6), вы принимаете array.length (6) - счет (2), поэтому 4 элемента (так [3, 4, 5, 6]), и вы копируете их в массив [0]. Это перезапишет первые 4 элемента массива вашим [3,4,5,6], так что у вас будет [3,4,5,6,5,6]. Обратите внимание, что вы никогда ничего не делали с последними двумя значениями. Это просто сдвигает значения, а не вращает их. Если вы хотите повернуть их, вам придется сохранить значения, которые вы собираетесь перезаписать, а затем записать их в конце.

Answer 3

Это выглядит правильно, потому что System.arraycopy принимает 5 параметров, как:

1. Источник массив: массив в вашем случае
2. Источник положение: в вашем случае 2, то есть 3 элемент.
3. Целевой массив: массив в вашем случае, источник и целевая матрица такие же, как ур.
4. Место назначения: в вашем случае, т.е. начало массива.
5. Длина: сколько элементов для перемещения, 6-2 = 4, то есть переход от 3-го, 4-го, 5, 6 элемента на 0-й, 1-й, 2-й, 3-й, так что 5 и 6 не изменились.

Похоже, что это правильный сдвиг.

Answer 4

См. docs.

государственной статической силы ArrayCopy (ЦСИ Object, INT srcPos, Object DEST и INT destPos, ИНТ длина)

Это будет копировать {длина} число элементов. В коде вы копируете array.length-count, что означает, что вы копируете только 4 элемента. Последние два элемента не копируются из источника. Таким образом, исходное значение остается.