As you perhaps already know, jdk7 milestone 5 (jdk7b76) is out.
This new milestone contains a lot of bug fixes and improvements. This blog entry is about two of them:

• Strings in switch
• Method handles (yes again)

Switch on String

This one of the small proposal changes (from Coins's project) to Java language in order to allow to switch on String values.
Let's take an example. Suppose you want a program with these outputs:

  $ java StringSwitch hello
  hello
  $ java StringSwitch -verbose hello
  hello switch string

Here is the corresponding Java code:

public class StringSwitch {
  public static void main(String[] args) {
    boolean verbose = false;
    for(String arg:args) {
      switch(arg) {
      case "hello":
        if (verbose)
          System.out.println("hello switch string");
        else
          System.out.println("hello");
        break;
      case "-verbose":
        System.out.println("verbose mode activated");
        verbose = true;
        break;
      }
    }
  }
}

And without jdk7

Here is another program with the same semantics but without the switch on strings. It uses a HashMap to avoid a cascade of if/else which could be very slow (*). So for each string, I associate a runnable, which is the code to run if the string match. Also note that because I define the code to run using an anonymous class, the local variable verbose has to be a captured and because this variable is modified, I use the usual workaround and declare it has an array of one element.

* Ok, in this example, because there is only two strings, this is not that slow.

public class StringHash {
  public static void main(String[] args) {
    final boolean[] verbose = new boolean[]{false};
    HashMap<String,Runnable> map =
      new HashMap<String, Runnable>();
    map.put("hello", new Runnable() {
      @Override
      public void run() {
        if (verbose[0])
          System.out.println("hello switch string");
        else
          System.out.println("hello");
      }
    });
    map.put("-verbose", new Runnable() {
      @Override
      public void run() {
        System.out.println("verbose mode activated");
        verbose[0] = true;
      }
    });
    
    for(String arg:args) {
      Runnable runnable = map.get(arg);
      if (runnable!=null)
        runnable.run();
    }
  }
}

With closure

In fact, the program above define two closures. By definition a closure is a function that is able to capture variables. Java 7 will not include a closure syntax but jdk7 VM already includes runtime support for closures. The current status of closure in Java can be seem as the opposite of the status of generics. Generics are a compiler artifact not understood by the VM (there is no reification). Closure are understood by the VM (using the package java.dyn) but there are not known by the Java type system.

The program below shows how to use method handle to solve our running problem. findStatic creates a method handle from an existing method (*) found by providing its declaring class, its name and its signature; a MethodType. insertArgument (also named currying) is a way to bound a value to a method handle to create a closure. Like with anonymous class syntax, the bounded value is a value and not a variable. Calling a method handle is done by using the method invoke which is polymorphic; that's why you have to specify the return type; the VM will verify that the declared types and the MethodType of the method handle are identical.

* In a close future, this will be done in one instruction by the VM, but I don't know if this instruction will surface in Java.

public class StringMH {
  private static void hello(boolean[] verbose) {
    if (verbose[0])
      System.out.println("hello switch string");
    else
      System.out.println("hello");
  }
  private static void verbose(boolean[] verbose) {
    System.out.println("verbose mode activated");
    verbose[0] = true;
  }
  
  public static void main(String[] args) {
    boolean[] verbose = new boolean[]{false};
    HashMap<String,MethodHandle> map =
      new HashMap<String,MethodHandle>();
    
    Lookup lookup = MethodHandles.lookup();
    MethodType methodType = MethodType.make(void.class, boolean[].class);
    MethodHandle helloMH = lookup.findStatic(StringMH.class, "hello", methodType);
    MethodHandle verboseMH = lookup.findStatic(StringMH.class, "verbose", methodType);
    
    map.put("hello", MethodHandles.insertArgument(helloMH, 0, verbose));
    map.put("-verbose", MethodHandles.insertArgument(verboseMH, 0, verbose));
    
    for(String arg:args) {
      MethodHandle mh = map.get(arg);
      if (mh!=null)
        mh.<void>invoke();
    }
  }
}

Because method handle code in the VM is not production ready you have to add some flags to be able to run this program. The VM will also output a warning saying that the JDK and the VM code are not aligned fortunately this program doesn't use that part of the code.

 java -XX:+UnlockExperimentalVMOptions -XX:+EnableInvokeDynamic StringMH -verbose hello

Enough fun for today, see you soon.
Cheers,
Rémi