从同一方法返回两个数组？

Question

我正在尝试编写一个程序，该程序将读取城市A和城市B中5天的高温。我必须为城市创建一个方法，该方法将吸收所有10个值并将它们返回给主要方法。 我最初只有一种方法，将[0]-[4]视为cityA，将[5]-[9]视为cityB，但是我的教授说这不是他想要的（即使答案在技术上是正确的）。

很难读他的笔迹，但这似乎是他说的要做的事。

编辑-根据建议，我将其变成了可变长度参数。 仍在努力使return语句正确，但除此之外，它看起来像我认为的样子。

编辑＃2-我刚刚意识到字符串城市在主要方法中被命名为城市。 修复了这个问题，但是现在我又遇到了另一个错误。 缺少返回值？ 我正在做这本书现在所说的几乎一切-书中的示例...

printMax(new double[] {1, 2, 3});
if (numbers.length == 0) {
System.out.println("No argument passed");
return;

__ _ __ _ __最新代码

public static double[] getHighTemperatures(String cityName, int numberOfDays) {
    Scanner keyboard = new Scanner(System.in);
    double[] highsForNewYork = getHighTemperatures("New York", 5);
    for (int i = 0; i < numberOfDays; i++)
    highsForNewYork[i] = keyboard.nextDouble();
    return(highsForNewYork);
}

__ _ __ _ __新代码

package program10a;

import java.util.Scanner;

public class compareCities {

    public static void main(String[] args) {
        double[] temp = new double[5];
        String[] cities = new String[]{"Miami", "Dallas";
        getCityTemp(temp, cities);
    }

    public static double[] getCityTemp(double[] temp, String... cities) {
        Scanner keyboard = new Scanner(System.in);
        if (cities.length == 0) {
            System.out.println("No argument passed.");
            return;
        }
        String cityA = cities[0];

        for (int i = 0; i < temp.length; i++) {
            System.out.print("Enter 5 temperatures for City A. ");
            temp[i] = keyboard.nextDouble();
            if (i < cities.length) {
                cityA = cities[i];
            }
        }

        String cityB = cities[0];

        for (int i = 0; i < temp.length; i++) {
            System.out.print("Enter 5 temperatures for City B. ");
            temp[i] = keyboard.nextDouble();
            if (i < cities.length) {
                cityB = cities[i];
            }
        }
    }
}

__ _ __ _ __下面是旧代码

public static double[] getCityHighA(double[] cityA) {
    Scanner keyboard = new Scanner(System.in);
    for (int i = 0; i < cityA.length; i++) {
        System.out.print("Enter 5 temperatures for City A. ");
        cityA[0] = keyboard.nextDouble();
        cityA[1] = keyboard.nextDouble();
        cityA[2] = keyboard.nextDouble();
        cityA[3] = keyboard.nextDouble();
        cityA[4] = keyboard.nextDouble();
        break;
    }
    return cityA;
}

public static double[] getCityHighB(double[] cityB) {
    Scanner keyboard = new Scanner(System.in);
    for (int i = 0; i < cityB.length; i++) {
        System.out.print("Enter 5 temperatures for City B. ");
        cityB[0] = keyboard.nextDouble();
        cityB[1] = keyboard.nextDouble();
        cityB[2] = keyboard.nextDouble();
        cityB[3] = keyboard.nextDouble();
        cityB[4] = keyboard.nextDouble();
        break;
    }
    return cityB;
}

这是最明智的选择，还是可以使用相同的方法将cityA和cityB传递回主方法？ 请注意，我还没有接触过对象（我已经看到了使用对象的类似主题，但我不知道该怎么做）。 谢谢！

Answer 1

与其尝试从一种方法返回2个数组，不如考虑如何使用相同的方法两次。

也许将其参数化，

public double[] getHighTemperatures(String cityName, int numberOfDays)

因此，您可以传递任意数量的城市，任意天数，而不是使用针对城市A进行硬编码的方法以及针对城市B进行硬编码的方法，而不是针对填充5个元素的数组进行硬编码。 您每次只需捕获结果。

double[] highsForNewYork = ...
double[] highsForLosAngeles = ...

Answer 2

您可以制作一个二维数组：

public static double[][] getCityHighs(...) {
    double[] cityA = new double[5];
    //....
    double[] cityB = new double[5];
    //....
    return new double[][]{cityA, cityB};
}

double [0]将等于cityA，double [1]将等于cityB。 因此，如果要获取cityA的第一个值，则可以执行array [0] [0];

或者，您可以创建一个存储两个城市的类：

class cities {
    double[] cityA;
    double[] cityB;
}

Answer 3

您的for循环非常循环。 :)

i变量在那里是有原因的。 代替您现在正在做什么，请执行以下操作：

for (int i = 0; i < cityB.length; ++i) {
    System.out.printf("Enter temperature #%d for City B: ", (i + 1));  // I _think_ there's printf() in Java and it works like C's...
    cityB[i] = keyboard.nextDouble();  // note the use of `i`
}

Answer 4

您应该使用二维数组，其中第一维是city ，第二维是temperature 。 像这样：

public static double[][] getHighs() {
  Scanner keyboard = new Scanner(System.in);
  double[][] temps = new double[2][5];

  for(int i = 0; i < temps.length; i++) {
    for(int j = 0; j < temps[i].length; i++) {
      System.out.println("Enter city "+i+"'s temperature #"+j);
      temps[i][j] = keyboard.nextDouble();
    }
  }

  return temps;
}

否则，您可以像@AnthonyPegram所说的那样对方法进行参数化。

Answer 5

首先，这很丑陋：

for (int i = 0; i < cityA.length; i++) {
   System.out.print("Enter 5 temperatures for City A. ");
   cityA[0] = keyboard.nextDouble();
   cityA[1] = keyboard.nextDouble();
   /* ... */
   break;

要么使用循环（提示：将for行向下移动一点，然后使cityA[]分配更通用），要么不使用循环并保留硬编码的数组引用。 （我更喜欢for循环。）

在极少数情况下，将break语句放入for循环的主体中是有意义的。 当然，这里不应该使用它。 （在学校时，您可能永远不会看到合理的案例。）

现在，到了你的问题的肉 ：从单一的函数返回两个数组。

我认为教授是在暗示你应该修改你这里有两种方法，为你调用两次 一个方法。 使您的函数足够通用，以处理两个城市的数组。 （这应该不难。找到函数之间的实际区别，并弄清楚如何在参数中传递不同的数据。）

您的教授可能还希望您返回多维数组：

/* pseudo-code! */
city[][];
city[0][0] = 1; city[0][1] = 2; /* ... */
city[1][0] = 10; city[1][1] = 5; /* ... */

但这似乎不太可能。 （似乎仅对两个城市来说也不值得。在需要处理三个或更多城市时考虑一下。）

更新资料

您的新代码看起来要好得多； 你快到了。

public static double[] getHighTemperatures(String cityName, int numberOfDays)
{
    Scanner keyboard = new Scanner(System.in);
    double[] highsForNewYork = getHighTemperatures("New York", 5);
    for (int i = 0; i < numberOfDays; i++)
        highsForNewYork[i] = keyboard.nextDouble();
    return (highsForNewYork);
}

getHighTemperatures()在这里递归调用自己。 虽然递归函数是一种非常有用的技术，但实际上并没有帮助。 您正在调用本质上是一个“帮助程序”，该程序可用于检索有关任何城市的数据，并在该程序中对您感兴趣的城市进行了硬编码。 关。 :)

public static void main(String[]args)
{
    double[] temp = new double[5];
    String[]cities = new String[] {
        "Miami", "Dallas";
        getCityTemp(temp, cities);
    }
}

main()具有城市列表，但是，您的数组初始化有点差。 另外，我想建议您的getCityTemp()函数尝试做太多事情-您的main()应该以非常高的水平描述整个程序要完成的工作。 （ main()函数应该几乎像大纲一样阅读。）

public static double[] getCityTemp(double[]temp, String ... cities)
{
    Scanner keyboard = new Scanner(System.in);
    if (cities.length == 0) {
        System.out.println("No argument passed.");
        return;
    }
    String cityA = cities[0];

    for (int i = 0; i < temp.length; i++) {
        System.out.print("Enter 5 temperatures for City A. ");
        temp[i] = keyboard.nextDouble();
        if (i < cities.length) {
            cityA = cities[i];
        }
    }
    /* ... */
}

我通常喜欢这种防御性编程-看到在依赖它之前已经传递了一些东西 -但有时当事情破裂时可以使用一个简单的Exception就可以了。 在应该保护自己的“内部API”与“外部API”有意义的错误返回值之间存在微妙的关系。 （将这些术语应用到几乎可以在一个屏幕上显示的程序时，它们显得过于宏大和浮夸。但是在您看到并构建更大的程序时，请记住这一点。）

但请注意， 此功能中也有键盘输入。 （这可能只是迭代开发的功能，我很晚才回到这个问题。） 最好将所有键盘输入和显示输出限制为一小组函数并进行计算 （我想您需要以便在程序的下一个迭代中对数组进行排序，因此可以在另一套例程中找到最小值，最大值，中位数，平均值，标准差等）。 尝试使每个功能尽可能少地工作：确保每个功能都做一件事。

建议改写如下：

public static void main(String[]args)
{
    String[] cities = {
        "Miami", "Dallas"
    };

    for (String city : cities) {
        double[] highs = getCityTemp(city, 5);
        printCityTemp(city, highs);
    }
}

我正在使用一种新的for循环样式，该样式可以避免所有int i=0; i<array.length; i++ int i=0; i<array.length; i++ 很多for循环都通用的int i=0; i<array.length; i++样板代码。 （很多for循环遍历数组的所有元素。）

public static double[] getCityTemp(String city, int days)
{
    Scanner keyboard = new Scanner(System.in);
    double[] highs = new double[days];

    System.out.print("Enter " + days + " temperatures for " + city + ": ");

    for (int i = 0; i < days; i++) {
        highs[i] = keyboard.nextDouble();
    }

    return highs;
}

所有输入都限于getCityTemp() ，使用不同的参数多次调用该函数以选择要显示的城市。

public static void printCityTemp(String city, double[] highs)
{
    System.out.print("Highs for " + city + " were: ");

    for (double high : highs) {
        System.out.print(high + " ");
    }

    System.out.println("");
    return;
}

这里有一个简单的输出例程，可确保正确执行输入。 我不知道它对您的应用程序是否理想，但是在调试时应该很有用。

请注意，我尚未对此进行测试-它可能会编译也可能不会编译。 可能不是。 考虑它比实际代码更多的伪代码。