Introduction

In Java, you do not need to pass the same value multiple times to String.format just because it appears more than once in the output. The format syntax supports argument indexes, which let you reuse an earlier argument anywhere in the format string.

The Default Behavior

Without indexes, String.format consumes arguments in order from left to right. That means repeated placeholders normally require repeated arguments.

1String name = "Mark";
2
3String message = String.format(
4    "%s likes %s because %s is useful.",
5    name,
6    name,
7    name
8);
9
10System.out.println(message);

This works, but it is repetitive and gets harder to maintain when the format string is long.

Reuse an Argument With an Index

Java format specifiers can include an explicit argument position. The syntax 1$ means "use the first argument again", 2$ means the second, and so on.

1String name = "Mark";
2
3String message = String.format(
4    "%1$s likes %1$s because %1$s is useful.",
5    name
6);
7
8System.out.println(message);

That is the usual answer to this question: pass the value once, then refer to it multiple times with the same argument index.

Why Argument Indexes Are Useful

Indexes are not only for repeated values. They are also useful when you need to reorder values in the output, which is common in localization and templates where word order changes by language.

1String first = "Ada";
2String second = "Lovelace";
3
4String fullName = String.format("%2$s, %1$s %2$s", first, second);
5System.out.println(fullName);

Because the format string controls the positions explicitly, the caller can pass the values once and the formatter can reuse or reorder them as needed.

Keep Types Matched to the Placeholder

The argument index only selects the argument. The conversion part of the specifier still matters. For example:

• '%1$s treats the first argument as a string representation'
• '%1$d expects the first argument to be an integer'
• '%1$.2f formats the first argument as a floating-point number with two decimals'

1int count = 7;
2
3String output = String.format(
4    "Count: %1$d, doubled count label: %1$d items",
5    count
6);
7
8System.out.println(output);

The same argument can be reused as long as the conversion makes sense for the underlying type.

A Practical Example

Consider building an SQL debug message, a file name, or a repeated label:

1String table = "orders";
2
3String logMessage = String.format(
4    "Reading table %1$s, validating table %1$s, finished table %1$s",
5    table
6);
7
8System.out.println(logMessage);

Passing table once is cleaner than repeating it three times in the argument list. It also reduces the chance of accidentally changing one copy and forgetting the others.

When Repetition Is Still Reasonable

If the format string is tiny, repeating the argument may not be a real problem. The indexed form becomes most valuable when:

• the same argument appears many times
• the template is long
• output order is not the same as input order
• the string is used in localization

In short, indexes are a readability tool as much as a convenience feature.

Common Pitfalls

The first mistake is forgetting the $ syntax. %1s is not the same as %1$s; the indexed form must include the dollar sign after the position.

Another common issue is mixing indexed and non-indexed placeholders in the same format string. That can lead to confusing behavior and is best avoided.

Type mismatches are another source of errors. Reusing %1$d is fine for integers, but it will fail if the first argument is actually a string.

Finally, do not overuse formatting for cases where normal string concatenation or text blocks would be clearer. String.format is most helpful when you truly need structured placeholder substitution.

Summary

• You do not need to pass the same Java argument multiple times to String.format.
• Use indexed placeholders such as %1$s to reuse the first argument.
• Argument indexes also help when values must appear in a different order.
• The conversion letter still has to match the argument type.
• Avoid mixing indexed and non-indexed placeholders in one format string.