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[]，创建字节列表并使用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） - count（2）所以4项（所以[3,4,5， 6]）并将它们复制到数组[0]。这将用[3,4,5,6]覆盖数组的前4项，所以你将[3,4,5,6,5,6]。请注意，您从未对最后两个值执行任何操作。这只是价值观，而不是旋转它们。如果你想旋转它们，你必须保存你要覆盖的值，然后在最后写它们。

Answer 3

它看起来是正确的，因为System.arraycopy将5个参数作为：

您的案例中的数组
来源位置：在您的情况2中，即第3个元素。
目标数组：数组，源和目标数组在你的情况下是相同的。
目的地位置：在您的情况下，即阵列的开始。
长度：要移动的元素数量，6-2 = 4，即从第3个，第4个移动，第5个，第6个元素到第0个，第1个，第2个，第3个，所以第5个和第6个不是改变。

看起来正在做正确的转变。

Answer 4

请参阅docs。

public static void arraycopy（Object src， int srcPos，对象dest， int destPos， int length）

它会复制{length}个元素。在您的代码中，您正在复制array.length-count，这意味着您只复制4个元素。最后两个元素不会从源复制。所以源值保持不变。

移动阵列

4 个答案: