Вложенные циклы — Java: Массивы

Во многих языках программирования есть очень полезная функция flatten. В определённых задачах она сильно упрощает жизнь и сокращает количество кода. Эта функция принимает на вход многомерный массив и выпрямляет его – сводит все к одному массиву, раскрывая каждый вложенный. Посмотрим на пример:

int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
App.flatten(matrix); // [1, 2, 3, 4, 5, 6]

Реализуем этот метод самостоятельно. В общем случае метод раскрывает массивы на всех уровнях вложенности. Но мы сделаем вариант метода, в котором происходит раскрытие только первого уровня. Для простоты наш метод будет выпрямлять матрицу – прямоугольную таблицу с числами. То есть количество элементов во всех вложенных массивах будет одинаково

Логика работы метода выглядит так:

1. Инициализируем массив-результат, в который запишутся все значения
2. Итерируем (проходим) по основному массиву и берем текущий элемент
3. Проходим по текущему элементу. Начинаем вложенный цикл, внутри которого идём по массиву и добавляем каждый его элемент в массив-результат
4. Возвращаем массив-результат

class App {
    public static int[] flatten(int[][] matrix) {
        var rowsCount = matrix.length;

        if (rowsCount == 0) {
            return new int[0];
        }

        var columnsCount = matrix[0].length;

        // Определяем, какое количество элементов будет в массиве-результате
        var elementsCount = rowsCount * columnsCount;

        // Инициализируем массив-результат
        int[] elements = new int[elementsCount];
        var index = 0;

        // Проходим по основному массиву
        for (var row: matrix) {
            // Проходим по вложенному массиву
            for (var element: row) {
                // Добавляем каждый элемент в массив-результат
                elements[index] = element;
                index++;
            }
        }

        // Возвращаем массив результат
        return elements;
    }
}

int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
var result = App.flatten(matrix);
System.out.println(Arrays.toString(result));
// => [1, 2, 3, 4, 5, 6]

https://replit.com/@hexlet/java-arrays-nested-loops-1#Main.java

Чисто технически во вложенных циклах нет ничего особенного. Их можно вкладывать внутрь любого блока и друг в друга сколько угодно раз. Но прямой связи между внешним и вложенным циклами нет. Внутренний цикл может использовать результаты внешнего, а может и работать по своей собственной логике независимо.

Вложенные циклы коварны. Их наличие может резко увеличить сложность кода, так как появляется множество постоянно изменяющихся переменных. Становится тяжело уследить за происходящими внутри процессами. Кроме того, вложенные циклы могут указывать на использование неэффективного алгоритма решения задачи. Это не всегда так, но вероятность такая есть.

Как избавиться от вложенных циклов? Есть три варианта. Первый – ничего не делать, иногда вложенные циклы это нормально, особенно в низкоуровневых алгоритмах. Второй – переписать алгоритм так, чтобы вложенного цикла не осталось вообще, даже в вызываемых методах. Когда это невозможно – использовать третий вариант. Вынести вложенный цикл в отдельный метод, либо заменить на уже готовый метод. Например, в библиотеке Apache Commons Lang есть метод ArrayUtils.contains(), который внутри себя представляет не что иное, как обход массива в цикле.

import org.apache.commons.lang3.ArrayUtils;

// Этот метод заменяет собой цикл
// Но не забывайте что внутри все равно остается полный обход массива
int[] coll = {1, 2, 3, 4, 5};
ArrayUtils.contains(coll, 4); // true

Пример выноса вложенного цикла на flatten в отдельный метод:

class App {
    // Выносим вложенный цикл в отдельный метод append()
    private static void append(int[] result, int[] current, int index) {
        // Изменяет первый массив напрямую
        // В данном случае такая реализация оправдана
        for (var item: current) {
            result[index] = item;
            index++;
        }
    }

    public static int[] flatten(int[][] matrix) {
        var rowsCount = matrix.length;

        if (rowsCount == 0) {
            return new int[0];
        }

        var columnsCount = matrix[0].length;
        var elementsCount = rowsCount * columnsCount;

        int[] elements = new int[elementsCount];
        var index = 0;

        // Проходим по основному массиву
        for (var row: matrix) {
            // Проход по вложенному массиву выполняет метод append()
            // Нет присваивания так как меняется сам result
            append(elements, row, index);
            index += columnsCount;
        }

        return elements;
    }
}

int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
var result = App.flatten(matrix);
System.out.println(Arrays.toString(result));
// => [1, 2, 3, 4, 5, 6]

https://replit.com/@hexlet/java-arrays-nested-loops-2#Main.java

---

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты