Cheap Tricks XV - Static Collections in Java

Being back in the Java game from Ruby, makes me miss a lot of the shortcuts. Despite the crushing pain I feel whenever I recognize a 5 line block of Java code that can be reproduced with one short Ruby line, being a professional Ruby developer was overall a great experience. It has made me so lazy, I have amassed quite the little toolkit to save precious lines. Here's another cheap trick around reducing the common need for a static block populated collections (NOTE: this isn't limited to Enums - if you are only dealing with Enums, just use EnumSet.of):

public class StateMachine
{
  enum State { STARTED, COMPLETED, CANCELLED, ABORTED }

  public static final Set<State> FINAL_STATES;
  static
  {
    HashSet<State> fs = new HashSet<State>();
    fs.add( COMPLETED );
    fs.add( CANCELLED );
    fs.add( ABORTED );
    FINAL_STATES = Collections.unmodifiableSet( fs );
  }
  // ...
}

into a trim one-liner:

import static StaticUtils.sset;
import static StateMachine.State.*;

public class StateMachine
{
  enum State { STARTED, COMPLETED, CANCELLED, ABORTED }

  static final List<State> FINAL_STATES = sset( COMPLETED, CANCELLED, ABORTED );
  // ...
}

Here's a code for a static list creator:

public final class StaticUtils
{
  public static final <T> Set<T> sset( T...objects )
  {
    HashSet<T> al = new HashSet<T>( objects.length );
    for ( T t : objects ) al.add( t );
    return Collections.unmodifiableSet( al );
  }
}

As one person pointed out, you can achieve the same effect for Lists via:

import static java.util.Arrays.asList;
import static StateMachine.State.*;

public class StateMachine
{
  enum State { STARTED, COMPLETED, CANCELLED, ABORTED }

  static final List<State> FINAL_STATES = asList( COMPLETED, CANCELLED, ABORTED );
  // ...
}

Slight modifications can be made for handling maps:

public final class StaticUtils
{
  // ...
  public static final <K, V> Map<K, V> smap( Pair<K, V>...pairs )
  {
    HashMap<K, V> hm = new HashMap<K, V>();
    for ( Pair<K, V> p : pairs ) hm.put( p.k, p.v );
    return Collections.unmodifiableMap( hm );
  }

  public static class Pair<K, V>
  {
    private Pair(K k, V v) { this.k = k; this.v = v; }
    private K k;
    private V v;
  }

  public static final Pair<K, V> p( K k, V v )
  {
    return new Pair<K, V>(k, v);
  }
}

Usage is similar, but bundles keys/values into a pair, the creation of which is shortcutted by the static "p" method.

import static StaticUtils.smap;
import static StaticUtils.p;
import static StateMachine.States.*;

public class StateMachine
{
  enum State { STARTED, COMPLETED, CANCELLED, ABORTED }

  static final Map<State, String> INCOMPLETE = smap( p(CANCELLED,"cancel"), p(ABORTED,"abort") );
  // ...
}