CollectionsHelper.java

package playground;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * Helps determine which collection to use.
 * 
 * NOTE: this should only be used to guide your choices, always read the Java documentation of the class of the returned instance.
 * 
 * This helper only covers some of the common List and Set collections.
 * 
 * @author Christophe Roussy
 */
public class CollectionsHelper {

 // https://www.geeksforgeeks.org/difference-between-linkedlist-and-linkedhashset-in-java/
 // https://javatutorial.net/choose-the-right-java-collection
 // http://anh.cs.luc.edu/363/notes/06A_Amortizing.html
 // https://www.developer.com/java/article.php/10922_3829891_2/Selecting-the-Best-Java-Collection-Class-for-Your-Application.htm
 // https://stackoverflow.com/questions/21974361/which-java-collection-should-i-use

 /**
 * NOTE: this should only be used to guide your choices, always read the Java documentation of the class of the returned instance.
 */
 public static final <T> Collection<T> buildCollectionWithDuplicates(

 final boolean isRandomAccessByPosition, // 1

 final boolean isForContainsChecks, // 2

 final boolean isForInsertOrRemoveAtStart, // 3

 final boolean isForQueue, // 4

 final boolean isSupportsNulls, // 5

 final int capacityHint // 6

 ) {
 // --- CAN HAVE DUPLICATES ---
 // Cannot be a SET.
 // https://stackoverflow.com/questions/322715/when-to-use-linkedlist-over-arraylist-in-java
 if (isRandomAccessByPosition || isForContainsChecks) {
 return new ArrayList<T>(capacityHint);
 }
 if (isForInsertOrRemoveAtStart) {
 if (isForQueue && !isSupportsNulls) {
 // https://docs.oracle.com/javase/6/docs/api/java/util/ArrayDeque.html
 // https://stackoverflow.com/questions/6163166/why-is-arraydeque-better-than-linkedlist
 return new ArrayDeque<T>(capacityHint);
 }
 return new LinkedList<T>(); // Consumes a lot of memory.
 }
 return new ArrayList<T>(capacityHint);
 }

 /**
 * NOTE: this should only be used to guide your choices, always read the Java documentation of the class of the returned instance.
 */
 public static final <T> Collection<T> buildCollectionWithDuplicatesWithThreads(

 final boolean isForMoreReadsThanWrites, // 1

 final int capacityHint // 2

 ) {
 // --- CAN HAVE DUPLICATES ---
 // Cannot be a SET.
 // https://stackoverflow.com/questions/322715/when-to-use-linkedlist-over-arraylist-in-java
 // https://stackoverflow.com/questions/28979488/difference-between-copyonwritearraylist-and-synchronizedlist
 if (isForMoreReadsThanWrites) {
 // COWAL does not throw ConcurrentModificationException, good for reads, bad for writes.
 return new CopyOnWriteArrayList<T>(); // COWAL
 }
 // Iterating must be synchronized.
 return Collections.synchronizedList(new ArrayList<T>(capacityHint));
 }

 /**
 * NOTE: this should only be used to guide your choices, always read the Java documentation of the class of the returned instance.
 */
 public static final <T> Collection<T> buildCollectionWithoutDuplicates(

 final boolean isPreserveInsertionOrder, // 1

 final boolean isForSortWithComparator, // 2

 final int capacityHint // 3

 ) {
 // --- NO DUPLICATES ---
 // Can be a SET.
 // https://stackoverflow.com/questions/20116660/hashset-vs-treeset-vs-linkedhashset-on-basis-of-adding-duplicate-value
 if (isPreserveInsertionOrder && isForSortWithComparator) {
 throw new AssertionError("Preserving insertion order and sorting by comparator is not compatible !");
 }
 if (isPreserveInsertionOrder) {
 return new LinkedHashSet<T>(capacityHint);
 }
 if (isForSortWithComparator) {
 return new TreeSet<T>();
 }
 return new HashSet<T>(capacityHint);
 }

 /**
 * NOTE: this should only be used to guide your choices, always read the Java documentation of the class of the returned instance.
 */
 public static final <T> Collection<T> buildCollectionWithoutDuplicatesWithThreads(

 final boolean isForMoreReadsThanWrites, // 1

 final boolean isForSortWithComparator // 2

 ) {
 // --- NO DUPLICATES ---
 // Can be a SET.
 // https://stackoverflow.com/questions/29249714/when-is-copyonwritearrayset-useful-to-achieve-thread-safe-hashset
 // https://stackoverflow.com/questions/6720396/different-types-of-thread-safe-sets-in-java
 if (isForSortWithComparator) {
 return new ConcurrentSkipListSet<T>();
 }
 if (isForMoreReadsThanWrites) {
 return new CopyOnWriteArraySet<T>();
 }
 return Collections.synchronizedSet(new HashSet<T>());
 }

 public static void main(final String[] args) {
 // Some examples:
 // --- WITH DUPLICATES.
 {
 final Collection<String> collection = buildCollectionWithDuplicates(true, false, true, true, true, 16);
 System.out.println(collection instanceof ArrayList<?>);
 System.out.println(collection.getClass().getName());
 }
 {
 final Collection<String> collection = buildCollectionWithDuplicatesWithThreads(true, 16);
 System.out.println(collection instanceof CopyOnWriteArrayList<?>);
 System.out.println(collection.getClass().getName());
 }
 {
 final Collection<String> collection = buildCollectionWithDuplicates(false, false, true, true, true, 16);
 System.out.println(collection instanceof LinkedList<?>);
 System.out.println(collection.getClass().getName());
 }
 // --- WITHOUT DUPLICATES.
 {
 final Collection<String> collection = buildCollectionWithoutDuplicates(true, false, 16);
 System.out.println(collection instanceof LinkedHashSet<?>);
 System.out.println(collection.getClass().getName());
 }
 {
 final Collection<String> collection = buildCollectionWithoutDuplicates(false, true, 16);
 System.out.println(collection instanceof TreeSet<?>);
 System.out.println(collection.getClass().getName());
 }
 {
 final Collection<String> collection = buildCollectionWithoutDuplicatesWithThreads(true, false);
 System.out.println(collection instanceof CopyOnWriteArraySet<?>);
 System.out.println(collection.getClass().getName());
 }
 }

}