[Bael 6056] - Move collection-related logic from core-java to core-java-collections (#4114)
* Added parent module on poms that have no parent defined * Removed dependency reduced pom from undertow module * [BAEL-6056] - Move collection-related logic from core-java to core-java-collections * [BAEL-6056] - Move collection-related logic from core-java to core-java-collections * [BAEL-6056] - Move collection-related logic from core-java to core-java-collections * [BAEL-6056] - Move collection-related logic from core-java to core-java-collections
This commit is contained in:
amit2103
committed by
Grzegorz Piwowarek
Grzegorz Piwowarek
parent
12cdd5357d
commit
cfd98d2fe3
@@ -0,0 +1,116 @@
|
||||
package com.baeldung.array.converter;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class ArrayConvertToListTest {
|
||||
|
||||
@Test
|
||||
public void givenAnStringArray_whenConvertArrayToList_thenListCreated() {
|
||||
String[] flowers = { "Ageratum", "Allium", "Poppy", "Catmint" };
|
||||
List<String> flowerList = Arrays.asList(flowers);
|
||||
|
||||
assertNotNull(flowerList);
|
||||
assertEquals(flowerList.size(), 4);
|
||||
assertEquals(flowerList.get(0), "Ageratum");
|
||||
assertEquals(flowerList.get(1), "Allium");
|
||||
assertEquals(flowerList.get(2), "Poppy");
|
||||
assertEquals(flowerList.get(3), "Catmint");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAnIntArray_whenConvertArrayToList_thenListWithOneElementCreated() {
|
||||
int[] primitives = { 1, 2, 3, 4 };
|
||||
List numbers = Arrays.asList(primitives);
|
||||
|
||||
assertNotNull(numbers);
|
||||
assertEquals(numbers.size(), 1);
|
||||
assertEquals(numbers.get(0), primitives);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void givenAnStringArray_whenConvertArrayToListAndAddAnElement_thenThrowUnsupportedOperationException() {
|
||||
String[] flowers = { "Ageratum", "Allium", "Poppy", "Catmint" };
|
||||
List<String> flowerList = Arrays.asList(flowers);
|
||||
|
||||
assertNotNull(flowerList);
|
||||
assertEquals(flowerList.size(), 4);
|
||||
assertEquals(flowerList.get(0), "Ageratum");
|
||||
assertEquals(flowerList.get(1), "Allium");
|
||||
assertEquals(flowerList.get(2), "Poppy");
|
||||
assertEquals(flowerList.get(3), "Catmint");
|
||||
|
||||
flowerList.add("Celosia");
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void givenAnStringArray_whenConvertArrayToListAndRemoveAnElement_thenThrowUnsupportedOperationException() {
|
||||
String[] flowers = { "Ageratum", "Allium", "Poppy", "Catmint" };
|
||||
List<String> flowerList = Arrays.asList(flowers);
|
||||
|
||||
assertNotNull(flowerList);
|
||||
assertEquals(flowerList.size(), 4);
|
||||
assertEquals(flowerList.get(0), "Ageratum");
|
||||
assertEquals(flowerList.get(1), "Allium");
|
||||
assertEquals(flowerList.get(2), "Poppy");
|
||||
assertEquals(flowerList.get(3), "Catmint");
|
||||
|
||||
flowerList.remove("Poppy");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAnStringArray_whenCreateListFromArrayAndAddAnElement_thenListOk() {
|
||||
String[] flowers = { "Ageratum", "Allium", "Poppy", "Catmint" };
|
||||
List<String> flowerList = Arrays.asList(flowers);
|
||||
|
||||
assertNotNull(flowerList);
|
||||
assertEquals(flowerList.size(), 4);
|
||||
|
||||
assertEquals(flowerList.get(0), "Ageratum");
|
||||
assertEquals(flowerList.get(1), "Allium");
|
||||
assertEquals(flowerList.get(2), "Poppy");
|
||||
assertEquals(flowerList.get(3), "Catmint");
|
||||
|
||||
List<String> newflowerList = new ArrayList<>(flowerList);
|
||||
|
||||
assertNotNull(newflowerList);
|
||||
assertEquals(newflowerList.size(), 4);
|
||||
assertEquals(newflowerList.get(0), "Ageratum");
|
||||
assertEquals(newflowerList.get(1), "Allium");
|
||||
assertEquals(newflowerList.get(2), "Poppy");
|
||||
assertEquals(newflowerList.get(3), "Catmint");
|
||||
|
||||
newflowerList.add("Celosia");
|
||||
|
||||
assertEquals(newflowerList.size(), 5);
|
||||
assertEquals(newflowerList.get(4), "Celosia");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenAnStringArray_whenIterateArrayAndAddTheElementsToNewListAndAddAnElement_thenListOk() {
|
||||
String[] flowers = { "Ageratum", "Allium", "Poppy", "Catmint" };
|
||||
|
||||
List<String> flowerList = new ArrayList<>();
|
||||
for(String flower: flowers) {
|
||||
flowerList.add(flower);
|
||||
}
|
||||
|
||||
assertNotNull(flowerList);
|
||||
assertEquals(flowerList.size(), 4);
|
||||
|
||||
assertEquals(flowerList.get(0), "Ageratum");
|
||||
assertEquals(flowerList.get(1), "Allium");
|
||||
assertEquals(flowerList.get(2), "Poppy");
|
||||
assertEquals(flowerList.get(3), "Catmint");
|
||||
|
||||
flowerList.add("Celosia");
|
||||
|
||||
assertEquals(flowerList.size(), 5);
|
||||
assertEquals(flowerList.get(4), "Celosia");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package com.baeldung.arraydeque;
|
||||
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.Deque;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import org.junit.Test;
|
||||
|
||||
public class ArrayDequeTest {
|
||||
|
||||
@Test
|
||||
public void whenOffer_addsAtLast() {
|
||||
final Deque<String> deque = new ArrayDeque<>();
|
||||
|
||||
deque.offer("first");
|
||||
deque.offer("second");
|
||||
|
||||
assertEquals("second", deque.getLast());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenPoll_removesFirst() {
|
||||
final Deque<String> deque = new ArrayDeque<>();
|
||||
|
||||
deque.offer("first");
|
||||
deque.offer("second");
|
||||
|
||||
assertEquals("first", deque.poll());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenPush_addsAtFirst() {
|
||||
final Deque<String> deque = new ArrayDeque<>();
|
||||
|
||||
deque.push("first");
|
||||
deque.push("second");
|
||||
|
||||
assertEquals("second", deque.getFirst());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenPop_removesLast() {
|
||||
final Deque<String> deque = new ArrayDeque<>();
|
||||
|
||||
deque.push("first");
|
||||
deque.push("second");
|
||||
|
||||
assertEquals("second", deque.pop());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
package com.baeldung.collection;
|
||||
|
||||
import java.util.ConcurrentModificationException;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import org.hamcrest.Matchers;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class WhenComparingTreeMapVsHashMap {
|
||||
|
||||
@Test
|
||||
public void whenInsertObjectsTreeMap_thenNaturalOrder() {
|
||||
Map<Integer, String> treemap = new TreeMap<>();
|
||||
treemap.put(3, "TreeMap");
|
||||
treemap.put(2, "vs");
|
||||
treemap.put(1, "HashMap");
|
||||
Assert.assertThat(treemap.keySet(), Matchers.contains(1, 2, 3));
|
||||
}
|
||||
|
||||
@Test(expected = NullPointerException.class)
|
||||
public void whenInsertNullInTreeMap_thenException() {
|
||||
Map<Integer, String> treemap = new TreeMap<>();
|
||||
treemap.put(null, "NullPointerException");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenInsertObjectsHashMap_thenRandomOrder() {
|
||||
Map<Integer, String> hashmap = new HashMap<>();
|
||||
hashmap.put(3, "TreeMap");
|
||||
hashmap.put(2, "vs");
|
||||
hashmap.put(1, "HashMap");
|
||||
Assert.assertThat(hashmap.keySet(), Matchers.containsInAnyOrder(1, 2, 3));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenInsertNullInHashMap_thenInsertsNull() {
|
||||
Map<Integer, String> hashmap = new HashMap<>();
|
||||
hashmap.put(null, null);
|
||||
Assert.assertNull(hashmap.get(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashMapAndTreeMap_whenputDuplicates_thenOnlyUnique() {
|
||||
Map<Integer, String> treeMap = new HashMap<>();
|
||||
treeMap.put(1, "Baeldung");
|
||||
treeMap.put(1, "Baeldung");
|
||||
|
||||
Assert.assertTrue(treeMap.size() == 1);
|
||||
|
||||
Map<Integer, String> treeMap2 = new TreeMap<>();
|
||||
treeMap2.put(1, "Baeldung");
|
||||
treeMap2.put(1, "Baeldung");
|
||||
|
||||
Assert.assertTrue(treeMap2.size() == 1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
package com.baeldung.collection;
|
||||
|
||||
import java.util.ConcurrentModificationException;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class WhenUsingHashSet {
|
||||
|
||||
@Test
|
||||
public void whenAddingElement_shouldAddElement() {
|
||||
Set<String> hashset = new HashSet<>();
|
||||
Assert.assertTrue(hashset.add("String Added"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingForElement_shouldSearchForElement() {
|
||||
Set<String> hashsetContains = new HashSet<>();
|
||||
hashsetContains.add("String Added");
|
||||
Assert.assertTrue(hashsetContains.contains("String Added"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingTheSizeOfHashSet_shouldReturnThesize() {
|
||||
Set<String> hashSetSize = new HashSet<>();
|
||||
hashSetSize.add("String Added");
|
||||
Assert.assertEquals(1, hashSetSize.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingForEmptyHashSet_shouldCheckForEmpty() {
|
||||
Set<String> emptyHashSet = new HashSet<>();
|
||||
Assert.assertTrue(emptyHashSet.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenRemovingElement_shouldRemoveElement() {
|
||||
Set<String> removeFromHashSet = new HashSet<>();
|
||||
removeFromHashSet.add("String Added");
|
||||
Assert.assertTrue(removeFromHashSet.remove("String Added"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenClearingHashSet_shouldClearHashSet() {
|
||||
Set<String> clearHashSet = new HashSet<>();
|
||||
clearHashSet.add("String Added");
|
||||
clearHashSet.clear();
|
||||
Assert.assertTrue(clearHashSet.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenIteratingHashSet_shouldIterateHashSet() {
|
||||
Set<String> hashset = new HashSet<>();
|
||||
hashset.add("First");
|
||||
hashset.add("Second");
|
||||
hashset.add("Third");
|
||||
Iterator<String> itr = hashset.iterator();
|
||||
while (itr.hasNext()) {
|
||||
System.out.println(itr.next());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = ConcurrentModificationException.class)
|
||||
public void whenModifyingHashSetWhileIterating_shouldThrowException() {
|
||||
Set<String> hashset = new HashSet<>();
|
||||
hashset.add("First");
|
||||
hashset.add("Second");
|
||||
hashset.add("Third");
|
||||
Iterator<String> itr = hashset.iterator();
|
||||
while (itr.hasNext()) {
|
||||
itr.next();
|
||||
hashset.remove("Second");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenRemovingElementUsingIterator_shouldRemoveElement() {
|
||||
Set<String> hashset = new HashSet<>();
|
||||
hashset.add("First");
|
||||
hashset.add("Second");
|
||||
hashset.add("Third");
|
||||
Iterator<String> itr = hashset.iterator();
|
||||
while (itr.hasNext()) {
|
||||
String element = itr.next();
|
||||
if (element.equals("Second"))
|
||||
itr.remove();
|
||||
}
|
||||
Assert.assertEquals(2, hashset.size());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
package com.baeldung.collection;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.ConcurrentModificationException;
|
||||
import java.util.Iterator;
|
||||
import java.util.NavigableSet;
|
||||
import java.util.Set;
|
||||
import java.util.SortedSet;
|
||||
import java.util.TreeSet;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
public class WhenUsingTreeSet {
|
||||
|
||||
private static class Element {
|
||||
private Integer id;
|
||||
|
||||
public Integer getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public void setId(Integer id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return id.toString();
|
||||
}
|
||||
}
|
||||
|
||||
private Comparator<Element> comparator = (ele1, ele2) -> {
|
||||
return ele1.getId()
|
||||
.compareTo(ele2.getId());
|
||||
};
|
||||
|
||||
@Test
|
||||
public void whenAddingElement_shouldAddElement() {
|
||||
Set<String> treeSet = new TreeSet<>();
|
||||
Assert.assertTrue(treeSet.add("String Added"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingForElement_shouldSearchForElement() {
|
||||
Set<String> treeSetContains = new TreeSet<>();
|
||||
treeSetContains.add("String Added");
|
||||
Assert.assertTrue(treeSetContains.contains("String Added"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenRemovingElement_shouldRemoveElement() {
|
||||
Set<String> removeFromTreeSet = new TreeSet<>();
|
||||
removeFromTreeSet.add("String Added");
|
||||
Assert.assertTrue(removeFromTreeSet.remove("String Added"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenClearingTreeSet_shouldClearTreeSet() {
|
||||
Set<String> clearTreeSet = new TreeSet<>();
|
||||
clearTreeSet.add("String Added");
|
||||
clearTreeSet.clear();
|
||||
Assert.assertTrue(clearTreeSet.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingTheSizeOfTreeSet_shouldReturnThesize() {
|
||||
Set<String> treeSetSize = new TreeSet<>();
|
||||
treeSetSize.add("String Added");
|
||||
Assert.assertEquals(1, treeSetSize.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingForEmptyTreeSet_shouldCheckForEmpty() {
|
||||
Set<String> emptyTreeSet = new TreeSet<>();
|
||||
Assert.assertTrue(emptyTreeSet.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenIteratingTreeSet_shouldIterateTreeSetInAscendingOrder() {
|
||||
Set<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
treeSet.add("Second");
|
||||
treeSet.add("Third");
|
||||
Iterator<String> itr = treeSet.iterator();
|
||||
while (itr.hasNext()) {
|
||||
System.out.println(itr.next());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenIteratingTreeSet_shouldIterateTreeSetInDescendingOrder() {
|
||||
TreeSet<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
treeSet.add("Second");
|
||||
treeSet.add("Third");
|
||||
Iterator<String> itr = treeSet.descendingIterator();
|
||||
while (itr.hasNext()) {
|
||||
System.out.println(itr.next());
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = ConcurrentModificationException.class)
|
||||
public void whenModifyingTreeSetWhileIterating_shouldThrowException() {
|
||||
Set<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
treeSet.add("Second");
|
||||
treeSet.add("Third");
|
||||
Iterator<String> itr = treeSet.iterator();
|
||||
while (itr.hasNext()) {
|
||||
itr.next();
|
||||
treeSet.remove("Second");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenRemovingElementUsingIterator_shouldRemoveElement() {
|
||||
Set<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
treeSet.add("Second");
|
||||
treeSet.add("Third");
|
||||
Iterator<String> itr = treeSet.iterator();
|
||||
while (itr.hasNext()) {
|
||||
String element = itr.next();
|
||||
if (element.equals("Second"))
|
||||
itr.remove();
|
||||
}
|
||||
Assert.assertEquals(2, treeSet.size());
|
||||
}
|
||||
|
||||
@Test(expected = NullPointerException.class)
|
||||
public void whenAddingNullToNonEmptyTreeSet_shouldThrowException() {
|
||||
Set<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
treeSet.add(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingFirstElement_shouldReturnFirstElement() {
|
||||
TreeSet<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
Assert.assertEquals("First", treeSet.first());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCheckingLastElement_shouldReturnLastElement() {
|
||||
TreeSet<String> treeSet = new TreeSet<>();
|
||||
treeSet.add("First");
|
||||
treeSet.add("Last");
|
||||
Assert.assertEquals("Last", treeSet.last());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingComparator_shouldSortAndInsertElements() {
|
||||
Set<Element> treeSet = new TreeSet<>(comparator);
|
||||
Element ele1 = new Element();
|
||||
ele1.setId(100);
|
||||
Element ele2 = new Element();
|
||||
ele2.setId(200);
|
||||
|
||||
treeSet.add(ele1);
|
||||
treeSet.add(ele2);
|
||||
|
||||
System.out.println(treeSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingHeadSet_shouldReturnElementsLessThanSpecifiedElement() {
|
||||
Set<Element> treeSet = new TreeSet<>(comparator);
|
||||
Element ele1 = new Element();
|
||||
ele1.setId(100);
|
||||
Element ele2 = new Element();
|
||||
ele2.setId(200);
|
||||
|
||||
treeSet.add(ele1);
|
||||
treeSet.add(ele2);
|
||||
|
||||
System.out.println(treeSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingSubSet_shouldReturnSubSetElements() {
|
||||
SortedSet<Integer> treeSet = new TreeSet<>();
|
||||
treeSet.add(1);
|
||||
treeSet.add(2);
|
||||
treeSet.add(3);
|
||||
treeSet.add(4);
|
||||
treeSet.add(5);
|
||||
treeSet.add(6);
|
||||
|
||||
Set<Integer> expectedSet = new TreeSet<>();
|
||||
expectedSet.add(2);
|
||||
expectedSet.add(3);
|
||||
expectedSet.add(4);
|
||||
expectedSet.add(5);
|
||||
|
||||
Set<Integer> subSet = treeSet.subSet(2, 6);
|
||||
Assert.assertEquals(expectedSet, subSet);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingHeadSet_shouldReturnHeadSetElements() {
|
||||
SortedSet<Integer> treeSet = new TreeSet<>();
|
||||
treeSet.add(1);
|
||||
treeSet.add(2);
|
||||
treeSet.add(3);
|
||||
treeSet.add(4);
|
||||
treeSet.add(5);
|
||||
treeSet.add(6);
|
||||
|
||||
Set<Integer> subSet = treeSet.headSet(6);
|
||||
Assert.assertEquals(subSet, treeSet.subSet(1, 6));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenUsingTailSet_shouldReturnTailSetElements() {
|
||||
NavigableSet<Integer> treeSet = new TreeSet<>();
|
||||
treeSet.add(1);
|
||||
treeSet.add(2);
|
||||
treeSet.add(3);
|
||||
treeSet.add(4);
|
||||
treeSet.add(5);
|
||||
treeSet.add(6);
|
||||
|
||||
Set<Integer> subSet = treeSet.tailSet(3);
|
||||
Assert.assertEquals(subSet, treeSet.subSet(3, true, 6, true));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
package com.baeldung.java.collections;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class ConcurrentModificationExceptionUnitTest {
|
||||
|
||||
@Test
|
||||
public void changingContentWithSetDoesNotThrowConcurrentModificationException() throws Exception {
|
||||
ArrayList<Object> array = new ArrayList<>(asList(0, "one", 2, "three"));
|
||||
|
||||
for (Object item : array) {
|
||||
array.set(3, 3);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removingElementUsingIteratorAPI() throws Exception {
|
||||
List<String> originalList = new ArrayList<>(asList("zero", "one", "two", "three"));
|
||||
|
||||
Iterator<String> iterator = originalList.iterator();
|
||||
|
||||
while (iterator.hasNext()) {
|
||||
String next = iterator.next();
|
||||
if (Objects.equals(next, "one")) iterator.remove();
|
||||
}
|
||||
|
||||
assertEquals(originalList, asList("zero", "two", "three"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void modifyingContentAndIteratingUsingListIteratorAPI() throws Exception {
|
||||
List<String> originalList = new ArrayList<>(asList("zero", "one", "two", "three"));
|
||||
|
||||
ListIterator<String> iterator = originalList.listIterator();
|
||||
|
||||
while (iterator.hasNext()) {
|
||||
String next = iterator.next();
|
||||
if (Objects.equals(next, "one")) {
|
||||
iterator.set("another");
|
||||
}
|
||||
|
||||
if (Objects.equals(next, "two")) {
|
||||
iterator.remove();
|
||||
}
|
||||
|
||||
if (Objects.equals(next, "three")) {
|
||||
iterator.add("four");
|
||||
}
|
||||
}
|
||||
|
||||
assertEquals(originalList, asList("zero", "another", "three", "four"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removingElementUsingCopyAndListAPI() throws Exception {
|
||||
List<String> originalList = new ArrayList<>(asList("zero", "one", "two", "three"));
|
||||
|
||||
List<String> listCopy = new ArrayList<>(originalList);
|
||||
|
||||
for (String next : listCopy) {
|
||||
if (Objects.equals(next, "one")) originalList.remove(originalList.indexOf(next) - 1);
|
||||
}
|
||||
|
||||
assertEquals(originalList, asList("one", "two", "three"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void copyOnWriteList() throws Exception {
|
||||
List<String> originalList = new CopyOnWriteArrayList<>(asList("zero", "one", "two", "three"));
|
||||
|
||||
for (String next : originalList) {
|
||||
if (Objects.equals(next, "one")) originalList.remove(originalList.indexOf(next) - 1);
|
||||
}
|
||||
|
||||
assertEquals(originalList, asList("one", "two", "three"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,296 @@
|
||||
package com.baeldung.java.list;
|
||||
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertFalse;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
public class CustomListUnitTest {
|
||||
@Test
|
||||
public void givenEmptyList_whenIsEmpty_thenTrueIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
|
||||
assertTrue(list.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNonEmptyList_whenIsEmpty_thenFalseIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add(null);
|
||||
|
||||
assertFalse(list.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithAnElement_whenSize_thenOneIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add(null);
|
||||
|
||||
assertEquals(1, list.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithAnElement_whenGet_thenThatElementIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
Object element = list.get(0);
|
||||
|
||||
assertEquals("baeldung", element);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenEmptyList_whenElementIsAdded_thenGetReturnsThatElement() {
|
||||
List<Object> list = new CustomList<>();
|
||||
boolean succeeded = list.add(null);
|
||||
|
||||
assertTrue(succeeded);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithAnElement_whenAnotherIsAdded_thenGetReturnsBoth() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.add(".com");
|
||||
Object element1 = list.get(0);
|
||||
Object element2 = list.get(1);
|
||||
|
||||
assertEquals("baeldung", element1);
|
||||
assertEquals(".com", element2);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenAddToSpecifiedIndex_thenExceptionIsThrown() {
|
||||
new CustomList<>().add(0, null);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenAddAllToTheEnd_thenExceptionIsThrown() {
|
||||
Collection<Object> collection = new ArrayList<>();
|
||||
List<Object> list = new CustomList<>();
|
||||
list.addAll(collection);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenAddAllToSpecifiedIndex_thenExceptionIsThrown() {
|
||||
Collection<Object> collection = new ArrayList<>();
|
||||
List<Object> list = new CustomList<>();
|
||||
list.addAll(0, collection);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenRemoveAtSpecifiedIndex_thenExceptionIsThrown() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.remove(0);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenRemoveSpecifiedElement_thenExceptionIsThrown() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.remove("baeldung");
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenRemoveAll_thenExceptionIsThrown() {
|
||||
Collection<Object> collection = new ArrayList<>();
|
||||
collection.add("baeldung");
|
||||
List<Object> list = new CustomList<>();
|
||||
list.removeAll(collection);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public void whenRetainAll_thenExceptionIsThrown() {
|
||||
Collection<Object> collection = new ArrayList<>();
|
||||
collection.add("baeldung");
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.retainAll(collection);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenEmptyList_whenContains_thenFalseIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
|
||||
assertFalse(list.contains(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithAnElement_whenContains_thenTrueIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
|
||||
assertTrue(list.contains("baeldung"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithAnElement_whenContainsAll_thenTrueIsReturned() {
|
||||
Collection<Object> collection = new ArrayList<>();
|
||||
collection.add("baeldung");
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
|
||||
assertTrue(list.containsAll(collection));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenList_whenContainsAll_thenEitherTrueOrFalseIsReturned() {
|
||||
Collection<Object> collection1 = new ArrayList<>();
|
||||
collection1.add("baeldung");
|
||||
collection1.add(".com");
|
||||
Collection<Object> collection2 = new ArrayList<>();
|
||||
collection2.add("baeldung");
|
||||
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
|
||||
assertFalse(list.containsAll(collection1));
|
||||
assertTrue(list.containsAll(collection2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenList_whenSet_thenOldElementIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
Object element = list.set(0, null);
|
||||
|
||||
assertEquals("baeldung", element);
|
||||
assertNull(list.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenList_whenClear_thenAllElementsAreRemoved() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.clear();
|
||||
|
||||
assertTrue(list.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenList_whenIndexOf_thenIndexZeroIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
|
||||
assertEquals(0, list.indexOf("baeldung"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenList_whenIndexOf_thenPositiveIndexOrMinusOneIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.add(".com");
|
||||
list.add(".com");
|
||||
|
||||
assertEquals(1, list.indexOf(".com"));
|
||||
assertEquals(-1, list.indexOf("com"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenLastIndexOf_thenIndexZeroIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
|
||||
assertEquals(0, list.lastIndexOf("baeldung"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenLastIndexOf_thenPositiveIndexOrMinusOneIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.add("baeldung");
|
||||
list.add(".com");
|
||||
|
||||
assertEquals(1, list.lastIndexOf("baeldung"));
|
||||
assertEquals(-1, list.indexOf("com"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenSubListZeroToOne_thenListContainingFirstElementIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
List<Object> subList = list.subList(0, 1);
|
||||
|
||||
assertEquals("baeldung", subList.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenSubListOneToTwo_thenListContainingSecondElementIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.add(".");
|
||||
list.add("com");
|
||||
List<Object> subList = list.subList(1, 2);
|
||||
|
||||
assertEquals(1, subList.size());
|
||||
assertEquals(".", subList.get(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithElements_whenToArray_thenArrayContainsThose() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
list.add(".com");
|
||||
Object[] array = list.toArray();
|
||||
|
||||
assertArrayEquals(new Object[] { "baeldung", ".com" }, array);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithAnElement_whenToArray_thenInputArrayIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
String[] input = new String[1];
|
||||
String[] output = list.toArray(input);
|
||||
|
||||
assertArrayEquals(new String[] { "baeldung" }, input);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenToArrayIsCalledWithEmptyInputArray_thenNewArrayIsReturned() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
String[] input = {};
|
||||
String[] output = list.toArray(input);
|
||||
|
||||
assertArrayEquals(new String[] { "baeldung" }, output);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenToArrayIsCalledWithLargerInput_thenOutputHasTrailingNull() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
String[] input = new String[2];
|
||||
String[] output = list.toArray(input);
|
||||
|
||||
assertArrayEquals(new String[] { "baeldung", null }, output);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListWithOneElement_whenIterator_thenThisElementIsNext() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
Iterator<Object> iterator = list.iterator();
|
||||
|
||||
assertTrue(iterator.hasNext());
|
||||
assertEquals("baeldung", iterator.next());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenIteratorHasNextIsCalledTwice_thenTheSecondReturnsFalse() {
|
||||
List<Object> list = new CustomList<>();
|
||||
list.add("baeldung");
|
||||
Iterator<Object> iterator = list.iterator();
|
||||
|
||||
iterator.next();
|
||||
assertFalse(iterator.hasNext());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,336 @@
|
||||
package com.baeldung.java.map;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class MapUnitTest {
|
||||
private static final Logger LOG = LoggerFactory.getLogger(MapUnitTest.class);
|
||||
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenRetrievesKeyset_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
|
||||
assertEquals(2, keys.size());
|
||||
assertTrue(keys.contains("name"));
|
||||
assertTrue(keys.contains("type"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenRetrievesValues_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Collection<String> values = map.values();
|
||||
|
||||
assertEquals(2, values.size());
|
||||
assertTrue(values.contains("baeldung"));
|
||||
assertTrue(values.contains("blog"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenHashMap_whenRetrievesEntries_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<Entry<String, String>> entries = map.entrySet();
|
||||
|
||||
assertEquals(2, entries.size());
|
||||
for (Entry<String, String> e : entries) {
|
||||
String key = e.getKey();
|
||||
String val = e.getValue();
|
||||
assertTrue(key.equals("name") || key.equals("type"));
|
||||
assertTrue(val.equals("baeldung") || val.equals("blog"));
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenKeySet_whenChangeReflectsInMap_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
assertEquals(2, map.size());
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
|
||||
keys.remove("name");
|
||||
assertEquals(1, map.size());
|
||||
}
|
||||
|
||||
@Test(expected = ConcurrentModificationException.class)
|
||||
public void givenIterator_whenFailsFastOnModification_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
Iterator<String> it = keys.iterator();
|
||||
map.remove("type");
|
||||
while (it.hasNext()) {
|
||||
String key = it.next();
|
||||
}
|
||||
}
|
||||
|
||||
public void givenIterator_whenRemoveWorks_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("name", "baeldung");
|
||||
map.put("type", "blog");
|
||||
|
||||
Set<String> keys = map.keySet();
|
||||
Iterator<String> it = keys.iterator();
|
||||
while (it.hasNext()) {
|
||||
it.next();
|
||||
it.remove();
|
||||
}
|
||||
assertEquals(0, map.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenHashCodeIsCalledOnPut_thenCorrect() {
|
||||
MyKey key = new MyKey(1, "name");
|
||||
Map<MyKey, String> map = new HashMap<>();
|
||||
map.put(key, "val");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenHashCodeIsCalledOnGet_thenCorrect() {
|
||||
MyKey key = new MyKey(1, "name");
|
||||
Map<MyKey, String> map = new HashMap<>();
|
||||
map.put(key, "val");
|
||||
map.get(key);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenGetWorks_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("key", "val");
|
||||
|
||||
String val = map.get("key");
|
||||
|
||||
assertEquals("val", val);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNewKey_whenPutReturnsNull_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String rtnVal = map.put("key1", "val1");
|
||||
|
||||
assertNull(rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUnmappedKey_whenGetReturnsNull_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String rtnVal = map.get("key1");
|
||||
|
||||
assertNull(rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullVal_whenPutReturnsNull_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String rtnVal = map.put("key1", null);
|
||||
|
||||
assertNull(rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullKeyAndVal_whenAccepts_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
map.put(null, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNullVal_whenRetrieves_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("key", null);
|
||||
|
||||
String val = map.get("key");
|
||||
|
||||
assertNull(val);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenContainsDistinguishesNullValues_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
|
||||
String val1 = map.get("key");
|
||||
boolean valPresent = map.containsKey("key");
|
||||
|
||||
assertNull(val1);
|
||||
assertFalse(valPresent);
|
||||
|
||||
map.put("key", null);
|
||||
String val = map.get("key");
|
||||
valPresent = map.containsKey("key");
|
||||
|
||||
assertNull(val);
|
||||
assertTrue(valPresent);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenPutReturnsPrevValue_thenCorrect() {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
map.put("key1", "val1");
|
||||
String rtnVal = map.put("key1", "val2");
|
||||
|
||||
assertEquals("val1", rtnVal);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCallsEqualsOnCollision_thenCorrect() {
|
||||
HashMap<MyKey, String> map = new HashMap<>();
|
||||
MyKey k1 = new MyKey(1, "firstKey");
|
||||
MyKey k2 = new MyKey(2, "secondKey");
|
||||
MyKey k3 = new MyKey(2, "thirdKey");
|
||||
|
||||
LOG.debug("storing value for k1");
|
||||
map.put(k1, "firstValue");
|
||||
|
||||
LOG.debug("storing value for k2");
|
||||
map.put(k2, "secondValue");
|
||||
|
||||
LOG.debug("storing value for k3");
|
||||
map.put(k3, "thirdValue");
|
||||
|
||||
LOG.debug("retrieving value for k1");
|
||||
String v1 = map.get(k1);
|
||||
|
||||
LOG.debug("retrieving value for k2");
|
||||
String v2 = map.get(k2);
|
||||
|
||||
LOG.debug("retrieving value for k3");
|
||||
String v3 = map.get(k3);
|
||||
|
||||
assertEquals("firstValue", v1);
|
||||
assertEquals("secondValue", v2);
|
||||
assertEquals("thirdValue", v3);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMap_whenGetsOrderedKeyset_thenCorrect() {
|
||||
LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
|
||||
map.put(1, null);
|
||||
map.put(2, null);
|
||||
map.put(3, null);
|
||||
map.put(4, null);
|
||||
map.put(5, null);
|
||||
Set<Integer> keys = map.keySet();
|
||||
Integer[] arr = keys.toArray(new Integer[0]);
|
||||
for (int i = 0; i < arr.length; i++) {
|
||||
assertEquals(new Integer(i + 1), arr[i]);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMap_whenAccessOrderWorks_thenCorrect() {
|
||||
LinkedHashMap<Integer, String> map = new LinkedHashMap<>(16, .75f, true);
|
||||
map.put(1, null);
|
||||
map.put(2, null);
|
||||
map.put(3, null);
|
||||
map.put(4, null);
|
||||
map.put(5, null);
|
||||
Set<Integer> keys = map.keySet();
|
||||
assertEquals("[1, 2, 3, 4, 5]", keys.toString());
|
||||
map.get(4);
|
||||
assertEquals("[1, 2, 3, 5, 4]", keys.toString());
|
||||
map.get(1);
|
||||
assertEquals("[2, 3, 5, 4, 1]", keys.toString());
|
||||
map.get(3);
|
||||
assertEquals("[2, 5, 4, 1, 3]", keys.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenLinkedHashMap_whenRemovesEldestEntry_thenCorrect() {
|
||||
LinkedHashMap<Integer, String> map = new MyLinkedHashMap<>(16, .75f, true);
|
||||
map.put(1, null);
|
||||
map.put(2, null);
|
||||
map.put(3, null);
|
||||
map.put(4, null);
|
||||
map.put(5, null);
|
||||
Set<Integer> keys = map.keySet();
|
||||
assertEquals("[1, 2, 3, 4, 5]", keys.toString());
|
||||
map.put(6, null);
|
||||
assertEquals("[2, 3, 4, 5, 6]", keys.toString());
|
||||
map.put(7, null);
|
||||
assertEquals("[3, 4, 5, 6, 7]", keys.toString());
|
||||
map.put(8, null);
|
||||
assertEquals("[4, 5, 6, 7, 8]", keys.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenOrdersEntriesNaturally_thenCorrect() {
|
||||
TreeMap<Integer, String> map = new TreeMap<>();
|
||||
map.put(3, "val");
|
||||
map.put(2, "val");
|
||||
map.put(1, "val");
|
||||
map.put(5, "val");
|
||||
map.put(4, "val");
|
||||
assertEquals("[1, 2, 3, 4, 5]", map.keySet().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenOrdersEntriesNaturally_thenCorrect2() {
|
||||
TreeMap<String, String> map = new TreeMap<>();
|
||||
map.put("c", "val");
|
||||
map.put("b", "val");
|
||||
map.put("a", "val");
|
||||
map.put("e", "val");
|
||||
map.put("d", "val");
|
||||
|
||||
assertEquals("[a, b, c, d, e]", map.keySet().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenOrdersEntriesByComparator_thenCorrect() {
|
||||
TreeMap<Integer, String> map = new TreeMap<>(Comparator.reverseOrder());
|
||||
map.put(3, "val");
|
||||
map.put(2, "val");
|
||||
map.put(1, "val");
|
||||
map.put(5, "val");
|
||||
map.put(4, "val");
|
||||
|
||||
assertEquals("[5, 4, 3, 2, 1]", map.keySet().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenTreeMap_whenPerformsQueries_thenCorrect() {
|
||||
TreeMap<Integer, String> map = new TreeMap<>();
|
||||
map.put(3, "val");
|
||||
map.put(2, "val");
|
||||
map.put(1, "val");
|
||||
map.put(5, "val");
|
||||
map.put(4, "val");
|
||||
|
||||
Integer highestKey = map.lastKey();
|
||||
Integer lowestKey = map.firstKey();
|
||||
Set<Integer> keysLessThan3 = map.headMap(3).keySet();
|
||||
Set<Integer> keysGreaterThanEqTo3 = map.tailMap(3).keySet();
|
||||
|
||||
assertEquals(new Integer(5), highestKey);
|
||||
assertEquals(new Integer(1), lowestKey);
|
||||
assertEquals("[1, 2]", keysLessThan3.toString());
|
||||
assertEquals("[3, 4, 5]", keysGreaterThanEqTo3.toString());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package com.baeldung.list.flattennestedlist;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.hamcrest.collection.IsIterableContainingInOrder;
|
||||
import org.junit.Test;
|
||||
|
||||
public class FlattenNestedListUnitTest {
|
||||
private List<List<String>> lol = asList(asList("one:one"), asList("two:one", "two:two", "two:three"), asList("three:one", "three:two", "three:three", "three:four"));
|
||||
|
||||
@Test
|
||||
public void givenNestedList_thenFlattenImperatively() {
|
||||
List<String> ls = flattenListOfListsImperatively(lol);
|
||||
|
||||
assertNotNull(ls);
|
||||
assertTrue(ls.size() == 8);
|
||||
// assert content
|
||||
assertThat(ls, IsIterableContainingInOrder.contains("one:one", "two:one", "two:two", "two:three", "three:one", "three:two", "three:three", "three:four"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNestedList_thenFlattenFunctionally() {
|
||||
List<String> ls = flattenListOfListsStream(lol);
|
||||
|
||||
assertNotNull(ls);
|
||||
assertTrue(ls.size() == 8);
|
||||
// assert content
|
||||
assertThat(ls, IsIterableContainingInOrder.contains("one:one", "two:one", "two:two", "two:three", "three:one", "three:two", "three:three", "three:four"));
|
||||
}
|
||||
|
||||
private <T> List<T> flattenListOfListsImperatively(List<List<T>> list) {
|
||||
List<T> ls = new ArrayList<>();
|
||||
list.forEach(ls::addAll);
|
||||
return ls;
|
||||
}
|
||||
|
||||
private <T> List<T> flattenListOfListsStream(List<List<T>> list) {
|
||||
return list.stream()
|
||||
.flatMap(Collection::stream)
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
package com.baeldung.list.listoflist;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
|
||||
public class ListOfListsUnitTest {
|
||||
|
||||
private List<List<? extends Stationery>> listOfLists = new ArrayList<>();
|
||||
private List<Pen> penList = new ArrayList<>();
|
||||
private List<Pencil> pencilList = new ArrayList<>();
|
||||
private List<Rubber> rubberList = new ArrayList<>();
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Before
|
||||
public void init() {
|
||||
listOfLists.add(penList);
|
||||
listOfLists.add(pencilList);
|
||||
listOfLists.add(rubberList);
|
||||
|
||||
((ArrayList<Pen>) listOfLists.get(0)).add(new Pen("Pen 1"));
|
||||
((ArrayList<Pencil>) listOfLists.get(1)).add(new Pencil("Pencil 1"));
|
||||
((ArrayList<Rubber>) listOfLists.get(2)).add(new Rubber("Rubber 1"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListOfLists_thenCheckNames() {
|
||||
assertEquals("Pen 1", ((Pen) listOfLists.get(0).get(0)).getName());
|
||||
assertEquals("Pencil 1", ((Pencil) listOfLists.get(1).get(0)).getName());
|
||||
assertEquals("Rubber 1", ((Rubber) listOfLists.get(2).get(0)).getName());
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test
|
||||
public void givenListOfLists_whenRemovingElements_thenCheckNames() {
|
||||
|
||||
((ArrayList<Pencil>) listOfLists.get(1)).remove(0);
|
||||
listOfLists.remove(1);
|
||||
assertEquals("Rubber 1", ((Rubber) listOfLists.get(1).get(0)).getName());
|
||||
listOfLists.remove(0);
|
||||
assertEquals("Rubber 1", ((Rubber) listOfLists.get(0).get(0)).getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenThreeList_whenCombineIntoOneList_thenCheckList() {
|
||||
ArrayList<Pen> pens = new ArrayList<>();
|
||||
pens.add(new Pen("Pen 1"));
|
||||
pens.add(new Pen("Pen 2"));
|
||||
ArrayList<Pencil> pencils = new ArrayList<>();
|
||||
pencils.add(new Pencil("Pencil 1"));
|
||||
pencils.add(new Pencil("Pencil 2"));
|
||||
ArrayList<Rubber> rubbers = new ArrayList<>();
|
||||
rubbers.add(new Rubber("Rubber 1"));
|
||||
rubbers.add(new Rubber("Rubber 2"));
|
||||
|
||||
List<ArrayList<? extends Stationery>> list = new ArrayList<ArrayList<? extends Stationery>>();
|
||||
list.add(pens);
|
||||
list.add(pencils);
|
||||
list.add(rubbers);
|
||||
|
||||
assertEquals("Pen 1", ((Pen) list.get(0).get(0)).getName());
|
||||
assertEquals("Pencil 1", ((Pencil) list.get(1).get(0)).getName());
|
||||
assertEquals("Rubber 1", ((Rubber) list.get(2).get(0)).getName());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package com.baeldung.weakhashmap;
|
||||
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.WeakHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static com.jayway.awaitility.Awaitility.await;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
public class WeakHashMapUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenWeakHashMap_whenCacheValueThatHasNoReferenceToIt_GCShouldReclaimThatObject() {
|
||||
//given
|
||||
WeakHashMap<UniqueImageName, BigImage> map = new WeakHashMap<>();
|
||||
BigImage bigImage = new BigImage("image_id");
|
||||
UniqueImageName imageName = new UniqueImageName("name_of_big_image");
|
||||
|
||||
map.put(imageName, bigImage);
|
||||
assertTrue(map.containsKey(imageName));
|
||||
|
||||
//when big image key is not reference anywhere
|
||||
imageName = null;
|
||||
System.gc();
|
||||
|
||||
//then GC will finally reclaim that object
|
||||
await().atMost(10, TimeUnit.SECONDS).until(map::isEmpty);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenWeakHashMap_whenCacheValueThatHasNoReferenceToIt_GCShouldReclaimThatObjectButLeaveReferencedObject() {
|
||||
//given
|
||||
WeakHashMap<UniqueImageName, BigImage> map = new WeakHashMap<>();
|
||||
BigImage bigImageFirst = new BigImage("foo");
|
||||
UniqueImageName imageNameFirst = new UniqueImageName("name_of_big_image");
|
||||
|
||||
BigImage bigImageSecond = new BigImage("foo_2");
|
||||
UniqueImageName imageNameSecond = new UniqueImageName("name_of_big_image_2");
|
||||
|
||||
map.put(imageNameFirst, bigImageFirst);
|
||||
map.put(imageNameSecond, bigImageSecond);
|
||||
assertTrue(map.containsKey(imageNameFirst));
|
||||
assertTrue(map.containsKey(imageNameSecond));
|
||||
|
||||
//when
|
||||
imageNameFirst = null;
|
||||
System.gc();
|
||||
|
||||
//then
|
||||
await().atMost(10, TimeUnit.SECONDS).until(() -> map.size() == 1);
|
||||
await().atMost(10, TimeUnit.SECONDS).until(() -> map.containsKey(imageNameSecond));
|
||||
}
|
||||
|
||||
|
||||
class BigImage {
|
||||
public final String imageId;
|
||||
|
||||
BigImage(String imageId) {
|
||||
this.imageId = imageId;
|
||||
}
|
||||
}
|
||||
|
||||
class UniqueImageName {
|
||||
public final String imageName;
|
||||
|
||||
UniqueImageName(String imageName) {
|
||||
this.imageName = imageName;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import com.google.common.collect.Sets;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.*;
|
||||
|
||||
import static java.util.stream.Collectors.*;
|
||||
import static org.hamcrest.CoreMatchers.equalTo;
|
||||
import static org.hamcrest.core.IsNot.not;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class ArrayListUnitTest {
|
||||
|
||||
private List<String> stringsToSearch;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
List<String> list = LongStream.range(0, 16).boxed().map(Long::toHexString).collect(toCollection(ArrayList::new));
|
||||
stringsToSearch = new ArrayList<>(list);
|
||||
stringsToSearch.addAll(list);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenNewArrayList_whenCheckCapacity_thenDefaultValue() {
|
||||
List<String> list = new ArrayList<>();
|
||||
assertTrue(list.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCollection_whenProvideItToArrayListCtor_thenArrayListIsPopulatedWithItsElements() {
|
||||
Collection<Integer> numbers = IntStream.range(0, 10).boxed().collect(toSet());
|
||||
|
||||
List<Integer> list = new ArrayList<>(numbers);
|
||||
assertEquals(10, list.size());
|
||||
assertTrue(numbers.containsAll(list));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenElement_whenAddToArrayList_thenIsAdded() {
|
||||
List<Long> list = new ArrayList<>();
|
||||
|
||||
list.add(1L);
|
||||
list.add(2L);
|
||||
list.add(1, 3L);
|
||||
|
||||
assertThat(Arrays.asList(1L, 3L, 2L), equalTo(list));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCollection_whenAddToArrayList_thenIsAdded() {
|
||||
List<Long> list = new ArrayList<>(Arrays.asList(1L, 2L, 3L));
|
||||
LongStream.range(4, 10).boxed().collect(collectingAndThen(toCollection(ArrayList::new), ys -> list.addAll(0, ys)));
|
||||
|
||||
assertThat(Arrays.asList(4L, 5L, 6L, 7L, 8L, 9L, 1L, 2L, 3L), equalTo(list));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenExistingElement_whenCallIndexOf_thenReturnCorrectIndex() {
|
||||
assertEquals(10, stringsToSearch.indexOf("a"));
|
||||
assertEquals(26, stringsToSearch.lastIndexOf("a"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCondition_whenIterateArrayList_thenFindAllElementsSatisfyingCondition() {
|
||||
Iterator<String> it = stringsToSearch.iterator();
|
||||
Set<String> matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));
|
||||
|
||||
List<String> result = new ArrayList<>();
|
||||
while (it.hasNext()) {
|
||||
String s = it.next();
|
||||
if (matchingStrings.contains(s)) {
|
||||
result.add(s);
|
||||
}
|
||||
}
|
||||
|
||||
assertEquals(6, result.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPredicate_whenIterateArrayList_thenFindAllElementsSatisfyingPredicate() {
|
||||
Set<String> matchingStrings = new HashSet<>(Arrays.asList("a", "c", "9"));
|
||||
|
||||
List<String> result = stringsToSearch.stream().filter(matchingStrings::contains).collect(toCollection(ArrayList::new));
|
||||
|
||||
assertEquals(6, result.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSortedArray_whenUseBinarySearch_thenFindElement() {
|
||||
List<String> copy = new ArrayList<>(stringsToSearch);
|
||||
Collections.sort(copy);
|
||||
int index = Collections.binarySearch(copy, "f");
|
||||
assertThat(index, not(equalTo(-1)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenIndex_whenRemove_thenCorrectElementRemoved() {
|
||||
List<Integer> list = IntStream.range(0, 10).boxed().collect(toCollection(ArrayList::new));
|
||||
Collections.reverse(list);
|
||||
|
||||
list.remove(0);
|
||||
assertThat(list.get(0), equalTo(8));
|
||||
|
||||
list.remove(Integer.valueOf(0));
|
||||
assertFalse(list.contains(0));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenListIterator_whenReverseTraversal_thenRetrieveElementsInOppositeOrder() {
|
||||
List<Integer> list = IntStream.range(0, 10).boxed().collect(toCollection(ArrayList::new));
|
||||
ListIterator<Integer> it = list.listIterator(list.size());
|
||||
List<Integer> result = new ArrayList<>(list.size());
|
||||
while (it.hasPrevious()) {
|
||||
result.add(it.previous());
|
||||
}
|
||||
|
||||
Collections.reverse(list);
|
||||
assertThat(result, equalTo(list));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenCondition_whenIterateArrayList_thenRemoveAllElementsSatisfyingCondition() {
|
||||
Set<String> matchingStrings = Sets.newHashSet("a", "b", "c", "d", "e", "f");
|
||||
|
||||
Iterator<String> it = stringsToSearch.iterator();
|
||||
while (it.hasNext()) {
|
||||
if (matchingStrings.contains(it.next())) {
|
||||
it.remove();
|
||||
}
|
||||
}
|
||||
|
||||
assertEquals(20, stringsToSearch.size());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import com.google.common.collect.Iterables;
|
||||
import com.google.common.collect.Lists;
|
||||
|
||||
import org.apache.commons.collections4.CollectionUtils;
|
||||
import org.apache.commons.collections4.IterableUtils;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
|
||||
public class CollectionsConcatenateUnitTest {
|
||||
|
||||
@Test
|
||||
public void givenUsingJava8_whenConcatenatingUsingConcat_thenCorrect() {
|
||||
Collection<String> collectionA = asList("S", "T");
|
||||
Collection<String> collectionB = asList("U", "V");
|
||||
Collection<String> collectionC = asList("W", "X");
|
||||
|
||||
Stream<String> combinedStream = Stream.concat(Stream.concat(collectionA.stream(), collectionB.stream()), collectionC.stream());
|
||||
Collection<String> collectionCombined = combinedStream.collect(Collectors.toList());
|
||||
|
||||
Assert.assertEquals(asList("S", "T", "U", "V", "W", "X"), collectionCombined);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingJava8_whenConcatenatingUsingflatMap_thenCorrect() {
|
||||
Collection<String> collectionA = asList("S", "T");
|
||||
Collection<String> collectionB = asList("U", "V");
|
||||
|
||||
Stream<String> combinedStream = Stream.of(collectionA, collectionB).flatMap(Collection::stream);
|
||||
Collection<String> collectionCombined = combinedStream.collect(Collectors.toList());
|
||||
|
||||
Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingGuava_whenConcatenatingUsingIterables_thenCorrect() {
|
||||
Collection<String> collectionA = asList("S", "T");
|
||||
Collection<String> collectionB = asList("U", "V");
|
||||
|
||||
Iterable<String> combinedIterables = Iterables.unmodifiableIterable(Iterables.concat(collectionA, collectionB));
|
||||
Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
|
||||
|
||||
Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingJava7_whenConcatenatingUsingIterables_thenCorrect() {
|
||||
Collection<String> collectionA = asList("S", "T");
|
||||
Collection<String> collectionB = asList("U", "V");
|
||||
|
||||
Iterable<String> combinedIterables = concat(collectionA, collectionB);
|
||||
Collection<String> collectionCombined = makeListFromIterable(combinedIterables);
|
||||
Assert.assertEquals(Arrays.asList("S", "T", "U", "V"), collectionCombined);
|
||||
}
|
||||
|
||||
public static <E> Iterable<E> concat(Iterable<? extends E> i1, Iterable<? extends E> i2) {
|
||||
return new Iterable<E>() {
|
||||
public Iterator<E> iterator() {
|
||||
return new Iterator<E>() {
|
||||
Iterator<? extends E> listIterator = i1.iterator();
|
||||
Boolean checkedHasNext;
|
||||
E nextValue;
|
||||
private boolean startTheSecond;
|
||||
|
||||
void theNext() {
|
||||
if (listIterator.hasNext()) {
|
||||
checkedHasNext = true;
|
||||
nextValue = listIterator.next();
|
||||
} else if (startTheSecond)
|
||||
checkedHasNext = false;
|
||||
else {
|
||||
startTheSecond = true;
|
||||
listIterator = i2.iterator();
|
||||
theNext();
|
||||
}
|
||||
}
|
||||
|
||||
public boolean hasNext() {
|
||||
if (checkedHasNext == null)
|
||||
theNext();
|
||||
return checkedHasNext;
|
||||
}
|
||||
|
||||
public E next() {
|
||||
if (!hasNext())
|
||||
throw new NoSuchElementException();
|
||||
checkedHasNext = null;
|
||||
return nextValue;
|
||||
}
|
||||
|
||||
public void remove() {
|
||||
listIterator.remove();
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public static <E> List<E> makeListFromIterable(Iterable<E> iter) {
|
||||
List<E> list = new ArrayList<>();
|
||||
for (E item : iter) {
|
||||
list.add(item);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApacheCommons_whenConcatenatingUsingUnion_thenCorrect() {
|
||||
Collection<String> collectionA = asList("S", "T");
|
||||
Collection<String> collectionB = asList("U", "V");
|
||||
|
||||
Iterable<String> combinedIterables = CollectionUtils.union(collectionA, collectionB);
|
||||
Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
|
||||
|
||||
Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenUsingApacheCommons_whenConcatenatingUsingChainedIterable_thenCorrect() {
|
||||
Collection<String> collectionA = asList("S", "T");
|
||||
Collection<String> collectionB = asList("U", "V");
|
||||
|
||||
Iterable<String> combinedIterables = IterableUtils.chainedIterable(collectionA, collectionB);
|
||||
Collection<String> collectionCombined = Lists.newArrayList(combinedIterables);
|
||||
|
||||
Assert.assertEquals(asList("S", "T", "U", "V"), collectionCombined);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
public class CollectionsJoinAndSplitJUnitTest {
|
||||
|
||||
private ArrayList<String> sauces = new ArrayList<>();
|
||||
private ArrayList<String> cheeses = new ArrayList<>();
|
||||
private ArrayList<String> vegetables = new ArrayList<>();
|
||||
|
||||
private ArrayList<ArrayList<String>> ingredients = new ArrayList<>();
|
||||
|
||||
@Before
|
||||
public void init() {
|
||||
sauces.add("Olive Oil");
|
||||
sauces.add("Marinara");
|
||||
|
||||
cheeses.add("Mozzarella");
|
||||
cheeses.add("Feta");
|
||||
cheeses.add("Parmesan");
|
||||
|
||||
vegetables.add("Olives");
|
||||
vegetables.add("Spinach");
|
||||
vegetables.add("Green Peppers");
|
||||
|
||||
ingredients.add(sauces);
|
||||
ingredients.add(cheeses);
|
||||
ingredients.add(vegetables);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenThreeArrayLists_whenJoiningIntoOneArrayList_shouldSucceed() {
|
||||
ArrayList<ArrayList<String>> toppings = new ArrayList<>();
|
||||
|
||||
toppings.add(sauces);
|
||||
toppings.add(cheeses);
|
||||
toppings.add(vegetables);
|
||||
|
||||
Assert.assertTrue(toppings.size() == 3);
|
||||
Assert.assertTrue(toppings.contains(sauces));
|
||||
Assert.assertTrue(toppings.contains(cheeses));
|
||||
Assert.assertTrue(toppings.contains(vegetables));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenOneArrayList_whenSplittingIntoTwoArrayLists_shouldSucceed() {
|
||||
|
||||
ArrayList<ArrayList<String>> removedToppings = new ArrayList<>();
|
||||
removedToppings.add(ingredients.remove(ingredients.indexOf(vegetables)));
|
||||
|
||||
Assert.assertTrue(removedToppings.contains(vegetables));
|
||||
Assert.assertTrue(removedToppings.size() == 1);
|
||||
Assert.assertTrue(ingredients.size() == 2);
|
||||
Assert.assertTrue(ingredients.contains(sauces));
|
||||
Assert.assertTrue(ingredients.contains(cheeses));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import org.apache.commons.collections4.ListUtils;
|
||||
import org.junit.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class CoreJavaCollectionsUnitTest {
|
||||
|
||||
private static final Logger LOG = LoggerFactory.getLogger(CoreJavaCollectionsUnitTest.class);
|
||||
|
||||
|
||||
// tests -
|
||||
|
||||
@Test
|
||||
public final void givenUsingTheJdk_whenArrayListIsSynchronized_thenCorrect() {
|
||||
final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
|
||||
final List<String> synchronizedList = Collections.synchronizedList(list);
|
||||
LOG.debug("Synchronized List is: " + synchronizedList);
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public final void givenUsingTheJdk_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
|
||||
final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
|
||||
final List<String> unmodifiableList = Collections.unmodifiableList(list);
|
||||
unmodifiableList.add("four");
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public final void givenUsingGuava_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
|
||||
final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
|
||||
final List<String> unmodifiableList = ImmutableList.copyOf(list);
|
||||
unmodifiableList.add("four");
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public final void givenUsingGuavaBuilder_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
|
||||
final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
|
||||
final ImmutableList<Object> unmodifiableList = ImmutableList.builder().addAll(list).build();
|
||||
unmodifiableList.add("four");
|
||||
}
|
||||
|
||||
@Test(expected = UnsupportedOperationException.class)
|
||||
public final void givenUsingCommonsCollections_whenUnmodifiableListIsCreatedFromOriginal_thenNoLongerModifiable() {
|
||||
final List<String> list = new ArrayList<String>(Arrays.asList("one", "two", "three"));
|
||||
final List<String> unmodifiableList = ListUtils.unmodifiableList(list);
|
||||
unmodifiableList.add("four");
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import static org.hamcrest.Matchers.hasSize;
|
||||
import static org.junit.Assert.assertThat;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.collections4.CollectionUtils;
|
||||
import org.apache.commons.collections4.PredicateUtils;
|
||||
import org.junit.Test;
|
||||
|
||||
import com.google.common.base.Predicates;
|
||||
import com.google.common.collect.Iterables;
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Sets;
|
||||
|
||||
public class JavaCollectionCleanupUnitTest {
|
||||
|
||||
// tests - removing nulls
|
||||
|
||||
@Test
|
||||
public final void givenListContainsNulls_whenRemovingNullsWithPlainJava_thenCorrect() {
|
||||
final List<Integer> list = Lists.newArrayList(null, 1, null);
|
||||
while (list.remove(null))
|
||||
;
|
||||
|
||||
assertThat(list, hasSize(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenListContainsNulls_whenRemovingNullsWithPlainJavaAlternative_thenCorrect() {
|
||||
final List<Integer> list = Lists.newArrayList(null, 1, null);
|
||||
list.removeAll(Collections.singleton(null));
|
||||
|
||||
assertThat(list, hasSize(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenListContainsNulls_whenRemovingNullsWithGuavaV1_thenCorrect() {
|
||||
final List<Integer> list = Lists.newArrayList(null, 1, null);
|
||||
Iterables.removeIf(list, Predicates.isNull());
|
||||
|
||||
assertThat(list, hasSize(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenListContainsNulls_whenRemovingNullsWithGuavaV2_thenCorrect() {
|
||||
final List<Integer> list = Lists.newArrayList(null, 1, null, 2, 3);
|
||||
final List<Integer> listWithoutNulls = Lists.newArrayList(Iterables.filter(list, Predicates.notNull()));
|
||||
|
||||
assertThat(listWithoutNulls, hasSize(3));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenListContainsNulls_whenRemovingNullsWithCommonsCollections_thenCorrect() {
|
||||
final List<Integer> list = Lists.newArrayList(null, 1, 2, null, 3, null);
|
||||
CollectionUtils.filter(list, PredicateUtils.notNullPredicate());
|
||||
|
||||
assertThat(list, hasSize(3));
|
||||
}
|
||||
|
||||
// tests - remove duplicates
|
||||
|
||||
@Test
|
||||
public final void givenListContainsDuplicates_whenRemovingDuplicatesWithPlainJava_thenCorrect() {
|
||||
final List<Integer> listWithDuplicates = Lists.newArrayList(0, 1, 2, 3, 0, 0);
|
||||
final List<Integer> listWithoutDuplicates = new ArrayList<>(new HashSet<>(listWithDuplicates));
|
||||
|
||||
assertThat(listWithoutDuplicates, hasSize(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenListContainsDuplicates_whenRemovingDuplicatesWithGuava_thenCorrect() {
|
||||
final List<Integer> listWithDuplicates = Lists.newArrayList(0, 1, 2, 3, 0, 0);
|
||||
final List<Integer> listWithoutDuplicates = Lists.newArrayList(Sets.newHashSet(listWithDuplicates));
|
||||
|
||||
assertThat(listWithoutDuplicates, hasSize(4));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
package org.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<Integer> targetList = Arrays.asList(sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenListConvertedToArray_thenCorrect() {
|
||||
final List<Integer> sourceList = Arrays.asList(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceList.toArray(new Integer[sourceList.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenArrayConvertedToList_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final List<Integer> targetList = Lists.newArrayList(sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenListConvertedToArray_thenCorrect() {
|
||||
final List<Integer> 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<Integer> 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<Integer> targetSet = new HashSet<Integer>(Arrays.asList(sourceArray));
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJavaV2_whenArrayConvertedToSet_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final Set<Integer> targetSet = new HashSet<Integer>();
|
||||
Collections.addAll(targetSet, sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenSetConvertedToArray_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceSet.toArray(new Integer[sourceSet.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenArrayConvertedToSet_thenCorrect() {
|
||||
final Integer[] sourceArray = { 0, 1, 2, 3, 4, 5 };
|
||||
final Set<Integer> targetSet = Sets.newHashSet(sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenSetConvertedToArray_thenCorrect() {
|
||||
final Set<Integer> 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<Integer> targetSet = new HashSet<>(6);
|
||||
CollectionUtils.addAll(targetSet, sourceArray);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCommonsCollections_whenSetConvertedToArray_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceSet.toArray(new Integer[sourceSet.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCommonsCollections_whenSetConvertedToArrayOfPrimitives_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final Integer[] targetArray = sourceSet.toArray(new Integer[sourceSet.size()]);
|
||||
final int[] primitiveTargetArray = ArrayUtils.toPrimitive(targetArray);
|
||||
}
|
||||
|
||||
// Set -> List; List -> Set
|
||||
|
||||
public final void givenUsingCoreJava_whenSetConvertedToList_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final List<Integer> targetList = new ArrayList<>(sourceSet);
|
||||
}
|
||||
|
||||
public final void givenUsingCoreJava_whenListConvertedToSet_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
final Set<Integer> targetSet = new HashSet<>(sourceList);
|
||||
}
|
||||
|
||||
public final void givenUsingGuava_whenSetConvertedToList_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
final List<Integer> targetList = Lists.newArrayList(sourceSet);
|
||||
}
|
||||
|
||||
public final void givenUsingGuava_whenListConvertedToSet_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
final Set<Integer> targetSet = Sets.newHashSet(sourceList);
|
||||
}
|
||||
|
||||
public final void givenUsingCommonsCollections_whenListConvertedToSet_thenCorrect() {
|
||||
final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
|
||||
|
||||
final Set<Integer> targetSet = new HashSet<>(6);
|
||||
CollectionUtils.addAll(targetSet, sourceList);
|
||||
}
|
||||
|
||||
public final void givenUsingCommonsCollections_whenSetConvertedToList_thenCorrect() {
|
||||
final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
|
||||
|
||||
final List<Integer> targetList = new ArrayList<>(6);
|
||||
CollectionUtils.addAll(targetList, sourceSet);
|
||||
}
|
||||
|
||||
// Map (values) -> Array, List, Set
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenMapValuesConvertedToArray_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final Collection<String> values = sourceMap.values();
|
||||
final String[] targetArray = values.toArray(new String[values.size()]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenMapValuesConvertedToList_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final List<String> targetList = new ArrayList<>(sourceMap.values());
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingGuava_whenMapValuesConvertedToList_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final List<String> targetList = Lists.newArrayList(sourceMap.values());
|
||||
}
|
||||
|
||||
@Test
|
||||
public final void givenUsingCoreJava_whenMapValuesConvertedToSet_thenCorrect() {
|
||||
final Map<Integer, String> sourceMap = createMap();
|
||||
|
||||
final Set<String> targetSet = new HashSet<>(sourceMap.values());
|
||||
}
|
||||
|
||||
// UTIL
|
||||
|
||||
private final Map<Integer, String> createMap() {
|
||||
final Map<Integer, String> sourceMap = new HashMap<>(3);
|
||||
sourceMap.put(0, "zero");
|
||||
sourceMap.put(1, "one");
|
||||
sourceMap.put(2, "two");
|
||||
return sourceMap;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
package org.baeldung.java.collections;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class JoinSplitCollectionsUnitTest {
|
||||
|
||||
@Test
|
||||
public void whenJoiningTwoArrays_thenJoined() {
|
||||
String[] animals1 = new String[] { "Dog", "Cat" };
|
||||
String[] animals2 = new String[] { "Bird", "Cow" };
|
||||
String[] result = Stream.concat(Arrays.stream(animals1), Arrays.stream(animals2)).toArray(String[]::new);
|
||||
|
||||
assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenJoiningTwoCollections_thenJoined() {
|
||||
Collection<String> collection1 = Arrays.asList("Dog", "Cat");
|
||||
Collection<String> collection2 = Arrays.asList("Bird", "Cow", "Moose");
|
||||
Collection<String> result = Stream.concat(collection1.stream(), collection2.stream()).collect(Collectors.toList());
|
||||
|
||||
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow", "Moose")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenJoiningTwoCollectionsWithFilter_thenJoined() {
|
||||
Collection<String> collection1 = Arrays.asList("Dog", "Cat");
|
||||
Collection<String> collection2 = Arrays.asList("Bird", "Cow", "Moose");
|
||||
Collection<String> result = Stream.concat(collection1.stream(), collection2.stream()).filter(e -> e.length() == 3).collect(Collectors.toList());
|
||||
|
||||
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Cow")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertArrayToString_thenConverted() {
|
||||
String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow" };
|
||||
String result = Arrays.stream(animals).collect(Collectors.joining(", "));
|
||||
|
||||
assertEquals(result, "Dog, Cat, Bird, Cow");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertCollectionToString_thenConverted() {
|
||||
Collection<String> animals = Arrays.asList("Dog", "Cat", "Bird", "Cow");
|
||||
String result = animals.stream().collect(Collectors.joining(", "));
|
||||
|
||||
assertEquals(result, "Dog, Cat, Bird, Cow");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertMapToString_thenConverted() {
|
||||
Map<Integer, String> animals = new HashMap<>();
|
||||
animals.put(1, "Dog");
|
||||
animals.put(2, "Cat");
|
||||
animals.put(3, "Cow");
|
||||
|
||||
String result = animals.entrySet().stream().map(entry -> entry.getKey() + " = " + entry.getValue()).collect(Collectors.joining(", "));
|
||||
|
||||
assertEquals(result, "1 = Dog, 2 = Cat, 3 = Cow");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertNestedCollectionToString_thenConverted() {
|
||||
Collection<List<String>> nested = new ArrayList<>();
|
||||
nested.add(Arrays.asList("Dog", "Cat"));
|
||||
nested.add(Arrays.asList("Cow", "Pig"));
|
||||
|
||||
String result = nested.stream().map(nextList -> nextList.stream().collect(Collectors.joining("-"))).collect(Collectors.joining("; "));
|
||||
|
||||
assertEquals(result, "Dog-Cat; Cow-Pig");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertCollectionToStringAndSkipNull_thenConverted() {
|
||||
Collection<String> animals = Arrays.asList("Dog", "Cat", null, "Moose");
|
||||
String result = animals.stream().filter(Objects::nonNull).collect(Collectors.joining(", "));
|
||||
|
||||
assertEquals(result, "Dog, Cat, Moose");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenSplitCollectionHalf_thenConverted() {
|
||||
Collection<String> animals = Arrays.asList("Dog", "Cat", "Cow", "Bird", "Moose", "Pig");
|
||||
Collection<String> result1 = new ArrayList<>();
|
||||
Collection<String> result2 = new ArrayList<>();
|
||||
AtomicInteger count = new AtomicInteger();
|
||||
int midpoint = Math.round(animals.size() / 2);
|
||||
|
||||
animals.forEach(next -> {
|
||||
int index = count.getAndIncrement();
|
||||
if (index < midpoint) {
|
||||
result1.add(next);
|
||||
} else {
|
||||
result2.add(next);
|
||||
}
|
||||
});
|
||||
|
||||
assertTrue(result1.equals(Arrays.asList("Dog", "Cat", "Cow")));
|
||||
assertTrue(result2.equals(Arrays.asList("Bird", "Moose", "Pig")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenSplitArrayByWordLength_thenConverted() {
|
||||
String[] animals = new String[] { "Dog", "Cat", "Bird", "Cow", "Pig", "Moose" };
|
||||
Map<Integer, List<String>> result = Arrays.stream(animals).collect(Collectors.groupingBy(String::length));
|
||||
|
||||
assertTrue(result.get(3).equals(Arrays.asList("Dog", "Cat", "Cow", "Pig")));
|
||||
assertTrue(result.get(4).equals(Arrays.asList("Bird")));
|
||||
assertTrue(result.get(5).equals(Arrays.asList("Moose")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertStringToArray_thenConverted() {
|
||||
String animals = "Dog, Cat, Bird, Cow";
|
||||
String[] result = animals.split(", ");
|
||||
|
||||
assertArrayEquals(result, new String[] { "Dog", "Cat", "Bird", "Cow" });
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertStringToCollection_thenConverted() {
|
||||
String animals = "Dog, Cat, Bird, Cow";
|
||||
Collection<String> result = Arrays.asList(animals.split(", "));
|
||||
|
||||
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertStringToMap_thenConverted() {
|
||||
String animals = "1 = Dog, 2 = Cat, 3 = Bird";
|
||||
|
||||
Map<Integer, String> result = Arrays.stream(animals.split(", ")).map(next -> next.split(" = ")).collect(Collectors.toMap(entry -> Integer.parseInt(entry[0]), entry -> entry[1]));
|
||||
|
||||
assertEquals(result.get(1), "Dog");
|
||||
assertEquals(result.get(2), "Cat");
|
||||
assertEquals(result.get(3), "Bird");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenConvertCollectionToStringMultipleSeparators_thenConverted() {
|
||||
String animals = "Dog. , Cat, Bird. Cow";
|
||||
|
||||
Collection<String> result = Arrays.stream(animals.split("[,|.]")).map(String::trim).filter(next -> !next.isEmpty()).collect(Collectors.toList());
|
||||
|
||||
assertTrue(result.equals(Arrays.asList("Dog", "Cat", "Bird", "Cow")));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
### Relevant Articles:
|
||||
- [Join and Split Arrays and Collections in Java](http://www.baeldung.com/java-join-and-split)
|
||||
- [Introduction to Java Servlets](http://www.baeldung.com/intro-to-servlets)
|
||||
@@ -0,0 +1,23 @@
|
||||
package org.baeldung.java.lists;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
|
||||
public class ListAssertJUnitTest {
|
||||
|
||||
private final List<String> list1 = Arrays.asList("1", "2", "3", "4");
|
||||
private final List<String> list2 = Arrays.asList("1", "2", "3", "4");
|
||||
private final List<String> list3 = Arrays.asList("1", "2", "4", "3");
|
||||
|
||||
@Test
|
||||
public void whenTestingForEquality_ShouldBeEqual() throws Exception {
|
||||
assertThat(list1).isEqualTo(list2).isNotEqualTo(list3);
|
||||
|
||||
assertThat(list1.equals(list2)).isTrue();
|
||||
assertThat(list1.equals(list3)).isFalse();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package org.baeldung.java.lists;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
public class ListJUnitTest {
|
||||
|
||||
private final List<String> list1 = Arrays.asList("1", "2", "3", "4");
|
||||
private final List<String> list2 = Arrays.asList("1", "2", "3", "4");
|
||||
private final List<String> list3 = Arrays.asList("1", "2", "4", "3");
|
||||
|
||||
@Test
|
||||
public void whenTestingForEquality_ShouldBeEqual() throws Exception {
|
||||
Assert.assertEquals(list1, list2);
|
||||
Assert.assertNotSame(list1, list2);
|
||||
Assert.assertNotEquals(list1, list3);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package org.baeldung.java.lists;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
public class ListTestNgUnitTest {
|
||||
|
||||
private final List<String> list1 = Arrays.asList("1", "2", "3", "4");
|
||||
private final List<String> list2 = Arrays.asList("1", "2", "3", "4");
|
||||
private final List<String> list3 = Arrays.asList("1", "2", "4", "3");
|
||||
|
||||
@Test
|
||||
public void whenTestingForEquality_ShouldBeEqual() throws Exception {
|
||||
assertEquals(list1, list2);
|
||||
assertNotSame(list1, list2);
|
||||
assertNotEquals(list1, list3);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package org.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 ListToSTring {
|
||||
|
||||
@Test
|
||||
public void whenListToString_thenPrintDefault() {
|
||||
List<Integer> intLIst = Arrays.asList(1, 2, 3);
|
||||
System.out.println(intLIst);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCollectorsJoining_thenPrintCustom() {
|
||||
List<Integer> 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<Integer> intList = Arrays.asList(1, 2, 3);
|
||||
System.out.println(StringUtils.join(intList, "|"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
### Relevant Articles:
|
||||
- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
|
||||
Reference in New Issue
Block a user