All The Ways Java Uses the Colon Character

1. Introduction

Many programming languages use the colon character (:) for various purposes. For example, C++ uses it with access modifiers and class inheritance, and JavaScript uses it with object declarations. The Python language relies on it heavily for things like function definitions, conditional blocks, loops, and more.

And it turns out Java has a lengthy list of places where the colon character shows up as well. In this tutorial, we’ll look at them all.

2. Enhanced for Loop

The for loop is one of the first control statements programmers learn in any language. Here’s its syntax in Java:

for (int i = 0; i < 10; i++) {
    // do something
}

Among other things, this control structure is perfect for iterating through the items in a collection or an array. In fact, this use case is so common that in Java 1.5, the language introduced a more compact form known as the for-each loop.

Below is an example of iterating through an array using the for-each syntax:

int[] numbers = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
for (int i : numbers) {
    // do something
}

Here we can notice the colon character. We should read this as “in”. Thus, the loop above can be thought of as “for every integer i in numbers”.

In addition to arrays, this syntax can also be used for Lists and Sets:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
for (Integer i : numbers) {
    // do something
}

The goal of the for-each loop is to eliminate the boilerplate associated with standard for loops and, thus, the chance of error that comes with it. However, it does so by sacrificing some functionality like skipping indices, reverse iterating, and more.

3. switch Statement

The next place we find the colon character in Java is in a switch statement. The switch statement is a more readable, and often more compact, form of if/else blocks.

Let’s take a look at an example:

void printAnimalSound(String animal) {
    if (animal.equals("cat")) {
        System.out.println("meow");
    }
    else if (animal.equals("lion")) {
        System.out.println("roar");
    }
    else if (animal.equals("dog") || animal.equals("seal")) {
        System.out.println("bark");
    }
    else {
        System.out.println("unknown");
    }
}

This same set of statements can be written using a switch statement:

void printAnimalSound(String animal) {
    switch(animal) {
        case "cat":
            System.out.println("meow");
            break;
        case "lion":
            System.out.println("roar");
            break;
        case "dog":
        case "seal":
            System.out.println("bark");
            break;
        default:
            System.out.println("unknown");
    }
}

In this case, the colon character appears at the end of each case. However, this is only true for traditional switch statements. In Java 12, the language added an expanded form of switch that uses expressions. In that case, we use the arrow operator (->) instead of the colon.

4. Labels

One of the often-forgotten features of Java is labels. While some programmers may have bad memories of labels and their association with goto statements, in Java, labels have a very important use.

Let’s consider a series of nested loops:

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if (checkSomeCondition()) {
            break;
        }
    }
}

In this case, the break keyword causes the inner loop to stop executing and return control to the outer loop. This is because, by default, the break statement returns control to the end of the nearest control block. In this case, that means the loop with the j variable. Let’s see how we can change the behavior with labels.

First, we need to rewrite our loops with labels:

outerLoop: for (int i = 0; i < 10; i++) {
    innerLoop: for (int j = 0; j < 10; j++) {
        if (checkSomeCondition()) {
            break outerLoop;
        }
    }
}

We have the same two loops, but each one now has a label:. One is named outerLoop, and the other is named innerLoop. We can notice that the break statement now has a label name following it. This instructs the JVM to transfer control to the end of that labeled statement rather than the default behavior. The result is that the break statement exits the loop with the i variable, effectively ending both loops.

5. Ternary Operator

The Java ternary operator is a shorthand for simple if/else statements. Let’s say we have the following code:

int x;
if (checkSomeCondition()) {
    x = 1;
}
else {
    x = 2;
}

Using the ternary operator, we can shorten the same code:

x = checkSomeCondition() ? 1 : 2;

Additionally, the ternary operator works well alongside other statements to make our code more readable:

boolean remoteCallResult = callRemoteApi();
LOG.info(String.format(
  "The result of the remote API call %s successful",
  remoteCallResult ? "was" : "was not"
));

This saves us the extra step of assigning the result of the ternary operator to a separate variable, making our code more compact and easier to understand.

6. Method References

Introduced in Java 8 as part of the lambda project, method references also use the colon character. Method references show up in several places throughout Java, most notably with streams. Let’s see a few examples.

Let’s say we have a list of names and want to capitalize each one. Prior to lambdas and method references, we might use a traditional for loop:

List<String> names = Arrays.asList("ross", "joey", "chandler");
List<String> upperCaseNames = new ArrayList<>();
for (String name : names) {
  upperCaseNames.add(name.toUpperCase());
}

We can simplify this with a stream and method reference:

List<String> names = Arrays.asList("ross", "joey", "chandler");
List<String> upperCaseNames = names
  .stream()
  .map(String::toUpperCase)
  .collect(Collectors.toList());

In this case, we’re using a reference to the toUpperCase() instance method in the String class as part of a map() operation.

Method references are useful for filter() operations as well, where a method takes a single argument and returns a boolean:

List<Animal> pets = Arrays.asList(new Cat(), new Dog(), new Parrot());
List<Animal> onlyDogs = pets
  .stream()
  .filter(Dog.class::isInstance)
  .collect(Collectors.toList());

In this case, we’re filtering a list of different animal types using a method reference to the isInstance() method available for all classes.

Finally, we can also use constructors with method references. We do this by combining the new operator with the class name and method reference:

List<Animal> pets = Arrays.asList(new Cat(), new Dog(), new Parrot());
Set<Animal> onlyDogs = pets
  .stream()
  .filter(Dog.class::isInstance)
  .collect(Collectors.toCollection(TreeSet::new));

In this case, we’re collecting the filtered animals into a new TreeSet instead of a List.

7. Assertions

Another often overlooked feature of the Java language is assertions. Introduced in Java 1.4, the assert keyword is used to test a condition. If that condition is false, it throws an error.

Let’s look at an example:

void verifyConditions() {
    assert getConnection() != null : "Connection is null";
}

In this example, if the return value of the method getConnection() is null, the JVM throws an AssertionError. The String after the colon is optional. It allows us to provide a message as part of the error that gets thrown when the condition is false.

We should keep in mind assertions are disabled by default. To use them, we must enable them using the -ea command line argument.

8. Conclusion

In this article, we learned how Java uses the colon character in a variety of different ways. Specifically, we saw how the colon character is used with enhanced for loops, switch statements, labels, ternary operators, method references, and assertions.

Many of these features have been around since the early days of Java, but several have been added as the language has changed and added new features.

As always, the code examples above can be found over on GitHub.