¿Cómo usar java.String.format en Scala?

Question

Estoy tratando de usar un método .format de una cadena. Pero si coloco% 1,% 2, etc. en la cadena, se lanza java.util.UnknownFormatConversionException que apunta a una parte confusa del código fuente de Java:

private void checkText(String s) {
int idx;
// If there are any ''%'' in the given string, we got a bad format
// specifier.
if ((idx = s.indexOf(''%'')) != -1) {
char c = (idx > s.length() - 2 ? ''%'' : s.charAt(idx + 1));
throw new UnknownFormatConversionException(String.valueOf(c));
}
}

De esto entiendo que % char está prohibido. Si es así, ¿entonces qué debo usar para los marcadores de posición de argumento?

Yo uso Scala 2.8.

Answer 1

Aquí hay una lista de formateadores usados ​​con String.format ()

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

Answer 2

Aunque @Londo mencionó el interpolador de cuerdas "s" de Scala, creo que el interpolador de cuerdas "f" de Scala es más relevante para la pregunta original. El ejemplo utilizado un poco de tiempo en otras respuestas también podría escribirse (desde Scala 2.10) de esta manera:

scala> val name = "Ivan"
name: String = Ivan
scala> val thing = "Scala"
thing: String = Scala
scala> val formatted = f"Hello $name%s, isn''t $thing%s cool?"
formatted: String = Hello Ivan, isn''t Scala cool?

La conexión a la pregunta original es tener en cuenta que:

• formatted se define con una cadena que tiene el prefijo con la letra "f". Este es el interpolador de cadenas "f" (formateo).
• El interpolador de cadenas "f" usa java.util.Formatter
• java.lang.String.format usa el mismo java.util.Formatter

Lo bueno de la interpolación de cadenas es que le permite ver qué variable se está sustituyendo directamente en la cadena en lugar de tener que coincidir con los argumentos del método String.format .

Answer 3

En Scala 2.10

val name = "Ivan"
val weather = "sunny"
s"Hello $name, it''s $weather today!"

Answer 4

En Scala, para la interpolación de cuerdas tenemos $ que salvan el día y hacen nuestra vida mucho más fácil:

Por ejemplo: desea definir una función que tome el nombre y la edad de entrada y diga Hola con el nombre y diga su edad. Eso se puede escribir así:

def funcStringInterpolationDemo(name:String,age:Int)=s"Hey ! my name is $name and my age is $age"

Por lo tanto, cuando llamas a esta función: así:

funcStringInterpolationDemo("Shivansh",22)

Su salida sería:

Hey ! my name is Shivansh and my age is 22

Puede escribir el código para cambiarlo en la misma línea, como si desea agregar 10 años a la edad.

entonces la función podría ser:

def funcStringInterpolationDemo(name:String,age:Int)=s"Hey ! my name is $name and my age is ${age+10}"

Y ahora la salida sería:

Hey ! my name is Shivansh and my age is 32

Answer 5

En lugar de mirar el código fuente, debes leer la String.format() y el formateador javadoc.

Se especifica el formato del valor después del%. Por ejemplo, para el entero decimal es d , y para String es s :

String aString = "world";
int aInt = 20;
String.format("Hello, %s on line %d", aString, aInt );

Salida:

Hello, world on line 20

Para hacer lo que intentaste (usar un índice de argumentos), usas: *n*$ ,

String.format("Line:%2$d. Value:%1$s. Result: Hello %1$s at line %2$d", aString, aInt );

Salida:

Line:20. Value:world. Result: Hello world at line 20

Answer 6

Esta es una lista de lo que String.format puede hacer. Lo mismo ocurre con printf

int i = 123;
o.printf( "|%d|%d|%n" , i, -i ); // |123|-123|
o.printf( "|%5d|%5d|%n" , i, -i ); // | 123| –123|
o.printf( "|%-5d|%-5d|%n" , i, -i ); // |123 |-123 |
o.printf( "|%+-5d|%+-5d|%n" , i, -i ); // |+123 |-123 |
o.printf( "|%05d|%05d|%n%n", i, -i ); // |00123|-0123|
o.printf( "|%X|%x|%n", 0xabc, 0xabc ); // |ABC|abc|
o.printf( "|%04x|%#x|%n%n", 0xabc, 0xabc ); // |0abc|0xabc|
double d = 12345.678;
o.printf( "|%f|%f|%n" , d, -d ); // |12345,678000| |-12345,678000|
o.printf( "|%+f|%+f|%n" , d, -d ); // |+12345,678000| |-12345,678000|
o.printf( "|% f|% f|%n" , d, -d ); // | 12345,678000| |-12345,678000|
o.printf( "|%.2f|%.2f|%n" , d, -d ); // |12345,68| |-12345,68|
o.printf( "|%,.2f|%,.2f|%n" , d, -d ); // |12.345,68| |-12.345,68|
o.printf( "|%.2f|%(.2f|%n", d, -d ); // |12345,68| |(12345,68)|
o.printf( "|%10.2f|%10.2f|%n" , d, -d ); // | 12345,68| | –12345,68|
o.printf( "|%010.2f|%010.2f|%n",d, -d ); // |0012345,68| |-012345,68|
String s = "Monsterbacke";
o.printf( "%n|%s|%n", s ); // |Monsterbacke|
o.printf( "|%S|%n", s ); // |MONSTERBACKE|
o.printf( "|%20s|%n", s ); // | Monsterbacke|
o.printf( "|%-20s|%n", s ); // |Monsterbacke |
o.printf( "|%7s|%n", s ); // |Monsterbacke|
o.printf( "|%.7s|%n", s ); // |Monster|
o.printf( "|%20.7s|%n", s ); // | Monster|
Date t = new Date();
o.printf( "%tT%n", t ); // 11:01:39
o.printf( "%tD%n", t ); // 04/18/08
o.printf( "%1$te. %1$tb%n", t ); // 18. Apr

Answer 7

La referencia oficial es la clase Formatter .

Answer 8

No es necesario utilizar números para indicar el posicionamiento. Por defecto, la posición del argumento es simplemente el orden en que aparece en la cadena.

Aquí hay un ejemplo de la forma correcta de usar esto:

String result = String.format("The format method is %s!", "great");
// result now equals "The format method is great!".

Siempre usarás un % seguido de algunos otros caracteres para que el método sepa cómo debe mostrar la cadena. %s es probablemente el más común, y solo significa que el argumento debe tratarse como una cadena.

No listaré todas las opciones, pero daré algunos ejemplos solo para darles una idea:

// we can specify the # of decimals we want to show for a floating point:
String result = String.format("10 / 3 = %.2f", 10.0 / 3.0);
// result now equals "10 / 3 = 3.33"
// we can add commas to long numbers:
result = String.format("Today we processed %,d transactions.", 1000000);
// result now equals "Today we processed 1,000,000 transactions."

String.format solo usa un java.util.Formatter , así que para una descripción completa de las opciones puede ver el Formatter javadocs .

Y, como menciona BalusC, verá en la documentación que es posible cambiar el orden predeterminado de los argumentos si lo necesita. Sin embargo, probablemente la única vez que necesite / quiera hacer esto es si está usando el mismo argumento más de una vez.

Answer 9

Puedes usar esto;

String.format("%1$s %2$s %2$s %3$s", "a", "b", "c");

Salida:

abbc

Answer 10

Si bien todas las respuestas anteriores son correctas, todas están en Java. Aquí hay un ejemplo de Scala:

val placeholder = "Hello %s, isn''t %s cool?"
val formatted = placeholder.format("Ivan", "Scala")

También tengo una publicación en el blog sobre cómo hacer un format como el operador % de Python que podría ser útil.

Answer 11

También tenga en cuenta que Scala extiende la cadena con varios métodos (mediante la conversión implícita a una WrappedString presentada por Predef), por lo que también podría hacer lo siguiente:

val formattedString = "Hello %s, isn''t %s cool?".format("Ivan", "Scala")