Java Loop Constructs and Clojure Equivalents

Java gives you loop statements. Clojure gives you expressions that return values. That difference matters more than the syntax.

When you move Java loop code into Clojure, start by asking what the loop is doing:

The rest of this page translates the Java constructs you already know into the Clojure choice that best preserves intent.

Classic for Loops: Counted Work

A Java for loop combines initialization, condition checking, mutation, and body execution:

1int total = 0;
2for (int i = 1; i <= 5; i++) {
3    total += i;
4}

In Clojure, the first translation is usually not direct recursion. If the loop is reducing a range to one value, use reduce:

1(def total
2  (reduce + (range 1 6)))

If the index is meaningful, make it data:

1(def labels
2  (map-indexed (fn [idx value]
3                 {:index idx
4                  :value value})
5               ["alpha" "beta" "gamma"]))

That mental move is important for Java engineers: the counter is often not control flow anymore; it is an input to a pure transformation.

Enhanced for: Collection Traversal

An enhanced Java for loop hides the index but still often mutates an external result:

1List<String> activeNames = new ArrayList<>();
2
3for (User user : users) {
4    if (user.isActive()) {
5        activeNames.add(user.getName());
6    }
7}

The Clojure version should make the transformation visible:

1(def active-names
2  (->> users
3       (filter :active?)
4       (map :name)
5       vec))

The result is explicit. There is no external collection to mutate, and each step can be tested independently.

while: State Until a Condition Fails

Java while loops are common when the number of iterations is not known:

1int attempts = 0;
2while (!ready() && attempts < 3) {
3    refresh();
4    attempts++;
5}

In Clojure, use a sequence operation if you are consuming values. Use loop/recur when you are advancing local state:

1(defn wait-until-ready [ready? refresh!]
2  (loop [attempts 0]
3    (cond
4      (ready?) :ready
5      (= attempts 3) :timed-out
6      :else (do
7              (refresh!)
8              (recur (inc attempts))))))

recur is not automatic tail-call optimization. It is an explicit jump back to the nearest loop or function entry, and Clojure only allows it in tail position. That restriction is useful because it makes stack-safe loops visible in the code.

do-while: Execute Once, Then Decide

Java’s do-while guarantees that the body runs at least once:

1String token;
2do {
3    token = readToken();
4} while (token.isBlank());

Clojure normally models that as a small recursive loop with the first read inside the loop body:

1(require '[clojure.string :as str])
2
3(defn read-nonblank-token [read-token]
4  (loop []
5    (let [token (read-token)]
6      (if (str/blank? token)
7        (recur)
8        token))))

This is one of the cases where loop/recur is clearer than forcing the code into map or reduce.

Break and Continue

Java gives you break and continue. Clojure usually encodes those decisions as data-flow choices:

Early termination with reduce uses reduced:

1(defn first-large-amount [amounts]
2  (reduce (fn [_ amount]
3            (when (> amount 1000)
4              (reduced amount)))
5          nil
6          amounts))

Use this sparingly. If some expresses the search directly, prefer it.

Choosing the Clojure Shape

    flowchart TD
	    A["Java loop"] --> B{"One result?"}
	    B -->|Yes| C["reduce or transduce"]
	    B -->|No| D{"New collection?"}
	    D -->|Yes| E["map, filter, keep, for, into"]
	    D -->|No| F{"Local evolving state?"}
	    F -->|Yes| G["loop/recur"]
	    F -->|No| H{"Nested recursive shape?"}
	    H -->|Yes| I["direct recursion or tree-seq"]
	    H -->|No| J["restate the problem as data transformation"]

Practice

1. Rewrite a Java loop that builds a list into a Clojure ->> pipeline.
2. Rewrite a Java loop that sums values into reduce.
3. Rewrite a Java while retry loop with loop/recur.
4. Identify one loop in your Java codebase that should remain imperative in Java but become a sequence transformation in Clojure.

Key Takeaways

• Java loops mix control flow, mutation, and result construction in one block.
• Clojure separates those concerns with sequence functions, reducers, explicit loop/recur, and direct recursion for nested shapes.
• Do not translate every Java loop into direct recursion. Translate the loop’s intent first.
• Use recur when you need an explicit local loop and can keep the recursive jump in tail position.

Quiz: Java Loops and Clojure Equivalents