Sprintf equivalent in Java

Strings are immutable types. You cannot modify them, only return new string instances.

Because of that, formatting with an instance method makes little sense, as it would have to be called like:

String formatted = "%s: %s".format(key, value);

The original Java authors (and .NET authors) decided that a static method made more sense in this situation, as you are not modifying the target, but instead calling a format method and passing in an input string.

Here is an example of why format() would be dumb as an instance method. In .NET (and probably in Java), Replace() is an instance method.

You can do this:

 "I Like Wine".Replace("Wine","Beer");

However, nothing happens, because strings are immutable. Replace() tries to return a new string, but it is assigned to nothing.

This causes lots of common rookie mistakes like:

inputText.Replace(" ", "%20");

Again, nothing happens, instead you have to do:

inputText = inputText.Replace(" ","%20");

Now, if you understand that strings are immutable, that makes perfect sense. If you don't, then you are just confused. The proper place for Replace() would be where format() is, as a static method of String:

 inputText = String.Replace(inputText, " ", "%20");

Now there is no question as to what's going on.

The real question is, why did the authors of these frameworks decide that one should be an instance method, and the other static? In my opinion, both are more elegantly expressed as static methods.

Regardless of your opinion, the truth is that you are less prone to make a mistake using the static version, and the code is easier to understand (No Hidden Gotchas).

Of course there are some methods that are perfect as instance methods, take String.Length()

int length = "123".Length();

In this situation, it's obvious we are not trying to modify "123", we are just inspecting it, and returning its length. This is a perfect candidate for an instance method.

My simple rules for Instance Methods on Immutable Objects:

• If you need to return a new instance of the same type, use a static method.
• Otherwise, use an instance method.

Since Java 13 you have formatted 1 method on String, which was added along with text blocks as a preview feature 2.You can use it instead of String.format()

Assertions.assertEquals("%s %d %.3f".formatted("foo", 123, 7.89),"foo 123 7.890");

You can do a printf with a PrintStream to anything that is an OutputStream.Somehow like this, printing into a string stream:

PrintStream ps = new PrintStream(baos);ps.printf("there is a %s from %d %s", "hello", 3, "friends");System.out.println(baos.toString());

This outputs following text there is a hello from 3 friendsThe string stream can be created like this ByteArrayOutputStream:

ByteArrayOutputStream baos = new ByteArrayOutputStream();

You can accumulate many formats:

PrintStream ps = new PrintStream(baos);ps.printf("there is a %s from %d %s ", "hello", 3, "friends");ps.printf("there are %d % from a %", 2, "kisses", "girl");System.out.println(baos.toString());

This outputs there is a hello from 3 friends there are 2 kisses from a girl
Call reset on ByteArrayOutputStream to generate a clean new string

ps.printf("there is a %s from %d %s", "flip", 5, "haters");baos.reset(); //need reset to write new stringps.printf("there are %d % from a %", 2, "kisses", "girl");System.out.println(baos.toString());

The output will be there are 2 kisses from a girl

Both solutions workto simulate printf, but in a different way.For instance, to convert a value to a hex string, you have the 2 following solutions:

• with format(), closest to sprintf():

  final static String HexChars = "0123456789abcdef";public static String getHexQuad(long v) {String ret;if(v > 0xffff) ret = getHexQuad(v >> 16); else ret = "";ret += String.format("%c%c%c%c",HexChars.charAt((int) ((v >> 12) & 0x0f)),HexChars.charAt((int) ((v >> 8) & 0x0f)),HexChars.charAt((int) ((v >> 4) & 0x0f)),HexChars.charAt((int) ( v & 0x0f)));return ret;}

• with replace(char oldchar , char newchar), somewhat faster but pretty limited:

   ...ret += "ABCD".replace('A', HexChars.charAt((int) ((v >> 12) & 0x0f))).replace('B', HexChars.charAt((int) ((v >> 8) & 0x0f))).replace('C', HexChars.charAt((int) ((v >> 4) & 0x0f))).replace('D', HexChars.charAt((int) ( v & 0x0f)));...

• There is a third solution consisting of just adding the char to ret one by one (char are numbers that add to each other!) such as in:

  ...ret += HexChars.charAt((int) ((v >> 12) & 0x0f)));ret += HexChars.charAt((int) ((v >> 8) & 0x0f)));...

...but that'd be really ugly.