How to initialize HashSet values by construction

Question

I need to create a Set with initial values   Set lt String gt  h   new HashSet lt String gt     h add  a    h add  b      Is there a way to do this in one line of code  For instance  it s useful for a final static field

User · Answer

You can do it in Java 6   Set lt String gt  h   new HashSet lt String gt  Arrays asList  a    b    c       But why   I don t find it to be more readable than explicitly adding elements

User · Answer

Using Java 8 we can create HashSet as    Stream of  A    B    C    D   collect Collectors toCollection HashSet  new      And if we want unmodifiable set we can create a utility method as     public static  lt T  A extends Set lt T gt  gt  Collector lt T  A  Set lt T gt  gt  toImmutableSet Supplier lt A gt  supplier            return Collector of                  supplier                  Set  add   left  right  - gt                        left addAll right                       return left                     Collections  unmodifiableSet           This method can be used as     Stream of  A    B    C    D   collect toImmutableSet HashSet  new

User · Answer

A bit convoluted but works from Java 5   Set lt String gt  h   new HashSet lt String gt  Arrays asList new String            a    b        Use a helper method to make it readable   Set lt String gt  h   asSet   a    b     public Set lt String gt  asSet String    values        return new HashSet lt String gt  java util Arrays asList values

User · Answer

In Java 8 I would use   Set lt String gt  set   Stream of  a    b   collect Collectors toSet       This gives you a mutable Set pre-initialized with  a  and  b   Note that while in JDK 8 this does return a HashSet  the specification doesn t guarantee it  and this might change in the future  If you specifically want a HashSet  do this instead   Set lt String gt  set   Stream of  a    b                            collect Collectors toCollection HashSet  new

User · Answer

This is an elegant solution   public static final  lt T gt  Set lt T gt  makeSet  SuppressWarnings  unchecked   T    o            return new HashSet lt T gt                  private static final long serialVersionUID   -3634958843858172518L                                for  T x   o                     add x

User · Answer

Collection literals were scheduled for Java 7  but didn t make it in  So nothing automatic yet    You can use guava s Sets   Sets newHashSet  a    b    c     Or you can use the following syntax  which will create an anonymous class  but it s hacky   Set lt String gt  h   new HashSet lt String gt           add  a        add  b

User · Answer

One of the most convenient ways is usage of generic Collections addAll   method  which takes a collection and varargs   Set lt String gt  h   new HashSet lt String gt     Collections addAll h   a    b

User · Answer

There is a shorthand that I use that is not very time efficient  but fits on a single line   Set lt String gt  h   new HashSet lt  gt  Arrays asList  a    b       Again  this is not time efficient since you are constructing an array  converting to a list and using that list to create a set   When initializing static final sets I usually write it like this   public static final String   SET VALUES   new String      a    b     public static final Set lt String gt  MY SET   new HashSet lt  gt  Arrays asList SET VALUES      Slightly less ugly and efficiency does not matter for the static initialization

User · Answer

If the contained type of the Set is an enumeration then there is java built factory method  since 1 5    Set lt MY ENUM gt  MY SET   EnumSet of  MY ENUM value1  MY ENUM value2

User · Answer

Combining answer by Michael Berdyshev with Generics and using constructor with initialCapacity  comparing with Arrays asList variant     import java util Collections    import java util HashSet    import java util Set      SafeVarargs   public static  lt T gt  Set lt T gt  buildSetModif final T    values        final Set lt T gt  modifiableSet   new HashSet lt T gt  values length       Collections addAll modifiableSet  values       return modifiableSet          SafeVarargs   public static  lt T gt  Set lt T gt  buildSetModifTypeSafe final T    values        return new HashSet lt T gt  Arrays asList values            SafeVarargs   public static  lt T gt  Set lt T gt  buildeSetUnmodif final T    values        return Collections unmodifiableSet buildSetModifTypeSafe values           Or use Set of  a    b    c   if you use Java 9        This is good if you pass a few values for init  for anything large use other methods If you accidentally mix types with buildSetModif the resulting T will be   extends Object  which is probably not what you want  this cannot happen with the buildSetModifTypeSafe variant  meaning that  buildSetModifTypeSafe 1  2   a    will not compile

User · Answer

The Builder pattern might be of use here  Today I had the same issue  where I needed Set mutating operations to return me a reference of the Set object  so I can pass it to super class constructor so that they too can continue adding to same set by in turn constructing a new StringSetBuilder off of the Set that the child class just built  The builder class I wrote looks like this  in my case it s a static inner class of an outer class  but it can be its own independent class as well    public interface Builder lt T gt        T build       static class StringSetBuilder implements Builder lt Set lt String gt  gt        private final Set lt String gt  set   new HashSet lt  gt          StringSetBuilder add String pStr            set add pStr           return this             StringSetBuilder addAll Set lt String gt  pSet            set addAll pSet           return this              Override     public Set lt String gt  build             return set            Notice the addAll   and add   methods  which are Set returning counterparts of Set add   and Set addAll    Finally notice the build   method  which returns a reference to the Set that the builder encapsulates  Below illustrates then how to use this Set builder   class SomeChildClass extends ParentClass       public SomeChildClass String pStr            super new StringSetBuilder   add pStr  build              class ParentClass       public ParentClass Set lt String gt  pSet            super new StringSetBuilder   addAll pSet  add  my own str   build

User · Answer

There are a few ways   Double brace initialization  This is a technique which creates an anonymous inner class which has an instance initializer which adds Strings to itself when an instance is created   Set lt String gt  s   new HashSet lt String gt           add  a        add  b         Keep in mind that this will actually create an new subclass of HashSet each time it is used  even though one does not have to explicitly write a new subclass   A utility method  Writing a method that returns a Set which is initialized with the desired elements isn t too hard to write   public static Set lt String gt  newHashSet String    strings        HashSet lt String gt  set   new HashSet lt String gt          for  String s   strings            set add s             return set      The above code only allows for a use of a String  but it shouldn t be too difficult to allow the use of any type using generics   Use a library  Many libraries have a convenience method to initialize collections objects   For example  Google Collections has a Sets newHashSet T     method which will populate a HashSet with elements of a specific type

User · Answer

import com google common collect Sets  Sets newHashSet  a    b      or  import com google common collect ImmutableSet  ImmutableSet of  a    b

User · Answer

If you have only one value and want to get an immutable set this would be enough   Set lt String gt  immutableSet   Collections singleton  a

User · Answer

I feel the most readable is to simply use google Guava    Set lt String gt  StringSet   Sets newSet  a    b    c

User · Answer

With Java 9 you can do the following   Set of  a    b      and you ll get an immutable Set containing the elements  For details see the Oracle documentation of interface Set

User · Answer

If you are looking for the most compact way of initializing a set then that was in Java9  Set lt String gt  strSet   Set of  quot Apple quot    quot Ball quot    quot Cat quot    quot Dog quot                           Detailed answer below                                   Using Java 10  Unmodifiable Sets  Set lt String gt  strSet1   Stream of  quot A quot    quot B quot    quot C quot    quot D quot             collect Collectors toUnmodifiableSet      Here the collector would actually return the unmodifiable set introduced in Java 9 as evident from the statement set - gt   Set lt T gt  Set of set toArray    in the source code  One point to note is that the method Collections unmodifiableSet   returns an unmodifiable view of the specified set  as per documentation   An unmodifiable view collection is a collection that is unmodifiable and is also a view onto a backing collection  Note that changes to the backing collection might still be possible  and if they occur  they are visible through the unmodifiable view  But the method Collectors toUnmodifiableSet   returns truly immutable set in Java 10   Using Java 9  Unmodifiable Sets  The following is the most compact way of initializing a set  Set lt String gt  strSet6   Set of  quot Apple quot    quot Ball quot    quot Cat quot    quot Dog quot     We have 12 overloaded versions of this convenience factory method   static  lt E gt  Set lt E gt  of   static  lt E gt  Set lt E gt  of E e1  static  lt E gt  Set lt E gt  of E e1  E e2         and so on static  lt E gt  Set lt E gt  of E    elems   Then a natural question is why we need overloaded versions when we have var-args  The answer is  every var-arg method creates an array internally and having the overloaded versions would avoid unnecessary creation of object and will also save us from the garbage collection overhead   Using Java 8  Modifiable Sets  Using Stream in Java 8  Set lt String gt  strSet1   Stream of  quot A quot    quot B quot    quot C quot    quot D quot             collect Collectors toCollection HashSet  new        stream from an array  String   stringArray  Set lt String gt  strSet2   Arrays stream stringArray            collect Collectors toCollection HashSet  new        stream from a list  List lt String gt  stringList  Set lt String gt  strSet3   stringList stream             collect Collectors toCollection HashSet  new      Using Java 8  Unmodifiable Sets  Using Collections unmodifiableSet   We can use Collections unmodifiableSet   as  Set lt String gt  strSet4   Collections unmodifiableSet strSet1    But it looks slightly awkward and we can write our own collector like this  class ImmutableCollector       public static  lt T gt  Collector lt T  Set lt T gt   Set lt T gt  gt  toImmutableSet             return Collector of HashSet  new  Set  add   l  r  - gt                l addAll r               return l             Collections  unmodifiablSet            And then use it as  Set lt String gt  strSet4   Stream of  quot A quot    quot B quot    quot C quot    quot D quot                 collect ImmutableCollector toImmutableSet           Using Collectors collectingAndThen   Another approach is to use the method   Collectors collectingAndThen     6  which lets us perform additional finishing transformations  import static java util stream Collectors    Set lt String gt  strSet5   Stream of  quot A quot    quot B quot    quot C quot    quot D quot   collect collectingAndThen     toCollection HashSet  new  Collections  unmodifiableSet     If we only care about Set then we can also use Collectors toSet   in place of Collectors toCollection HashSet  new

User · Answer

A generalization of coobird s answer s utility function for creating new HashSets   public static  lt T gt  Set lt T gt  newHashSet T    objs        Set lt T gt  set   new HashSet lt T gt         for  T o   objs            set add o             return set

User · Answer

With the release of java9 and the convenience factory methods this is possible in a cleaner way   Set set   Set of  a    b    c

User · Answer

Can use static block for initialization   private static Set lt Integer gt  codes1          new HashSet lt Integer gt  Arrays asList 1  2  3  4     private static Set lt Integer gt  codes2           new HashSet lt Integer gt  Arrays asList 5  6  7  8     private static Set lt Integer gt  h   new HashSet lt Integer gt      static      h add codes1       h add codes2

User · Answer

You can also use vavr  import io vavr collection HashSet   HashSet of  quot a quot    quot b quot   toJavaSet

User · Answer

ugly  Double Brace Initialization without side effects   Set lt String gt  a   new HashSet lt  gt  new HashSet lt String gt           add  1        add  2          But in some cases  if we mentioned that is a good smell to make final collections unmutable  it could be really useful   final Set lt String gt  a   Collections unmodifiableSet new HashSet lt String gt          add  1        add  2

User · Answer

With Eclipse Collections there are a few different ways to initialize a Set containing the characters  a  and  b  in one statement   Eclipse Collections has containers for both object and primitive types  so I illustrated how you could use a Set lt String gt  or CharSet in addition to mutable  immutable  synchronized and unmodifiable versions of both   Set lt String gt  set       Sets mutable with  a    b    HashSet lt String gt  hashSet       Sets mutable with  a    b   asLazy   into new HashSet lt String gt      Set lt String gt  synchronizedSet       Sets mutable with  a    b   asSynchronized    Set lt String gt  unmodifiableSet       Sets mutable with  a    b   asUnmodifiable     MutableSet lt String gt  mutableSet       Sets mutable with  a    b    MutableSet lt String gt  synchronizedMutableSet       Sets mutable with  a    b   asSynchronized    MutableSet lt String gt  unmodifiableMutableSet       Sets mutable with  a    b   asUnmodifiable     ImmutableSet lt String gt  immutableSet       Sets immutable with  a    b    ImmutableSet lt String gt  immutableSet2       Sets mutable with  a    b   toImmutable     CharSet charSet       CharSets mutable with  a    b    CharSet synchronizedCharSet       CharSets mutable with  a    b   asSynchronized    CharSet unmodifiableCharSet       CharSets mutable with  a    b   asUnmodifiable    MutableCharSet mutableCharSet       CharSets mutable with  a    b    ImmutableCharSet immutableCharSet       CharSets immutable with  a    b    ImmutableCharSet immutableCharSet2       CharSets mutable with  a    b   toImmutable      Note  I am a committer for Eclipse Collections

User · Answer

Just a small note  regardless of which of the fine approaches mentioned here you end up with  if this is a default that usually goes unmodified  like a default setting in a library you are creating   it is a good idea to follow this pattern      Initialize default values with the method you prefer  even in a static block    It s a good idea to make sure these defaults aren t modifiable private final static Set lt String gt  DEFAULT VALUES   Collections unmodifiableSet       private Set lt String gt  values   DEFAULT VALUES    The benefit depends on the number of instances you create of that class and how likely it s that defaults will be changed   If you decide to follow this pattern  then you also get to pick the method of set initialization that s most readable  As the micro differences in efficiency between the different methods will probably not matter much as you will be initializing the set only once

[java] How to initialize HashSet values by construction?

Examples related to java

Examples related to collections

Examples related to constructor

Examples related to initialization

Examples related to hashset