java中如何获取2d数组列表的最大/最小值

我在c#中被问到了同样的问题，我发现使用linq可以很容易地做到这一点

---

但是，既然java中没有linq的替代方案，我怎么能简单地做到这一点呢？

如果数组未排序，那么找到最小值和最大值的唯一真正方法就是遍历整个过程

int[][] array = new int[10][10];
int min = array[0][0];
int max = array[0][0];
for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array[0].length; j++){
        if(array[i][j] < min){
            min = array[i][j];
        }
        if(array[i][j] > max){
            max = array[i][j];
        }
    }
}  

int[][]数组=新的int[10][10]；
int min=数组[0][0]；
int max=数组[0][0]；
for（int i=0；imax）{
max=数组[i][j]；
}
}
}  

我刚刚重读了这个问题，我想你指的是一个

ArrayList

，它是：

ArrayList<int[][]> arrayList = new ArrayList<int[][]>();

int min = arrayList.get(0)[0][0];
int max = arrayList.get(0)[0][0];

for(int[][] array : arrayList){
    for(int i = 0; i < array.length; i++){
        for(int j = 0; j < array[0].length; j++){
            if(array[i][j] < min){
                min = array[i][j];
            }
            if(array[i][j] > max){
                max = array[i][j];
            }
        }
    }
}

ArrayList ArrayList=new ArrayList（）；
int min=arrayList.get（0）[0][0]；
int max=arrayList.get（0）[0][0]；
for（int[][]数组：arrayList）{
for（int i=0；imax）{
max=数组[i][j]；
}
}
}
}

如果数组未排序，找到最小值和最大值的唯一真正方法是遍历整个数组

int[][] array = new int[10][10];
int min = array[0][0];
int max = array[0][0];
for(int i = 0; i < array.length; i++){
    for(int j = 0; j < array[0].length; j++){
        if(array[i][j] < min){
            min = array[i][j];
        }
        if(array[i][j] > max){
            max = array[i][j];
        }
    }
}  

int[][]数组=新的int[10][10]；
int min=数组[0][0]；
int max=数组[0][0]；
for（int i=0；imax）{
max=数组[i][j]；
}
}
}  

我刚刚重读了这个问题，我想你指的是一个

ArrayList

，它是：

ArrayList<int[][]> arrayList = new ArrayList<int[][]>();

int min = arrayList.get(0)[0][0];
int max = arrayList.get(0)[0][0];

for(int[][] array : arrayList){
    for(int i = 0; i < array.length; i++){
        for(int j = 0; j < array[0].length; j++){
            if(array[i][j] < min){
                min = array[i][j];
            }
            if(array[i][j] > max){
                max = array[i][j];
            }
        }
    }
}

ArrayList ArrayList=new ArrayList（）；
int min=arrayList.get（0）[0][0]；
int max=arrayList.get（0）[0][0]；
for（int[][]数组：arrayList）{
for（int i=0；imax）{
max=数组[i][j]；
}
}
}
}

如果您想要类似于LINQ的东西，可以使用Java8 streams：

// prepare arrays
List<int[][]> kidsL = new ArrayList<>();
int[][] square1 = new int[8][8];
int[][] square2 = new int[8][8];
int[][] square3 = new int[8][8];
for (int i = 0; i < 8; i++)
    for (int j = 0; j < 8; j++) {
        square1[i][j] = 1;
        square2[i][j] = 2;
        square3[i][j] = 3;
    }
kidsL.add(square1);
kidsL.add(square2);
kidsL.add(square3);

// find min
kidsL.stream()
        .mapToInt(a -> Arrays.stream(a).flatMapToInt(Arrays::stream).sum())
        .min()
        .ifPresent(System.err::println);

// find max
kidsL.stream()
        .mapToInt(a -> Arrays.stream(a).flatMapToInt(Arrays::stream).sum())
        .max()
        .ifPresent(System.err::println);

但它不如简单的循环有效，因为要计算两次和

当然，您可以添加中间操作来存储总和列表，然后根据该操作计算最小/最大值

// intermediate list of sums
List<Integer> sums = kidsL.stream()
        .mapToInt(a -> Arrays.stream(a).flatMapToInt(Arrays::stream).sum())
        .boxed().collect(Collectors.toList());

sums.stream().mapToInt(i -> i)
        .min()
        .ifPresent(System.err::println);

sums.stream().mapToInt(i -> i)
        .max()
        .ifPresent(System.err::println);

//中间总和列表
列表总和=kidsL.stream（）
.mapToInt（a->Arrays.stream（a）.flatMapToInt（Arrays:：stream）.sum（））
.boxed（）.collect（collector.toList（））；
sums.stream（）.mapToInt（i->i）
.min（）
.ifPresent（System.err:：println）；
sums.stream（）.mapToInt（i->i）
.max（）
.ifPresent（System.err:：println）；

如果您想要类似于LINQ的东西，可以使用Java8 streams：

// prepare arrays
List<int[][]> kidsL = new ArrayList<>();
int[][] square1 = new int[8][8];
int[][] square2 = new int[8][8];
int[][] square3 = new int[8][8];
for (int i = 0; i < 8; i++)
    for (int j = 0; j < 8; j++) {
        square1[i][j] = 1;
        square2[i][j] = 2;
        square3[i][j] = 3;
    }
kidsL.add(square1);
kidsL.add(square2);
kidsL.add(square3);

// find min
kidsL.stream()
        .mapToInt(a -> Arrays.stream(a).flatMapToInt(Arrays::stream).sum())
        .min()
        .ifPresent(System.err::println);

// find max
kidsL.stream()
        .mapToInt(a -> Arrays.stream(a).flatMapToInt(Arrays::stream).sum())
        .max()
        .ifPresent(System.err::println);

但它不如简单的循环有效，因为要计算两次和

当然，您可以添加中间操作来存储总和列表，然后根据该操作计算最小/最大值

// intermediate list of sums
List<Integer> sums = kidsL.stream()
        .mapToInt(a -> Arrays.stream(a).flatMapToInt(Arrays::stream).sum())
        .boxed().collect(Collectors.toList());

sums.stream().mapToInt(i -> i)
        .min()
        .ifPresent(System.err::println);

sums.stream().mapToInt(i -> i)
        .max()
        .ifPresent(System.err::println);

//中间总和列表
列表总和=kidsL.stream（）
.mapToInt（a->Arrays.stream（a）.flatMapToInt（Arrays:：stream）.sum（））
.boxed（）.collect（collector.toList（））；
sums.stream（）.mapToInt（i->i）
.min（）
.ifPresent（System.err:：println）；
sums.stream（）.mapToInt（i->i）
.max（）
.ifPresent（System.err:：println）；

似乎是重复的问题。参考此链接->您可以使用排序算法，该算法将使数组的第一个元素为最小值，最后一个元素为最大值。如果将数组转换为

列表

，您还可以研究使用lambda表达式。这是一个很好的初学者编程问题。你为什么不试试呢？首先从1d数组开始。@Teja我不这么认为，我有一个2d数组列表-arrays@LoganKulinski我做了第一个解决方案，因为不幸的是我的IDE不支持lanbda表达式。看起来像是重复的问题。参考此链接->您可以使用排序算法，该算法将使数组的第一个元素为最小值，最后一个元素为最大值。如果将数组转换为

列表

，您还可以研究使用lambda表达式。这是一个很好的初学者编程问题。你为什么不试试呢？首先从1d数组开始。@Teja我不这么认为，我有一个2d数组列表-arrays@LoganKulinski我做了第一个解决方案，因为我的IDE不支持lanbda表达式。谢谢。这正是我想要的。但不幸的是IDE（处理环境）不支持lambda表达式…所以我想我应该选择其他解决方案。谢谢。这正是我想要的。但不幸的是，IDE（处理环境）不支持lambda表达式……所以我想我应该选择其他解决方案。但这并不是我想要的（我需要将每个2d数组的总和存储在一个列表中，然后在该列表中找到最大值和最小值）。但是经过一些修改，我解决了我的问题，多亏了你，但这并不是我想要的（我需要将每个2d数组的总和存储在一个列表中，然后在该列表中找到最大值和最小值）。但经过一些修改，多亏了你，我解决了我的问题