为什么将数组传递给另一个方法会改变原始数组?

时间:2013-02-20 15:42:40

标签: java arrays

在下面的代码中,调用swapBig(a,some number,somenumber),其中a是一个数组,被复制到swapBig()中的bleh []。当交换bleh []中的值时,[]中的相应值也会更改。为什么会发生这种情况,以及如何编写代码以便只修改bleh []而不是原始的a []?非常感谢!

public static void swapBig(String bleh[], int to, int from){ //switches data
    //Actually performing the swaps
    String temp;
    temp = bleh[to];
    bleh[to] = bleh[from];
    bleh[from] = temp;
}
public static void quickSort(String a[], String b[], String c[], String d[],
String e[],String f[], int from, int to){
    //performing the quickSort
    if (from >= to) return;
    int p = (from + to) / 2;
    int i = from;
    int j = to;
    while (i <= j){
        if (a[i].compareTo(a[p]) <= 0)
            i++;
        else if (a[j].compareTo(a[p]) >= 0)
            j--;
        else{
            swapBig(a, i, j);
            swapBig(b, i, j);
            swapBig(c, i, j);
            swapBig(d, i, j);
            swapBig(e, i, j);
            swapBig(f, i, j);
            i++;
            j--;
        }
    }
    if (p<j){
        swapBig(a, p, j);
        swapBig(b, p, j);
        swapBig(c, p, j);
        swapBig(d, p, j);
        swapBig(e, p, j);
        swapBig(f, p, j);
        p = j;
    }else if (p>i){
        swapBig(a, p, i);
        swapBig(b, p, i);
        swapBig(c, p, i);
        swapBig(d, p, i);
        swapBig(e, p, i);
        swapBig(f, p, i);
        p = i;
    }
    quickSort(a, b, c, d,e,f, from, p-1);
    quickSort(a, b, c, d,e,f, p + 1, to);
}

public static void main (String args [])
{
    //Asking for options (what to sort by/search for)
    System.out.println("Sort or Search?");
    String look = promptFor.nextLine();
    if (look.equalsIgnoreCase("Sort")){
    System.out.println("Sort by First, Last, Instrument, Instrument Family, 
    Special Title, or University:");
    String toSortBy = promptFor.nextLine();
    if (toSortBy.equalsIgnoreCase("First"))
        quickSort(fname,lname,inst,instFam,title,uni,0,9);
    if (toSortBy.equalsIgnoreCase("Last"))
        quickSort(lname,fname,inst,instFam,title,uni,0,9);
    if (toSortBy.equalsIgnoreCase("Instrument"))
        quickSort(inst,lname,fname,instFam,title,uni,0,9);
    if (toSortBy.equalsIgnoreCase("Instrument Family"))
        quickSort(instFam,lname,inst,fname,title,uni,0,9);
    if (toSortBy.equalsIgnoreCase("Special Title"))
        quickSort(title,lname,inst,instFam,uni,fname,0,9);
    if (toSortBy.equalsIgnoreCase("University"))
        quickSort(uni,lname,inst,instFam,title,fname,0,9);
    print();
    main(null);     }
    else if (look.equalsIgnoreCase("Search")) {
    System.out.println("Which last name do you wish to search for?");
        searchFor(promptFor.nextLine());
    }
    else
    {
        System.out.println("Command Not Recognized\n");
        main(null);
    }
}

}

6 个答案:

答案 0 :(得分:6)

您正在传递对数组的引用,而不是它的副本。

答案 1 :(得分:2)

变量bleh被复制变量a的值,所以实际上bleh指向实际对象,如果用bleh修改,这将改变实际对象,这是因为of java支持按值传递。

如果在传递之前克隆它,则可以获得所需的结果。

答案 2 :(得分:2)

这很简单。

交换数组的值,因为您将数组传递给交换函数,而在Java中,参数通过引用传递。

要避免这种情况。

String[] tempArray = a.clone();
swapBig(tempArray, i, j); //This will not change the values in a, but tempArray.

答案 3 :(得分:1)

因为您已经传递了对象的引用,所以使用此引用的任何操作都将修改主对象

答案 4 :(得分:1)

如果要传递数组的副本,请使用arrayVar.clone()方法,System.arraycopy()或Array.copyOf()。

答案 5 :(得分:0)

将数组传递给方法时,java不会为该方法创建数组X的副本。它将引用传递给数组X。

示例:

public void swap(Color a, Color b) {
    Color temp = a;
    a = b;
    b = temp;
}

这无效。但是,

.
.
.
   swap(x, y);
}

public void swap(Color[] a, Color[] b) {
   Color temp = a[0];
   a[0] = b[0];
   b[0] = temp;
}

这会将x []的第一个值与y []的第一个值交换。