Java labels. To be or not to be [closed]

Question

Before I start this question I know the java 'goto' is a big no go.

So I've been writing a program and I have some indented Loops and statements and I need to BREAK multiple on command. Rather than having a load of boolean variables and if(!<booleanName>) BREAK; statements throughout these loops and statements what is everyone's opinions on using labels to break them using the BREAK <label> statement?

e.g.

 for(...) {

      indented_example_loops:     // Label name
           for(...) {
                for(...) {
                     if(match) break indented_example_loops;
                     // ^ Break statement to break the 2 for loops at once
                }
           }

 }

Perfectly okay? Okay to do occasionally? Completely avoid? or should i go to a corner and call the Devil to take my soul?

Answer 1

It's all about readability and ease of understanding.

The easiest to understand loops are those with simple end conditions and no breaks at all. So if you can write your loops like that, do it.

while (someCondition) {
  // do stuff
}

Next comes the loop with a simple end condition and a single break:

while (someCondition) {
  // do stuff
  if (otherCondition) {
    break;
  }
  // maybe some more stuff
}

Everything that's more complex than this is a potential problem. A break with a label is always tricky, because you'll have to hunt for the label to find out which statement/block the break escapes from (i.e. the break will continue after the labeled block/statement).

The worst kind (the one you almost always want to avoid) is a nested loop where you break somewhere in the middle.

while (someCondition) {
  myLabel:
  for (Foo foo : getAllFoos()) {
    for (Bar bar : foo.getBars()) {
      // do stuff
      if (someCondition(bar)) {
        break myLabel; // BAD!
      }
      // some more stuff
    }
  }
}

The problem here is that the actual flow of processing becomes really hard to follow. If you start having code like this, then you should definitely refactor it.

A common refactoring is to extract one (or more) nested loops into a method and turning the break into a return. This has the added benefit of giving a name to that piece of the code. If the name is chosen well, then that will help greatly in understanding the code.

Answer 2

You are opening yourself up to spaghetti code

While the language allows you to do this, it is not good practice. There are many alternative looping structures that will achieve the same objective and make your code much more readable.

Essentially, labels and gotos are a holdover from assembly language code (which is all about labels and gotos). It really has no place in higher level languages.

Answer 3

Separate the iteration and the processing by encapsulating the iteration.

Iterating over multi-level structures with nested loops leads to applications where most of the code is looping noise. To process all the Level2Things in a Level0Thing, replace your nested loops with this:

for (Level2Thing t2: topThing.level2Things()) {
   // do something
}

where level2Things() returns an Iterable<Level2Thing>.

You can find some sample code for encapsulating nested iterations here.

Answer 4

For very deeply nested loops or complex code flow, I often declare anonymous Runnables. While not directly related to the question, it is still relevant. I'm sure there is a better example than this, but it's a start.

public int ComplexFunction() {
    final Integer value = new Integer();
    final Boolean quit = new Boolean(false);

    final Runnable doTest = new Runnable() {
        public void run() {
            if (value.intVal() > 100) {
                quit = new Boolean(true);
            }
        }
    }


    while (true) {
        value = new Integer(value.intVal() + 5);
        doTest.run();
        if (quit.booleanVal() == true) {
            return 1;
        }
    }
    return 0;
}