在Java 2D数组中查找最小值和最大值

我想弄明白这一点已经有一段时间了，需要一些帮助。我需要找到最小/最大值，并将其打印出来，以用于多维数组。以下是我尝试过的两种方法

import java.util.*;

class MinMax {
    public static void main(String[] args) {
        int[][] data = {{3, 2, 5},
                {1, 4, 4, 8, 13},
                {9, 1, 0, 2},
                {0, 2, 6, 3, -1, -8}};
        Arrays.sort(data);
        System.out.println("Minimum = " + data[0]);
        System.out.println("Maximum = " + data[data.length - 1]);
    }
}

此版本符合要求，但未运行

import java.util.*;

class MinMax {
    public static void main(String[] args) {
        int[][] data = {{3, 2, 5},
                {1, 4, 4, 8, 13},
                {9, 1, 0, 2},
                {0, 2, 6, 3, -1, -8}};

    public static int getMaxValue(int[] numbers) {
        int maxValue = numbers[0];
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > maxValue) {
                maxValue = numbers[i];
            }
            return maxValue;
            {
                public static int getMinValue (int[] numbers) {
                    int minValue = numbers[0];
                    for (int i = 1; i < numbers.length; i++) {
                        if (numbers[i] < minValue) {
                            minValue = numbers[i];
                        }
                    }
                return minValue;
            }

import java.util.*；
类极小极大值{
公共静态void main（字符串[]args）{
int[]data={{3,2,5}，
{1, 4, 4, 8, 13},
{9, 1, 0, 2},
{0, 2, 6, 3, -1, -8}};
公共静态int getMaxValue（int[]数字）{
int maxValue=数字[0]；
对于（int i=1；imaxValue）{
最大值=数字[i]；
}
返回最大值；
{
公共静态int getMinValue（int[]数字）{
int minValue=数字[0]；
对于（int i=1；i

---

这个版本在编译过程中给我带来了很多错误。非常感谢您的帮助。

好的，我已经修复了您的代码。实际上，您的错误是没有遍历多维数组的所有单元格

因此，我在getMinValue/getMinValue方法和固定数组元素寻址中添加了额外的循环

import java.util.*;

class MinMax {
    public static void main(String[] args) {
        int[][] data = {
                {3, 2, 5},
                {1, 4, 4, 8, 13},
                {9, 1, 0, 2},
                {0, 2, 6, 3, -1, -8}
        };
        System.out.println(getMaxValue(data));
        System.out.println(getMinValue(data));
    }


    public static int getMaxValue(int[][] numbers) {
        int maxValue = numbers[0][0];
        for (int j = 0; j < numbers.length; j++) {
            for (int i = 0; i < numbers[j].length; i++) {
                if (numbers[j][i] > maxValue) {
                    maxValue = numbers[j][i];
                }
            }
        }
        return maxValue;
    }

    public static int getMinValue(int[][] numbers) {
        int minValue = numbers[0][0];
        for (int j = 0; j < numbers.length; j++) {
            for (int i = 0; i < numbers[j].length; i++) {
                if (numbers[j][i] < minValue ) {
                    minValue = numbers[j][i];
                }
            }
        }
        return minValue ;
    }
}

import java.util.*；
类极小极大值{
公共静态void main（字符串[]args）{
int[][]数据={
{3, 2, 5},
{1, 4, 4, 8, 13},
{9, 1, 0, 2},
{0, 2, 6, 3, -1, -8}
};
System.out.println（getMaxValue（数据））；
System.out.println（getMinValue（数据））；
}
公共静态int getMaxValue（int[][]个数字）{
int maxValue=数字[0][0]；
对于（int j=0；jmaxValue）{
最大值=数字[j][i]；
}
}
}
返回最大值；
}
公共静态int getMinValue（int[][]个数字）{
int minValue=数字[0][0]；
对于（int j=0；j

我有一个更有趣的解决方案，使用Java 8:）

---

显然，这是一个不同于您的解决方案。但它做的事情是相同的。首先，我们将2D数组转换为

int

s的

流

。为此，我们首先需要调用

flatMapToInt

。我们这样做是为了以平面方式流化数组中的所有元素。想象一下，如果我们只是开始使用单个索引迭代整个2D数组。它是这样的。一旦我们将数组转换成流，我们将使用IntSummaryStatistics，以便对最小值和最大值重复使用相同的流。

您的问题是：您正在对

int

数组进行排序，而不是在ea中对每个

int

数组进行排序ch

int

数组

要解决此问题：循环遍历

int

数组中的每个

int

数组

使用

Arrays.sort（）查找2D
int
数组的最大值和最小值的说明：

声明一个2D
int
数组以对名为
data
的数据进行排序
声明两个
int
s，一个保存最大值，另一个保存最小值。

最大值的初始值应为
Integer.MIN\u值
，最小值的初始值应为
Integer.MAX\u值
，以确保处理负值

通过
数据
从
0
循环到
数据。长度
：
排序
数据[i]
检查
数据[i]
的第一个值是否小于最小值，如果小于，则进行更改
检查
数据[i]
的最后一个值是否大于最大值，如果大于，则进行更改

输出结果
示例：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] data = {{3, 2, 5},
            {1, 4, 4, 8, 13},
            {9, 1, 0, 2},
            {0, 2, 6, 3, -1, -8} };

        int maximum = Integer.MIN_VALUE;
        int minimum = Integer.MAX_VALUE;

        for(int i = 0; i < data.length; i++) {
            Arrays.sort(data[i]);

            if(data[i][0] < minimum) minimum = data[i][0];
            if(data[i][data[i].length - 1] > maximum) maximum = data[i][data[i].length - 1];
        }

        System.out.println("Minimum = " + maximum);  
        System.out.println("Maximum = " + minimum); 
    }
}

导入java.util.array；
公共班机{
公共静态void main（字符串[]args）{
int[]data={{3,2,5}，
{1, 4, 4, 8, 13},
{9, 1, 0, 2},
{0, 2, 6, 3, -1, -8} };
int最大值=Integer.MIN_值；
int最小值=整数最大值；
对于（int i=0；imax）max=data[i][data[i].length-1]；
}
System.out.println（“最小值=”+最大值）；
System.out.println（“最大值=”+最小值）；
}
}
封装阵列；
公共类最大值{
// 2 5 7 9
// 3 6 8 1
公共静态void main（字符串[]arg）{
int a[][]={{2,5,7,9}，{3,6,8,1}；
int max=a[0][0]；
对于（int i=0；我可以请您适当缩进代码吗？在每种情况下，您似乎忽略了一个事实，即您有一个int数组。请考虑如何在每个
int[]中迭代访问每个
int
data中的数组
。哪个版本的Java在方法中的方法中合法化了方法？方法引用很有趣：
x->Arrays.stream（x）
可以简化为
Arrays:：stream
。你知道我觉得什么很有趣。一旦我开始做Java8的事情，有些事情非常简单，需要的代码也少得多。我想知道在Java8之前我们是如何编码的？我遇到了一个小错误
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] data = {{3, 2, 5},
            {1, 4, 4, 8, 13},
            {9, 1, 0, 2},
            {0, 2, 6, 3, -1, -8} };

        int maximum = Integer.MIN_VALUE;
        int minimum = Integer.MAX_VALUE;

        for(int i = 0; i < data.length; i++) {
            Arrays.sort(data[i]);

            if(data[i][0] < minimum) minimum = data[i][0];
            if(data[i][data[i].length - 1] > maximum) maximum = data[i][data[i].length - 1];
        }

        System.out.println("Minimum = " + maximum);  
        System.out.println("Maximum = " + minimum); 
    }
}