c# - online - Java Equivalente al String.Format de.NET

text to c# string

Question

¿Existe un equivalente al String.Format de .NET en Java?

Answer 1

Eche un vistazo a los métodos String.format y PrintStream.format .

Ambos se basan en la clase java.util.Formatter .

Ejemplo de 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"

Ejemplo de System.out.format:

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

Answer 2

Esta no es realmente una respuesta a la pregunta del OP, pero puede ser útil para otros que buscan una manera simple de realizar la sustitución de cadenas en una cadena que contenga "elementos de formato" de estilo 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();
}

(Y en caso de que tenga curiosidad, estoy usando este código como parte de un envoltorio simple para los métodos de registro de Android, para que sea más fácil registrar varias cosas en un solo mensaje de registro).

Answer 3

Hay MessageFormat.format() que usa la notación .net.

Answer 4

Hay un String.format en Java, aunque la sintaxis es un poco diferente de en .NET.

Answer 5

La respuesta de 10 centavos a esto es:

C # ''s

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

es equivalente a Java

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

Tenga en cuenta el índice basado en 1, y la "s" significa convertir a cadena usando .toString (). Hay muchas otras conversiones disponibles y opciones de formato:

http://download.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html#syntax

Answer 6

También puede usar %s para la cadena ya que el índice es un argumento opcional.

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

Es menos ruidoso

Nota sobre %s de la documentación de Java:

Si el argumento arg es nulo, entonces el resultado es "nulo". Si arg implementa Formattable, entonces se invoca arg.formatTo. De lo contrario, el resultado se obtiene al invocar arg.toString ().