Java Convenience Factory Methods for Collections – Java集合的方便工厂方法

最后修改: 2017年 2月 1日

1. Overview


Java 9 brings the long-awaited syntactic sugar for creating small unmodifiable Collection instances using a concise code one-liner. As per JEP 269, new convenience factory methods will be included in JDK 9.

Java 9 带来了期待已久的语法糖,用于使用简明的代码单线程创建小型的不可修改的Collection实例。根据JEP 269,JDK 9将包含新的便利工厂方法。

In this article, we’ll cover its usage along with the implementation details.


2. History and Motivation


Creating a small immutable Collection in Java is very verbose using the traditional way.


Let’s take an example of a Set:


Set<String> set = new HashSet<>();
set = Collections.unmodifiableSet(set);

That’s way too much code for a simple task and it should be possible to be done in a single expression.


The above is also true for a Map.


However, for List, there’s a factory method:


List<String> list = Arrays.asList("foo", "bar", "baz");

Although this List creation is better than the constructor initialization, this is less obvious as the common intuition would not be to look into Arrays class for methods to create a List:


There are other ways of reducing verbosity like the double-brace initialization technique:


Set<String> set = Collections.unmodifiableSet(new HashSet<String>() {{
    add("foo"); add("bar"); add("baz");

or by using Java 8 Streams:

或通过使用Java 8 Streams

Stream.of("foo", "bar", "baz")
  .collect(collectingAndThen(toSet(), Collections::unmodifiableSet));

The double brace technique is only a little less verbose but greatly reduces the readability (and is considered an anti-pattern).


The Java 8 version, though, is a one-line expression, and it has some problems, too. First, it’s not obvious and intuitive. Second, it’s still verbose. Third, it involves the creation of unnecessary objects. And fourth, this method can’t be used for creating a Map.

不过,Java 8的版本是一个单行表达式,它也有一些问题。首先,它不是很明显和直观的。第二,它仍然很冗长。第三,它涉及到创建不必要的对象。第四,这个方法不能用于创建Map

To summarize the shortcomings, none of the above approaches treat the specific use case creating a small unmodifiable Collection first-class class problem.

总结一下缺点,上述方法都没有处理创建一个小型的不可修改的Collection 第一类的具体用例问题。

3. Description and Usage


Static methods have been provided for List, Set, and Map interfaces which take the elements as arguments and return an instance of List, Set, and Map, respectively.


This method is named of(…) for all the three interfaces.


3.1. List and Set


The signature and characteristics of List and Set factory methods are the same:


static <E> List<E> of(E e1, E e2, E e3)
static <E> Set<E>  of(E e1, E e2, E e3)

usage of the methods:


List<String> list = List.of("foo", "bar", "baz");
Set<String> set = Set.of("foo", "bar", "baz");

As we can see, it’s very simple, short, and concise.


In the example, we’ve used the method with takes exactly three elements as parameters and returns a List / Set of size 3.

在这个例子中,我们使用的方法是以三个元素作为参数并返回大小为3的List / Set

But, there are 12 overloaded versions of this method – eleven with 0 to 10 parameters and one with var-args:


static <E> List<E> of()
static <E> List<E> of(E e1)
static <E> List<E> of(E e1, E e2)
// ....and so on

static <E> List<E> of(E... elems)

For most practical purposes, 10 elements would be sufficient, but if more are required, the var-args version can be used.


Now, we may ask, what is the point of having 11 extra methods if there’s a var-args version that can work for any number of elements.


The answer to that is performance. Every var-args method call implicitly creates an array. Having the overloaded methods avoid unnecessary object creation and the garbage collection overhead thereof. On the contrary, Arrays.asList always creates that implicit array and, consequently, is less efficient when the number of elements is low.


During the creation of a Set using a factory method, if duplicate elements are passed as parameters, then IllegalArgumentException is thrown at runtime:


@Test(expected = IllegalArgumentException.class)
public void onDuplicateElem_IfIllegalArgExp_thenSuccess() {
    Set.of("foo", "bar", "baz", "foo");

An important point to note here is that since the factory methods use generics, primitive types get autoboxed.


If an array of primitive type is passed, a List of array of that primitive type is returned.

如果传递了一个原始类型的数组,就会返回该原始类型的List array

For example:


int[] arr = { 1, 2, 3, 4, 5 };
List<int[]> list = List.of(arr);

In this case, a List<int[]> of size 1 is returned and the element at index 0 contains the array.


3.2. Map

3.2. 地图

The signature of Map factory method is:


static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3)

and the usage:


Map<String, String> map = Map.of("foo", "a", "bar", "b", "baz", "c");

Similarly to List and Set, the of(…) method is overloaded to have 0 to 10 key-value pairs.


In the case of Map, there is a different method for more than 10 key-value pairs:


static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends V>... entries)

and it’s usage:


Map<String, String> map = Map.ofEntries(
  new AbstractMap.SimpleEntry<>("foo", "a"),
  new AbstractMap.SimpleEntry<>("bar", "b"),
  new AbstractMap.SimpleEntry<>("baz", "c"));

Passing in duplicate values for Key would throw an IllegalArgumentException:


@Test(expected = IllegalArgumentException.class)
public void givenDuplicateKeys_ifIllegalArgExp_thenSuccess() {
    Map.of("foo", "a", "foo", "b");

Again, in the case of Map too, the primitive types are autoboxed.


4. Implementation Notes


The collections created using the factory methods are not commonly used implementations.


For example, the List is not an ArrayList and the Map is not a HashMap. Those are different implementations that are introduced in Java 9. These implementations are internal and their constructors have restricted access.

例如,List不是ArrayListMap不是HashMap。这些都是Java 9中引入的不同的实现。 这些实现是内部的,它们的构造函数有限制的访问。

In this section, we’ll see some important implementation differences which are common to all three types of collections.


4.1. Immutable


The collections created using factory methods are immutable, and changing an element, adding new elements, or removing an element throws UnsupportedOperationException:


@Test(expected = UnsupportedOperationException.class)
public void onElemAdd_ifUnSupportedOpExpnThrown_thenSuccess() {
    Set<String> set = Set.of("foo", "bar");
@Test(expected = UnsupportedOperationException.class)
public void onElemModify_ifUnSupportedOpExpnThrown_thenSuccess() {
    List<String> list = List.of("foo", "bar");
    list.set(0, "baz");
@Test(expected = UnsupportedOperationException.class)
public void onElemRemove_ifUnSupportedOpExpnThrown_thenSuccess() {
    Map<String, String> map = Map.of("foo", "a", "bar", "b");

4.2. No null Element Allowed


In the case of List and Set, no elements can be null. In the case of a Map, neither keys nor values can be null. Passing null argument throws a NullPointerException:


@Test(expected = NullPointerException.class)
public void onNullElem_ifNullPtrExpnThrown_thenSuccess() {
    List.of("foo", "bar", null);

As opposed to List.of, the Arrays.asList method accepts null values.


4.3. Value-Based Instances


The instances created by factory methods are value-based. This means that factories are free to create a new instance or return an existing instance.


Hence, if we create Lists with same values, they may or may not refer to the same object on the heap:


List<String> list1 = List.of("foo", "bar");
List<String> list2 = List.of("foo", "bar");

In this case, list1 == list2 may or may not evaluate to true depending on the JVM.

在这种情况下,list1 == list2可能会也可能不会评估为true,这取决于JVM。

4.4. Serialization


Collections created from factory methods are Serializable if the elements of the collection are Serializable.


5. Conclusion


In this article, we introduced the new factory methods for Collections introduced in Java 9.

在这篇文章中,我们介绍了Java 9中引入的集合的新工厂方法。

We concluded why this feature is a welcome change by going over some past methods for creating unmodifiable collections. We covered it’s usage and highlighted key points to be considered while using them.


Finally, we clarified that these collections are different from the commonly used implementations and pointed out key differences.


The complete source code and unit tests for this article are available over on GitHub.