iSharkFly-Docs/java-tutorials
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved guava set related code to guava-collections-set module

Browse Source
This commit is contained in:
Sushant 2019-05-04 12:56:10 +03:00
parent f2de02990d
commit 7dae64dd74
5 changed files with 272 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
guava-collections/src/test/java/org/baeldung/guava/GuavaMapFromSet.java → guava-collections-set/src/test/java/org/baeldung/guava/GuavaMapFromSet.java
View File

@ -1,14 +1,9 @@
package org.baeldung.guava;
import java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import com.google.common.base.Function;
import java.util.*;
public class GuavaMapFromSet<K, V> extends AbstractMap<K, V> {
private class SingleEntry implements Entry<K, V> {
@ -54,7 +49,7 @@ public class GuavaMapFromSet<K, V> extends AbstractMap<K, V> {
}
@Override
public Map.Entry<K, V> next() {
public Entry<K, V> next() {
K key = this.inner.next();
return new SingleEntry(key);
}
@ -72,7 +67,7 @@ public class GuavaMapFromSet<K, V> extends AbstractMap<K, V> {
}
@Override
public Iterator<Map.Entry<K, V>> iterator() {
public Iterator<Entry<K, V>> iterator() {
return new EntryIterator();
}
@ -94,7 +89,7 @@ public class GuavaMapFromSet<K, V> extends AbstractMap<K, V> {
}
@Override
public Set<Map.Entry<K, V>> entrySet() {
public Set<Entry<K, V>> entrySet() {
return this.entries;
}

7
guava-collections/src/test/java/org/baeldung/guava/GuavaMapFromSetUnitTest.java → guava-collections-set/src/test/java/org/baeldung/guava/GuavaMapFromSetUnitTest.java
View File

@ -1,15 +1,14 @@
package org.baeldung.guava;
import static org.junit.Assert.assertTrue;
import com.google.common.base.Function;
import org.junit.Test;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.junit.Test;
import com.google.common.base.Function;
import static org.junit.Assert.assertTrue;
public class GuavaMapFromSetUnitTest {

126
guava-collections-set/src/test/java/org/baeldung/guava/GuavaRangeSetUnitTest.java Normal file
View File

@ -0,0 +1,126 @@
package org.baeldung.guava;
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import com.google.common.collect.TreeRangeSet;
import org.junit.Test;
import static org.junit.Assert.*;
public class GuavaRangeSetUnitTest {
@Test
public void givenRangeSet_whenQueryWithinRange_returnsSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 5));
numberRangeSet.add(Range.closed(6, 8));
assertTrue(numberRangeSet.contains(1));
assertFalse(numberRangeSet.contains(9));
}
@Test
public void givenRangeSet_whenEnclosesWithinRange_returnsSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 10));
numberRangeSet.add(Range.closed(15, 18));
assertTrue(numberRangeSet.encloses(Range.closed(4, 5)));
assertFalse(numberRangeSet.encloses(Range.closed(4, 11)));
}
@Test
public void givenRangeSet_whenComplementIsCalled_returnsSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 5));
numberRangeSet.add(Range.closed(6, 8));
final RangeSet<Integer> numberRangeComplementSet = numberRangeSet.complement();
assertTrue(numberRangeComplementSet.contains(-1000));
assertFalse(numberRangeComplementSet.contains(2));
assertFalse(numberRangeComplementSet.contains(3));
assertTrue(numberRangeComplementSet.contains(1000));
}
@Test
public void givenRangeSet_whenIntersectsWithinRange_returnsSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 10));
numberRangeSet.add(Range.closed(15, 18));
assertTrue(numberRangeSet.intersects(Range.closed(4, 17)));
assertFalse(numberRangeSet.intersects(Range.closed(19, 200)));
}
@Test
public void givenRangeSet_whenRemoveRangeIsCalled_removesSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 5));
numberRangeSet.add(Range.closed(6, 8));
numberRangeSet.add(Range.closed(9, 15));
numberRangeSet.remove(Range.closed(3, 5));
numberRangeSet.remove(Range.closed(7, 10));
assertTrue(numberRangeSet.contains(1));
assertFalse(numberRangeSet.contains(9));
assertTrue(numberRangeSet.contains(12));
}
@Test
public void givenRangeSet_whenSpanIsCalled_returnsSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 5));
numberRangeSet.add(Range.closed(6, 8));
final Range<Integer> experienceSpan = numberRangeSet.span();
assertEquals(0, experienceSpan.lowerEndpoint().intValue());
assertEquals(8, experienceSpan.upperEndpoint().intValue());
}
@Test
public void givenRangeSet_whenSubRangeSetIsCalled_returnsSubRangeSucessfully() {
final RangeSet<Integer> numberRangeSet = TreeRangeSet.create();
numberRangeSet.add(Range.closed(0, 2));
numberRangeSet.add(Range.closed(3, 5));
numberRangeSet.add(Range.closed(6, 8));
final RangeSet<Integer> numberSubRangeSet = numberRangeSet.subRangeSet(Range.closed(4, 14));
assertFalse(numberSubRangeSet.contains(3));
assertFalse(numberSubRangeSet.contains(14));
assertTrue(numberSubRangeSet.contains(7));
}
@Test
public void givenImmutableRangeSet_whenQueryWithinRange_returnsSucessfully() {
final RangeSet<Integer> numberRangeSet = ImmutableRangeSet.<Integer> builder()
.add(Range.closed(0, 2))
.add(Range.closed(3, 5))
.add(Range.closed(6, 8)).build();
assertTrue(numberRangeSet.contains(6));
assertFalse(numberRangeSet.contains(15));
}
@Test(expected = IllegalArgumentException.class)
public void givenImmutableRangeMap_whenRangeOverlaps_ThrowsException() {
ImmutableRangeSet.<Integer> builder()
.add(Range.closed(0, 2))
.add(Range.closed(3, 5))
.add(Range.closed(5, 8)).build();
}
}

138
guava-collections-set/src/test/java/org/baeldung/guava/GuavaSetOperationsUnitTest.java Normal file
View File

@ -0,0 +1,138 @@
package org.baeldung.guava;
import com.google.common.base.Function;
import com.google.common.base.Joiner;
import com.google.common.collect.*;
import org.junit.Test;
import java.util.List;
import java.util.Set;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
public class GuavaSetOperationsUnitTest {
@Test
public void whenCalculateUnionOfSets_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> union = Sets.union(first, second);
assertThat(union, containsInAnyOrder('a', 'b', 'c', 'd'));
}
@Test
public void whenCalculateSetsProduct_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b');
final Set<Character> second = ImmutableSet.of('c', 'd');
final Set<List<Character>> result = Sets.cartesianProduct(ImmutableList.of(first, second));
final Function<List<Character>, String> func = new Function<List<Character>, String>() {
@Override
public final String apply(final List<Character> input) {
return Joiner
.on(" ").join(input);
}
};
final Iterable<String> joined = Iterables.transform(result, func);
assertThat(joined, containsInAnyOrder("a c", "a d", "b c", "b d"));
}
@Test
public void whenCalculatingSetIntersection_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> intersection = Sets.intersection(first, second);
assertThat(intersection, containsInAnyOrder('b', 'c'));
}
@Test
public void whenCalculatingSetSymmetricDifference_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> intersection = Sets.symmetricDifference(first, second);
assertThat(intersection, containsInAnyOrder('a', 'd'));
}
@Test
public void whenCalculatingPowerSet_thenCorrect() {
final Set<Character> chars = ImmutableSet.of('a', 'b');
final Set<Set<Character>> result = Sets.powerSet(chars);
final Set<Character> empty = ImmutableSet.<Character> builder().build();
final Set<Character> a = ImmutableSet.of('a');
final Set<Character> b = ImmutableSet.of('b');
final Set<Character> aB = ImmutableSet.of('a', 'b');
assertThat(result, contains(empty, a, b, aB));
}
@Test
public void whenCreateRangeOfIntegersSet_thenCreated() {
final int start = 10;
final int end = 30;
final ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(start, end), DiscreteDomain.integers());
assertEquals(21, set.size());
assertEquals(10, set.first().intValue());
assertEquals(30, set.last().intValue());
}
@Test
public void whenCreateRangeSet_thenCreated() {
final RangeSet<Integer> rangeSet = TreeRangeSet.create();
rangeSet.add(Range.closed(1, 10));
rangeSet.add(Range.closed(12, 15));
assertEquals(2, rangeSet.asRanges().size());
rangeSet.add(Range.closed(10, 12));
assertTrue(rangeSet.encloses(Range.closed(1, 15)));
assertEquals(1, rangeSet.asRanges().size());
}
@Test
public void whenInsertDuplicatesInMultiSet_thenInserted() {
final Multiset<String> names = HashMultiset.create();
names.add("John");
names.add("Adam", 3);
names.add("John");
assertEquals(2, names.count("John"));
names.remove("John");
assertEquals(1, names.count("John"));
assertEquals(3, names.count("Adam"));
names.remove("Adam", 2);
assertEquals(1, names.count("Adam"));
}
@Test
public void whenGetTopUsingMultiSet_thenCorrect() {
final Multiset<String> names = HashMultiset.create();
names.add("John");
names.add("Adam", 5);
names.add("Jane");
names.add("Tom", 2);
final Set<String> sorted = Multisets.copyHighestCountFirst(names).elementSet();
final List<String> topTwo = Lists.newArrayList(sorted).subList(0, 2);
assertEquals(2, topTwo.size());
assertEquals("Adam", topTwo.get(0));
assertEquals("Tom", topTwo.get(1));
}
}

114
guava-collections/src/test/java/org/baeldung/guava/GuavaCollectionTypesUnitTest.java
View File

@ -111,120 +111,6 @@ public class GuavaCollectionTypesUnitTest {
assertThat(immutable, contains("John", "Adam", "Jane", "Tom"));
}
// sets
@Test
public void whenCalculateUnionOfSets_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> union = Sets.union(first, second);
assertThat(union, containsInAnyOrder('a', 'b', 'c', 'd'));
}
@Test
public void whenCalculateSetsProduct_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b');
final Set<Character> second = ImmutableSet.of('c', 'd');
final Set<List<Character>> result = Sets.cartesianProduct(ImmutableList.of(first, second));
final Function<List<Character>, String> func = new Function<List<Character>, String>() {
@Override
public final String apply(final List<Character> input) {
return Joiner.on(" ").join(input);
}
};
final Iterable<String> joined = Iterables.transform(result, func);
assertThat(joined, containsInAnyOrder("a c", "a d", "b c", "b d"));
}
@Test
public void whenCalculatingSetIntersection_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> intersection = Sets.intersection(first, second);
assertThat(intersection, containsInAnyOrder('b', 'c'));
}
@Test
public void whenCalculatingSetSymmetricDifference_thenCorrect() {
final Set<Character> first = ImmutableSet.of('a', 'b', 'c');
final Set<Character> second = ImmutableSet.of('b', 'c', 'd');
final Set<Character> intersection = Sets.symmetricDifference(first, second);
assertThat(intersection, containsInAnyOrder('a', 'd'));
}
@Test
public void whenCalculatingPowerSet_thenCorrect() {
final Set<Character> chars = ImmutableSet.of('a', 'b');
final Set<Set<Character>> result = Sets.powerSet(chars);
final Set<Character> empty = ImmutableSet.<Character> builder().build();
final Set<Character> a = ImmutableSet.of('a');
final Set<Character> b = ImmutableSet.of('b');
final Set<Character> aB = ImmutableSet.of('a', 'b');
assertThat(result, contains(empty, a, b, aB));
}
@Test
public void whenCreateRangeOfIntegersSet_thenCreated() {
final int start = 10;
final int end = 30;
final ContiguousSet<Integer> set = ContiguousSet.create(Range.closed(start, end), DiscreteDomain.integers());
assertEquals(21, set.size());
assertEquals(10, set.first().intValue());
assertEquals(30, set.last().intValue());
}
@Test
public void whenCreateRangeSet_thenCreated() {
final RangeSet<Integer> rangeSet = TreeRangeSet.create();
rangeSet.add(Range.closed(1, 10));
rangeSet.add(Range.closed(12, 15));
assertEquals(2, rangeSet.asRanges().size());
rangeSet.add(Range.closed(10, 12));
assertTrue(rangeSet.encloses(Range.closed(1, 15)));
assertEquals(1, rangeSet.asRanges().size());
}
@Test
public void whenInsertDuplicatesInMultiSet_thenInserted() {
final Multiset<String> names = HashMultiset.create();
names.add("John");
names.add("Adam", 3);
names.add("John");
assertEquals(2, names.count("John"));
names.remove("John");
assertEquals(1, names.count("John"));
assertEquals(3, names.count("Adam"));
names.remove("Adam", 2);
assertEquals(1, names.count("Adam"));
}
@Test
public void whenGetTopUsingMultiSet_thenCorrect() {
final Multiset<String> names = HashMultiset.create();
names.add("John");
names.add("Adam", 5);
names.add("Jane");
names.add("Tom", 2);
final Set<String> sorted = Multisets.copyHighestCountFirst(names).elementSet();
final List<String> topTwo = Lists.newArrayList(sorted).subList(0, 2);
assertEquals(2, topTwo.size());
assertEquals("Adam", topTwo.get(0));
assertEquals("Tom", topTwo.get(1));
}
@Test
public void whenCreateImmutableMap_thenCreated() {
final Map<String, Integer> salary = ImmutableMap.<String, Integer> builder().put("John", 1000).put("Jane", 1500).put("Adam", 2000).put("Tom", 2000).build();