Take a look at String.format. Note, however, that it takes format specifiers similar to those of C's printf family of functions -- for example:

String.format("Hello %s, %d", "world", 42);

…would return "Hello world, 42". The "format string" link points to the complete official spec, but for simple cases, this much shorter documentation may be helpful for an introduction to format specifiers even though it's outdated and about Lava. The most commonly used ones are:

• %s - insert a string
• %d - insert a signed integer (decimal)
• %f - insert a real number, standard notation

This is radically different from C#, which uses positional references with an optional format specifier. That means that you can't do things like:

String.format("The {0} is repeated again: {0}", "word");

... without actually repeating the parameter passed to printf/format. (see The Scrum Meister's comment below)

If you just want to print the result directly, you may find System.out.printf (PrintStream.printf) to your liking.

New JDK features

String templates since Java 21 (as the first preview)

Introduced as JEP-460 (Preview) in Java 21 and later as JEP-459 (Second Preview) in Java 22. The API is not definitive and this part of the answer is a subject of changes.

This enhancement brings template processors for performing string interpolation.

• STR is statically imported implicitly and interpolated immediatelly:

  int x = 10;
  int y = 20;
  // results in "10 + 20 = 30"
  String result = STR."\{x} + \{y} = \{x + y}";
  

• RAW must be statically imported explicitly and the interpolation is deffered:

  int x = 10;
  int y = 20;
  StringTemplate st = RAW."\{x} + \{y} = \{x + y}";
  ...
  // results in "10 + 20 = 30"
  String result = STR.process(st);
  

• FMT combines STR with Java's Formatter:

  int x = 10;
  int y = 20;
  // results in "10 + 20 =      30.00"
  String result = FMT."%d\{x} + %d\{y} = %7.2f\{x + y}";
  

Format-first since Java 15, alternative to String#format

There is a new instance method called String#formatted(Object... args) as of Java 15.

The internal implementation is the same as String#format(String format, Object... args).

Formats using this string as the format string, and the supplied arguments.

String step1 = "one";
String step2 = "two";

// results in "Step one of two"
String string = "Step %s of %s".formatted(step1, step2);     

Advantage: The difference is that the method is not static and the formatting pattern is a string itself from which a new one is created based on the args. This allows chaining to build the format itself first.

Disadvantage: There is no overloaded method with Locale, therefore uses the default one. If you need to use a custom Locale, you have to stick with String#format(Locale l, String format, Object... args).

Old JDK features

These are not deprecated and remain relevant until today.

String#format

The most frequent way to format a String is using this static method, that is long available since Java 5 and has two overloaded methods:

• String#format(String format, Object args...)
• String#format(Locale l, String format, Object args...)

The method is easy to use and the format pattern is defined by underlying formatter.

String step1 = "one";
String step2 = "two";

// results in "Step one of two"
String string = String.format("Step %s of %s", step1, step2); 

You can pass a Locale to respect the language and regional specification. Refer to this answer for more information: https://stackoverflow.com/a/6431949/3764965 (credits to Martin Törnwall).

MessageFormat

The MessageFormat class is available since the first version of Java and is suitable for internationalization. In the simplest form, there is a static method for formatting:

• MessageFormat#format​(String pattern, Object... arguments)

String step1 = "one";
String step2 = "two";

// results in "Step one of two"
String string = MessageFormat.format("Step {0} of {1}", step1, step2);

Remember MessageFormat follows a specific pattern different from String#format, refer to its JavaDoc for more details: MessageFormat - patterns.

It is possible to use Locale, however, one has to instantiate the object of the class and pass it to the constructor since the static method above uses the default constructor with the default locale. Refer to this answer for more information: https://stackoverflow.com/a/6432100/3764965 (credits to ataylor).

StringBuilder and String concatenation

These are well known and described anywhere else.

Non-JDK solutions

There are plenty of ways to format Strings using external libraries. They add little to no benefit if the libraries are imported solely for the purpose of String formatting. Few examples:

• Apache Commons: StringSubstitutor, examples in its JavaDoc.
• Cactoos: FormattedText, examples here.
• Interestingly, Guava doesn't plan to add formatting or templating features: #1142.
• ... and other custom implementations.

^{Feel free to add more, however, I find no reason to further expand this section.}

If you choose not to use String.format, the other option is the + binary operator

String str = "Step " + a + " of " + b;

This is the equivalent of

new StringBuilder("Step ").append(String.valueOf(1)).append(" of ").append(String.valueOf(2));

Whichever you use is your choice. StringBuilder is faster, but the speed difference is marginal. I prefer to use the + operator (which does a StringBuilder.append(String.valueOf(X))) and find it easier to read.

I've wrote my simple method for it :

public class SomeCommons {
    /** Message Format like 'Some String {0} / {1}' with arguments */
    public static String msgFormat(String s, Object... args) {
        return new MessageFormat(s).format(args);
    }
}

so you can use it as:

SomeCommons.msgFormat("Step {1} of {2}", 1 , "two");

public class StringFormat {

    public static void main(String[] args) {
            Scanner sc=new Scanner(System.in);
            System.out.println("================================");
            for(int i=0;i<3;i++){
                String s1=sc.next();
                int x=sc.nextInt();
                System.out.println(String.format("%-15s%03d",s1,x));
            }
            System.out.println("================================");

    }
}

outpot "================================"
ved15space123 ved15space123 ved15space123 "================================

Java solution

• The "-" is used to left indent

• The "15" makes the String's minimum length it takes up be 15

• The "s" (which is a few characters after %) will be substituted by our String
• The 0 pads our integer with 0s on the left
• The 3 makes our integer be a minimum length of 3

JEP 430: String Templates (Preview)

You can use Java's String Templates feature. It is described in JEP 430, and it appears in JDK 21 as a preview feature.

Here is an example use:

String name = "Joan";
String info = STR."My name is \{name}";
assert info.equals("My name is Joan");   // true

Java's string templates are more versatile, and much safer, than features in other languagues such as C#'s string interpolation and Python's f-strings. For example, string concatenation or interpolation makes SQL injection attacks possible:

String query = "SELECT * FROM Person p WHERE p.last_name = '" + name + "'";
ResultSet rs = conn.createStatement().executeQuery(query);

but this variant (from JEP 430) prevents SQL injection:

PreparedStatement ps = DB."SELECT * FROM Person p WHERE p.last_name = \{name}";
ResultSet rs = ps.executeQuery();

Apache Commons Text's StringSubstitutor provides a simple and readable way to format Strings with named variables.

import org.apache.commons.text.StringSubstitutor;
// ...
Map<String, String> values = new HashMap<>();
values.put("animal", "quick brown fox");
values.put("target", "lazy dog");
StringSubstitutor sub = new StringSubstitutor(values);
String result = sub.replace("The ${animal} jumped over the ${target}.");
// "The quick brown fox jumped over the lazy dog."

This class supports providing default values for variables.

String result = sub.replace("The number is ${undefined.property:-42}.");
// "The number is 42."

To use recursive variable replacement, call setEnableSubstitutionInVariables(true);.

Map<String, String> values = new HashMap<>();
values.put("b", "c");
values.put("ac", "Test");
StringSubstitutor sub = new StringSubstitutor(values);
sub.setEnableSubstitutionInVariables(true);
String result = sub.replace("${a${b}}");
// "Test"

This solution worked for me. I needed to create urls for a REST client dynamically so I created this method, so you just have to pass the restURL like this

/customer/{0}/user/{1}/order

and add as many params as you need:

public String createURL (String restURL, Object ... params) {       
    return new MessageFormat(restURL).format(params);
}

You just have to call this method like this:

createURL("/customer/{0}/user/{1}/order", 123, 321);

The output

"/customer/123/user/321/order"

java.util.Formatter

Java has the java.util.Formatter which is used internally for String formatting methods. It's quite powerful, albeit more complex to use.

Here is a guide for what you should use depending on your version of Java.

Java 15 and later

Call instance method String#formatted.

// Sequential string arguments
"foo %s baz %s".formatted("bar", "foobar");

// Indexed string arguments
"foo %1$s baz %2$s".formatted("bar", "foobar");

Java 5 to Java 14

Call static method String.format.

// Sequential string arguments
String.format("foo %s baz %s", "bar", "foobar");

// Indexed string arguments
String.format("foo %1$s baz %2$s", "bar", "foobar");

Java 4 and earlier

MessageFormat.format("foo {0} baz {1}", "bar", "foo");

That last example is for completeness' sake, and you should not be using it since it's the slowest of all options.

I wrote this function it does just the right thing. Interpolate a word starting with $ with the value of the variable of the same name.

private static String interpol1(String x){
    Field[] ffield =  Main.class.getDeclaredFields();
    String[] test = x.split(" ") ;
    for (String v : test ) {
        for ( Field n: ffield ) {
            if(v.startsWith("$") && ( n.getName().equals(v.substring(1))  )){
                try {
                    x = x.replace("$" + v.substring(1), String.valueOf( n.get(null)));
                }catch (Exception e){
                    System.out.println("");
                }
            }
        }
    }
    return x;
}

The org.apache.commons.text.StringSubstitutor helper class from Apache Commons Text provides named variable substitution

Map<String, String> valuesMap = new HashMap<>();
valuesMap.put("animal", "quick brown fox");
valuesMap.put("target", "lazy dog");
String resolved = new StringSubstitutor(valuesMap).replace("The ${animal} jumped over the ${target}.");
System.out.println(resolved); // The quick brown fox jumped over the lazy dog.