Java 返回数组中的最大值

我是Java的初学者，我正在试图弄清楚为什么我的方法不返回输入数组中的最大值。我的想法是，当调用该方法时，for循环将搜索数组的每个值。然后，它开始将第一个值设置为最大值，大于该值的任何值随后都将成为最大值

非常感谢您的帮助

public double displayLargest (double[][] l) {
    for (int x=0; x < l.length-1; x++) {
        for (int y=0; y < l[x].length; y++) {
            double w = l[0][0];
            if (w < l[x][y]) {
                x++;
                y++;
                w = l[x][y];
                maxValue = w;
            }
        }
    }
    System.out.println("The largest value in the array is: " + maxValue);
    return maxValue;
}

公共双显示器最大（双[]l）{
对于（int x=0；x

以下方法将返回二维输入数组中的最大值

double

，如果不存在值，则返回

null

public Double displayLargest(double[][] l){
    Double maxValue = null;

    for (int x=0; x < l.length; x++) {
        for (int y=0; y < l[x].length; y++) {

            if (maxValue == null || maxValue < l[x][y]) {
                maxValue = l[x][y];
            }
        }
    }

    System.out.println("The largest value in the array is: " + maxValue);

    return maxValue;
}

公共双显示器最大（双[]l）{
Double maxValue=null；
对于（int x=0；x

以下方法将返回二维输入数组中的最大值

double

，如果不存在值，则返回

null

public Double displayLargest(double[][] l){
    Double maxValue = null;

    for (int x=0; x < l.length; x++) {
        for (int y=0; y < l[x].length; y++) {

            if (maxValue == null || maxValue < l[x][y]) {
                maxValue = l[x][y];
            }
        }
    }

    System.out.println("The largest value in the array is: " + maxValue);

    return maxValue;
}

公共双显示器最大（双[]l）{
Double maxValue=null；
对于（int x=0；x

试试看

double maxVal=-double.MAX_值；//看见http://stackoverflow.com/questions/3884793/why-is-double-min-value-in-not-negative
对于（int x=0；xtry

double maxVal=-double.MAX_VALUE；//请参阅http://stackoverflow.com/questions/3884793/why-is-double-min-value-in-not-negative
对于（int x=0；x
double max=l[0][0]；
//这里有两个回路
if（max

您总是将数组的第一个值赋给w，您应该在任何循环之前声明它。否则，您总是将该值与l[0][0]进行比较。
double max=l[0][0]；
//这里有两个回路
if（max

您总是将数组的第一个值赋给w，您应该在任何循环之前声明它。否则，您总是将该值与l[0][0]进行比较。
我给出了一个简单的方法

int[][] array2 = 
   {{1, 2, 3, 4, 5},
    {6, 7, 8, 9, 10},
    {11, 12, 13, 14, 15},
    {16,17,18,19}};
      int result = Arrays.stream(array2)
    .flatMapToInt(h2 -> Arrays.stream(h2))
    .min()
    .getAsInt();
      System.out.println(result);

这是给max的

int[][] array2 = 
   {{1, 2, 3, 4, 5},
    {6, 7, 8, 9, 10},
    {11, 12, 13, 14, 15},
    {16,17,18,19}};
      int result = Arrays.stream(array2)
    .flatMapToInt(h2 -> Arrays.stream(h2))
    .max()
    .getAsInt();
      System.out.println(result);

我已经给出了这样做的简单方法

int[][] array2 = 
   {{1, 2, 3, 4, 5},
    {6, 7, 8, 9, 10},
    {11, 12, 13, 14, 15},
    {16,17,18,19}};
      int result = Arrays.stream(array2)
    .flatMapToInt(h2 -> Arrays.stream(h2))
    .min()
    .getAsInt();
      System.out.println(result);

这是给max的

int[][] array2 = 
   {{1, 2, 3, 4, 5},
    {6, 7, 8, 9, 10},
    {11, 12, 13, 14, 15},
    {16,17,18,19}};
      int result = Arrays.stream(array2)
    .flatMapToInt(h2 -> Arrays.stream(h2))
    .max()
    .getAsInt();
      System.out.println(result);

我强烈建议您从有意义的变量名开始。接下来，我建议您更喜欢传统的
for
循环（尤其是嵌套循环时）。最后，我会默认为
NaN
，这样您就可以处理
null
和空数组。类似于

public static double displayLargest(double[][] arrayOfArray) {
    double maxValue = Double.NaN;
    if (arrayOfArray != null) {
        for (double[] array : arrayOfArray) { // <-- for each array in arrayOfArray
            for (double value : array) {      // <-- for each value in the array
                if (!Double.isNaN(maxValue)) {
                    maxValue = Double.max(maxValue, value);
                } else { // <-- the first value.
                    maxValue = value;
                }
            }
        }
    }
    System.out.println("The largest value in the array is: " + maxValue);
    return maxValue;
}

public static double display最大（double[][]arrayOfArray）{
double maxValue=double.NaN；
if（arrayOfArray！=null）{
对于（double[]array:arrayOfArray）{/我强烈建议您从有意义的变量名开始。接下来，我建议您更喜欢传统的
for
循环（尤其是嵌套循环时）.最后，我将默认设置为
NaN
，这样您就可以处理
null
和空数组。例如

public static double displayLargest(double[][] arrayOfArray) {
    double maxValue = Double.NaN;
    if (arrayOfArray != null) {
        for (double[] array : arrayOfArray) { // <-- for each array in arrayOfArray
            for (double value : array) {      // <-- for each value in the array
                if (!Double.isNaN(maxValue)) {
                    maxValue = Double.max(maxValue, value);
                } else { // <-- the first value.
                    maxValue = value;
                }
            }
        }
    }
    System.out.println("The largest value in the array is: " + maxValue);
    return maxValue;
}

public static double display最大（double[][]arrayOfArray）{
double maxValue=double.NaN；
if（arrayOfArray！=null）{
for（双[]数组：arrayOfArray）{//Gawd，我讨厌单字符变量，这让代码很难读！Gawd，我讨厌单字符变量，这让代码很难读！@ScaryWombat数组本身就是一个对象。数组可以为null，在这种情况下，内部数组可以为null。@ScaryWombat数组本身就是一个对象。数组可以为null，在这种情况下，内部数组可以为null。