JAVA-11533 Move core-java related modules to core-java-modules (#12119)
* JAVA-11533 Move core-java related modules to core-java-modules * JAVA-11533 Remove moved modules from old parent pom * JAVA-11533 Updated Readme and pom of parent module * JAVA-11533 Revert changes made to Readme of parent module * JAVA-11533 Moved articles to respective submouldes
This commit is contained in:
anuragkumawat
GitHub
@@ -4,6 +4,6 @@ This module contains modules about core Java
|
||||
|
||||
## Relevant articles:
|
||||
|
||||
- [Multi-Module Maven Application with Java Modules](https://www.baeldung.com/maven-multi-module-project-java-jpms)
|
||||
- [Understanding the NumberFormatException in Java](https://www.baeldung.com/java-number-format-exception)
|
||||
- [Will an Error Be Caught by Catch Block in Java?](https://www.baeldung.com/java-error-catch)
|
||||
|
||||
|
||||
|
||||
@@ -13,4 +13,5 @@ This module contains articles about core java exceptions
|
||||
- [The StackOverflowError in Java](https://www.baeldung.com/java-stack-overflow-error)
|
||||
- [Checked and Unchecked Exceptions in Java](https://www.baeldung.com/java-checked-unchecked-exceptions)
|
||||
- [Common Java Exceptions](https://www.baeldung.com/java-common-exceptions)
|
||||
- [Will an Error Be Caught by Catch Block in Java?](https://www.baeldung.com/java-error-catch)
|
||||
- [[Next -->]](/core-java-modules/core-java-exceptions-2)
|
||||
@@ -0,0 +1,12 @@
|
||||
## Java Collections Cookbooks and Examples
|
||||
|
||||
This module contains articles about conversions among Collection types and arrays in Java.
|
||||
|
||||
### Relevant Articles:
|
||||
|
||||
- [Array to String Conversions](https://www.baeldung.com/java-array-to-string)
|
||||
- [Mapping Lists with ModelMapper](https://www.baeldung.com/java-modelmapper-lists)
|
||||
- [Converting List to Map With a Custom Supplier](https://www.baeldung.com/list-to-map-supplier)
|
||||
- [Arrays.asList vs new ArrayList(Arrays.asList())](https://www.baeldung.com/java-arrays-aslist-vs-new-arraylist)
|
||||
- [Iterate Over a Set in Java](https://www.baeldung.com/java-iterate-set)
|
||||
- More articles: [[<-- prev]](../java-collections-conversions)
|
||||
@@ -0,0 +1,45 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<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>
|
||||
<artifactId>java-collections-conversions-2</artifactId>
|
||||
<version>0.1.0-SNAPSHOT</version>
|
||||
<name>java-collections-conversions-2</name>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<parent>
|
||||
<groupId>com.baeldung.core-java-modules</groupId>
|
||||
<artifactId>core-java-modules</artifactId>
|
||||
<version>0.0.1-SNAPSHOT</version>
|
||||
</parent>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-lang3</artifactId>
|
||||
<version>${commons-lang3.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.modelmapper</groupId>
|
||||
<artifactId>modelmapper</artifactId>
|
||||
<version>${modelmapper.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>io.vavr</groupId>
|
||||
<artifactId>vavr</artifactId>
|
||||
<version>0.10.3</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<finalName>java-collections-conversions-2</finalName>
|
||||
<resources>
|
||||
<resource>
|
||||
<directory>src/main/resources</directory>
|
||||
<filtering>true</filtering>
|
||||
</resource>
|
||||
</resources>
|
||||
</build>
|
||||
|
||||
</project>
|
||||
+70
@@ -0,0 +1,70 @@
|
||||
package com.baeldung.convertlisttomap;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.function.BiConsumer;
|
||||
import java.util.function.BinaryOperator;
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Supplier;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* Convert a string list to a map whose key is the string's length and value is the collection with same length.
|
||||
* Give a list {"Baeldung", "is", "very", "cool"}.
|
||||
* After conversion we'll get a map like:
|
||||
* {8 : ["Baeldung"], 2 : ["is"], 4 : ["very", "cool"]}.
|
||||
*
|
||||
* @author leasy.zhang
|
||||
*
|
||||
*/
|
||||
public class ListToMapConverter {
|
||||
|
||||
public Map<Integer, List<String>> groupingByStringLength(List<String> source,
|
||||
Supplier<Map<Integer, List<String>>> mapSupplier,
|
||||
Supplier<List<String>> listSupplier) {
|
||||
|
||||
return source.stream()
|
||||
.collect(Collectors.groupingBy(String::length, mapSupplier, Collectors.toCollection(listSupplier)));
|
||||
}
|
||||
|
||||
public Map<Integer, List<String>> streamCollectByStringLength(List<String> source,
|
||||
Supplier<Map<Integer, List<String>>> mapSupplier,
|
||||
Supplier<List<String>> listSupplier) {
|
||||
|
||||
BiConsumer<Map<Integer, List<String>>, String> accumulator = (response, element) -> {
|
||||
Integer key = element.length();
|
||||
List<String> values = response.getOrDefault(key, listSupplier.get());
|
||||
values.add(element);
|
||||
response.put(key, values);
|
||||
};
|
||||
|
||||
BiConsumer<Map<Integer, List<String>>, Map<Integer, List<String>>> combiner = (res1, res2) -> {
|
||||
res1.putAll(res2);
|
||||
};
|
||||
|
||||
return source.stream()
|
||||
.collect(mapSupplier, accumulator, combiner);
|
||||
}
|
||||
|
||||
public Map<Integer, List<String>> collectorToMapByStringLength(List<String> source,
|
||||
Supplier<Map<Integer, List<String>>> mapSupplier,
|
||||
Supplier<List<String>> listSupplier) {
|
||||
|
||||
Function<String, Integer> keyMapper = String::length;
|
||||
|
||||
Function<String, List<String>> valueMapper = (element) -> {
|
||||
List<String> collection = listSupplier.get();
|
||||
collection.add(element);
|
||||
return collection;
|
||||
};
|
||||
|
||||
BinaryOperator<List<String>> mergeFunction = (existing, replacement) -> {
|
||||
existing.addAll(replacement);
|
||||
return existing;
|
||||
};
|
||||
|
||||
return source.stream()
|
||||
.collect(Collectors.toMap(keyMapper, valueMapper, mergeFunction, mapSupplier));
|
||||
}
|
||||
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
import org.modelmapper.ModelMapper;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* This is a helper class that contains method for custom mapping of the users list.
|
||||
* Initially, an instance of ModelMapper was created.
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class MapperUtil {
|
||||
|
||||
private static ModelMapper modelMapper = new ModelMapper();
|
||||
|
||||
|
||||
private MapperUtil() {
|
||||
|
||||
|
||||
}
|
||||
|
||||
public static <S, T> List<T> mapList(List<S> source, Class<T> targetClass) {
|
||||
|
||||
return source
|
||||
.stream()
|
||||
.map(element -> modelMapper.map(element, targetClass))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
}
|
||||
+70
@@ -0,0 +1,70 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
/**
|
||||
* User model entity class
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class User {
|
||||
|
||||
private String userId;
|
||||
private String username;
|
||||
private String email;
|
||||
private String contactNumber;
|
||||
private String userType;
|
||||
|
||||
// Standard constructors, getters and setters
|
||||
|
||||
public User() {
|
||||
}
|
||||
|
||||
public User(String userId, String username, String email, String contactNumber, String userType) {
|
||||
this.userId = userId;
|
||||
this.username = username;
|
||||
this.email = email;
|
||||
this.contactNumber = contactNumber;
|
||||
this.userType = userType;
|
||||
}
|
||||
|
||||
public String getUserId() {
|
||||
return userId;
|
||||
}
|
||||
|
||||
public void setUserId(String userId) {
|
||||
this.userId = userId;
|
||||
}
|
||||
|
||||
public String getUsername() {
|
||||
return username;
|
||||
}
|
||||
|
||||
public void setUsername(String userName) {
|
||||
this.username = userName;
|
||||
}
|
||||
|
||||
public String getEmail() {
|
||||
return email;
|
||||
}
|
||||
|
||||
public void setEmail(String email) {
|
||||
this.email = email;
|
||||
}
|
||||
|
||||
public String getContactNumber() {
|
||||
return contactNumber;
|
||||
}
|
||||
|
||||
public void setContactNumber(String contactNumber) {
|
||||
this.contactNumber = contactNumber;
|
||||
}
|
||||
|
||||
public String getUserType() {
|
||||
return userType;
|
||||
}
|
||||
|
||||
public void setUserType(String userType) {
|
||||
this.userType = userType;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
/**
|
||||
* UserDTO model class
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class UserDTO {
|
||||
|
||||
private String userId;
|
||||
private String username;
|
||||
private String email;
|
||||
|
||||
// getters and setters
|
||||
|
||||
public String getUserId() {
|
||||
return userId;
|
||||
}
|
||||
|
||||
public void setUserId(String userId) {
|
||||
this.userId = userId;
|
||||
}
|
||||
|
||||
public String getUsername() {
|
||||
return username;
|
||||
}
|
||||
|
||||
public void setUsername(String username) {
|
||||
this.username = username;
|
||||
}
|
||||
|
||||
public String getEmail() {
|
||||
return email;
|
||||
}
|
||||
|
||||
public void setEmail(String email) {
|
||||
this.email = email;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
/**
|
||||
* UserList class that contain collection of users
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class UserList {
|
||||
|
||||
private Collection<User> users;
|
||||
|
||||
public Collection<User> getUsers() {
|
||||
return users;
|
||||
}
|
||||
|
||||
public void setUsers(Collection<User> users) {
|
||||
this.users = users;
|
||||
}
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* UserListDTO class that contain list of username properties
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class UserListDTO {
|
||||
|
||||
private List<String> usernames;
|
||||
|
||||
public List<String> getUsernames() {
|
||||
return usernames;
|
||||
}
|
||||
|
||||
public void setUsernames(List<String> usernames) {
|
||||
this.usernames = usernames;
|
||||
}
|
||||
}
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
import org.modelmapper.AbstractConverter;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* UsersListConverter class map the property data from the list of users into the list of user names.
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class UsersListConverter extends AbstractConverter<List<User>, List<String>> {
|
||||
|
||||
@Override
|
||||
protected List<String> convert(List<User> users) {
|
||||
|
||||
return users
|
||||
.stream()
|
||||
.map(User::getUsername)
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
}
|
||||
+35
@@ -0,0 +1,35 @@
|
||||
package com.baeldung.arrayconversion;
|
||||
|
||||
import org.assertj.core.api.ListAssert;
|
||||
import org.hamcrest.CoreMatchers;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ArrayToListConversionUnitTest {
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void givenAnArray_whenConvertingToList_returnUnmodifiableListUnitTest() {
|
||||
String[] stringArray = new String[] { "A", "B", "C", "D" };
|
||||
List<String> stringList = Arrays.asList(stringArray);
|
||||
stringList.set(0, "E");
|
||||
assertThat(stringList).containsExactly("E", "B", "C", "D");
|
||||
assertThat(stringArray).containsExactly("E", "B", "C", "D");
|
||||
stringList.add("F");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAnArray_whenConvertingToList_returnModifiableListUnitTest() {
|
||||
String[] stringArray = new String[] { "A", "B", "C", "D" };
|
||||
List<String> stringList = new ArrayList<>(Arrays.asList(stringArray));
|
||||
stringList.set(0, "E");
|
||||
assertThat(stringList).containsExactly("E", "B", "C", "D");
|
||||
assertThat(stringArray).containsExactly("A", "B", "C", "D");
|
||||
stringList.add("F");
|
||||
assertThat(stringList).containsExactly("E", "B", "C", "D", "F");
|
||||
}
|
||||
}
|
||||
+135
@@ -0,0 +1,135 @@
|
||||
package com.baeldung.convertarraytostring;
|
||||
|
||||
import com.google.common.base.Joiner;
|
||||
import com.google.common.base.Splitter;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static org.hamcrest.CoreMatchers.instanceOf;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class ArrayToStringUnitTest {
|
||||
|
||||
// convert with Java
|
||||
|
||||
@Test
|
||||
public void givenAStringArray_whenConvertBeforeJava8_thenReturnString() {
|
||||
|
||||
String[] strArray = { "Convert", "Array", "With", "Java" };
|
||||
StringBuilder stringBuilder = new StringBuilder();
|
||||
|
||||
for (int i = 0; i < strArray.length; i++) {
|
||||
stringBuilder.append(strArray[i]);
|
||||
}
|
||||
String joinedString = stringBuilder.toString();
|
||||
|
||||
assertThat(joinedString, instanceOf(String.class));
|
||||
assertEquals("ConvertArrayWithJava", joinedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAString_whenConvertBeforeJava8_thenReturnStringArray() {
|
||||
|
||||
String input = "lorem ipsum dolor sit amet";
|
||||
String[] strArray = input.split(" ");
|
||||
|
||||
assertThat(strArray, instanceOf(String[].class));
|
||||
assertEquals(5, strArray.length);
|
||||
|
||||
input = "loremipsum";
|
||||
strArray = input.split("");
|
||||
assertThat(strArray, instanceOf(String[].class));
|
||||
assertEquals(10, strArray.length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAnIntArray_whenConvertBeforeJava8_thenReturnString() {
|
||||
|
||||
int[] strArray = { 1, 2, 3, 4, 5 };
|
||||
StringBuilder stringBuilder = new StringBuilder();
|
||||
|
||||
for (int i = 0; i < strArray.length; i++) {
|
||||
stringBuilder.append(Integer.valueOf(strArray[i]));
|
||||
}
|
||||
String joinedString = stringBuilder.toString();
|
||||
|
||||
assertThat(joinedString, instanceOf(String.class));
|
||||
assertEquals("12345", joinedString);
|
||||
}
|
||||
|
||||
// convert with Java Stream API
|
||||
|
||||
@Test
|
||||
public void givenAStringArray_whenConvertWithJavaStream_thenReturnString() {
|
||||
|
||||
String[] strArray = { "Convert", "With", "Java", "Streams" };
|
||||
String joinedString = Arrays.stream(strArray)
|
||||
.collect(Collectors.joining());
|
||||
assertThat(joinedString, instanceOf(String.class));
|
||||
assertEquals("ConvertWithJavaStreams", joinedString);
|
||||
|
||||
joinedString = Arrays.stream(strArray)
|
||||
.collect(Collectors.joining(","));
|
||||
assertThat(joinedString, instanceOf(String.class));
|
||||
assertEquals("Convert,With,Java,Streams", joinedString);
|
||||
}
|
||||
|
||||
|
||||
// convert with Apache Commons
|
||||
|
||||
@Test
|
||||
public void givenAStringArray_whenConvertWithApacheCommons_thenReturnString() {
|
||||
|
||||
String[] strArray = { "Convert", "With", "Apache", "Commons" };
|
||||
String joinedString = StringUtils.join(strArray);
|
||||
|
||||
assertThat(joinedString, instanceOf(String.class));
|
||||
assertEquals("ConvertWithApacheCommons", joinedString);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAString_whenConvertWithApacheCommons_thenReturnStringArray() {
|
||||
|
||||
String input = "lorem ipsum dolor sit amet";
|
||||
String[] strArray = StringUtils.split(input, " ");
|
||||
|
||||
assertThat(strArray, instanceOf(String[].class));
|
||||
assertEquals(5, strArray.length);
|
||||
}
|
||||
|
||||
|
||||
// convert with Guava
|
||||
|
||||
@Test
|
||||
public void givenAStringArray_whenConvertWithGuava_thenReturnString() {
|
||||
|
||||
String[] strArray = { "Convert", "With", "Guava", null };
|
||||
String joinedString = Joiner.on("")
|
||||
.skipNulls()
|
||||
.join(strArray);
|
||||
|
||||
assertThat(joinedString, instanceOf(String.class));
|
||||
assertEquals("ConvertWithGuava", joinedString);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void givenAString_whenConvertWithGuava_thenReturnStringArray() {
|
||||
|
||||
String input = "lorem ipsum dolor sit amet";
|
||||
|
||||
List<String> resultList = Splitter.on(' ')
|
||||
.trimResults()
|
||||
.omitEmptyStrings()
|
||||
.splitToList(input);
|
||||
String[] strArray = resultList.toArray(new String[0]);
|
||||
|
||||
assertThat(strArray, instanceOf(String[].class));
|
||||
assertEquals(5, strArray.length);
|
||||
}
|
||||
}
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
package com.baeldung.convertlisttomap;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
public class ListToMapUnitTest {
|
||||
|
||||
private ListToMapConverter converter;
|
||||
private List<String> source;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
converter = new ListToMapConverter();
|
||||
source = Arrays.asList("List", "Map", "Set", "Tree");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithJava8GroupBy_thenReturnMap() {
|
||||
Map<Integer, List<String>> convertedMap = converter.groupingByStringLength(source, HashMap::new, ArrayList::new);
|
||||
assertTrue(convertedMap.get(3)
|
||||
.contains("Map"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithJava8Collect_thenReturnMap() {
|
||||
Map<Integer, List<String>> convertedMap = converter.streamCollectByStringLength(source, HashMap::new, ArrayList::new);
|
||||
assertTrue(convertedMap.get(3)
|
||||
.contains("Map"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithCollectorToMap_thenReturnMap() {
|
||||
Map<Integer, List<String>> convertedMap = converter.collectorToMapByStringLength(source, HashMap::new, ArrayList::new);
|
||||
assertTrue(convertedMap.get(3)
|
||||
.contains("Map"));
|
||||
}
|
||||
|
||||
}
|
||||
+92
@@ -0,0 +1,92 @@
|
||||
package com.baeldung.modelmapper;
|
||||
|
||||
import org.hamcrest.Matchers;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.modelmapper.ModelMapper;
|
||||
import org.modelmapper.TypeMap;
|
||||
import org.modelmapper.TypeToken;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.hasItems;
|
||||
import static org.hamcrest.Matchers.hasProperty;
|
||||
import static org.junit.Assert.assertThat;
|
||||
|
||||
|
||||
/**
|
||||
* This class has test methods of mapping Integer to Character list,
|
||||
* mapping users list to DTO list using MapperUtil custom type method and property mapping using converter class
|
||||
*
|
||||
* @author Sasa Milenkovic
|
||||
*/
|
||||
public class UsersListMappingUnitTest {
|
||||
|
||||
private ModelMapper modelMapper;
|
||||
private List<User> users;
|
||||
|
||||
@Before
|
||||
public void init() {
|
||||
|
||||
modelMapper = new ModelMapper();
|
||||
|
||||
TypeMap<UserList, UserListDTO> typeMap = modelMapper.createTypeMap(UserList.class, UserListDTO.class);
|
||||
|
||||
typeMap.addMappings(mapper -> mapper.using(new UsersListConverter())
|
||||
.map(UserList::getUsers, UserListDTO::setUsernames));
|
||||
|
||||
users = new ArrayList();
|
||||
users.add(new User("b100", "user1", "[email protected]", "111-222", "USER"));
|
||||
users.add(new User("b101", "user2", "[email protected]", "111-333", "USER"));
|
||||
users.add(new User("b102", "user3", "[email protected]", "111-444", "ADMIN"));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenInteger_thenMapToCharacter() {
|
||||
|
||||
List<Integer> integers = new ArrayList<Integer>();
|
||||
|
||||
integers.add(1);
|
||||
integers.add(2);
|
||||
integers.add(3);
|
||||
|
||||
List<Character> characters = modelMapper.map(integers, new TypeToken<List<Character>>() {
|
||||
}.getType());
|
||||
|
||||
assertThat(characters, hasItems('1', '2', '3'));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsersList_whenUseGenericType_thenMapToUserDTO() {
|
||||
|
||||
// Mapping lists using custom (generic) type mapping
|
||||
|
||||
List<UserDTO> userDtoList = MapperUtil.mapList(users, UserDTO.class);
|
||||
|
||||
assertThat(userDtoList, Matchers.<UserDTO>hasItem(
|
||||
Matchers.both(hasProperty("userId", equalTo("b100")))
|
||||
.and(hasProperty("email", equalTo("[email protected]")))
|
||||
.and(hasProperty("username", equalTo("user1")))));
|
||||
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsersList_whenUseConverter_thenMapToUsernames() {
|
||||
|
||||
// Mapping lists using property mapping and converter
|
||||
|
||||
UserList userList = new UserList();
|
||||
userList.setUsers(users);
|
||||
UserListDTO dtos = new UserListDTO();
|
||||
modelMapper.map(userList, dtos);
|
||||
|
||||
assertThat(dtos.getUsernames(), hasItems("user1", "user2", "user3"));
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
package com.baeldung.setiteration;
|
||||
|
||||
import com.google.common.collect.Sets;
|
||||
import io.vavr.collection.Stream;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
class SetIteration {
|
||||
|
||||
@Test
|
||||
void givenSet_whenIteratorUsed_shouldIterateOverElements() {
|
||||
// given
|
||||
Set<String> names = Sets.newHashSet("Tom", "Jane", "Karen");
|
||||
|
||||
// when
|
||||
Iterator<String> namesIterator1 = names.iterator();
|
||||
Iterator<String> namesIterator2 = names.iterator();
|
||||
|
||||
// then
|
||||
namesIterator1.forEachRemaining(System.out::println);
|
||||
while(namesIterator2.hasNext()) {
|
||||
System.out.println(namesIterator2.next());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenSet_whenStreamUsed_shouldIterateOverElements() {
|
||||
// given
|
||||
Set<String> names = Sets.newHashSet("Tom", "Jane", "Karen");
|
||||
|
||||
// when & then
|
||||
String namesJoined = names.stream()
|
||||
.map(String::toUpperCase)
|
||||
.peek(System.out::println)
|
||||
.collect(Collectors.joining());
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenSet_whenEnhancedLoopUsed_shouldIterateOverElements() {
|
||||
// given
|
||||
Set<String> names = Sets.newHashSet("Tom", "Jane", "Karen");
|
||||
|
||||
// when & then
|
||||
for (String name : names) {
|
||||
System.out.println(name);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenSet_whenMappedToArray_shouldIterateOverElements() {
|
||||
// given
|
||||
Set<String> names = Sets.newHashSet("Tom", "Jane", "Karen");
|
||||
|
||||
// when & then
|
||||
Object[] namesArray = names.toArray();
|
||||
for (int i = 0; i < namesArray.length; i++) {
|
||||
System.out.println(i + ": " + namesArray[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void givenSet_whenZippedWithIndex_shouldIterateOverElements() {
|
||||
// given
|
||||
Set<String> names = Sets.newHashSet("Tom", "Jane", "Karen");
|
||||
|
||||
// when & then
|
||||
Stream.ofAll(names)
|
||||
.zipWithIndex()
|
||||
.forEach(t -> System.out.println(t._2() + ": " + t._1()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
## Java Collections Cookbooks and Examples
|
||||
|
||||
This module contains articles about conversions among Collection types and arrays in Java.
|
||||
|
||||
### Relevant Articles:
|
||||
- [Converting between an Array and a List in Java](https://www.baeldung.com/convert-array-to-list-and-list-to-array)
|
||||
- [Converting between an Array and a Set in Java](https://www.baeldung.com/convert-array-to-set-and-set-to-array)
|
||||
- [Convert a Map to an Array, List or Set in Java](https://www.baeldung.com/convert-map-values-to-array-list-set)
|
||||
- [Converting a List to String in Java](https://www.baeldung.com/java-list-to-string)
|
||||
- [How to Convert List to Map in Java](https://www.baeldung.com/java-list-to-map)
|
||||
- [Converting a Collection to ArrayList in Java](https://www.baeldung.com/java-convert-collection-arraylist)
|
||||
- [Java 8 Collectors toMap](https://www.baeldung.com/java-collectors-tomap)
|
||||
- [Converting Iterable to Collection in Java](https://www.baeldung.com/java-iterable-to-collection)
|
||||
- [Converting Iterator to List](https://www.baeldung.com/java-convert-iterator-to-list)
|
||||
- More articles: [[next -->]](../java-collections-conversions-2)
|
||||
@@ -0,0 +1,40 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<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>
|
||||
<artifactId>java-collections-conversions</artifactId>
|
||||
<version>0.1.0-SNAPSHOT</version>
|
||||
<name>java-collections-conversions</name>
|
||||
<packaging>jar</packaging>
|
||||
|
||||
<parent>
|
||||
<groupId>com.baeldung.core-java-modules</groupId>
|
||||
<artifactId>core-java-modules</artifactId>
|
||||
<version>0.0.1-SNAPSHOT</version>
|
||||
</parent>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-collections4</artifactId>
|
||||
<version>${commons-collections4.version}</version>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>org.apache.commons</groupId>
|
||||
<artifactId>commons-lang3</artifactId>
|
||||
<version>${commons-lang3.version}</version>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
<build>
|
||||
<finalName>java-collections-conversions</finalName>
|
||||
<resources>
|
||||
<resource>
|
||||
<directory>src/main/resources</directory>
|
||||
<filtering>true</filtering>
|
||||
</resource>
|
||||
</resources>
|
||||
</build>
|
||||
|
||||
</project>
|
||||
+48
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
+30
@@ -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<String, String> listToMap(List<Book> books) {
|
||||
return books.stream().collect(Collectors.toMap(Book::getIsbn, Book::getName));
|
||||
}
|
||||
|
||||
public Map<Integer, Book> listToMapWithDupKeyError(List<Book> books) {
|
||||
return books.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity()));
|
||||
}
|
||||
|
||||
public Map<Integer, Book> listToMapWithDupKey(List<Book> books) {
|
||||
return books.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity(), (existing, replacement) -> existing));
|
||||
}
|
||||
|
||||
public Map<Integer, Book> listToConcurrentMap(List<Book> books) {
|
||||
return books.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity(), (o1, o2) -> o1, ConcurrentHashMap::new));
|
||||
}
|
||||
|
||||
public TreeMap<String, Book> listToSortedMap(List<Book> books) {
|
||||
return books.stream()
|
||||
.collect(Collectors.toMap(Book::getName, Function.identity(), (o1, o2) -> o1, TreeMap::new));
|
||||
}
|
||||
}
|
||||
|
||||
+52
@@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
+27
@@ -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;
|
||||
}
|
||||
}
|
||||
+43
@@ -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<Integer, Animal> convertListBeforeJava8(List<Animal> list) {
|
||||
|
||||
Map<Integer, Animal> map = new HashMap<>();
|
||||
|
||||
for (Animal animal : list) {
|
||||
map.put(animal.getId(), animal);
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
public Map<Integer, Animal> convertListAfterJava8(List<Animal> list) {
|
||||
Map<Integer, Animal> map = list.stream().collect(Collectors.toMap(Animal::getId, Function.identity()));
|
||||
return map;
|
||||
}
|
||||
|
||||
public Map<Integer, Animal> convertListWithGuava(List<Animal> list) {
|
||||
|
||||
Map<Integer, Animal> map = Maps.uniqueIndex(list, Animal::getId);
|
||||
return map;
|
||||
}
|
||||
|
||||
public Map<Integer, Animal> convertListWithApacheCommons(List<Animal> list) {
|
||||
|
||||
Map<Integer, Animal> map = new HashMap<>();
|
||||
|
||||
MapUtils.populateMap(map, list, Animal::getId);
|
||||
|
||||
return map;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<configuration>
|
||||
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
|
||||
<encoder>
|
||||
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
|
||||
</pattern>
|
||||
</encoder>
|
||||
</appender>
|
||||
|
||||
<root level="INFO">
|
||||
<appender-ref ref="STDOUT" />
|
||||
</root>
|
||||
</configuration>
|
||||
+53
@@ -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<Book> 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<Integer, Book> 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"));
|
||||
}
|
||||
}
|
||||
+145
@@ -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<Foo> 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<Foo> newList = new ArrayList<>(srcCollection);
|
||||
verifyShallowCopy(srcCollection, newList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Section 4. Using the Streams API
|
||||
*/
|
||||
@Test
|
||||
public void whenUsingStream_thenVerifyShallowCopy() {
|
||||
ArrayList<Foo> newList = srcCollection.stream().collect(toCollection(ArrayList::new));
|
||||
|
||||
verifyShallowCopy(srcCollection, newList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Section 5. Deep Copy
|
||||
*/
|
||||
@Test
|
||||
public void whenUsingDeepCopy_thenVerifyDeepCopy() {
|
||||
ArrayList<Foo> 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<Foo> 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<Foo> a, Collection<Foo> b) {
|
||||
assertEquals("Collections have different lengths", a.size(), b.size());
|
||||
Iterator<Foo> iterA = a.iterator();
|
||||
Iterator<Foo> 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<Foo> a, Collection<Foo> b) {
|
||||
assertEquals("Collections have different lengths", a.size(), b.size());
|
||||
Iterator<Foo> iterA = a.iterator();
|
||||
Iterator<Foo> 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<Foo> c) {
|
||||
String prevName = null;
|
||||
for (Foo foo : c) {
|
||||
if (prevName == null || foo.getName().compareTo(prevName) > 0) {
|
||||
prevName = foo.getName();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
+100
@@ -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<Integer> iterator;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
iterator = Arrays.asList(1, 2, 3)
|
||||
.iterator();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAnIterator_whenConvertIteratorToListUsingWhileLoop_thenReturnAList() {
|
||||
|
||||
List<Integer> 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<Integer> 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<Integer> iterable = () -> iterator;
|
||||
|
||||
// Extract List from stream
|
||||
List<Integer> 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<Integer> 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<Integer> 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<Integer> actualList = IteratorUtils.toList(iterator);
|
||||
|
||||
assertThat(actualList, hasSize(3));
|
||||
assertThat(actualList, containsInAnyOrder(1, 2, 3));
|
||||
}
|
||||
}
|
||||
+68
@@ -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<Animal> 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<Integer, Animal> map = convertListService.convertListBeforeJava8(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertAfterJava8_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListAfterJava8(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithGuava_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListWithGuava(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAList_whenConvertWithApacheCommons_thenReturnMapWithTheSameElements() {
|
||||
|
||||
Map<Integer, Animal> map = convertListService.convertListWithApacheCommons(list);
|
||||
|
||||
assertThat(map.values(), containsInAnyOrder(list.toArray()));
|
||||
}
|
||||
|
||||
}
|
||||
+68
@@ -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<Animal> 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<Integer, Animal> map = convertListService.convertListBeforeJava8(duplicatedIdList);
|
||||
|
||||
assertThat(map.values(), hasSize(4));
|
||||
assertThat(map.values(), hasItem(duplicatedIdList.get(4)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenADupIdList_whenConvertWithApacheCommons_thenReturnMapWithRewrittenElement() {
|
||||
|
||||
Map<Integer, Animal> 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);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
+122
@@ -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<String> iterable = Arrays.asList("john", "tom", "jane");
|
||||
Iterator<String> iterator = iterable.iterator();
|
||||
|
||||
@Test
|
||||
public void whenConvertIterableToListUsingJava_thenSuccess() {
|
||||
List<String> result = new ArrayList<String>();
|
||||
for (String str : iterable) {
|
||||
result.add(str);
|
||||
}
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIterableToListUsingJava8_thenSuccess() {
|
||||
List<String> result = new ArrayList<String>();
|
||||
iterable.forEach(result::add);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIterableToListUsingJava8WithSpliterator_thenSuccess() {
|
||||
List<String> result = StreamSupport.stream(iterable.spliterator(), false)
|
||||
.collect(Collectors.toList());
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIterableToListUsingGuava_thenSuccess() {
|
||||
List<String> result = Lists.newArrayList(iterable);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIterableToImmutableListUsingGuava_thenSuccess() {
|
||||
List<String> result = ImmutableList.copyOf(iterable);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIterableToListUsingApacheCommons_thenSuccess() {
|
||||
List<String> result = IterableUtils.toList(iterable);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
// ======================== Iterator
|
||||
|
||||
@Test
|
||||
public void whenConvertIteratorToListUsingJava_thenSuccess() {
|
||||
List<String> result = new ArrayList<String>();
|
||||
while (iterator.hasNext()) {
|
||||
result.add(iterator.next());
|
||||
}
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIteratorToListUsingJava8_thenSuccess() {
|
||||
List<String> result = new ArrayList<String>();
|
||||
iterator.forEachRemaining(result::add);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIteratorToListUsingJava8WithSpliterator_thenSuccess() {
|
||||
List<String> result = StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false)
|
||||
.collect(Collectors.toList());
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIteratorToListUsingGuava_thenSuccess() {
|
||||
List<String> result = Lists.newArrayList(iterator);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIteratorToImmutableListUsingGuava_thenSuccess() {
|
||||
List<String> result = ImmutableList.copyOf(iterator);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertIteratorToListUsingApacheCommons_thenSuccess() {
|
||||
List<String> result = IteratorUtils.toList(iterator);
|
||||
|
||||
assertThat(result, contains("john", "tom", "jane"));
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user