Question

在下面的代码中，调用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);
    }
}

}

Answer 1

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

Answer 2

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

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

Answer 3

这很简单。

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

要避免这种情况。

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

Answer 4

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

Answer 5

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

Answer 6

将数组传递给方法时，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 []的第一个值交换。

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

6 个答案: