Поиск массива с наименьшим максимальным значением элемента

Ваш код находит наименьшее значение во всех массивах (по крайней мере, если вы исправите опечатку от list.get(i)[i] до list.get(i)[j]).

Вы должны найти максимальный элемент каждого массива, а затем проверить, меньше ли этот максимум, чем все ранее найденные максимумы:

int minIndex = 0;
int min = Integer.MAX_VALUE;
for (int i=0; i<list.size(); i++) {
    int max = Integer.MIN_VALUE;
    for (int j=0; j<list.get(i).length; j++) { // find max element of current array
        if (list.get(i)[j] > max) {
            max = list.get(i)[j]; 
            if (max > min) {
                break; // we already know the max of this array is not the smallest max
            }
        }
    }
    if (max < min) { // check if the max of the current array is the smallest max so far
        min = max;
        minIndex = i; //index of the array in arraylist
    }
}

Вы можете попробовать это, например:

import java.util.Arrays;
import java.util.Comparator;

public class MaxMinArray {

    public static int[]  maxMinFromArray(int[][] arrays){
       return  Arrays.stream(arrays).min(Comparator.comparingInt(x -> Arrays.stream(x).max().orElse(0))).orElse(null);
    }
}

Я проверил это на вашем примере :):

import org.junit.Test;

import static org.junit.Assert.*;

public class MaxMinArrayTest {

    @Test
    public void testMaxMinArray(){
        int[][] arrays = new int[][] {{1,2,5}, {0,1,2}, {8,0,0}};
        int[] result = MaxMinArray.maxMinFromArray(arrays);
        assertArrayEquals(new int[]{0,1,2}, result);
    }
}

В качестве альтернативы циклу for вы можете попытаться решить эту проблему с помощью потоковое API. Идея точно такая же:

• найти максимальный элемент в каждом подсписке.
• используйте компаратор, чтобы найти подсписок с минимальным элементом среди максимальных элементов.

List.of(List.of(1, 2, 5), List.of(0, 1, 2), List.of(8, 0, 0)) 
        .stream()
        .min((a, b) ->  
               a.stream().max(Integer::compare).get()
                 .compareTo(
                    b.stream().max(Integer::compare).get()
                 )
        ).get(); 

Кода меньше, возможно, легко понять назначение кода. Вы даже можете сделать код короче, используя метод Comparator::comparing:

List.of(List.of(1, 2, 5), List.of(0, 1, 2), List.of(8, 0, 0))
        .stream()
        .min(Comparator.comparing(Collections::max))
        .get();

Давайте посмотрим, что здесь происходит более подробно.

List.of(List.of(1, 2, 5), List.of(0, 1, 2), List.of(8, 0, 0))
        // lets get stream of list Stream<List<Integer>>. 
        .stream()
        // find sublist which has minimum maximum element. 
        .min((a, b) ->  
               // a & b are sublist, for example: [1,2,5], [0,1,2]
               // find maximum from a [1,2,5] which is [5]
               a.stream().max(Integer::compare).get()
               // compare maximum from a to maximum from b 
                 .compareTo(
                 // find maximum from a [0,1,2] which is [2]
                    b.stream().max(Integer::compare).get()
                 )
               // get minimum out of [5,2]
        ).get(); // [0, 1, 2]

Таким образом, выполнение может выглядеть примерно так:

Initial list is: [1,2,5], [0,1,2], [8, 0, 0]
find minimum list based on maximum: 
min( max([1,2,5]), max([0,1,2])) 
min( [5], [2]) 
[2] -> list [0,1,2] contains minimum maximum element so far, go the the next iteration
find minimum list based on maximum: 
min( max([0,1,2]), max([8, 0, 0]) ) 
min( [2], [8]) 
[2] -> list [0,1,2] contains minimum maximum element so far, 
there no other element in the stream, [0,1,2] is final result. 

Я надеюсь, что вы найдете это полезным.