[BAEL-16086] - Moved core-java-arrays module, added missing pom.xml, fixed pmd errors

core-java-modules/core-java-arrays-2/.gitignore

@@ -0,0 +1,25 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml

core-java-modules/core-java-arrays-2/README.MD

@@ -0,0 +1,3 @@
+## Relevant Articles
+
+- [Extending an Array’s Length](https://www.baeldung.com/java-array-add-element-at-the-end)

core-java-modules/core-java-arrays-2/pom.xml

@@ -0,0 +1,50 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.baeldung</groupId>
+    <artifactId>core-java-arrays-2</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-arrays-2</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-arrays-2</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+
+        <!-- util -->
+        <commons-lang3.version>3.9</commons-lang3.version>
+        <!-- testing -->
+        <assertj-core.version>3.10.0</assertj-core.version>
+    </properties>
+
+</project>

core-java-modules/core-java-arrays-2/src/main/java/com/baeldung/array/conversions/StreamArrayConversion.java

@@ -0,0 +1,52 @@
+package com.baeldung.array.conversions;
+
+import java.util.Arrays;
+import java.util.function.IntFunction;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class StreamArrayConversion {
+
+    public static String[] stringStreamToStringArrayUsingFunctionalInterface(Stream<String> stringStream) {
+        IntFunction<String[]> intFunction = new IntFunction<String[]>() {
+            @Override
+            public String[] apply(int value) {
+                return new String[value];
+            }
+        };
+
+        return stringStream.toArray(intFunction);
+    }
+
+    public static String[] stringStreamToStringArrayUsingMethodReference(Stream<String> stringStream) {
+        return stringStream.toArray(String[]::new);
+    }
+
+    public static String[] stringStreamToStringArrayUsingLambda(Stream<String> stringStream) {
+        return stringStream.toArray(value -> new String[value]);
+    }
+
+    public static Integer[] integerStreamToIntegerArray(Stream<Integer> integerStream) {
+        return integerStream.toArray(Integer[]::new);
+    }
+
+    public static int[] intStreamToPrimitiveIntArray(Stream<Integer> integerStream) {
+        return integerStream.mapToInt(i -> i).toArray();
+    }
+
+    public static Stream<String> stringArrayToStreamUsingArraysStream(String[] stringArray) {
+        return Arrays.stream(stringArray);
+    }
+
+    public static Stream<String> stringArrayToStreamUsingStreamOf(String[] stringArray) {
+        return Stream.of(stringArray);
+    }
+
+    public static IntStream primitiveIntArrayToStreamUsingArraysStream(int[] intArray) {
+        return Arrays.stream(intArray);
+    }
+
+    public static Stream<int[]> primitiveIntArrayToStreamUsingStreamOf(int[] intArray) {
+        return Stream.of(intArray);
+    }
+}

core-java-modules/core-java-arrays-2/src/main/java/com/baeldung/array/looping/LoopDiagonally.java

@@ -0,0 +1,45 @@
+package com.baeldung.array.looping;
+
+public class LoopDiagonally {
+
+
+    public String loopDiagonally(String[][] twoDArray) {
+
+        int length = twoDArray.length;
+        int diagonalLines = (length + length) - 1;
+        int itemsInDiagonal = 0;
+        int midPoint = (diagonalLines / 2) + 1;
+        StringBuilder output = new StringBuilder();
+
+        for (int i = 1; i <= diagonalLines; i++) {
+
+            StringBuilder items = new StringBuilder();
+            int rowIndex;
+            int columnIndex;
+
+            if (i <= midPoint) {
+                itemsInDiagonal++;
+                for (int j = 0; j < itemsInDiagonal; j++) {
+                    rowIndex = (i - j) - 1;
+                    columnIndex = j;
+                    items.append(twoDArray[rowIndex][columnIndex]);
+                }
+            } else {
+                itemsInDiagonal--;
+                for (int j = 0; j < itemsInDiagonal; j++) {
+                    rowIndex = (length - 1) - j;
+                    columnIndex = (i - length) + j;
+                    items.append(twoDArray[rowIndex][columnIndex]);
+                }
+            }
+
+            if (i != diagonalLines) {
+                output.append(items).append(" ");
+            } else {
+                output.append(items);
+            }
+        }
+
+        return output.toString();
+    }
+}

core-java-modules/core-java-arrays-2/src/test/java/com/baeldung/array/conversions/StreamArrayConversionUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.array.conversions;
+
+import static com.baeldung.array.conversions.StreamArrayConversion.intStreamToPrimitiveIntArray;
+import static com.baeldung.array.conversions.StreamArrayConversion.integerStreamToIntegerArray;
+import static com.baeldung.array.conversions.StreamArrayConversion.stringStreamToStringArrayUsingFunctionalInterface;
+import static com.baeldung.array.conversions.StreamArrayConversion.stringStreamToStringArrayUsingLambda;
+import static com.baeldung.array.conversions.StreamArrayConversion.stringStreamToStringArrayUsingMethodReference;
+import static com.baeldung.array.conversions.StreamArrayConversion.stringArrayToStreamUsingArraysStream;
+import static com.baeldung.array.conversions.StreamArrayConversion.stringArrayToStreamUsingStreamOf;
+import static com.baeldung.array.conversions.StreamArrayConversion.primitiveIntArrayToStreamUsingArraysStream;
+import static com.baeldung.array.conversions.StreamArrayConversion.primitiveIntArrayToStreamUsingStreamOf;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.Iterators;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import org.junit.Test;
+
+public class StreamArrayConversionUnitTest {
+
+    private String[] stringArray = new String[]{"baeldung", "convert", "to", "string", "array"};
+    private Integer[] integerArray = new Integer[]{1, 2, 3, 4, 5, 6, 7};
+    private int[] intPrimitiveArray = new int[]{1, 2, 3, 4, 5, 6, 7};
+
+    @Test
+    public void givenStringStream_thenConvertToStringArrayUsingFunctionalInterface() {
+        Stream<String> stringStream = Stream.of("baeldung", "convert", "to", "string", "array");
+        assertArrayEquals(stringArray, stringStreamToStringArrayUsingFunctionalInterface(stringStream));
+    }
+
+    @Test
+    public void givenStringStream_thenConvertToStringArrayUsingMethodReference() {
+        Stream<String> stringStream = Stream.of("baeldung", "convert", "to", "string", "array");
+        assertArrayEquals(stringArray, stringStreamToStringArrayUsingMethodReference(stringStream));
+    }
+
+    @Test
+    public void givenStringStream_thenConvertToStringArrayUsingLambda() {
+        Stream<String> stringStream = Stream.of("baeldung", "convert", "to", "string", "array");
+        assertArrayEquals(stringArray, stringStreamToStringArrayUsingLambda(stringStream));
+    }
+
+    @Test
+    public void givenIntegerStream_thenConvertToIntegerArray() {
+        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
+        assertArrayEquals(integerArray, integerStreamToIntegerArray(integerStream));
+    }
+
+    @Test
+    public void givenIntStream_thenConvertToIntegerArray() {
+        Stream<Integer> integerStream = IntStream.rangeClosed(1, 7).boxed();
+        assertArrayEquals(intPrimitiveArray, intStreamToPrimitiveIntArray(integerStream));
+    }
+
+    @Test
+    public void givenStringArray_whenConvertedTwoWays_thenConvertedStreamsAreEqual() {
+        assertTrue(Iterators
+            .elementsEqual(stringArrayToStreamUsingArraysStream(stringArray).iterator(),
+                stringArrayToStreamUsingStreamOf(stringArray).iterator()));
+    }
+
+    @Test
+    public void givenPrimitiveArray_whenConvertedTwoWays_thenConvertedStreamsAreNotEqual() {
+        assertFalse(Iterators.elementsEqual(
+            primitiveIntArrayToStreamUsingArraysStream(intPrimitiveArray).iterator(),
+            primitiveIntArrayToStreamUsingStreamOf(intPrimitiveArray).iterator()));
+    }
+}

core-java-modules/core-java-arrays-2/src/test/java/com/baeldung/array/looping/LoopDiagonallyUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.array.looping;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LoopDiagonallyUnitTest {
+
+    @Test
+    public void twoArrayIsLoopedDiagonallyAsExpected() {
+
+        LoopDiagonally loopDiagonally = new LoopDiagonally();
+        String[][] twoDArray = {{"a", "b", "c"},
+                                {"d", "e", "f"},
+                                {"g", "h", "i"}};
+
+        String output = loopDiagonally.loopDiagonally(twoDArray);
+        assertEquals("a db gec hf i", output);
+    }
+}