Reverse Rows of 2d Array in Java (#17228)

* adding reverse rows method and test

* adding streams and collections.reverse methods

* adds new approaches with deque and collectiosn reverse

* adding stream reversal method

* adds customized collectors and mappers for reversing rows

* fix tests

* removing unused dependency

* removing commons-lang ArrayUtils references

* switching to assertj

* fix class and test names

Author: pedrolopes9-7

core-java-modules/core-java-arrays-multidimensional/src/main/java/com/baeldung/array/reversearray/ReverseArrayElements.java

@@ -0,0 +1,76 @@
+package com.baeldung.array.reversearray;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class ReverseArrayElements {
+
+    public static void reverseRowsUsingSimpleForLoops(int[][] array) {
+        for (int row = 0; row < array.length; row++) {
+            for (int col = 0; col < array[row].length / 2; col++) {
+                int current = array[row][col];
+                array[row][col] = array[row][array[row].length - col - 1];
+                array[row][array[row].length - col - 1] = current;
+            }
+        }
+    }
+
+    public static void reverseRowsUsingNestedIntStreams(int[][] array) {
+        IntStream.range(0, array.length)
+            .forEach(row -> IntStream.range(0, array[row].length / 2)
+                .forEach(col -> {
+                    int current = array[row][col];
+                    array[row][col] = array[row][array[row].length - col - 1];
+                    array[row][array[row].length - col - 1] = current;
+                }));
+    }
+
+    public static void reverseRowsUsingCollectionsReverse(int[][] array) {
+        for (int row = 0; row < array.length; row++) {
+            List<Integer> collectionBoxedRow = Arrays.stream(array[row])
+                .boxed()
+                .collect(Collectors.toList());
+
+            Collections.reverse(collectionBoxedRow);
+
+            array[row] = collectionBoxedRow.stream()
+                .mapToInt(Integer::intValue)
+                .toArray();
+        }
+    }
+
+    public static void reverseRowsUsingCollectionsReverse(List<List<Integer>> array) {
+        array.forEach(Collections::reverse);
+    }
+
+    static <T> Collector<T, ?, List<T>> toReversedList() {
+        return Collector.of(
+            ArrayDeque::new,
+            (Deque<T> deque, T element) -> deque.addFirst(element),
+            (d1, d2) -> {
+                d2.addAll(d1);
+                return d2;
+            },
+            ArrayList::new
+        );
+    }
+
+    static <T> List<T> reverse(List<T> input) {
+        Object[] temp = input.toArray();
+
+        Stream<T> stream = (Stream<T>) IntStream.range(0, temp.length)
+            .mapToObj(i -> temp[temp.length - i - 1]);
+
+        return stream.collect(Collectors.toList());
+    }
+}
+
+

core-java-modules/core-java-arrays-multidimensional/src/test/java/com/baeldung/array/reversearray/ReverseArrayElementsUnitTest.java

@@ -0,0 +1,78 @@
+package com.baeldung.array.reversearray;
+
+import static com.baeldung.array.reversearray.ReverseArrayElements.toReversedList;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+class ReverseArrayElementsUnitTest {
+
+    @Test
+    void givenArray_whenCallReverseRows_thenAllRowsReversed() {
+        int[][] input = new int[][] { { 1, 2, 3 }, { 3, 2, 1 }, { 2, 1, 3 } };
+
+        int[][] expected = new int[][] { { 3, 2, 1 }, { 1, 2, 3 }, { 3, 1, 2 } };
+        ReverseArrayElements.reverseRowsUsingSimpleForLoops(input);
+
+        assertThat(input).isEqualTo(expected);
+    }
+
+    @Test
+    void givenArray_whenCallReverseRowsUsingNestedIntStreams_thenAllRowsReversed() {
+        int[][] input = new int[][] { { 1, 2, 3 }, { 3, 2, 1 }, { 2, 1, 3 } };
+
+        int[][] expected = new int[][] { { 3, 2, 1 }, { 1, 2, 3 }, { 3, 1, 2 } };
+        ReverseArrayElements.reverseRowsUsingNestedIntStreams(input);
+
+        assertThat(input).isEqualTo(expected);
+    }
+
+    @Test
+    void givenArray_whenCallReverseRowsUsingCollectionsReverse_thenAllRowsReversed() {
+        int[][] input = new int[][] { { 1, 2, 3 }, { 3, 2, 1 }, { 2, 1, 3 } };
+
+        int[][] expected = new int[][] { { 3, 2, 1 }, { 1, 2, 3 }, { 3, 1, 2 } };
+        ReverseArrayElements.reverseRowsUsingCollectionsReverse(input);
+
+        assertThat(input).isEqualTo(expected);
+    }
+
+    @Test
+    void givenArray_whenCallReverseRowsUsingCollectionsReverseWithList_thenAllRowsReversed() {
+        List<List<Integer>> input = asList(asList(1, 2, 3), asList(3, 2, 1), asList(2, 1, 3));
+        List<List<Integer>> expected = asList(asList(3, 2, 1), asList(1, 2, 3), asList(3, 1, 2));
+
+        ReverseArrayElements.reverseRowsUsingCollectionsReverse(input);
+
+        assertThat(input).isEqualTo(expected);
+    }
+
+    @Test
+    void givenStreamOf2dArrays_whenMappingWithReverse_thenOutputStreamIsAlsoReversed() {
+        List<List<Integer>> input = asList(asList(1, 2, 3), asList(3, 2, 1), asList(2, 1, 3));
+        List<List<Integer>> expected = asList(asList(3, 2, 1), asList(1, 2, 3), asList(3, 1, 2));
+
+        List<List<Integer>> result = input.stream()
+            .map(ReverseArrayElements::reverse)
+            .collect(Collectors.toList());
+
+        assertThat(result).isEqualTo(expected);
+    }
+
+    @Test
+    void givenStreamOf2dArrays_whenMappingWithCollectReversed_thenOutputStreamIsAlsoReversed() {
+        List<List<Integer>> input = asList(asList(1, 2, 3), asList(3, 2, 1), asList(2, 1, 3));
+        List<List<Integer>> expected = asList(asList(3, 2, 1), asList(1, 2, 3), asList(3, 1, 2));
+
+        List<List<Integer>> result = input.stream()
+            .map(a -> a.stream()
+                .collect(toReversedList()))
+            .collect(Collectors.toList());
+
+        assertThat(result).isEqualTo(expected);
+    }
+}