Como usar java.String.format no Scala?

Eu estou tentando usar um método .format de uma seqüência de caracteres. Mas se eu colocar% 1,% 2, etc. na string, java.util.UnknownFormatConversionException será lançado apontando para uma parte confusa do código-fonte 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)); } } 

Disso eu entendo que % char é proibido. Se sim, então o que devo usar para marcadores de argumento?

Eu uso o Scala 2.8.

Embora todas as respostas anteriores estejam corretas, elas estão todas em Java. Aqui está um exemplo do Scala:

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

Eu também tenho uma postagem no blog sobre como fazer o format como o operador % do Python, que pode ser útil.

Você não precisa usar números para indicar posicionamento. Por padrão, a posição do argumento é simplesmente a ordem em que aparece na string.

Aqui está um exemplo da maneira correta de usar isso:

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

Você sempre usará um % seguido por alguns outros caracteres para informar ao método como ele deve exibir a string. %s é provavelmente o mais comum, e significa apenas que o argumento deve ser tratado como uma string.

Não vou listar todas as opções, mas vou dar alguns exemplos apenas para lhe dar uma ideia:

 // 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 apenas usa um java.util.Formatter , portanto, para obter uma descrição completa das opções, você pode ver os javadocs do Formatter .

E, como menciona o BalusC, você verá na documentação que é possível alterar a ordem padrão dos argumentos, se necessário. No entanto, provavelmente a única vez que você precisaria / queira fazer isso é se estiver usando o mesmo argumento mais de uma vez.

Em vez de olhar o código-fonte, você deve ler a syntax javadoc String.format () e Formatter .

Você especifica o formato do valor após o%. Por exemplo, para um inteiro decimal é d , e para String é s :

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

Saída:

 Hello, world on line 20 

Para fazer o que você tentou (use um índice de argumento), você usa: *n*$ ,

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

Saída:

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

Você pode usar isso;

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

Saída:

abbc

Observe também que o Scala estende o String com vários methods (por meio da conversão implícita para um WrappedString trazido pelo Predef), portanto, você também pode fazer o seguinte:

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

A referência oficial é a class Formatter .

Na Scala 2.10

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

Esta é uma lista do que String.format pode fazer. O mesmo vale para 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 

Aqui está uma lista de formatadores usados ​​com String.format ()

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

Embora @Londo tenha mencionado o interpolador de strings de Scala, acho que o interpolador de string “f” de Scala é mais relevante para a questão original. O exemplo usado em algumas outras respostas também pode ser escrito (desde Scala 2.10) desta forma:

 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? 

A conexão com a pergunta original é estar ciente de que:

  • formatted é definido com uma cadeia que é prefixada com a letra “f”. Este é o interpolador de string “f” (formatação).
  • O interpolador de seqüência “f” usa java.util.Formatter
  • java.lang.String.format usa o mesmo java.util.Formatter

O interessante da interpolação de strings é que ela permite ver qual variável está sendo substituída diretamente na string, em vez de ter que combiná-la com os argumentos para o método String.format .

Em scala, para interpolação de strings temos $ que economiza o dia e torna nossa vida muito mais fácil:

Por exemplo: você deseja definir uma function que aceita o nome e a idade da input e diz Olá com o nome e informa sua idade. Isso pode ser escrito assim:

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

Por isso, quando você chama esta function: assim:

 funcStringInterpolationDemo("Shivansh",22) 

Sua saída seria:

 Hey ! my name is Shivansh and my age is 22 

Você pode escrever o código para alterá-lo na mesma linha, como se você quiser adicionar 10 anos à idade!

então a function poderia ser:

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

E agora a saída seria:

 Hey ! my name is Shivansh and my age is 32