Java has a lot of boilerplate code, although each new version tries to remove a bit more every time. One area particularly affected is when you have to declare and initialise lists, maps or sets (some of it hopefully simplified in Java 7). Here’s some sample code:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
...
Map<String, String> map = new HashMap<String, String>();
List<String> list = new ArrayList<String>();
Set<String> set = new HashSet<String>();
String[] array = new String[] {};

To create any of these, you have to type a lot. Sometimes you make a mistake and have to retype. And half a minute later you’ve got one line of code that just declares a list. Also, you can have Eclipse automatically add imports when you save, but Eclipse normally can’t guess the correct List, instead prompting you to choose between java.util.List and java.awt.List (why isn’t there an option to use the former as the default?).

But Eclipse templates can help you avoid the hassle. Not only will it create the correct import statements, but also remove the effort of typing out the same type in the interface and implementation collection. If you’re new to templates, then see this tip to get an overview.

Continue reading →

When you’re writing JUnit tests, you’ll often find yourself repeating the same boilerplate code. Take the following code:

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class EngineTest {
    @Before
    public void setup() {
        ...
    }

    @Test
    public void test() throws Exception {
        ...
    }

    @After
    public void tearDown() {
        ...
    }
}

If you want to add a test, you have to somehow add lines 3, 11, 12 and 14 before you even get to the actual test. The same holds for setup and teardown code. We know that Eclipse can help with adding imports automatically when you save or autocomplete, but it still takes time to get everything in place.

Eclipse templates can help take away the drudgery by adding all this boilerplate code automatically. It can automatically add a test, setup and teardown methods together with calls to assertEquals, assertTrue and others. I’m assuming JUnit 4 in all the templates. If you’re new to templates, then see this tip to get an overview.

Continue reading →

Logging statements have taken up a nice chunk of my programming life. Info, debug and warning statements are common, especially since some team standards require that logging be done consistently (eg. at the start and end of all methods). Take the following code:

import org.apache.log4j.Logger;
...
public class Engine {
    private final static Logger logger = Logger.getLogger(Engine.class);

    public void someMethod() {
        ...
        logger.debug("Doing something here");
        ...
    }

To get the statement on line 8 you first have to insert line 4, generate the import on line 1 (eg. with Ctrl+Shift+O) and then move back to line 8 to type out the statement. That’s a lot of time for just one statement.

So here are some templates to help with this. The templates assume log4j since most people use that (right?), but can easily be adapted for Java Logging or other framework. If you’re new to templates, then see this tip to get an overview.

Continue reading →

You may find yourself having to write the following code once too often, especially at the start of a method to validate arguments:

if (account == null) {
    throw new IllegalArgumentException("Account is required");
}

//Or for strings
if (name == null || name.length() == 0) {   //Or even StringUtils.isBlank() of Apache Commons
    throw new IllegalArgumentException("Name is required");
}

Well, here  are templates that makes it easy to validate an object or string and throw an IllegalArgumentException if it isn’t.

Continue reading →

We’re still waiting for closures to come to  Java – the saga continues. Until then we’ll need to write the filter boilerplate code  manually. Filter loops often take an input array/collection, match each element with a condition and, if the condition matches, adds the element to another, filtered list. Here’s an example:

List filteredNames = new ArrayList();

for (String name : names) { //names is the original String Collection/array
    if (name.contains("Sam")) {
        filteredNames.add(name);
    }
}

This code is tedious, error-prone and a time-waster. It takes a minute or two or even longer to write without any errors.

You can use Eclipse templates to generate a filter loop in about 20 seconds. If you haven’t worked with templates before, see this post for an overview.

I’ve created a template that produces a List declaration, enhanced for loop, if statement and an add to the filtered list. The list’s type is taken from the nearest array/collection in scope so should be a fairly good match. It even generates import statements for the List and ArrayList.

You can either import the template (recommended; much faster) or create the template manually.

Continue reading →

We constantly have to check for nulls in Java. There are ways/ideas to cut down on them (eg. Safe Navigation Operator, type annotations, Null Object, better API design) but they’re either not here yet or not used often enough. So you’ll often need code similar to the following:

Transport transport = SomeAPI.createTransport(...);
//...
if (transport != null) {
    //... Do something with transport...
    if (transport.getSomething() != null) {
        //... Do something with transport.getSomething ...
    }
}

Typing the null-check is fine until you have to retype it 5 times a day, every day for 10 years (well, at least it feels like that).

You can use an Eclipse template to stop the madness. If you haven’t worked with templates before, see this post for an overview.

I’ve created a template that produces an if-statement with a not-null check on a variable that Eclipse will guess at first but give you the option to override it.

You can either import the template (recommended; much faster) or create the template manually.

Continue reading →