Java 将数组传递给方法并返回数组

这是我正在研究的问题

使用for循环生成一个由10个随机整数组成的数组，所有整数的范围为100到200，包括100到200。使用Arrays类对整个数组进行排序和显示接下来，将数组作为唯一参数传递给一个方法，该方法将数组中的每个元素加倍，然后返回数组。使用foreach循环将返回数组中的所有元素显示在一行上，以单个空格分隔。后一个循环还应确定返回数组中所有元素的总和。如示例输出中所示，使用“千”逗号显示总和

这是我的代码：

package bryant7and8;

import java.util.Arrays;


public static void main(String[] args) {

    int[] myList = new int[10];

        for (int i = 0; i < myList.length; i++) {
            myList[i] = 100 + (int) (Math.random() * ((110 - 10) + 1));

    }
    Arrays.sort(myList);
    System.out.println(Arrays.toString(myList));

    doubleArray (myList);
    System.out.println(doubleArray(myList));
}

public static int[] doubleArray(int[] array) {
    for (int i = 0; i < array.length; i++) {
        array[i] *= 2;
    }

    return array;
}

包bryant7和8；
导入java.util.array；
公共静态void main（字符串[]args）{
int[]myList=新int[10]；
for（int i=0；i

}

我不知道如何通过阵列，我已经做了几个小时了，我的书籍解释没有帮助。我也为这些可怕的问题道歉，我对stackoverflow还是个新手

void doubleArray(int[] values){
    //change the value array, with doubling logic

}

由于数组是通过引用传递的，因此传递的数组将被更改。没有必要退货

---

由于数组是通过引用传递的，因此传递的数组将被更改。不需要返回它。

您只需要一个方法，该方法将数组作为参数，修改该数组，然后返回相同的数组

private int[] doubleArray(int[] arr) {

    for (int i = 0; i < arr.length; i++) {
        arr[i] *= 2;
    }

    return arr;
}

private int[]双数组（int[]arr）{
对于（int i=0；i

---

编辑：正如其他答案所指出的，您不需要返回数组。您仍在修改原始数组，因此所做的任何更改都将保留在此方法范围之外。

您只需要一个将数组作为参数的方法，修改该数组，然后返回相同的数组

private int[] doubleArray(int[] arr) {

    for (int i = 0; i < arr.length; i++) {
        arr[i] *= 2;
    }

    return arr;
}

private int[]双数组（int[]arr）{
对于（int i=0；i

---

编辑：正如其他答案所指出的，您不需要返回数组。您仍在修改原始数组，因此所做的任何更改都将保留在此方法范围之外。

您应该编写如下方法：

public static int[] doubleArray (int[] array) {
    //double the array... I think you know how to do this part.
    return array;
}

doubleArray (myArray);

现在假设您有一个名为

myArray

的数组，您可以将其传递到如下方法中：

public static int[] doubleArray (int[] array) {
    //double the array... I think you know how to do this part.
    return array;
}

doubleArray (myArray);

然后

myArray

中的元素将加倍。您还可以将该方法的返回值用于其他用途

或者，您可以返回另一个全新阵列：

public static int[] doubleArray (int[] array) {
    int[] newArray = new int[array.length];
    //put all the stuff in "array" in "newArray"
    //double the new array... I think you know how to do this part.
    return newArray;
}

---

然后，当您调用该方法时，传入的参数将不会更改。但是返回值具有双重数组。

您应该编写如下方法：

public static int[] doubleArray (int[] array) {
    //double the array... I think you know how to do this part.
    return array;
}

doubleArray (myArray);

现在假设您有一个名为

myArray

的数组，您可以将其传递到如下方法中：

public static int[] doubleArray (int[] array) {
    //double the array... I think you know how to do this part.
    return array;
}

doubleArray (myArray);

然后

myArray

中的元素将加倍。您还可以将该方法的返回值用于其他用途

或者，您可以返回另一个全新阵列：

public static int[] doubleArray (int[] array) {
    int[] newArray = new int[array.length];
    //put all the stuff in "array" in "newArray"
    //double the new array... I think you know how to do this part.
    return newArray;
}

---

然后，当您调用该方法时，传入的参数将不会更改。但是返回值具有双重数组。

只需创建一个静态方法（您将从static main（）方法调用它），将数组作为参数传递给它。对它做一些修改

public static void doubleTheArrayElements(myList){
//put your logic here
}

在main方法中调用它：

doubleTheArrayElements（myList）

---

无需返回数组，因为Java中的参数是通过引用传递的。

只需创建一个静态方法（您将从static main（）方法调用它），将数组作为参数传递给它。对它做一些修改

public static void doubleTheArrayElements(myList){
//put your logic here
}

在main方法中调用它：

doubleTheArrayElements（myList）

---

无需返回数组，因为Java参数是通过引用传递的。

您最好相信Java是通过值传递的。有关详细信息，请参阅

整个代码如下所示，仅供参考。调用公共静态int[]notByReference（int[]arr）方法后，myList不会指向新对象。相反，已为复制的变量指定了新对象的新引用

import java.util.Arrays;

public class ArrayTenRandom {

    public static void main(String[] args) {

        int[] myList = new int[10];

        for (int i = 0; i < myList.length; i++) {
            myList[i] = 100 + (int) (Math.random() * ((110 - 10) + 1));

        }
        Arrays.sort(myList);
        System.out.println(Arrays.toString(myList));
        doubleArray(myList);
        System.out.println(Arrays.toString(myList));
        notByReference(myList);
        System.out.println(Arrays.toString(myList));

    }

    public static void doubleArray(int[] arr){
        for(int i = 0; i < arr.length; i++){
            arr[i] = arr[i] * 2;
        }
    }

    public static int[] notByReference(int[] arr){
        arr = new int[2];
        System.out.println(Arrays.toString(arr));
        return arr;
    }
}

导入java.util.array；
公共类数组随机数{
公共静态void main（字符串[]args）{
int[]myList=新int[10]；
for（int i=0；i

您最好相信java是通过值传递的。有关详细信息，请参阅

整个代码如下所示，仅供参考。调用公共静态int[]notByReference（int[]arr）方法后，myList不会指向新对象。相反，已为复制的变量指定了新对象的新引用

import java.util.Arrays;

public class ArrayTenRandom {

    public static void main(String[] args) {

        int[] myList = new int[10];

        for (int i = 0; i < myList.length; i++) {
            myList[i] = 100 + (int) (Math.random() * ((110 - 10) + 1));

        }
        Arrays.sort(myList);
        System.out.println(Arrays.toString(myList));
        doubleArray(myList);
        System.out.println(Arrays.toString(myList));
        notByReference(myList);
        System.out.println(Arrays.toString(myList));

    }

    public static void doubleArray(int[] arr){
        for(int i = 0; i < arr.length; i++){
            arr[i] = arr[i] * 2;
        }
    }

    public static int[] notByReference(int[] arr){
        arr = new int[2];
        System.out.println(Arrays.toString(arr));
        return arr;
    }
}

导入java.util.array；
公共类数组随机数{
公共静态void main（字符串[]args）{
int[]myList=新int[10]；
for（int i=0；i