1

在下面的代码中，调用 swapBig(a,some number,somenumber)，其中 a 是一个数组，被复制到 swapBig() 中的 bleh[]。当 bleh[] 中的值被交换时，a[] 中的相应值也会改变。为什么会发生这种情况，我将如何编写代码以便只修改 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);
    }
}

}
4

6 回答 6

6

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

于 2013-02-20T15:43:52.340 回答
2

变量bleh被复制变量的值，a因此实际上bleh指向实际对象，如果您使用它进行修改bleh将更改实际对象，这是因为 java 支持按值传递。

如果在通过之前克隆它，您可以获得所需的结果。

于 2013-02-20T15:46:23.000 回答
2

这很简单。

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

为了避免这种情况。

String[] tempArray = a.clone();
swapBig(tempArray, i, j); //This will not change the values in a, but tempArray.
于 2013-02-20T15:48:24.210 回答
1

因为你已经传递了对象的引用，任何使用这个引用的操作都会修改主对象

于 2013-02-20T15:45:53.383 回答
1

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

于 2013-02-20T15:46:52.833 回答
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[] 的第一个值交换。

于 2020-07-18T11:31:17.010 回答