虽然斯蒂芬·欧文的回答非常准确，纠正了你问题中的所有信念，但这仍然回答了你的问题，试图尽量减少陈述的数量。

public class CoolDude {
  public static void main(String[] args) {
    for (int i = 100; i <= 500; i++)
      if (i % 5 == 0 || i % 11 == 0) // This is the condition where we decide to print something
        System.out.printf("%s%s- %d%n", i % 5 == 0 ? "Cool " : "", i % 11 == 0 ? "Dude " : "", i);
  }
}

然而，这段代码复制了一个最昂贵的部分：模。此外，此解决方案不可读！
当试图找出解决方案是有用的尝试几个关键绩效指标，然后找到最佳的优化。在这种情况下，您想要优化行的数量，这绝对不是您上面看到的最好的。如果有什么尝试首先得到一个工作的解决方案，然后是一个可读的，最后是一个优化的文件，你为什么它是优化的，以便保持可读性。
例如，这里是我能想到的最优化的版本。它肯定包含更多的行，但也肯定是更快，因为我跳过所有无效的数字，从来没有做一个模（只有两个除法和两个乘法为整个程序）。

public class CoolDude {
  public static void main(String[] args) {
    final int min = 100;
    final int max = 500;
    for (int i5 = nextMultiple(min, 5), i11 = nextMultiple(min, 11); i5 <= max || i11 <= max; ) {
      if (i5 < i11) {
        System.out.printf("Cool - %d%n", i5);
        i5 += 5;
      } else if (i11 < i5) {
        System.out.printf("Dude - %d%n", i11);
        i11 += 11;
      } else { // i5 == i11
        System.out.printf("Cool Dude - %d%n", i5);
        i5 += 5;
        i11 += 11;
      }
    }
  }
  static int nextMultiple(int number, int divisor) {
    int roundToLower = (number - 1) / divisor * divisor;
    return roundToLower + divisor;
  }
}

您可以重新构造决策树，这样就只需要对循环中的数字进行2次检查（每个检查有1次操作和1次比较）。目前，在最佳情况下，决策树需要2次操作和2次比较( i 在最坏的情况下，可以被5和11）以及4次运算和4次比较整除( i 不可被5或11整除），但我们可以将其减少到只有2个比较和2个运算，这将导致更高性能的循环。这样一来， i 对于每个数字，只有一次测试5和11的可除性，因此无论循环的哪个阶段，都只需要进行2次运算和2次比较。这是您在尝试优化循环时应该考虑的优化类型。
我还做了你的 print 方法调用 printf 而是调用，将两个print语句缩减为1。这是一个printf备忘单，如果你不熟悉它，可以使用它。
现在，这么做只会使代码的大小减少1行，虽然我确信通过巧妙地使用三元运算符或其他方法可以进一步减少代码的大小，但作为一般规则，通过行数来衡量代码质量是一个可怕的指标，决不应使用，尤其是当我们谈论像java这样的编译语言时。我可以对下面的代码做很多事情，以牺牲可读性和/或性能为代价来减少行数，但是除了程序员之间的竞争之外，没有什么真正的意义，比如代码高尔夫（但即使这样，你也在竞争最低的字符数，而不是行数）。
与其追求较短的代码，不如追求最佳的big-o表示法复杂性，这样代码的性能更高，更少的代码行不一定与性能相关。

public class CoolDude {
    public static void main(String[] args) {
        for (int i = 100; i <= 500; ++i) {
            if (i % 5 == 0) {
                if (i % 11 == 0) {
                    System.out.printf("Cool Dude - %d\n", i);
                } else {
                    System.out.printf("Cool - %d\n", i);
                }
            } else if (i % 11 == 0) {
                System.out.printf("Dude - %d\n", i);
            }
        }
    }
}

IntStream.rangeClosed(100,500).forEach(i->{
        if(i%5 == 0 && i%11 == 0) {
            System.out.println("Cool Dude - "+i );
        } else if (i%5 == 0) {
            System.out.println("Cool - "+i );
        } else if (i%11 == 0) {
            System.out.println("Dude - "+i );
        }
    });

下面的代码应该会减少代码行数，尽管它似乎运行得不快。它还修正了连字符周围的间距，并可能简化了逻辑。

public class CoolDude {
public static void main(String args[]) {
    for (int i = 100; i <= 500; ++i) {
        StringBuilder coolDude = new StringBuilder(15); //15 chars max "Cool Dude - 495"
        if (i % 5 == 0) {
            coolDude.append("Cool ".toCharArray());
        }
        if (i % 11 == 0) {
            coolDude.append("Dude ".toCharArray());
        }
        if (coolDude.length() > 0) {
            System.out.println(coolDude.append(("- " + i).toCharArray()));
        }
    }
}
}

修订：我的观点是，可以利用每次通过循环只进行一次mod计算的优势。在尝试使用stringbuilders和一条线来节省时间的过程中迷失了方向（正如其他人指出的，这不是一个值得实现的目标）。我用print和println来解释。

public class CoolDude {
public static void main(String args[]) {
    boolean printed = false;
    for (int i = 100; i <= 500; ++i, printed = false) {
        if (i % 5 == 0) {
            System.out.print("Cool ");
            printed = true;
        }
        if (i % 11 == 0) {
            System.out.print("Dude ");
            printed = true;
        }
        if (printed) {
            System.out.println("- " + i);
        }
    }
}
}