Java int to String - Integer.toString (i) против нового Integer (i) .toString ()

428

Иногда ява озадачивает меня.
У меня есть огромное количество инициализаций int, чтобы сделать.

В чем реальная разница?

  1. Integer.toString(i)
  2. new Integer(i).toString()
marcolopes
источник
20
Я бы просто использовал "" + 42, но эй, это я. Форма № 2 приведет к созданию нового целочисленного объекта (для большинства значений i) в качестве промежуточного. Это также больше печатать.
16
@pst: если промежуточный объект является проблемой для вас, то "" + 42не лучше, так как для него требуется промежуточное звено, StringBuilderкоторое намного тяжелее, чем Integer.
Иоахим Зауэр
47
"+ 42 может сработать, но это плохая идея. Люди, подобные мне, придут, посмотрят ваш код и попытаются выяснить, что, черт возьми, случилось с пустой строкой.
Mainguy
3
Я бы не рекомендовал, "" + 42потому что в случае добавления строк целых чисел вы можете в конечном итоге добавить значения, а не реализовать их.
BoltzmannBrain
20
Если вам не нравится много печатать, то, вероятно, вам не следует программировать на Java.
Адам Пирс

Ответы:

548

Integer.toStringвызывает статический метод в классе Integer. Это не нуждается в экземпляре Integer.

Если вы вызываете, new Integer(i)вы создаете экземпляр типа Integer, который является полным Java-объектом, инкапсулирующим значение вашего int. Затем вы вызываете toStringметод, чтобы попросить его вернуть строковое представление самого себя .

Если все, что вам нужно, это распечатать int, вы бы использовали первый, потому что он легче, быстрее и не использует дополнительную память (кроме возвращаемой строки).

Если вы хотите, чтобы объект представлял целочисленное значение - например, поместил его в коллекцию - вы бы использовали второй, поскольку он дает вам полноценный объект для выполнения всех видов вещей, которые вы не можете делать с голым int.

джинсовый
источник
96

new Integer(i).toString()сначала создает (избыточный) объект-оболочку i(который сам может быть объектом-оболочкой Integer).

Integer.toString(i) является предпочтительным, потому что он не создает ненужных объектов.

oksayt
источник
43

Другой вариант - статический String.valueOfметод.

String.valueOf(i)

Это кажется немного более правильным, чем Integer.toString(i)для меня. Когда тип i изменится, например, с intна double, код останется правильным.

fhucho
источник
2
Да. Если вы не должны использовать RADIX (в этом случае вы должны использовать Integer.toString)
marcolopes
14
  1. new Integer(i).toString();

    Этот оператор создает объект Integer и затем вызывает его методы toString(i)для возврата строкового представления значения Integer .

  2. Integer.toString(i);

    Он возвращает объект String, представляющий конкретное int (целое число) , но здесь toString(int)есть staticметод.

Summary в первом случае возвращает строковое представление объектов, а во втором случае возвращает строковое представление целого числа.

Dhiraj
источник
13

Я также настоятельно рекомендую использовать

int integer = 42;
String string = integer + "";

Просто и эффективно.

Джаспер Холтон
источник
38
это определенно дурной тон, потому что он опирается на довольно тонкую часть языка Java и менее эффективен, чем Integer.toString (i). Смотрите это ТАК сообщение
rickcnagy
Это может быть неэффективно. Я предлагаю использовать некоторые обычные варианты, такие как Integer.toString или String.valueOf. Проверьте здесь javadevnotes.com/java-integer-to-string-examples
JavaDev
Это вообще плохая идея делать вещи таким не интуитивным способом. Более очевидные варианты, такие как, Integer.toString()могут использовать некоторые дополнительные нажатия клавиш, но они намного понятнее, что очень важно, когда вы хотите сохранить код.
Кельвин Ли
Не вызовет ли это автоматически toString()метод целочисленной переменной ?
Анкит Дешпанде
11

Хотя мне нравится рекомендация Фхучо о

String.valueOf(i)

Ирония в том, что этот метод на самом деле вызывает

Integer.toString(i)

Таким образом, используйте, String.valueOf(i)если вам нравится, как он читает, и вам не нужен radix, но также знайте, что он менее эффективен, чем Integer.toString(i).

Натан Уэйт
источник
4

С точки зрения измерения производительности, если вы рассматриваете производительность по времени, то Integer.toString (i); это дорого, если вы звоните менее 100 миллионов раз. Иначе, если это более 100 миллионов вызовов, тогда новый Integer (10) .toString () будет работать лучше.

Ниже приведен код, через который вы можете попытаться измерить производительность,

public static void main(String args[]) {
            int MAX_ITERATION = 10000000;
        long starttime = System.currentTimeMillis();
        for (int i = 0; i < MAX_ITERATION; ++i) {
            String s = Integer.toString(10);
        }
        long endtime = System.currentTimeMillis();
        System.out.println("diff1: " + (endtime-starttime));

        starttime = System.currentTimeMillis();
        for (int i = 0; i < MAX_ITERATION; ++i) {
            String s1 = new Integer(10).toString();
        }
        endtime = System.currentTimeMillis();
        System.out.println("diff2: " + (endtime-starttime));
    }

С точки зрения памяти,

new Integer (i) .toString ();

будет занимать больше памяти, так как каждый раз будет создавать объект, поэтому произойдет фрагментация памяти.

Dhiraj
источник
2
Я вставил этот код в IntelliJ IDEA и получил предупреждение: " new Integer(10).toString() can be simplified to Integer.toString(10)"
оксайт 15.10.10
Этот код работает для меня. Я получаю около 420 миллисекунд для Integer.toString (10) и 525 миллисекунд для нового Integer (10) .toString ()
Джейк Стивенс-Хаас
1
См. Stackoverflow.com/questions/504103/… ...
Петр Тума
Помогло бы сначала прогреться, иначе результаты не действительны!
Sixones
Если вы говорите, что одно дорого в одном случае, а другое лучше в другом, это означает, что другое лучше / дешевле во всех ситуациях.
Sgene9
2

Лучше:

Integer.valueOf(i).toString()
рю
источник
9
Почему это лучше?
Эмиль
1
Я думаю, что это лучше, потому что, как @Dhiraj указал, что с точки зрения памяти, "new Integer (i) .toString ();" займет больше памяти, потому что он создает новый объект вместо того, чтобы просто получить значение Integer и преобразовать его в строку.
Патриция
4
@Lucy Integer.valueOf (i) возвращает новое целое число, поэтому нет никакой разницы
inigoD
Вы не даете ответ на вопрос вообще. Вопрос в том, в чем разница между бла и бла, а не в том, что лучше заменить бла.
ahitt6345
2

Простой способ - просто объединить ""с целым числом:

int i = 100;

String s = "" + i;

теперь sбудет иметь 100строковое значение.

Шив Буя
источник
1

Здесь Integer.toStringвызывает статический метод в классе Integer. Это не требует объекта для вызова.

Если вы звоните new Integer(i), сначала создайте экземпляр типа Integer, который является полным Java-объектом, инкапсулирующим значение вашего int i. Затем вы вызываете toStringметод, чтобы попросить его вернуть строковое представление самого себя.

Шайлей Шимпи
источник
0

1.Integer.toString(i)

Integer i = new Integer(8);
    // returns a string representation of the specified integer with radix 8
 String retval = i.toString(516, 8);
System.out.println("Value = " + retval);

2.new Integer(i).toString()

 int i = 506;

String str = new Integer(i).toString();
System.out.println(str + " : " + new Integer(i).toString().getClass());////506 : class java.lang.String
Шива Нандам Сирмаригари
источник