It just takes the variables hour, minute, and second and bring it the the format 05:23:42. Maybe another example would be this:

String s = String.format("Hello %s answered your question", "placeofm");

When you print the string to show it in the console it would look like this

System.out.println(s);

Hello placeofm answered your question

The placeholder %02d is for a decimal number with two digits. %s is for a String like my name in the sample above. If you want to learn Java you have to read the docs. Here it is for the String class. You can find the format method with a nice explanation. To read this docs is really important not even in Java.

In addition to String.format, also take a look java.text.MessageFormat. The format less terse and a bit closer to the C# example you've provided and you can use it for parsing as well.

For example:

int someNumber = 42;
String someString = "foobar";
Object[] args = {new Long(someNumber), someString};
MessageFormat fmt = new MessageFormat("String is \"{1}\", number is {0}.");
System.out.println(fmt.format(args));

A nicer example takes advantage of the varargs and autoboxing improvements in Java 1.5 and turns the above into a one-liner:

MessageFormat.format("String is \"{1}\", number is {0}.", 42, "foobar");

MessageFormat is a little bit nicer for doing i18nized plurals with the choice modifier. To specify a message that correctly uses the singular form when a variable is 1 and plural otherwise, you can do something like this:

String formatString = "there were {0} {0,choice,0#objects|1#object|1<objects}";
MessageFormat fmt = new MessageFormat(formatString);
fmt.format(new Object[] { new Long(numberOfObjects) });

Text Blocks were finalized and permanently added in JDK 15 and some additional methods added to support text blocks. One of this methods is:

String::formatted(Object... args)

And I know the functions of two codes below are the same.

As you mentioned in your question both methods do the same job and return same results. The goal of introducing such a method is:

simplify value substitution in the Text Block.

Based on JEP (JDK Enhancement Proposals) 378:

Text blocks do not directly support string interpolation. Interpolation may be considered in a future JEP. In the meantime, the new instance method String::formatted aids in situations where interpolation might be desired.

As an example you consider this code segment:

String code = String.format("""
      public void print(%s o) {
          System.out.println(Objects.toString(o));
      }
      """, type);

We can change it using formatted method as:

String source = """
        public void print(%s object) {
            System.out.println(Objects.toString(object));
        }
        """.formatted(type);

Which is cleaner.

Also consider these minor differences between them when using the methods:

public static String format(String format, Object... args)

• Returns a formatted string using the format string and arguments.
• It's a static method of String class.
• It's introduced in Java SE 5 [since 2004].

public String formatted(Object... args)

• Formats using this string as the format string, and the supplied arguments.
• It's an instance method of String class.
• It's introduced in Java SE 15 (JDK 15) [since 2020].
• This method is equivalent to String.format(this, args)