Hey there! Let's unpack that tricky for loop you're seeing in your linked list delete method—first the English pronunciation, then when and why to use this style.

1. How to Read This For Loop in English #

The loop in question is:

for ( ; tmp != null && !(tmp.info.equals(el)); pred = pred.next, tmp = tmp.next);

You'd read it out loud like this:

"For [no initial setup], while tmp is not null AND tmp's info does NOT equal the element we're deleting, update pred to point to its next node AND tmp to point to its next node—then exit the loop when the condition fails."

Breaking down the parts clearly:

• The first empty section (; right at the start): We don't need any initialization inside the for loop because we already set up pred and tmp before the loop runs.
• The middle section: This is the loop's continuation condition—the loop keeps going only as long as both tmp isn't at the end of the list and we haven't found the target element.
• The last section: This is the update clause—every iteration moves both the predecessor pointer (pred) and current pointer (tmp) forward one step in the list, keeping them synchronized.
• The trailing ;: This means there's no code inside the loop body—all the necessary work happens in the condition check and variable updates.

2. Best Use Cases for This Style of For Loop #

This compact for loop is perfect for specific scenarios:

• Tracking synchronized variables: Like in your linked list example, when you need to keep two pointers (predecessor and current) in lockstep as you traverse. Putting both updates in the for loop's final clause keeps logic grouped together, which is cleaner than spreading updates across a while loop.
• Pre-initialized loop variables: When your loop variables are already set up before the loop starts (like pred and tmp here), skipping the initialization section avoids redundant code.
• Loop-as-search: When the loop's only job is to iterate until a condition is met (finding an element, reaching the end of a collection) and you don't need to run any extra code inside the loop body. The empty body (;) signals that all action lives in the condition and update steps.

3. Context in Your Delete Method #

Let's tie this back to your code to see why it works so well here:
Before the loop, we set pred = head and tmp = head.next—we start searching from the second node because we already handled the edge case where the head itself is the element to delete.

The loop exits when either:

• tmp becomes null (we reached the end of the list without finding the element), OR
• tmp.info.equals(el) is true (we found the element to delete).

Once the loop ends, if tmp isn't null, we know we found our target—so we skip over tmp by setting pred.next = tmp.next, effectively removing it from the linked list.

This style keeps the traversal logic concise and contained, avoiding messy while loops with scattered variable updates.

内容的提问来源于stack exchange，提问作者Alan Kamali