Verso Java 7: Project Coin

Dopo le news su performance e linguaggi dinamici, scendiamo un pizzico più in profondità  nell’analizzare i futuri cambiamenti nello scrivere codice Java.

Parzialmente influenzato proprio dai linguaggi dinamici (Mark Reinhold parla guarda caso di Python) il sottoprogetto di OpenJDK Project Coin è finalizzato a rendere più rapida e produttiva la scrittura di codice grazie a migliorie quali il supporto al tipo String nel costrutto switch (era ora!).

Finalmente, quindi, potremo scrivere codice come:

String  s = ...
switch(s) {
  case "quux":
    processQuux(s);
    //  fall-through
  case "foo":
  case "bar":
    processFooOrBar(s);
    break;
  case "baz":
    processBaz(s);
    // fall-through
  default:
    processDefault(s);
    break;
}

Altra novità  mirata a rendere più compatto il codice è l’operatore <> (indicato come diamond), ossia le parentesi angolari che - ormai da qualche anno, dall’introduzione dei generics - ogni sviluppatore Java ha imparato a riconoscere. Mi riferisco, volendo modellare un'ipotetica estrazione del lotto, ad una dichiarazione di variabile del tipo List<Integer> estrazione;.

Da Dolphin in poi, sarà  possibile usare l’operatore diamond (lo si potrebbe considerare un “sottintendere” il contenuto delle parentesi angolari) quando:

• si costruisce un oggetto e contestualmente lo si assegna ad una variabile. Esempio:

//prima di  Java 7
Map> anagrams = new  HashMap>();
//da Java 7 in poi
Map> anagrams = new HashMap();

• si ritorna come parametro una variabile. Esempio:

class TreeNode<T> {
  T value;
  TreeNode<T> left, right;
  private List<List<T>> buildPathsInternal(
    List<List<T>> list, List<T> currPath, TreeNode<T> node) {
    if (node == null) {
      // type inference does not save typing here; see section on Wildcards.
      list.add(new ArrayList<T>(currPath));
      return list;
    }
    currPath.add(node);
    buildPathsInternal(list, currPath, node.left);
    buildPathsInternal(list, currPath, node.right);
    currPath.remove(node);
    return list;
  }
  public List<List<T>> getAllPaths(TreeNode<T> head) {
    // Type inference saves typing here:
    return buildPathsInternal(new ArrayList<>(), new LinkedList<>(), head);
  }
}

Gli esempi sono tratti dal blog di Joseph D. Darcy, da cui è possibile apprendere ulteriori dettagli su Project Coin.