Я пытаюсь использовать метод .format
для строки. Но если я помещаю в строку% 1,% 2 и т.д., Java.util.UnknownFormatConversionException указывается на запутанную часть исходного кода 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));
}
}
Отсюда я понимаю, что %
char запрещено. Если да, то что я должен использовать для заполнителей аргументов?
Я использую Scala 2.8.
Хотя все предыдущие ответы верны, все они на Java. Вот пример Scala:
val placeholder = "Hello %s, isn't %s cool?"
val formatted = placeholder.format("Ivan", "Scala")
У меня также есть сообщение в блоге о создании format
например, оператора Python %
который может быть полезен.
Вам не нужно использовать цифры для указания позиционирования. По умолчанию позиция аргумента - это просто порядок, в котором он отображается в строке.
Вот пример правильного способа использования этого:
String result = String.format("The format method is %s!", "great");
// result now equals "The format method is great!".
Вы всегда будете использовать %
, за которым следуют некоторые другие символы, чтобы метод знал, как он должен отображать строку. %s
, вероятно, является наиболее распространенным, и это просто означает, что аргумент следует рассматривать как строку.
Я не буду перечислять каждый вариант, но я приведу несколько примеров, чтобы дать вам представление:
// 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
просто использует java.util.Formatter
, поэтому для полного описания параметров вы можете увидеть Formatter javadocs.
И, как упоминает BalusC, вы увидите в документации, что возможно изменить порядок аргументов по умолчанию, если вам нужно. Однако, вероятно, единственный раз, когда вам нужно/нужно сделать это, вы используете один и тот же аргумент более одного раза.
Вместо того, чтобы смотреть на исходный код, вы должны прочитать javadoc String.format() и Синтаксис форматирования.
Вы определяете формат значения после%. Например, для десятичного целого это d
, а для String - s
:
String aString = "world";
int aInt = 20;
String.format("Hello, %s on line %d", aString, aInt );
Выход:
Hello, world on line 20
Чтобы сделать то, что вы попробовали (используйте индекс аргументов), вы используете: *n*$
,
String.format("Line:%2$d. Value:%1$s. Result: Hello %1$s at line %2$d", aString, aInt );
Вывод:
Line:20. Value:world. Result: Hello world at line 20
Вы можете использовать это:
String.format("%1$s %2$s %2$s %3$s", "a", "b", "c");
Выход:
a b b c
{0}
и {1}
вместо %1$
и %2$
.
Также обратите внимание, что Scala расширяет String с помощью нескольких методов (через неявное преобразование в WrappedString, приводимое Predef), поэтому вы также можете сделать следующее:
val formattedString = "Hello %s, isn't %s cool?".format("Ivan", "Scala")
Официальной ссылкой является класс Formatter
.
В Scala 2.10
val name = "Ivan"
val weather = "sunny"
s"Hello $name, it $weather today!"
printf
, вы даже можете определить свою собственную интерполяцию (у меня нет) не пытайтесь). $name
означает , что он должен быть заменить со значением переменного name
, вы можете также сделать операцию в интерполяции, например , s"Hello ${name.toUpperCase}, it's $weather today!"
Это список того, что может сделать String.format
. То же самое касается 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
Вот список форматировщиков, используемых с String.format()
http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html
Хотя @Londo упомянул строковый интерполятор Scala "s", я думаю, что Scala "f" строковый интерполятор более уместен для оригинал вопрос. Пример, использованный несколько раз в других ответах, также можно записать (начиная с Scala 2.10) следующим образом:
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?
Соединение с исходным вопросом должно быть известно, что:
formatted
определяется строкой, которая имеет префикс с буквой "f" . Это интерполятор строки "f" (форматирование).java.util.Formatter
java.lang.String.format
использует тот же java.util.Formatter
Хорошая вещь о строковой интерполяции заключается в том, что она позволяет вам увидеть, какая переменная заменяется непосредственно в строке, а не сопоставлять ее с аргументами метода String.format
.
В scala для строки Interpolation мы имеем $, что экономит день и облегчит нашу жизнь:
Пример:. Вы хотите определить функцию, которая вводит имя и возраст ввода, и говорит "Привет" с именем и говорит о своем возрасте. Это можно записать так:
def funcStringInterpolationDemo(name:String,age:Int)=s"Hey ! my name is $name and my age is $age"
Следовательно, когда вы вызываете эту функцию: вот так:
funcStringInterpolationDemo("Shivansh",22)
Его вывод будет:
Hey ! my name is Shivansh and my age is 22
Вы можете написать код, чтобы изменить его в той же строке, например, если вы хотите добавить 10 лет к возрасту!
тогда функция может быть:
def funcStringInterpolationDemo(name:String,age:Int)=s"Hey ! my name is $name and my age is ${age+10}"
И теперь выход будет:
Hey ! my name is Shivansh and my age is 32
format
Java работал так же.