web-dev-qa-db-fra.com

Java équivalent à String.Format de .NET

Existe-t-il un équivalent de String.Format .NET en Java?

c#java.netstring
60
BuddyJoe

Jetez un œil aux méthodes String.format et PrintStream.format .

Les deux sont basés sur classe Java.util.Formatter .

Exemple String.format: 

Calendar c = new GregorianCalendar(1995, MAY, 23);
String s = String.format("Duke's Birthday: %1$tm %1$te,%1$tY", c);
// -> s == "Duke's Birthday: May 23, 1995"

Exemple System.out.format: 

// Writes a formatted string to System.out.
System.out.format("Local time: %tT", Calendar.getInstance());
// -> "Local time: 13:34:18"
31
dtb

La réponse de 10 cents à ceci est:

C #


String.Format("{0} -- {1} -- {2}", ob1, ob2, ob3)

est équivalent à Java


String.format("%1$s -- %2$s -- %3$s", ob1, ob2, ob3)

Notez l'index basé sur 1 et le "s" signifie pour convertir en chaîne en utilisant .toString (). Il existe de nombreuses autres conversions et options de formatage disponibles:

http://download.Oracle.com/javase/1.5.0/docs/api/Java/util/Formatter.html#syntax

116
Oscar Boykin

Il y a MessageFormat.format() qui utilise la notation .net.

30
MrSnowflake

Vous pouvez également simplement utiliser %s pour chaîne puisque l'index est un argument optionnel.

String name = "Jon";
int age = 26;
String.format("%s is %s years old.", name, age);

C'est moins bruyant.

Remarque sur %s dans la documentation Java:

Si l'argument arg est nul, le résultat est "nul". Si arg implémente Formattable, alors arg.formatTo est invoqué. Sinon, le résultat est obtenu en appelant arg.toString ().

18
Nicolas Guillaume

Il y a un String.format en Java, bien que la syntaxe soit légèrement différente de celle en .NET.

7
Mark Byers

Ce n'est pas vraiment une réponse à la question de l'OP, mais cela peut être utile à ceux qui recherchent un moyen simple d'effectuer la substitution de chaînes en une chaîne contenant des "éléments de format" de style C #.

   /**
    * Method to "format" an array of objects as a single string, performing two possible kinds of
    * formatting:
    *
    * 1. If the first object in the array is a String, and depending on the number of objects in the
    *    array, then a very simplified and simple-minded C#-style formatting is done. Format items
    *    "{0}", "{1}", etc., are replaced by the corresponding following object, converted to string
    *    (of course). These format items must be as shown, with no fancy formatting tags, and only
    *    simple string substitution is done.
    *
    * 2. For the objects in the array that do not get processed by point 1 (perhaps all of them,
    *    perhaps none) they are converted to String and concatenated together with " - " in between.
    *
    * @param objectsToFormat  Number of objects in the array to process/format.
    * @param arrayOfObjects  Objects to be formatted, or at least the first objectsToFormat of them.
    * @return  Formatted string, as described above.
    */
   public static String formatArrayOfObjects(int objectsToFormat, Object... arrayOfObjects) {

      // Make a preliminary pass to avoid problems with nulls
      for (int i = 0; i < objectsToFormat; i++) {
         if (arrayOfObjects[i] == null) {
            arrayOfObjects[i] = "null";
         }
      }

      // If only one object, just return it as a string
      if (objectsToFormat == 1) {
         return arrayOfObjects[0].toString();
      }

      int nextObject = 0;
      StringBuilder stringBuilder = new StringBuilder();

      // If first object is a string it is necessary to (maybe) perform C#-style formatting
      if (arrayOfObjects[0] instanceof String) {
         String s = (String) arrayOfObjects[0];

         while (nextObject < objectsToFormat) {

            String formatItem = "{" + nextObject + "}";
            nextObject++;
            if (!s.contains(formatItem)) {
               break;
            }

            s = s.replace(formatItem, arrayOfObjects[nextObject].toString());
         }

         stringBuilder.append(s);
      }

      // Remaining objects (maybe all of them, maybe none) are concatenated together with " - "
      for (; nextObject < objectsToFormat; nextObject++) {
         if (nextObject > 0) {
            stringBuilder.append(" - ");
         }
         stringBuilder.append(arrayOfObjects[nextObject].toString());
      }

      return stringBuilder.toString();
   }

(Et au cas où vous seriez curieux, j'utilise ce code dans le cadre d'un simple wrapper pour les méthodes de journalisation Android, pour faciliter la journalisation de plusieurs éléments dans un seul message de journal). )

3
RenniePet