Мне интересно, почему существует метод String.valueOf(int i)? Я использую этот метод для преобразования int в String и только что обнаружил метод Integer.toString(int i).
После просмотра реализации этих методов я увидел, что первый вызывает второй. Как следствие, все мои призывы к String.valueOf(int i) включают в себя еще один вызов, чем прямой вызов Integer.toString(int i)
Только два разных способа сделать одно и то же. Это может быть историческая причина (не помню, если кто-то пришел перед другим).
В строковом типе мы имеем несколько методов valueOf
static String valueOf(boolean b)
static String valueOf(char c)
static String valueOf(char[] data)
static String valueOf(char[] data, int offset, int count)
static String valueOf(double d)
static String valueOf(float f)
static String valueOf(int i)
static String valueOf(long l)
static String valueOf(Object obj)
Как мы видим, эти методы способны разрешать все типы чисел
каждая реализация конкретного метода, как вы представили: Итак, для целых чисел
Integer.toString(int i)
для двойного
Double.toString(double d)
и т.д.
По-моему, это не какая-то историческая вещь, но разработчику более полезно использовать метод valueOf из класса String, чем из соответствующего типа, поскольку это приводит к меньшему количеству изменений для нас.
Пример 1:
public String doStuff(int num) {
// Do something with num...
return String.valueOf(num);
}
Sample2:
public String doStuff(int num) {
// Do something with num...
return Integer.toString(num);
}
Как мы видим в примере 2, мы должны сделать два изменения, в отличие от образца 1.
В моем заключении использование метода valueOf из класса String более гибко и поэтому доступно там.
Огромное различие заключается в том, что если вы вызываете toString() в нулевом объекте, вы получите NullPointerException, тогда как при использовании String.valueOf() вы не можете проверить значение null.
Класс String предоставляет методы valueOf для всех примитивных типов и типа Object, поэтому я предполагаю, что это удобные методы, к которым можно получить доступ через один класс.
NB Результаты профилирования
Средняя intToString = 5368ms, Средняя строкаValueOf = 5689ms (для 100 000 000 операций)
public class StringIntTest {
public static long intToString () {
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
String j = Integer.toString(i);
}
long finishTime = System.currentTimeMillis();
return finishTime - startTime;
}
public static long stringValueOf () {
long startTime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
String j = String.valueOf(i);
}
long finishTime = System.currentTimeMillis();
return finishTime - startTime;
}
public static void main(String[] args) {
long intToStringElapsed = 0;
long stringValueOfElapsed = 0;
for (int i = 0; i < 10; i++) {
intToStringElapsed += intToString();
stringValueOfElapsed+= stringValueOf();
}
System.out.println("Average intToString = "+ (intToStringElapsed /10));
System.out.println("Average stringValueOf = " +(stringValueOfElapsed / 10));
}
}
Если вы посмотрите на исходный код для класса String, он на самом деле вызывает Integer.toString(), когда вы вызываете valueOf().
При этом Integer.toString() может быть немного быстрее, если вызовы метода не оптимизируются во время компиляции (что они, вероятно, есть).
Из источников Java:
/**
* Returns the string representation of the {@code int} argument.
* <p>
* The representation is exactly the one returned by the
* {@code Integer.toString} method of one argument.
*
* @param i an {@code int}.
* @return a string representation of the {@code int} argument.
* @see java.lang.Integer#toString(int, int)
*/
public static String valueOf(int i) {
return Integer.toString(i);
}
Таким образом, они дают точно такой же результат, а один на самом деле вызывает другое. String.valueOf более гибкий, если вы позже можете изменить тип.
Реализация String.valueOf(), который вы видите, является самым простым способом удовлетворения контракта, указанного в API: "Представление точно тот, который возвращается методом Integer.toString() одного аргумента."
Чтобы ответить на вопрос OPs, это просто вспомогательная оболочка, чтобы иметь другой вызов, и сводится к выбору стиля, и это все. Я думаю, здесь много дезинформации, и лучшее, что может сделать разработчик Java, - это посмотреть на реализацию для каждого метода, это один или два клика в любой среде IDE. Вы ясно увидите, что String.valueOf(int) просто вызывает Integer.toString(int) для вас.
Следовательно, существует абсолютно нулевая разница, поскольку они создают буфер char, просматривают цифры в числе, затем копируют их в новую строку и возвращают (поэтому каждый создает один объект String). Единственное различие - это один дополнительный вызов, который компилятор в любом случае исключает для одного вызова.
Значит, это не так, как вы называете, а не код. Что касается комментариев о nulls, он принимает примитив, поэтому он не может быть null! Вы получите ошибку времени компиляции, если вы не инициализируете переданный int. Таким образом, нет никакой разницы в том, как он обрабатывает нули, поскольку в этом случае они несуществуют.
Вам не следует беспокоиться об этом дополнительном вызове, который бы стоил вам проблем с эффективностью. Если есть какая-либо стоимость, она будет минимальной и должна быть незначительной в более общей картине вещей.
Возможно, причина, по которой они существуют, - это обеспечить читаемость. В контексте многих типов, преобразованных в String, тогда различные вызовы String.valueOf(SomeType) могут быть более читабельными, чем различные вызовы SomeType.toString.
Используя метод String.valueOf(), вам не нужно беспокоиться о данных (будь то int, long, char, char [], boolean, Object), вы можете просто вызвать:
используя единственный синтаксис String.valueOf(), все, что вы передаете в качестве параметра, преобразуется в String и возвращается.
В противном случае, если вы используете Integer.toString(), Float.toString() и т.д. (т.е. SomeType.toString()), вам нужно будет проверить тип данных параметра, который вы хотите преобразовать в строку. Итак, лучше использовать String.valueOf() для таких преобразований.
Если у вас есть массив класса объектов, который содержит разные значения, такие как Integer, char, Float и т.д., то с помощью метода String.valueOf() вы можете легко преобразовать элементы такого массива в форму String. Напротив, если вы хотите использовать SomeType.toString(), то сначала вам нужно будет узнать о них их классы типов данных (возможно, используя оператор "instanceOf" ), а затем вы можете продолжить только для типа.
Метод String.valueOf(), когда он вызывается, соответствует передаваемому параметру (будь то его Integer, char, Float и т.д.) и с помощью метода перегрузки вызовов, которые используют метод valueOf(), параметр которого сопоставляется, а затем внутри этого метода их прямой вызов соответствующему методу "toString()".
Итак, мы можем видеть, как издержки на проверку типа данных, а затем вызов соответствующего метода "toString()" удаляются. Только нам нужно вызвать метод String.valueOf(), не заботясь о том, что мы хотим преобразовать в String.
Вывод: метод String.valueOf() имеет значение только при стоимости еще одного вызова.
my openion - valueof(), всегда вызываемый tostring() для представления, и поэтому для rpresentaion типа primitive значение обобщается. java по умолчанию не поддерживает тип данных, но определяет его работу с objaect и классом, что все это делает в cllas и сделанный объект .here Integer.toString(int i) создает предел для преобразования только целого числа.
Не существует различий между Integer.toString(5) и String.valueOf(5);
потому что String.valueOf возвращает:
public static String valueOf(int i) {
return Integer.toString(i);
}
public static String valueOf(float f) {
return Float.toString(f);
}
и т.д..
toString()
valueOf()
обрабатывает примитивные типы, а также типы объектов.
Integer a = null;
System.out.println(Integer.toString()) ; NUll pointer exception
System.out.println(String.valueOf() ; give NULL as value
проверить эту ссылку очень хорошо. http://code4reference.com/2013/06/which-one-is-better-valueof-or-tostring/