From 0a53cbd9d359c85d54bac2d891ae8f060660d4d3 Mon Sep 17 00:00:00 2001 From: "Kent@lhind.hp.g5" Date: Fri, 23 Apr 2021 19:33:57 +0200 Subject: [PATCH] [BAEL-4918] concat Arrays in java --- .../baeldung/arrayconcat/ArrayConcatUtil.java | 65 ++++++++++++ .../arrayconcat/ArrayConcatUtilUnitTest.java | 99 +++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arrayconcat/ArrayConcatUtil.java create mode 100644 core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arrayconcat/ArrayConcatUtilUnitTest.java diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arrayconcat/ArrayConcatUtil.java b/core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arrayconcat/ArrayConcatUtil.java new file mode 100644 index 0000000000..15ac48ea7d --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/main/java/com/baeldung/arrayconcat/ArrayConcatUtil.java @@ -0,0 +1,65 @@ +package com.baeldung.arrayconcat; + +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class ArrayConcatUtil { + private ArrayConcatUtil() {} + + static T[] concatWithCollection(T[] array1, T[] array2) { + List resultList = new ArrayList<>(array1.length + array2.length); + Collections.addAll(resultList, array1); + Collections.addAll(resultList, array2); + + @SuppressWarnings("unchecked") + //the type cast is safe as the array1 has the type T[] + T[] resultArray = (T[]) Array.newInstance(array1.getClass().getComponentType(), 0); + return resultList.toArray(resultArray); + } + + static T[] concatWithArrayCopy(T[] array1, T[] array2) { + T[] result = Arrays.copyOf(array1, array1.length + array2.length); + System.arraycopy(array2, 0, result, array1.length, array2.length); + return result; + } + + static T concatWithCopy2(T array1, T array2) { + if (!array1.getClass().isArray() || !array2.getClass().isArray()) { + throw new IllegalArgumentException("Only arrays are accepted."); + } + + Class compType1 = array1.getClass().getComponentType(); + Class compType2 = array2.getClass().getComponentType(); + + if (!compType1.equals(compType2)) { + throw new IllegalArgumentException("Two arrays have different types."); + } + + int len1 = Array.getLength(array1); + int len2 = Array.getLength(array2); + + @SuppressWarnings("unchecked") + //the cast is safe due to the previous checks + T result = (T) Array.newInstance(compType1, len1 + len2); + + System.arraycopy(array1, 0, result, 0, len1); + System.arraycopy(array2, 0, result, len1, len2); + + return result; + } + + @SuppressWarnings("unchecked") + static T[] concatWithStream(T[] array1, T[] array2) { + return Stream.concat(Arrays.stream(array1), Arrays.stream(array2)) + .toArray(size -> (T[]) Array.newInstance(array1.getClass().getComponentType(), size)); + } + + static int[] concatIntArraysWithIntStream(int[] array1, int[] array2) { + return IntStream.concat(Arrays.stream(array1), Arrays.stream(array2)).toArray(); + } +} diff --git a/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arrayconcat/ArrayConcatUtilUnitTest.java b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arrayconcat/ArrayConcatUtilUnitTest.java new file mode 100644 index 0000000000..77c368d763 --- /dev/null +++ b/core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arrayconcat/ArrayConcatUtilUnitTest.java @@ -0,0 +1,99 @@ +package com.baeldung.arrayconcat; + + +import com.google.common.collect.ObjectArrays; +import com.google.common.primitives.Ints; +import org.apache.commons.lang3.ArrayUtils; +import org.junit.Test; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.fail; + +public class ArrayConcatUtilUnitTest { + private final String[] strArray1 = { "element 1", "element 2", "element 3" }; + private final String[] strArray2 = { "element 4", "element 5" }; + private final String[] expectedStringArray = { "element 1", "element 2", "element 3", "element 4", "element 5" }; + + private final int[] intArray1 = { 0, 1, 2, 3 }; + private final int[] intArray2 = { 4, 5, 6, 7 }; + private final int[] expectedIntArray = { 0, 1, 2, 3, 4, 5, 6, 7 }; + + @Test + public void givenTwoStringArrays_whenConcatWithList_thenGetExpectedResult() { + String[] result = ArrayConcatUtil.concatWithCollection(strArray1, strArray2); + assertThat(result).isEqualTo(expectedStringArray); + } + + @Test + public void givenTwoStringArrays_whenConcatWithCopy_thenGetExpectedResult() { + String[] result = ArrayConcatUtil.concatWithArrayCopy(strArray1, strArray2); + assertThat(result).isEqualTo(expectedStringArray); + } + + @Test + public void givenTwoStrings_whenConcatWithCopy2_thenGetException() { + String exMsg = "Only arrays are accepted."; + try { + ArrayConcatUtil.concatWithCopy2("String Nr. 1", "String Nr. 2"); + fail(String.format("IllegalArgumentException with message:'%s' should be thrown. But it didn't", exMsg)); + } catch (IllegalArgumentException e) { + assertThat(e).hasMessage(exMsg); + } + } + + @Test + public void givenTwoArraysInDifferentTypes_whenConcatWithCopy2_thenGetException() { + String[] strArray = new String[] { "test 1", "test 2" }; + Integer[] integerArray = new Integer[] { 7, 11 }; + String exMsg = "Two arrays have different types."; + + try { + ArrayConcatUtil.concatWithCopy2(strArray, integerArray); + fail(String.format("IllegalArgumentException with message:'%s' should be thrown. But it didn't", exMsg)); + } catch (IllegalArgumentException e) { + assertThat(e).hasMessage(exMsg); + } + } + + @Test + public void givenTwoArrays_whenConcatWithCopy2_thenGetExpectedResult() { + String[] result = ArrayConcatUtil.concatWithCopy2(strArray1, strArray2); + assertThat(result).isEqualTo(expectedStringArray); + + int[] intResult = ArrayConcatUtil.concatWithCopy2(intArray1, intArray2); + assertThat(intResult).isEqualTo(expectedIntArray); + } + + @Test + public void givenTwoStringArrays_whenConcatWithStream_thenGetExpectedResult() { + String[] result = ArrayConcatUtil.concatWithStream(strArray1, strArray2); + assertThat(result).isEqualTo(expectedStringArray); + } + + @Test + public void givenTwoIntArrays_whenConcatWithIntStream_thenGetExpectedResult() { + int[] intResult = ArrayConcatUtil.concatIntArraysWithIntStream(intArray1, intArray2); + assertThat(intResult).isEqualTo(expectedIntArray); + } + + @Test + public void givenTwoArrays_whenConcatWithCommonsLang_thenGetExpectedResult() { + String[] result = ArrayUtils.addAll(strArray1, strArray2); + assertThat(result).isEqualTo(expectedStringArray); + + int[] intResult = ArrayUtils.addAll(intArray1, intArray2); + assertThat(intResult).isEqualTo(expectedIntArray); + } + + @Test + public void givenTwoStringArrays_whenConcatWithGuava_thenGetExpectedResult() { + String[] result = ObjectArrays.concat(strArray1, strArray2, String.class); + assertThat(result).isEqualTo(expectedStringArray); + } + + @Test + public void givenTwoIntArrays_whenConcatWithGuava_thenGetExpectedResult() { + int[] intResult = Ints.concat(intArray1, intArray2); + assertThat(intResult).isEqualTo(expectedIntArray); + } +}