Sprintf equivalent in Java

Question

Printf got added to Java with the 1.5 release but I can't seem to find how to send the output to a string rather than a file (which is what sprintf does in C). Does anyone know how to do this?

Answer 1

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.

Answer 2

@erickson.

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

Because of that, "foo".format() makes little sense, as it would have to be called like

string newString = "foo".format();

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

EDIT: Heh, this site can be so amusing sometimes. I got downvoted for mentioning the fact that strings are immutable types.

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:

// Contrived Example
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 whats 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, but erickson seems to think both belong as instance 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, its obvious we are not trying to modify "123", we 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.

Answer 3

// Store the formatted string in 'result'
String result = String.format("%4d", i * j);

// Write the result to standard output
System.out.println( result );

See format and its syntax