Java方法参数是否被突变？

Question

由于某种原因,我的方法perfectShuffle(int [] values)正在改变传递给它的参数,请告诉我为什么这是......这对我没有意义,因为Java是一种"通过价值传递"编程语言.

public class Shuffler {

    /**
     * The number of consecutive shuffle steps to be performed in each call to
     * each sorting procedure.
     */
    private static final int SHUFFLE_COUNT = 4;

    /**
     * The number of values to shuffle.
     */
    private static final int VALUE_COUNT = 5;

    /**
     * Tests shuffling methods.
     * 
     * @param args
     *            is not used.
     */
    public static void main(String[] args) {
        System.out.println("Results of " + SHUFFLE_COUNT
                + " consecutive perfect shuffles:");
        int[] values1 = new int[VALUE_COUNT];
        for (int i = 0; i < values1.length; i++) {
            values1[i] = i;
        }
        for (int j = 1; j <= SHUFFLE_COUNT; j++) {
            perfectShuffle(values1);
            System.out.print("  " + j + ":");
            for (int k = 0; k < values1.length; k++) {
                System.out.print(" " + values1[k]);
            }
            System.out.println();
        }
        System.out.println();

        System.out.println("Results of " + SHUFFLE_COUNT
                + " consecutive efficient selection shuffles:");
        int[] values2 = new int[VALUE_COUNT];
        for (int i = 0; i < values2.length; i++) {
            values2[i] = i;
        }
        for (int j = 1; j <= SHUFFLE_COUNT; j++) {
            values2 = selectionShuffle(values2);
            System.out.print("  " + j + ":");
            for (int k = 0; k < values2.length; k++) {
                System.out.print(" " + values2[k]);
            }
            System.out.println();
        }
        System.out.println();
    }

    /**
     * Apply a "perfect shuffle" to the argument. The perfect shuffle algorithm
     * splits the deck in half, then interleaves the cards in one half with the
     * cards in the other.
     * 
     * @param values
     *            is an array of integers simulating cards to be shuffled.
     */
    public static void perfectShuffle(int[] values) {
        int max = (values.length+1)/2;
        int[] shuffled = new int[values.length];
        int k = 0;
        for (int j = 0; j < (values.length); j++) {
            shuffled[k] = values[j];
            k++;
        }
        k = 0;
        for (int j = 0; j < max; j++) {
            values[k] = shuffled[j];
            k += 2;
        }
        k=1;
        for (int j = max+1; j < values.length; j++){
            values[k] = shuffled[j];
            k+=2;
        }
    }

    /**
     * Apply an "efficient selection shuffle" to the argument. The selection
     * shuffle algorithm conceptually maintains two sequences of cards: the
     * selected cards (initially empty) and the not-yet-selected cards
     * (initially the entire deck). It repeatedly does the following until all
     * cards have been selected: randomly remove a card from those not yet
     * selected and add it to the selected cards. An efficient version of this
     * algorithm makes use of arrays to avoid searching for an as-yet-unselected
     * card.
     * 
     * @param values
     *            is an array of integers simulating cards to be shuffled.
     */
    public static int[] selectionShuffle(int[] values) {
        Random rand = new Random();
        for (int k = values.length - 1; k > 0; k--) {
            int r = rand.nextInt((k) + 1);
            int transfer = values[k];
            values[k] = values[r];
            values[r] = transfer;
        }
        return values;
    }


}

Answer 1

实际上,传递的值是对数组的引用,因此在数组上操作会直接改变调用者中数组的内容.使用数组的副本来确保不变性.