Open Source Collections in Java

Welcome to the blog about Collections in Java. In this article, I am going to introduce a concept of Apache Commons, Guava, Fastutil, Trove, and Goldman Sachs Collections libraries, as well as their Interfaces, Classes, and Methods supported by examples. I hope you will enjoy the content and gain some new experience.

The Collection in Java provides an architecture to manipulate with the group of objects. The collections provide:

More about these points I’ll explain below, and they will be categorized by different libraries.

Apache Commons Collections

In this section, we will focus on Apache Commons Collections, what exactly this library provides; how to implement the library; its Interfaces, Classes, and Methods, provided with examples on how to ignore Null values, merge lists, and use Bags, BidiMaps, or MapIterator.

Apache Commons Collections provide the following features:

How to use a library: To use this library, all you have to do is to insert dependency code into your project. Assuming that you know how to use Maven, you can find the code on the official website:

  <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
  <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-collections4</artifactId>
        <version>4.1</version>
  </dependency>

More information about Maven, and how to use it, you can find in this article.

The other way you can apply Apache Commons Collections is throught downloading the library from the official website. When applying this one, you need to extract your commons-collections4-4.2-bin.tar.gz with WinRar and open your environment (Eclipse). After creating a project, go to Build Path - Configure Build Path… - choose Libraries - click Add External JARs… - finally, locate your extracted folder and import all the jars.

Synchronization: Apache Commons Collections and Java collections have a similar synchronization solution. The bulk of the various implementations of Collections, Maps, and Bags are not thread safe without additional synchronization, therefore synchronizeXXX method on Collections is recommended for these implementations in order to be synchronized in a multithreaded application use.

Below, you can find some Interfaces from Package org.apache.commons.collections4, supported by Apache Commons Collections. For further information feel free to check the official website:

Interfaces Description
Bag<E> A Collection that counts the number of times an object appears in the collection
SortedBag<E> Type of Bag that maintains a sorted order among its unique representative members
BidiMap<K, V> A Map that allows Bi-Directional lookup between key and values
OrderedBidiMap<K, V> A Map that allows Bi-Directional lookup between key and values and retains and provides access to an ordering
SortedBidiMap<K, V> A Map that allows bidirectional lookup between key and values and retains both keys and values in sorted order
Equator<T> A function which determines equality between objects of type T
Get<K, V> The "read" subset of the Map interface
IterableGet<K, V> The "read" subset of the Map interface
IterableMap<K, V> A Map that can be iterated directly without creating an entry set
KeyValue<K, V> A key-value pair
ListValuedMap<K, V> A Map that holds a list of values against each key
MultiValuedMap<K, V> A Map that holds a collection of values against each key
MultiSet<E> A Collection that counts the number of times an object appears in the collection
Unmodifiable Marker interface for collections, maps, and iterators that are unmodifiable

Below, you can find some Classes from Package org.apache.commons.collections4 supported by Apache Commons Collections. For further information feel free to check the official website:

Classes Description
BagUtils Provides utility methods and decorators for Bag and SortedBag instances
CollectionUtils Provides utility methods and decorators for Collection instances
EnumerationUtils Provides utility methods for Enumeration instances
ListUtils Provides utility methods and decorators for List instances
MapUtils Provides utility methods and decorators for Map and SortedMap instances
QueueUtils Provides utility methods and decorators for Queue instances
SetUtils Provides utility methods and decorators for Set and SortedSet instances

In Apache Commons Collections exist 19 Packages with diverse Interfaces, Classes, and Methods. We shared only a few Interfaces and Classes from one Package and highly encourage you to check the others on the official website, therefore we can focus more on the practical examples.

Example - Ignore Null values

        List<String> list = new LinkedList<String>();
    
        list.add("Apple");
      CollectionUtils.addIgnoreNull(list, "Avocado");
        list.add("Orange");
        CollectionUtils.addIgnoreNull(list, null);
        list.add("Banana");
      
        System.out.println(list);

        if(list.contains(null)) {
          System.out.println("Null value is present");
        } else {
          System.out.println("Null value is not present");
        }
        /*
        As you can see at the end, in the list NULL value does not exist.
  Method addIgnoreNull is very useful if you want to forbid NULL values in your lists.
        */

Example - Merging lists

  List<String> list1 = new LinkedList<String>();
    List<String> list2 = new LinkedList<String>();
        
  list1.add("Banana");
  list1.add("Apple");
        
  list2.add("Orange");
     
  List<String> sortedList = CollectionUtils.collate(list1, list2);
      
  System.out.println(sortedList);
      
  //This method makes it easier to combine multiple lists 

Example - Bags usage

        //Create Bag
        Bag<String> bag = new HashBag<>();

        //Add "Banana" five times to the bag
        bag.add("Banana", 5);
      
        //Add "Orange" one time to the bag
        bag.add("Orange");
      
        //Add "Apple" two times to the bag
        bag.add("Apple", 2);
      
        //Show content of the Bag
        System.out.println("Bag content: " + bag);
      
        //Show the set of unique values in the bag
        System.out.println("Unique values: " + bag.uniqueSet());
      
        //Show the number of "Apple" present in bag
        System.out.println("Apple is presented " + bag.getCount("Apple") + " times.");
      
        //Remove 2 appearances of "Banana" from the bag
        bag.remove("Banana", 2);
      
        //Show content of the Bag
        System.out.println("Content of the bag after removed 2 appearances of Banana: " + bag);
      
        //Show the number of "Banana" present in bag
        System.out.println("Banana is present " + bag.getCount("Banana") + " times.");

Example - BidiMap usage

        //Create BidiMap
        BidiMap<String, String> bidiMap = new TreeBidiMap<>();

        //Add keys and values
        bidiMap.put("Banana", "fruit");
        bidiMap.put("BMW", "car");
        bidiMap.put("Red", "color");
      
        //Show BidiMap content
        System.out.println("Content of bidiMap: " + bidiMap);
      
        //Show the value of Banana key
        System.out.println("The value of Banana key is: " + bidiMap.get("Banana")); 
      
        //Show the key of fruit value
        System.out.println("The key of fruit value is: " + bidiMap.getKey("fruit"));
  
        //Remove by value fruit
        bidiMap.removeValue("fruit");
        System.out.println("BidiMap content after removed value: " + bidiMap);
      
        //Remove by key BMW
        bidiMap.remove("BMW");
        System.out.println("BidiMap content after removed key: " + bidiMap);
        
        bidiMap.put("Banana", "fruit");
        bidiMap.put("BMW", "car");
        System.out.println(bidiMap);
      
        //Create new BidiMap to show method used to replace the site of key/value
        BidiMap<String, String> inversedBidiMap = bidiMap.inverseBidiMap();  
      System.out.println("Inversed BidiMap: " + inversedBidiMap);

Example - MapIterator usage

        //Create IterableMap
  IterableMap<String, String> iterableMap = new HashedMap<>();

  //Add keys and values
  iterableMap.put("Banana", "fruit");
  iterableMap.put("BMW", "car");
  iterableMap.put("Red", "color");

  //Create MapIterator
  MapIterator<String, String> mapIterator = iterableMap.mapIterator();
        
  //Go through MapIterator
  while (mapIterator.hasNext()) {
          
    //Put a key in variable key with type Object
          Object key = mapIterator.next();
            
          //Put value in variable value with type Object
          Object value = mapIterator.getValue();
  
          //Show content of key and value in this iteration
          System.out.println("Key is: " + key + ", and value is: " + value);
  }
      
  //Show IterableMap content
  System.out.println("Content of the IterableMap is: " + iterableMap);
        
  //Remove key "Banana"
  iterableMap.remove("Banana");
  System.out.println("Content of the IterableMap after change is: " + iterableMap);
        
  //Change the value of key "BMW"
  iterableMap.replace("BMW", "color");
  System.out.println("Content of the IterableMap after change is: " + iterableMap);

Guava - Google’s Collections

In this section, we will focus on Guava and how to take advantage of it in order to get easier and faster code writing; what benefits this library provides; how to implement the library, its Interfaces, Classes, and Methods, provided with evidences on how to use MultiSet, MultiMap, Optional & Ordering Classes.

As well as Apache Commons Collections, Guava represents an open source set of libraries. Guava is created by Google and provides the following benefits:

Guava provides static methods to facilitate the declaration of a variable, like it’s mentioned below:

  List<String> list = new ArrayList<String>();
  list.add("Banana");
  list.add("Apple");
  list.add("Avocado");
  list.add("Orange");

  // Or simplier
  List<String> list2 = Lists.newArrayList("Banana", "Apple", "Avocado", "Orange");
  List<Map<String, String>> map = new LinkedList<Map<String, String>>();

  //Or simplier
  List<Map<String, String>> map2 = Lists.newLinkedList();

Now you can sum up all the information and conclude, that writing a code is much easier with Guava.

How to use the library: Dependancy for Maven’s library importation is listed hereafter:

  <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
  <dependency>
      <groupId>com.google.guava</groupId>
      <artifactId>guava</artifactId>
        <version>19.0</version>
  </dependency>

More information about Maven, and how to use it, you can find in this article.

Below, you can find some Interfaces from Package com.google.common.collect, supported by Guava. For further information feel free to check the official website:

Interfaces Description
BiMap<K, V> A Bidirectional Map that preserves the uniqueness of its values and keys
ListMultimap<K, V> A Multimap that can hold duplicate key-value pairs and maintains the insertion ordering of values for a given key
Multimap<K, V> A Collection that maps keys to values, similar to Map, but each key may be associated with multiple values
Multiset<E> A Collection that supports order-independent equality, like Set, but may have duplicate elements
Table<R, C, V> A Collection that associates an ordered pair of keys, called a row key and a column key, with a single value

Below, you can find some Classes from Package com.google.common.collect supported by Guava. For further information feel free to check the official website:

Classes Description
ArrayListMultimap<K, V> A Multimap that uses an ArrayList to store the values for a given key
ArrayTable<R, C, V> Fixed-size Table implementation backed by a two-dimensional array
ImmutableBiMap<K, V> A BiMap whose content will never change
ImmutableList<E> A List whose content will never change
LinkedListMultimap<K, V> A ListMultimap that supports deterministic iteration order for both keys and values
Ordering<T> A Comparator with additional methods to support common operations

In Guava exist 16 Packages with numerous Interfaces, Classes, and Methods. We shared only a few Interfaces and Classes from one Package and encourage you to check the others on the official website.

Example - MultiSet

  /*
  A Multiset is not a Set, it represents a bag which contains some sets of elements.
  */
  
    // Create Multiset
    Multiset<String> multiSet = HashMultiset.create();
     
    // Add values
    multiSet.add("Banana");
    multiSet.add("Apple");
    multiSet.add("Orange");
    multiSet.add("Avocado");
    multiSet.add("Banana");
     
    System.out.println("Number of elements in multiSet: " + multiSet.size());

    System.out.println("Number of Banana in multiSet: " + multiSet.count("Banana"));
     
    // Delete element Banana
    multiSet.remove("Banana");
    System.out.println("Number of elements in multiSet: " + multiSet.size());
    System.out.println("Number of Banana in multiSet: " + multiSet.count("Banana"));

Example - MultiMap

  /*
  A MultiMap is like a Map, although it may contain duplicated keys and provides 
  an easy way to handle mapping from keys to a collection of values.
  */

        //Create MultiMap
        Multimap<String,String> multiMap = ArrayListMultimap.create();
         
        //Add values
        multiMap.put("fruit", "Banana");
        multiMap.put("fruit", "Apple");
        multiMap.put("fruit", "Banana");
        multiMap.put("fruit", "Avocado");
        multiMap.put("fruit", "Orange");
          
        multiMap.put("car", "BMW");
        multiMap.put("car", "BMW");
        multiMap.put("car", "Opel");
        multiMap.put("car", "Fiat");
   
        System.out.println("Total items in multiMap: " + multiMap.size());
        System.out.println("Total fruits in multiMap: " + multiMap.get("fruit").size());
        System.out.println("fruits in multiMap: " + multiMap.get("fruit"));
         
        //Remove value Banana with key fruit
        multiMap.remove("fruit", "Banana");
         
        //There is still 1 Banana
        System.out.println("Total items in multiMap: " + multiMap.size());
        System.out.println("Total fruits in multiMap: " + multiMap.get("fruit").size());
        System.out.println("fruits in multiMap: " + multiMap.get("fruit"));         
        System.out.println("Total items in car: " + multiMap.get("car").size());
        System.out.println("car Items: " + multiMap.get("car"));  

Example - Optional usage

  /*
  The Optional object is used to represent null with absent value.
  */

        OptionalDemo optionalDemo = new OptionalDemo();

        Integer value =  null;
        Integer value2 =  new Integer(11);
        Integer value3 =  new Integer(5);
        Integer value4 =  null;
        Integer value5 =  null;
      
        //Allows NULL value
        Optional<Integer> x = Optional.fromNullable(value);
      
        //Does not allow NULL value
        Optional<Integer> y = Optional.of(value2);
      
        //Does not allow NULL value
        Optional<Integer> z = Optional.of(value3);

        //Does not allow NULL value
        //Optional<Integer> v = Optional.of(value4); This throws NullPointerException

        //Allows NULL value
        Optional<Integer> w = Optional.fromNullable(value5);

        System.out.println(optionalDemo.calculation(x, y, z, w));

    public Integer calculation(Optional<Integer> x, Optional<Integer> y, 
    Optional<Integer> z, Optional<Integer> w) {
           
          System.out.println("x is present: " + x.isPresent());
          System.out.println("y is present: " + y.isPresent());
          System.out.println("z is present: " + z.isPresent());
          System.out.println("w is present: " + w.isPresent());

          //Returns the value if present otherwise returns the default value passed
          Integer value1 = x.or(new Integer(0));  
          System.out.println(value1);

          //Gets the value, value should be present
          Integer value2 = y.get();
          System.out.println(value2);
      
          Integer value3 = z.get();
          System.out.println(value3);
      
          //Integer value5 = w.get(); Can't be called because of an absent value

          return value1 + value2 - value3;
    }

Example - Ordering

        // Create Lists
        List<Integer> numbers = Lists.newArrayList(1,7,4,22,1,-13,222);
        List<String> fruits = Lists.newArrayList("Banana","Avocado","Banana","Orange","Apple");

        // Create Ordering
        Ordering ordering = Ordering.natural();
        System.out.println("Numbers: " + numbers);      
        System.out.println("Fruits: " + fruits);
        
        // Sort elements
        Collections.sort(numbers,ordering);
        Collections.sort(fruits,ordering);
        System.out.println("Sorted numbers: " + numbers);      
        System.out.println("Sorted numbers: " + fruits);
       
        // Sort descending
        Collections.sort(fruits,ordering.reverse());
        System.out.println("Reverse: " + fruits);

        numbers.add(null);
        System.out.println("Null added to Sorted numbers: " + numbers); 

        Collections.sort(numbers,ordering.nullsFirst());
        System.out.println("Null at first position: " + numbers);

FastUtil Collections

In this section, we’ll focus on FastUtil and why it takes the 1st place in performance tests; what this library provides; how to implement the library, its Interfaces, Classes, and Methods; provided with evidences on how to use DoubleArrayList, Long2IntArrayMap & create Read-Only and Sorted Maps.

FastUtil characterizes high performance and the fastest implementations available. Some benefits it provides are listed below:

Speed test: According to the benchmarks, FastUtil has the title of the “fastest” implementation. This title is justified with the following benefits:

For further information, feel free to check this website, and we highly recommend you to try performing your own tests.

In addition to the advantages FastUtil provides, you need to pay attention to the following shortcomings. For further information, feel free to check the official website:

Another characteristic is a huge jar file, because of numerous Classes. Thus, you can customize it and use the alternative way of selecting specific Classes.

How to use a library: Dependancy for Maven’s library importation is listed hereafter:

  <!-- https://mvnrepository.com/artifact/it.unimi.dsi/fastutil -->
  <dependency>
        <groupId>it.unimi.dsi</groupId>
        <artifactId>fastutil</artifactId>
        <version>8.1.0</version>
  </dependency>

More information about Maven, and how to use it, you can find in this article.

Below, you can find some Interfaces from Package it.unimi.dsi.fastutil, supported by FastUtil. For further information feel free to check the official website:

Interfaces Description
BidirectionalIterator<K> A Bidirectional Iterator
BigList<K> A list with big indices (64-bit)
BigSwapper An object that can swap elements whose positions are specified by longs
Function<K, V> A function mapping keys into values
PriorityQueue<K> A Priority Queue

Below, you can find some Classes from Package it.unimi.dsi.fastutil.ints supported by FastUtil. For further information feel free to check the official website:

Classes Description
Int2BooleanFunctions.Singleton An immutable class representing a type-specific singleton function
Int2ByteFunctions.SynchronizedFunction A synchronized wrapper class for functions
Int2CharMaps.Singleton An immutable class representing a type-specific singleton map
Int2DoubleSortedMaps A class providing static methods and objects that do useful things with type-specific sorted maps
Int2FloatSortedMaps.Singleton An immutable class representing a type-specific singleton sorted map
Int2IntMaps.UnmodifiableMap An unmodifiable wrapper class for maps

In FastUtil exist 11 Packages with numerous Interfaces, Classes, and Methods. We shared only a few Interfaces and Classes and encourage you to check the others on the official website.

Example - DoubleArrayList

  // Create DoubleArrayList
  DoubleArrayList dal = new DoubleArrayList();  
      
  // Add values - Note that there are 2 ways of adding values push and add
  dal.push(11);  
  dal.push(2.5);  
  dal.push(13.5);  
  dal.add(7.5);  
  dal.add(22.5);
  dal.add(11);
      
  System.out.println(dal);
      
  // Check if there is element with value 11
  System.out.println(dal.contains(11));
      
  // Show element on 0th position
  // Note that there are 2 ways of showing values on position 0 peek and get
  System.out.println(dal.peek(0)); 
      
  // Remove element with value 11
  dal.rem(11);
  System.out.println(dal);
      
  // Show element on 0th position
  System.out.println(dal.get(0));
      
  // Remove element - There are few ways of removing elements pop, rem, remove
  dal.pop();
  System.out.println(dal);
      
  // Show the last element in dal
  System.out.println(dal.get(dal.size() - 1));

Example - Long2IntArrayMap

  // Create Long2IntArrayMap
  Long2IntArrayMap map = new Long2IntArrayMap();
    
  // Add values
  map.put(1, 25512);
  map.put(22, 21231);
  map.put(15, 123124);
  map.put(10L, 11231123);
    
  // Remove value
  map.remove(10L);
    
  // Show element with key 22
  System.out.println(map.get(22));
    
  // Set default value to show if key is not found
  map.defaultReturnValue(-1);
  System.out.println(map.get(14));
    
  System.out.println(map);
  
  // Delete all values from map
  map.clear();
  System.out.println(map);

Example - Read-Only and Sorted Maps

  // Create Int2IntMap
  Int2IntMap map = new Int2IntArrayMap();
    
  // Add elements
  map.put(1, 12);
  map.put(12, 4);
  map.put(3, 8);
  map.put(4, 4);
    
  System.out.println(map);
  
  // Create read-only Map, which prohibits the entry of new elements or any changes on the map
  Int2IntMap map2 = Int2IntMaps.unmodifiable(map);
  // map2.put(5, 5); Throws an Exception
  // map2.remove(1); Throws an Exception
  
  // Create Int2IntSortedMap
  Int2IntSortedMap map3 = new Int2IntAVLTreeMap();
    
  // Add elements
  map3.put(1, 12);
  map3.put(12, 4);
  map3.put(3, 8);
  map3.put(4, 4);
  System.out.println(map3);
  
  // Create read-only sorted Map
  Int2IntSortedMap sortedMap = Int2IntSortedMaps.unmodifiable(map3);

Trove Library

In this section, we will focus on Trove, what this library provide; how to implement the library, its Interfaces, Classes, and Methods, supported by examples of ArrayLists, Sets, and Maps.

Trove, in contrast to FastUtil, is significantly smaller. The obvious advantages of this library are high speed regular and primitive Collections, as well as reduced memory consumption. A fascinating feature is that almost all the Classes and Interfaces start with “T”. Trove allows storing primitive data types in Collections, which is especially useful if there is a large ArrayList/Set/Map with keys or values that could be of a primitive type.

Here, the most important Collections are ArrayLists, Sets, and Maps, whereas SortedMaps and Maps with a fixed iteration order do not exist. To conclude from the text below, the Trove Maps and Sets use open addressing instead of the chaining approach.

How to use a library: To use this library, all you have to do is to insert Maven’s dependency code to your project.

  <!-- https://mvnrepository.com/artifact/net.sf.trove4j/trove4j -->
  <dependency>
        <groupId>net.sf.trove4j</groupId>
        <artifactId>trove4j</artifactId>
        <version>3.0.3</version>
  </dependency>

More information about Maven, and how to use it, you can find in this article.

Below, you can find some Interfaces supported by Trove. For further information feel free to check the official website:

Interfaces Description
TDoubleDoubleMap A primitive Map of double keys and values
TFloatIntMap A primitive Map of float keys and int values
TIntFloatMap A primitive Map of int keys and float values
TDoubleSet A Set that uses an open-addressed hash table to store its contents
TIntSet A Set that uses an open-addressed hash table to store its contents

Below, you can find some Classes supported by Trove. For further information feel free to check the official website:

Classes Description
TCollections Trove equivalent of the Collections Class
TDoubleArrayList A resizable ArrayList of double primitives
TLongArrayList A resizable ArrayList of long primitives

Example - ArrayList

      // Create ArrayList
      TIntArrayList x = new TIntArrayList();
      
      // Add values
      x.add(new int[]{11,2,14,7,22,2});
      System.out.println(x);
      
      // Remove element with value 2
      x.remove(2);
      
      // Sort x - it is must for binarySearch method
      x.sort();
      System.out.println(x);
      
      // Show element position in x, by value
      // If method did not find value, returns -1
      System.out.println(x.binarySearch(1)); 
      System.out.println(x.binarySearch(11));
      
      System.out.println("Max value is: " + x.max() + ", and min value is: " + x.min());
      
      // Reverse elements on positions 2, 3 and 4
      x.reverse(2, 5);
      
      // Show x if procedure is true
      System.out.println(x.grep(new TIntProcedure() {
      
    public boolean execute(int value) {
      return 1==1;
    }
  }));

Example - Set

      // Create ArrayList
      TDoubleSet x = new TDoubleHashSet();
      
      // Add values
      x.addAll(new double[]{11.5,2.3,14,7.1,22,2.3});
      System.out.println(x);
      
      // Remove element with value 2
      x.remove(2.3);
      System.out.println(x);
      
      // Create iterator
      TDoubleIterator iterator = x.iterator();
      
      // Show elements
      while (iterator.hasNext()) System.out.println(iterator.next()); 

Example - Map

      // Create Map
      TIntIntMap x = new TIntIntHashMap();
      
      // Add values
      x.put(1, 12);
      x.put(11, 12);
      x.put(2, 2);
      x.put(5, 10);
      x.put(12, 20);
      System.out.println(x);
      
      // Remove element with value 2
      x.remove(5);
      System.out.println(x);
      
      // Create iterator
      TIntIntIterator iterator = x.iterator();

      // Show elements
      while (iterator.hasNext()) {        
          // Advance() method is must to show keys and values of Map
        iterator.advance();
        System.out.println("Key: " + iterator.key() + ", value: " + iterator.value());    
      }

Goldman Sachs Collections (Eclipse Collections)

In this section, we will focus on GS Collections and you’ll see the elements this library is similar to four previously mentioned libraries; what this library provides and what are the most used iteration patterns; how to implement the library, its Interfaces, Classes, and Methods, supported by examples about how to use Bags, BiMaps, Lists, Sets & their transformations from one to another; and plenty of useful Methods provided by these Collections.

Just like Trove, Goldman Sachs Collections is optimized for performance and memory usage. It allows storing primitive data types in Collections. Its focus is on the iterative improvment and has the possibility of creating Immutable Collections, Bags, Multimaps, BiMaps, and Intervals. Alike Guava, writing the code is much easier with Goldman Sachs Collections. This library provides sort(), min(), max(), select(), collect() methods for all kinds of Collections.

How to use a library: To use this library, all you have to do is to insert Maven’s dependency code to your project.

  <!-- https://mvnrepository.com/artifact/com.goldmansachs/gs-collections-forkjoin -->
  <dependency>
        <groupId>com.goldmansachs</groupId>
        <artifactId>gs-collections-forkjoin</artifactId>
        <version>7.0.1</version>
  </dependency>

More information about Maven, and how to use it, you can find in this article.

According to the official website, the most used iteration patterns in Goldman Sachs Collections are:

More about patterns you can find on official links: link1, link2, and link3.

Below, you can find some Interfaces supported by Goldman Sachs Collections. For further information feel free to check the official website:

Interfaces Description
Bag<T> A Bag whose elements are unordered and may contain duplicate entries
ImmutableSortedBag<T> A sorted Bag that is immutable
BiMap<K, V> A Map that allows bidirectional lookup between key and values
MapIterable<K, V> A Read-only Map
Multimap<K, V> A Map that can associate multiple values for keys
ImmutableSortedSet<T> A non-modifiable sorted Set

Below, you can find some Classes supported by Goldman Sachs Collections. For further information feel free to check the official website:

</tr>
Classes Description
SynchronizedBag<T> A synchronized view of a MutableBag
ImmutableArrayBag<T> A non-modifiable Array Bag
DropIterator<T> Iterates over the elements of the iterator skipping the first count elements or the full iterator if the count is non-positive

Example - Bag

      // Create immutable bag and add values - all in one line of code
      Bag<String> bag = Bags.immutable.of("Banana", "Avocado", "Apple", "Orange", "Avocado", "Avocado");
      
      System.out.println(bag);      
      System.out.println("First element is: " + bag.getFirst() + ", and last element is: " + bag.getLast());
      System.out.println("Number of different elements in bag: " + bag.sizeDistinct());
      System.out.println("Number of all elements in bag: " + bag.size());
      
      // Transform bag to a list
      List<String> list = bag.toList();
      
      System.out.println("Elements in list: " + list);
      
      // List is mutable, in opposite of created immutable bag, so we can add values
      list.add("Kiwi");
      
      // Create comparator so we can sort the list
      Comparator<? super String> comparator = Comparators.reverseNaturalOrder();
      list.sort(comparator);
      System.out.println("Elements in list after change: " + list);

Example - BiMap

      // Create BiMap and add elements
      BiMap<Integer, String> map = BiMaps.mutable.of(1,"Banana",22,"Avocado",5,"Kiwi",7,"Orange");
      ((MutableBiMap<Integer, String>) map).put(3,"Apple");
      
      System.out.println("Keys in map: " + map.keysView() + ", values in map: " + map.valuesView());
      
      // Transform map to mutable list
      MutableList<String> mutableList = map.toSortedList();
      mutableList.add("Orange");
      System.out.println(mutableList);
      
      // Transform mutable to immutable list
      ImmutableList<String> immutableList = mutableList.toImmutable();   

Example - List

      // Create IntList and add values
      IntList list = IntLists.mutable.of(1,4,5,22,13);  
      ((MutableIntCollection) list).add(11);
    
      System.out.println("The average value of elements in list is: " + list.average());
      
      // Create MutableList and add values
      MutableList<String> fruits = FastList.newListWith("Banana","Orange","Apple","Kiwi","Avocado");
      System.out.println(fruits);
      
  // Create MutableListMultimap and add values from fruits with keys expressed in the number of letters each word contains
  MutableListMultimap<Integer, String> multimap = fruits.groupBy(StringFunctions.length());
      System.out.println(multimap);
  
      // Create Map
      Map<Integer, String> map = new HashMap();
        
      // Add keys from list and values from fruits to a Map
      for(int i = 0; i < list.size() - 1; i++) 
        map.put(list.get(i), fruits.get(i));
      
      System.out.println(map);  

Example - Set

      // Create ImmutableDoubleSet and add values
      ImmutableDoubleSet set = DoubleSets.immutable.of(4.2,3.3,15.5,8.4);
      
      // Show elements stored in Set
      set.forEach((DoubleProcedure) System.out::println);
      System.out.println("Max value is: " + set.max());
      System.out.println("Min value is: " + set.min());
      System.out.println("Average value is: " + set.average());
      
      // Method freeze() returns a copy similar to immutable
      ImmutableDoubleSet set2 = (ImmutableDoubleSet) set.freeze();
      
      // Transform Set to sorted List
      DoubleList list = set2.toSortedList();
      
      // Elements are sorted by value
      list.forEach((DoubleProcedure) System.out::println);

If you like this article, you may be interested in Lists, Sets, Maps, Queues, and Deques. Feel free to browse.