diff --git a/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertToMap/Book.java b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertToMap/Book.java new file mode 100644 index 0000000000..847e0bd8cd --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertToMap/Book.java @@ -0,0 +1,48 @@ +package com.baeldung.convertToMap; + +public class Book { + private String name; + private int releaseYear; + private String isbn; + + + @Override + public String toString() { + return "Book{" + + "name='" + name + '\'' + + ", releaseYear=" + releaseYear + + ", isbn='" + isbn + '\'' + + '}'; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getReleaseYear() { + return releaseYear; + } + + public void setReleaseYear(int releaseYear) { + this.releaseYear = releaseYear; + } + + public String getIsbn() { + return isbn; + } + + public void setIsbn(String isbn) { + this.isbn = isbn; + } + + public Book(String name, int releaseYear, String isbn) { + this.name = name; + this.releaseYear = releaseYear; + this.isbn = isbn; + } +} + diff --git a/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertToMap/ConvertToMap.java b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertToMap/ConvertToMap.java new file mode 100644 index 0000000000..317cdca529 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertToMap/ConvertToMap.java @@ -0,0 +1,30 @@ +package com.baeldung.convertToMap; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class ConvertToMap { + public Map listToMap(List books) { + return books.stream().collect(Collectors.toMap(Book::getIsbn, Book::getName)); + } + + public Map listToMapWithDupKeyError(List books) { + return books.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity())); + } + + public Map listToMapWithDupKey(List books) { + return books.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity(), (existing, replacement) -> existing)); + } + + public Map listToConcurrentMap(List books) { + return books.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity(), (o1, o2) -> o1, ConcurrentHashMap::new)); + } + + public TreeMap listToSortedMap(List books) { + return books.stream() + .collect(Collectors.toMap(Book::getName, Function.identity(), (o1, o2) -> o1, TreeMap::new)); + } +} + diff --git a/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertcollectiontoarraylist/Foo.java b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertcollectiontoarraylist/Foo.java new file mode 100644 index 0000000000..5c9464182e --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertcollectiontoarraylist/Foo.java @@ -0,0 +1,52 @@ +package com.baeldung.convertcollectiontoarraylist; + +/** + * This POJO is the element type of our collection. It has a deepCopy() method. + * + * @author chris + */ +public class Foo { + + private int id; + private String name; + private Foo parent; + + public Foo() { + } + + public Foo(int id, String name, Foo parent) { + this.id = id; + this.name = name; + this.parent = parent; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public Foo getParent() { + return parent; + } + + public void setParent(Foo parent) { + this.parent = parent; + } + + public Foo deepCopy() { + return new Foo( + this.id, this.name, this.parent != null ? this.parent.deepCopy() : null); + } + +} diff --git a/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertlisttomap/Animal.java b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertlisttomap/Animal.java new file mode 100644 index 0000000000..b8eddf71a5 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertlisttomap/Animal.java @@ -0,0 +1,27 @@ +package com.baeldung.convertlisttomap; + +public class Animal { + private int id; + private String name; + + public Animal(int id, String name) { + this.id = id; + this.setName(name); + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} diff --git a/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertlisttomap/ConvertListToMapService.java b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertlisttomap/ConvertListToMapService.java new file mode 100644 index 0000000000..57579e948f --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/main/java/com/baeldung/convertlisttomap/ConvertListToMapService.java @@ -0,0 +1,43 @@ +package com.baeldung.convertlisttomap; + +import com.google.common.collect.Maps; +import org.apache.commons.collections4.MapUtils; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class ConvertListToMapService { + + public Map convertListBeforeJava8(List list) { + + Map map = new HashMap<>(); + + for (Animal animal : list) { + map.put(animal.getId(), animal); + } + return map; + } + + public Map convertListAfterJava8(List list) { + Map map = list.stream().collect(Collectors.toMap(Animal::getId, Function.identity())); + return map; + } + + public Map convertListWithGuava(List list) { + + Map map = Maps.uniqueIndex(list, Animal::getId); + return map; + } + + public Map convertListWithApacheCommons(List list) { + + Map map = new HashMap<>(); + + MapUtils.populateMap(map, list, Animal::getId); + + return map; + } +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertToMap/ConvertToMapUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertToMap/ConvertToMapUnitTest.java new file mode 100644 index 0000000000..d6eab461d7 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertToMap/ConvertToMapUnitTest.java @@ -0,0 +1,53 @@ +package com.baeldung.convertToMap; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + + +public class ConvertToMapUnitTest { + + private List bookList; + private ConvertToMap convertToMap = new ConvertToMap(); + + @Before + public void init() { + bookList = new ArrayList<>(); + bookList.add(new Book("The Fellowship of the Ring", 1954, "0395489318")); + bookList.add(new Book("The Two Towers", 1954, "0345339711")); + bookList.add(new Book("The Return of the King", 1955, "0618129111")); + } + + @Test + public void whenConvertFromListToMap() { + assertTrue(convertToMap.listToMap(bookList).size() == 3); + } + + @Test(expected = IllegalStateException.class) + public void whenMapHasDuplicateKey_without_merge_function_then_runtime_exception() { + convertToMap.listToMapWithDupKeyError(bookList); + } + + @Test + public void whenMapHasDuplicateKeyThenMergeFunctionHandlesCollision() { + Map booksByYear = convertToMap.listToMapWithDupKey(bookList); + assertEquals(2, booksByYear.size()); + assertEquals("0395489318", booksByYear.get(1954).getIsbn()); + } + + @Test + public void whenCreateConcurrentHashMap() { + assertTrue(convertToMap.listToConcurrentMap(bookList) instanceof ConcurrentHashMap); + } + + @Test + public void whenMapisSorted() { + assertTrue(convertToMap.listToSortedMap(bookList).firstKey().equals("The Fellowship of the Ring")); + } +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertcollectiontoarraylist/CollectionToArrayListUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertcollectiontoarraylist/CollectionToArrayListUnitTest.java new file mode 100644 index 0000000000..b8134de08a --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertcollectiontoarraylist/CollectionToArrayListUnitTest.java @@ -0,0 +1,145 @@ +package com.baeldung.convertcollectiontoarraylist; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Comparator; +import java.util.HashSet; +import java.util.Iterator; +import static java.util.stream.Collectors.toCollection; +import org.junit.BeforeClass; +import org.junit.Test; +import static org.junit.Assert.*; + +/** + * + * @author chris + */ +public class CollectionToArrayListUnitTest { + private static Collection srcCollection = new HashSet<>(); + + public CollectionToArrayListUnitTest() { + } + + @BeforeClass + public static void setUpClass() { + int i = 0; + Foo john = new Foo(i++, "John", null); + Foo mary = new Foo(i++, "Mary", null); + Foo sam = new Foo(i++, "Sam", john); + Foo alice = new Foo(i++, "Alice", john); + Foo buffy = new Foo(i++, "Buffy", sam); + srcCollection.add(john); + srcCollection.add(mary); + srcCollection.add(sam); + srcCollection.add(alice); + srcCollection.add(buffy); + } + + /** + * Section 3. Using the ArrayList Constructor + */ + @Test + public void whenUsingConstructor_thenVerifyShallowCopy() { + ArrayList newList = new ArrayList<>(srcCollection); + verifyShallowCopy(srcCollection, newList); + } + + /** + * Section 4. Using the Streams API + */ + @Test + public void whenUsingStream_thenVerifyShallowCopy() { + ArrayList newList = srcCollection.stream().collect(toCollection(ArrayList::new)); + + verifyShallowCopy(srcCollection, newList); + } + + /** + * Section 5. Deep Copy + */ + @Test + public void whenUsingDeepCopy_thenVerifyDeepCopy() { + ArrayList newList = srcCollection.stream() + .map(Foo::deepCopy) + .collect(toCollection(ArrayList::new)); + + verifyDeepCopy(srcCollection, newList); + } + + /** + * Section 6. Controlling the List Order + */ + @Test + public void whenUsingSortedStream_thenVerifySortOrder() { + ArrayList newList = srcCollection.stream() + .sorted(Comparator.comparing(Foo::getName)) + .collect(toCollection(ArrayList::new)); + + assertTrue("ArrayList is not sorted by name", isSorted(newList)); + } + + /** + * Verify that the contents of the two collections are the same + * @param a + * @param b + */ + private void verifyShallowCopy(Collection a, Collection b) { + assertEquals("Collections have different lengths", a.size(), b.size()); + Iterator iterA = a.iterator(); + Iterator iterB = b.iterator(); + while (iterA.hasNext()) { + // test instance identity + assertSame("Foo instances differ!", iterA.next(), iterB.next()); + } + } + + /** + * Verify that the contents of the two collections are the same + * @param a + * @param b + */ + private void verifyDeepCopy(Collection a, Collection b) { + assertEquals("Collections have different lengths", a.size(), b.size()); + Iterator iterA = a.iterator(); + Iterator iterB = b.iterator(); + while (iterA.hasNext()) { + Foo nextA = iterA.next(); + Foo nextB = iterB.next(); + // should not be same instance + assertNotSame("Foo instances are the same!", nextA, nextB); + // but should have same content + assertFalse("Foo instances have different content!", fooDiff(nextA, nextB)); + } + } + + /** + * Return true if the contents of a and b differ. Test parent recursively + * @param a + * @param b + * @return False if the two items are the same + */ + private boolean fooDiff(Foo a, Foo b) { + if (a != null && b != null) { + return a.getId() != b.getId() + || !a.getName().equals(b.getName()) + || fooDiff(a.getParent(), b.getParent()); + } + return !(a == null && b == null); + } + + /** + * @param c collection of Foo + * @return true if the collection is sorted by name + */ + private static boolean isSorted(Collection c) { + String prevName = null; + for (Foo foo : c) { + if (prevName == null || foo.getName().compareTo(prevName) > 0) { + prevName = foo.getName(); + } else { + return false; + } + } + return true; + } +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertiteratortolist/ConvertIteratorToListServiceUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertiteratortolist/ConvertIteratorToListServiceUnitTest.java new file mode 100644 index 0000000000..7d94f88d21 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertiteratortolist/ConvertIteratorToListServiceUnitTest.java @@ -0,0 +1,100 @@ +package com.baeldung.convertiteratortolist; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.collection.IsCollectionWithSize.hasSize; +import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; + +import org.apache.commons.collections4.IteratorUtils; +import org.junit.Before; +import org.junit.Test; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; + +public class ConvertIteratorToListServiceUnitTest { + + Iterator iterator; + + @Before + public void setUp() { + iterator = Arrays.asList(1, 2, 3) + .iterator(); + } + + @Test + public void givenAnIterator_whenConvertIteratorToListUsingWhileLoop_thenReturnAList() { + + List actualList = new ArrayList<>(); + + // Convert Iterator to List using while loop dsf + while (iterator.hasNext()) { + actualList.add(iterator.next()); + } + + assertThat(actualList, hasSize(3)); + assertThat(actualList, containsInAnyOrder(1, 2, 3)); + } + + @Test + public void givenAnIterator_whenConvertIteratorToListAfterJava8_thenReturnAList() { + List actualList = new ArrayList<>(); + + // Convert Iterator to List using Java 8 + iterator.forEachRemaining(actualList::add); + + assertThat(actualList, hasSize(3)); + assertThat(actualList, containsInAnyOrder(1, 2, 3)); + } + + @Test + public void givenAnIterator_whenConvertIteratorToListJava8Stream_thenReturnAList() { + + // Convert iterator to iterable + Iterable iterable = () -> iterator; + + // Extract List from stream + List actualList = StreamSupport + .stream(iterable.spliterator(), false) + .collect(Collectors.toList()); + + assertThat(actualList, hasSize(3)); + assertThat(actualList, containsInAnyOrder(1, 2, 3)); + } + + @Test + public void givenAnIterator_whenConvertIteratorToImmutableListWithGuava_thenReturnAList() { + + // Convert Iterator to an Immutable list using Guava library in Java + List actualList = ImmutableList.copyOf(iterator); + + assertThat(actualList, hasSize(3)); + assertThat(actualList, containsInAnyOrder(1, 2, 3)); + } + + @Test + public void givenAnIterator_whenConvertIteratorToMutableListWithGuava_thenReturnAList() { + + // Convert Iterator to a mutable list using Guava library in Java + List actualList = Lists.newArrayList(iterator); + + assertThat(actualList, hasSize(3)); + assertThat(actualList, containsInAnyOrder(1, 2, 3)); + } + + @Test + public void givenAnIterator_whenConvertIteratorToMutableListWithApacheCommons_thenReturnAList() { + + // Convert Iterator to a mutable list using Apache Commons library in Java + List actualList = IteratorUtils.toList(iterator); + + assertThat(actualList, hasSize(3)); + assertThat(actualList, containsInAnyOrder(1, 2, 3)); + } +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertlisttomap/ConvertListToMapServiceUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertlisttomap/ConvertListToMapServiceUnitTest.java new file mode 100644 index 0000000000..4d783f4525 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertlisttomap/ConvertListToMapServiceUnitTest.java @@ -0,0 +1,68 @@ +package com.baeldung.convertlisttomap; + +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; + +public class ConvertListToMapServiceUnitTest { + List list; + + private ConvertListToMapService convertListService; + + @Before + public void init() { + this.convertListService = new ConvertListToMapService(); + this.list = new ArrayList<>(); + + Animal cat = new Animal(1, "Cat"); + list.add(cat); + Animal dog = new Animal(2, "Dog"); + list.add(dog); + Animal pig = new Animal(3, "Pig"); + list.add(pig); + Animal cow = new Animal(4, "Cow"); + list.add(cow); + Animal goat = new Animal(5, "Goat"); + list.add(goat); + + } + + @Test + public void givenAList_whenConvertBeforeJava8_thenReturnMapWithTheSameElements() { + + Map map = convertListService.convertListBeforeJava8(list); + + assertThat(map.values(), containsInAnyOrder(list.toArray())); + } + + @Test + public void givenAList_whenConvertAfterJava8_thenReturnMapWithTheSameElements() { + + Map map = convertListService.convertListAfterJava8(list); + + assertThat(map.values(), containsInAnyOrder(list.toArray())); + } + + @Test + public void givenAList_whenConvertWithGuava_thenReturnMapWithTheSameElements() { + + Map map = convertListService.convertListWithGuava(list); + + assertThat(map.values(), containsInAnyOrder(list.toArray())); + } + + @Test + public void givenAList_whenConvertWithApacheCommons_thenReturnMapWithTheSameElements() { + + Map map = convertListService.convertListWithApacheCommons(list); + + assertThat(map.values(), containsInAnyOrder(list.toArray())); + } + +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertlisttomap/ConvertListWithDuplicatedIdToMapServiceUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertlisttomap/ConvertListWithDuplicatedIdToMapServiceUnitTest.java new file mode 100644 index 0000000000..5e6828a3d5 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/convertlisttomap/ConvertListWithDuplicatedIdToMapServiceUnitTest.java @@ -0,0 +1,68 @@ +package com.baeldung.convertlisttomap; + +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.hasItem; +import static org.hamcrest.Matchers.hasSize; + +public class ConvertListWithDuplicatedIdToMapServiceUnitTest { + List duplicatedIdList; + + private ConvertListToMapService convertListService = new ConvertListToMapService(); + + @Before + public void init() { + + this.duplicatedIdList = new ArrayList<>(); + + Animal cat = new Animal(1, "Cat"); + duplicatedIdList.add(cat); + Animal dog = new Animal(2, "Dog"); + duplicatedIdList.add(dog); + Animal pig = new Animal(3, "Pig"); + duplicatedIdList.add(pig); + Animal cow = new Animal(4, "Cow"); + duplicatedIdList.add(cow); + Animal goat = new Animal(4, "Goat"); + duplicatedIdList.add(goat); + + } + + @Test + public void givenADupIdList_whenConvertBeforeJava8_thenReturnMapWithRewrittenElement() { + + Map map = convertListService.convertListBeforeJava8(duplicatedIdList); + + assertThat(map.values(), hasSize(4)); + assertThat(map.values(), hasItem(duplicatedIdList.get(4))); + } + + @Test + public void givenADupIdList_whenConvertWithApacheCommons_thenReturnMapWithRewrittenElement() { + + Map map = convertListService.convertListWithApacheCommons(duplicatedIdList); + + assertThat(map.values(), hasSize(4)); + assertThat(map.values(), hasItem(duplicatedIdList.get(4))); + } + + @Test(expected = IllegalStateException.class) + public void givenADupIdList_whenConvertAfterJava8_thenException() { + + convertListService.convertListAfterJava8(duplicatedIdList); + } + + @Test(expected = IllegalArgumentException.class) + public void givenADupIdList_whenConvertWithGuava_thenException() { + + convertListService.convertListWithGuava(duplicatedIdList); + + } + +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/collections/IterableToCollectionUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/collections/IterableToCollectionUnitTest.java new file mode 100644 index 0000000000..0283191b74 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/collections/IterableToCollectionUnitTest.java @@ -0,0 +1,122 @@ +package com.baeldung.java.collections; + +import static org.hamcrest.Matchers.contains; +import static org.junit.Assert.assertThat; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.Spliterator; +import java.util.Spliterators; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; + +import org.apache.commons.collections4.IterableUtils; +import org.apache.commons.collections4.IteratorUtils; +import org.junit.Test; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; + +public class IterableToCollectionUnitTest { + + Iterable iterable = Arrays.asList("john", "tom", "jane"); + Iterator iterator = iterable.iterator(); + + @Test + public void whenConvertIterableToListUsingJava_thenSuccess() { + List result = new ArrayList(); + for (String str : iterable) { + result.add(str); + } + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIterableToListUsingJava8_thenSuccess() { + List result = new ArrayList(); + iterable.forEach(result::add); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIterableToListUsingJava8WithSpliterator_thenSuccess() { + List result = StreamSupport.stream(iterable.spliterator(), false) + .collect(Collectors.toList()); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIterableToListUsingGuava_thenSuccess() { + List result = Lists.newArrayList(iterable); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIterableToImmutableListUsingGuava_thenSuccess() { + List result = ImmutableList.copyOf(iterable); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIterableToListUsingApacheCommons_thenSuccess() { + List result = IterableUtils.toList(iterable); + + assertThat(result, contains("john", "tom", "jane")); + } + + // ======================== Iterator + + @Test + public void whenConvertIteratorToListUsingJava_thenSuccess() { + List result = new ArrayList(); + while (iterator.hasNext()) { + result.add(iterator.next()); + } + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIteratorToListUsingJava8_thenSuccess() { + List result = new ArrayList(); + iterator.forEachRemaining(result::add); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIteratorToListUsingJava8WithSpliterator_thenSuccess() { + List result = StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false) + .collect(Collectors.toList()); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIteratorToListUsingGuava_thenSuccess() { + List result = Lists.newArrayList(iterator); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIteratorToImmutableListUsingGuava_thenSuccess() { + List result = ImmutableList.copyOf(iterator); + + assertThat(result, contains("john", "tom", "jane")); + } + + @Test + public void whenConvertIteratorToListUsingApacheCommons_thenSuccess() { + List result = IteratorUtils.toList(iterator); + + assertThat(result, contains("john", "tom", "jane")); + } +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/collections/JavaCollectionConversionUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/collections/JavaCollectionConversionUnitTest.java new file mode 100644 index 0000000000..7947d1b6c7 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/collections/JavaCollectionConversionUnitTest.java @@ -0,0 +1,145 @@ +package com.baeldung.java.collections; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.commons.lang3.ArrayUtils; +import org.junit.Test; + +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.google.common.primitives.Ints; + +@SuppressWarnings("unused") +public class JavaCollectionConversionUnitTest { + + // List -> array; array -> List + + @Test + public final void givenUsingCoreJava_whenArrayConvertedToList_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final List targetList = Arrays.asList(sourceArray); + } + + @Test + public final void givenUsingCoreJava_whenListConvertedToArray_thenCorrect() { + final List sourceList = Arrays.asList(0, 1, 2, 3, 4, 5); + final Integer[] targetArray = sourceList.toArray(new Integer[0]); + } + + @Test + public final void givenUsingGuava_whenArrayConvertedToList_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final List targetList = Lists.newArrayList(sourceArray); + } + + @Test + public final void givenUsingGuava_whenListConvertedToArray_thenCorrect() { + final List sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5); + final int[] targetArray = Ints.toArray(sourceList); + } + + @Test + public final void givenUsingCommonsCollections_whenArrayConvertedToList_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final List targetList = new ArrayList<>(6); + CollectionUtils.addAll(targetList, sourceArray); + } + + // Set -> array; array -> Set + + @Test + public final void givenUsingCoreJavaV1_whenArrayConvertedToSet_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final Set targetSet = new HashSet(Arrays.asList(sourceArray)); + } + + @Test + public final void givenUsingCoreJavaV2_whenArrayConvertedToSet_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final Set targetSet = new HashSet(); + Collections.addAll(targetSet, sourceArray); + } + + @Test + public final void givenUsingCoreJava_whenSetConvertedToArray_thenCorrect() { + final Set sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5); + final Integer[] targetArray = sourceSet.toArray(new Integer[0]); + } + + @Test + public final void givenUsingGuava_whenArrayConvertedToSet_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final Set targetSet = Sets.newHashSet(sourceArray); + } + + @Test + public final void givenUsingGuava_whenSetConvertedToArray_thenCorrect() { + final Set sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5); + final int[] targetArray = Ints.toArray(sourceSet); + } + + @Test + public final void givenUsingCommonsCollections_whenArrayConvertedToSet_thenCorrect() { + final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 }; + final Set targetSet = new HashSet<>(6); + CollectionUtils.addAll(targetSet, sourceArray); + } + + @Test + public final void givenUsingCommonsCollections_whenSetConvertedToArrayOfPrimitives_thenCorrect() { + final Set sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5); + final Integer[] targetArray = sourceSet.toArray(new Integer[0]); + final int[] primitiveTargetArray = ArrayUtils.toPrimitive(targetArray); + } + + // Map (values) -> Array, List, Set + + @Test + public final void givenUsingCoreJava_whenMapValuesConvertedToArray_thenCorrect() { + final Map sourceMap = createMap(); + + final Collection values = sourceMap.values(); + final String[] targetArray = values.toArray(new String[0]); + } + + @Test + public final void givenUsingCoreJava_whenMapValuesConvertedToList_thenCorrect() { + final Map sourceMap = createMap(); + + final List targetList = new ArrayList<>(sourceMap.values()); + } + + @Test + public final void givenUsingGuava_whenMapValuesConvertedToList_thenCorrect() { + final Map sourceMap = createMap(); + + final List targetList = Lists.newArrayList(sourceMap.values()); + } + + @Test + public final void givenUsingCoreJava_whenMapValuesConvertedToSet_thenCorrect() { + final Map sourceMap = createMap(); + + final Set targetSet = new HashSet<>(sourceMap.values()); + } + + // UTIL + + private final Map createMap() { + final Map sourceMap = new HashMap<>(3); + sourceMap.put(0, "zero"); + sourceMap.put(1, "one"); + sourceMap.put(2, "two"); + return sourceMap; + } + +} diff --git a/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/lists/ListToStringUnitTest.java b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/lists/ListToStringUnitTest.java new file mode 100644 index 0000000000..0fdc096d14 --- /dev/null +++ b/core-java-modules/core-java-collections-conversions/src/test/java/com/baeldung/java/lists/ListToStringUnitTest.java @@ -0,0 +1,31 @@ +package com.baeldung.java.lists; + +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + +import org.apache.commons.lang3.StringUtils; +import org.junit.Test; + +public class ListToStringUnitTest { + + @Test + public void whenListToString_thenPrintDefault() { + List intLIst = Arrays.asList(1, 2, 3); + System.out.println(intLIst); + } + + @Test + public void whenCollectorsJoining_thenPrintCustom() { + List intList = Arrays.asList(1, 2, 3); + System.out.println(intList.stream() + .map(n -> String.valueOf(n)) + .collect(Collectors.joining("-", "{", "}"))); + } + + @Test + public void whenStringUtilsJoin_thenPrintCustom() { + List intList = Arrays.asList(1, 2, 3); + System.out.println(StringUtils.join(intList, "|")); + } +}