What are good patterns / techniques to reduce verbosity of Java

Question

One of the things that can be a little annoying about Java is the amount of code you need to express concepts. I am a believer in the "less code is better" philosophy, and I'd like to know how I can write Java without being so frustratingly verbose. Recently, I read the Hidden Features of Java question and was introduced to using double-brace initialization to simulate a List or Map literal. There are, of course, drawbacks to using this method, but it does allow you to do certain things with significantly fewer characters and (if you format it right) make the code a lot cleaner and clearer. I'm wondering if there aren't other clever tricks and lesser known language features which could make my code more concise.

I'd like to see answers with an explanation of the technique, the more verbose way which it replaces, and any potential drawbacks to using the technique.

Answer 1

Prior to the introduction of the diamond operator in Java 7, static factory methods for creating generic types could be used to reduce verbosity by reducing the need to repeat the type parameter. (This is because without the diamond operator, Java never infers the type parameter on constructors, but it will on methods calls.) Google Collections uses this technique, so you can write:

Set<MyClassWithALongName> set = Sets.newHashSet();

instead of:

Set<MyClassWithALongName> set = new HashSet<MyClassWithALongName>();

Look in the Lists, Sets and Maps classes of Google Collections for methods starting with "new" for more examples of this.

Unless you are writing for an old version of Java, as of Java 7 it is better to just use the diamond operator.

Answer 2

A similar one you probably already know about, using the "varargs" feature:

String[] array = new String[] {"stack", "over", "flow"};
List<String> list = Arrays.asList(array);

can be abbreviated

List<String> list = Arrays.asList("stack", "over", "flow");

Admittedly not a huge savings, but it does reduce the verbosity a little bit. As Thomas notes, the list will be immutable, so watch out for that. Actually, you can modify the list, you just can't change its length. Thanks to pimlottc for pointing that out.

Answer 3

Use a dependency injection framework like spring. I'm almost always amazed at how much code construction logic produces.

Answer 4

I've found that the most (only?) effective way to write concise java is to not write java at all. In cases where I needed to write something quickly that still interoperates with Java, I've found Groovy to be an excellent choice. Using a more concise language that still compiles to JVM bytecode can be an excellent solution. While I have no personal experiences with it, I've heard that Scala is an even better choice than Groovy in many cases.

Answer 5

Check out lambdaj. It has lots of features that can help to make your code more concise and readable.

Answer 6

Fluent interfaces can help - using builders and method chaining to make something resembling a DSL in java. The code you end up with can be a little harder to read though as it breaks Java's normal coding conventions such as removing the set / get from properties.

So in a fake Swing fluent interface you might define a button thus:

JButton button = Factory.button().icon(anIcon).tooltip("Wow").swing();

Another approach is to use another language there are many that integrate well with the JVM such as:

• JRuby
• Scala
• Cal

Answer 7

A "closeQuietly" method can be used in try/finally blocks in situations where IO exceptions on close are uninteresting (or impossible).

Closeable c = null;
try {
    ...
    c = openIt(...);
    ...
} finally {
    closeQuietly(c);
}

where:

/** Close 'c' if it is not null, squashing IOExceptions */
public void closeQuietly(Closeable c) {
    if (c != null) {
        try {
            c.close();
        } catch (IOException ex) {
            // log error 
        }
    }
}

---

Note that with Java 7 and later, the new "try with resources" syntax makes this particular example redundant.

Answer 8

I found a blog post giving an interesting technique which allows for writing a map literal in Java like you would be able to do in Perl, Python, Ruby, etc: Building your own literals in Java - Tuples and Maps I really like this approach! I'll just summarize it here.

The basic idea is to create a generic pair class and define static functions that will construct a pair, and a map from a varargs array of pairs. This allows the following concise map literal definition:

Map(o("height", 3), o("width", 15), o("weight", 27));

Where o is the name of the static function to construct a pair of T1 and T2 objects, for any object types T1 and T2, and Map is the name of the static function to construct a Map. I'm not sure I like the choice of Map as the name of the map construction function because it is the same as the name of the Java interface, but the concept is still good.

Answer 9

Static initialisers

Example 1 (Map):

Map<String, String> myMap = new HashMap<String, String>() {{
    put ("a", "b");
    put ("c", "d");
}};

Example 2(List):

List<String> myList = new ArrayList<String>() {{
    add("a");
    add("b");
    add("c");
}};

Answer 10

More Guave goodness to initialize immutable maps (which I'm finding to be a way more common case than initializing mutable maps): the ImmutableMap.of(...) variants

Map<Service, Long> timeouts = ImmutableMap.of(
    orderService, 1500, 
    itemService, 500);

Answer 11

Ever have to iterate through a collection, just to map its elements by one of its properties? No more, thanks to Maps.uniqueIndex():

private void process(List<Module> modules) {

    Map<String, Module> byName = Maps.uniqueIndex(modules, new Function<Module, String>() {
            @Override public String apply(Module input) {
                return input.getName();
            }
        });

or if this is frequent enough, make the function a public static final member of Module so that the above is reduced to:

    Map<String, Module> byName = Maps.uniqueIndex(modules, Module.KEY_FUNCTION);