CertPal

The JDK7 milestone 5 update is available for download. Developers now have a chance to try coding with the new language semantics and see for themselves what it is like. The 4 major changes that affect the way one codes in java as of JDK 7 are

• Using underscores in numerals.

• Diamond syntax used to work with collections + generics.

• Using Strings in switch statements.

• Making use of binary literals

Here is a short code sample that you can use to check the new features out. Use a plain text editor and your old friends javac and java, to test it out. IDEs will not support the new syntax and will most likely complain.

Sample JDK 7 Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

public class Jdk7Tests {
 
    public static void main(String[] args) {
        Jdk7Tests jdk7Tests = new Jdk7Tests();
        jdk7Tests.integersWithUnderscores();
        jdk7Tests.stringSwitch();
        jdk7Tests.binaryLiteral();
        jdk7Tests.diamond();
    }
 
    private void integersWithUnderscores()
    {
        int i = 1_2;
        System.out.println(i);
        i*=10;
        System.out.println(i);
        int j=2_0;
        System.out.println(i-j);       
    }
 
    private void stringSwitch()
    {
        String key = "akey";
        switch (key)
        {
        case "":
        {
            System.out.println("Nothing");
            break;
        }
 
        case "akey":
        {
            System.out.println("Matched akey");
            break;
        }
        default:
        break;
        }
    }
 
    private void binaryLiteral()
    {
        byte aByte = (byte)0b001;
        short aShort = (short)0b010;
        System.out.println(aByte + " " + aShort);
    }
 
    private void diamond()
    {
        Set<String> set = new TreeSet<>();
        set.add("c");
        set.add("b");
        set.add("a");
        for (String val : set)
        {
            System.out.println(val);
        }
    }
}

Underscores and numerals:

This feature will be great to process SSNs / phone numbers. No more putting the data into a String, parsing it, stripping it off underscores, and then putting it into an integer. But confusion arises when you try to do some arithmetic with the numeral. What is 1_2 * 2 ? The JVM strips the underscores when processing the operation as can be seen from the code example above. Thus 1_2 * 10 = 120 and 120 – 2_0 = 100. Simple

Diamond:

This should simplify instantiating collections. Time to update my auto complete code templates in anticipation of JDK 7. It is a little easier to read the code inside the diamond() method, in my opinion. Nothing more to the syntax though.

Switch with strings:

This is a pretty neat feature. You can now switch using Strings besides int, etc etc. Code that used to assign int variables to their corresponding String counterparts can now use this feature to simplify their code. Often code that contains call back methods in several places might set a int variable in one place, indicating that a particular String was found and then process this at a later point in time, using a switch construct. Some developers use this technique to write code that processes XML with SAX. They should be able to chop a few lines off that code using this feature.

Binary literals:

You can now use a binary literal representation and have that converted to a data type, say a byte or short, with very little code. I am not able to think of a scenario where I would use this regularly. But some of those coding practice problems that involve bits should be easier to write up

Other features of interest that do not necessarily affect programming, involve better algorithm implementations and performance improvements. These improvements are said to bring a many fold increase to performance in some applications. Test them out if you have the time.