The Collection Interface

Collections are objects that group multiple elements and store, retrieve, and manipulate those elements. The Collection interface is at the root of the collection hierarchy. Subinterfaces of Collection include List, Queue, and Set. Table 15-1 shows these interfaces and whether they are ordered or allow duplicates. The Map interface is also included in the table, as it is part of the framework.

Implementations

Table 15-2 lists commonly used collection type implementations, their interfaces, and whether or not they are ordered, sorted, and/or contain duplicates.

Collection Framework Methods

The subinterfaces of the Collection interface provide several valuable method signatures, as shown in Table 15-3.

Collection.stream() returns a sequential Stream with the context collection as its source. Collection.parallelStream() returns a parallel Stream with the context collection as its source.

Collections Class Algorithms

The Collections class, not to be confused with the Collection interface, contains several valuable static methods (e.g., algorithms). These methods can be invoked on a variety of collection types. Table 15-4 shows commonly used Collection class methods, their acceptable parameters, and return values.

See Chapter 16 for more information on typed parameters (e.g., <T>).

Algorithm Efficiencies

Algorithms and data structures are optimized for different reasons—some for random element access or insertion/deletion, others for keeping things in order. Depending on your needs, you may have to switch algorithms and structures.

Common collection algorithms, their types, and average time efficiencies are shown in Table 15-5.

The Big O notation is used to indicate time efficiencies, where n is the number of elements (see Table 15-6).

Comparator Functional Interface

Several methods in the Collections class assume that the objects in the collection are comparable. If there is no natural ordering, a helper class can implement the Comparator functional interface to specify how the objects are to be ordered. The code example here orders surnames by their generated metaphone codes:

import org.apache.commons.codec.language.Metaphone;
public class MetaphoneCode {
  private String metaphoneCode;
  public MetaphoneCode(String surname) {
    Metaphone m = new Metaphone();
    metaphoneCode = m.metaphone(surname) + "(" + surname + ")";
  }
  public String getMetaphoneCode() {
    return metaphoneCode;
  }
  public void setMetaphoneCode(String metaphoneCode) {
    this.metaphoneCode = metaphoneCode;
  }
  public String toString() {
    return this.metaphoneCode;
  }
}

import java.util.Comparator;
public class SurnameSort implements Comparator <MetaphoneCode> {
  @Override
  public int compare (MetaphoneCode mc1, MetaphoneCode mc2) {
    return mc1.getMetaphoneCode().compareTo(mc2.getMetaphoneCode());
  }
}

import java.util.ArrayList;
import java.util.Collections;
public class SurnameApp {
  public static void main(String[] args) {
    MetaphoneCode m1 = new MetaphoneCode("Whitede");
    MetaphoneCode m2 = new MetaphoneCode("Whitehead");
    MetaphoneCode m3 = new MetaphoneCode("Whitted");
    MetaphoneCode m4 = new MetaphoneCode("Whitshead");
    MetaphoneCode m5 = new MetaphoneCode("White");
    ArrayList<MetaphoneCode> mlist = new ArrayList <>();
    mList.add(m1);
    mList.add(m2);
    mList.add(m3);
    mList.add(m4);
    mList.add(m5);
    System.out.println("Unsorted: " + mList );
    SurnameSort cSort = new SurnameSort();
    Collections.sort(mList, cSort);
    System.out.println("Sorted: " + mList );
  }
}

$ Unsorted: [WTT (Whitede), WTHT( Whitehead), WTT (Whitted), WTXT (Whitshead), WT (White)]
$ Sorted: [WT (White), WTHT (Whitehead), WTT (Whitede), WTT (Whitted), WTXT (Whitshead)]

The SurnameSort class implemented the Comparator interface that was used by the cSort instance. Optionally, an anonymous inner class could have been created to avoid the work of creating the seperate SurnameSort class:

// Replace: SurnameSort cSort = new SurnameSort();
Comparator<MetaphoneCode> cSort = new Comparator<MetaphoneCode>() {
  public int compare(MetaphoneCode mc1, MetaphoneCode mc2) {
    return mc1.getMetaphoneCode().compareTo(mc2.getMetaphoneCode());
  }
};

Since Comparator is a functional interface, a lambda expression could have been used to make the code more readable:

Comparator<MetaphoneCode> cSort = (MetaphoneCode mc1, MetaphoneCode mc2)
  -> mc1.getMetaphoneCode().compareTo(mc2.getMetaphoneCode());

Class names do not need to be explicitly stated in the argument list, as the lambda expressions have knowledge of the target types. That is, notice (mc1, mc2) versus (MetaphoneCode mc1, MetaphoneCode mc2):

// Example 1
Comparator <MetaphoneCode> cSort = (mc1, mc2)
  -> mc1.getMetaphoneCode().compareTo(mc2.getMetaphoneCode());
Collections.sort(mList, cSort);

// Example 2
Collections.sort(mList, (mc1, mc2)
 -> mc1.getMetaphoneCode().compareTo(mc2.getMetaphoneCode()));

Convenience Factory Methods

JDK 9 introduces new convenience factory methods that create compact unmodifiable collection (e.g., List, Set, Map) ins⁠tances. Therefore, multiple lines of code can be refactored into one:

// Pre Java 9 immutable list instantiation
List<String> haplogroups = new ArrayList<>();
haplogroups.add("I2");
haplogroups.add("I2B");
haplogroups.add("IJ");
haplogroups = Collections.unmodifiableList(haplogroups);

// Refactored Java 9 immutable list instantiation
List <String> haplogroups = List.of("I2","I2B", "IJ");