Как мне конвертировать из int в String?

Это приемлемо, но я никогда не писал ничего подобного. Я бы предпочел это:

String strI = Integer.toString(i);

Это нехорошо.

При выполнении преобразования из int в строку это должно использоваться:

int i = 5;
String strI = String.valueOf(i);

Это не только оптимизация ¹. Мне не нравится

"" + i

потому что он не выражает то, что я действительно хочу сделать ².

Я не хочу добавлять целое число в (пустую) строку. Я хочу преобразовать целое число в строку:

Integer.toString(i)

Или, не мой предпочтительный, но все же лучше, чем конкатенация, получить строковое представление объекта (целое):

String.valueOf(i)

^{1. Для кода, который вызывается очень часто, как и в циклах, оптимизация наверняка также является точкой не для использования конкатенации.}

^{2. это недействительно для использования реальной конкатенации, как в System.out.println("Index: " + i);или String id = "ID" + i;}

Многие вводные университетские курсы, похоже, учат этому стилю по двум причинам (по моему опыту):

• Это не требует понимания классов или методов. Обычно это преподается до того, как слово "класс" когда-либо упоминается, и даже вызовы метода. Поэтому использование чего-то типа String.valueOf(…) будет путать студентов.

• Это иллюстрация "перегрузки оператора" - на самом деле это было продано нам как идиоматический перегруженный оператор (здесь мало удивительно, так как Java не позволяет пользовательскую перегрузку оператора).

Таким образом, он может либо родиться из дидактической необходимости (хотя Id утверждает, что это просто плохое преподавание), либо можно использовать для иллюстрации принципа, который в противном случае довольно сложно продемонстрировать на Java.

Выражение

"" + i

приводит к преобразованию строки i во время выполнения. Общий тип выражения String. i сначала преобразуется в объект Integer (new Integer(i)), затем вызывается String.valueOf(Object obj). Таким образом, это эквивалентно

"" + String.valueOf(new Integer(i));

Очевидно, что это немного менее результативно, чем просто вызов String.valueOf(new Integer(i)), который даст тот же результат.

Преимущество ""+i заключается в том, что ввод текста проще/быстрее, и некоторые люди могут подумать, что его легче читать. Это не запах кода, поскольку он не указывает на какую-либо более глубокую проблему.

(Ссылка: JLS 15.8.1)

Лично я не вижу в этом коде ничего плохого.

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

Что касается выбора между Integer.toString или String.valueOf, все дело в вкусе.
... И внутренне, String.valueOf вызывает метод Integer.toString. :)

Другим способом, о котором я знаю, является класс Integer:

Integer.toString(int n);
Integer.toString(int n, int radix);

Конкретный пример (хотя я бы не думал, что вам нужно):

String five = Integer.toString(5); // returns "5"

Он также работает для других примитивных типов, например Double.toString.

Подробнее см. здесь.

Эта методика преподавалась на уровне бакалавриата, начиная с класса Java, который я взял более десяти лет назад. Тем не менее, я должен отметить, что, IIRC, мы еще не получили методы класса String и Integer.

Техника проста и быстрая. Если все, что я делаю, это что-то печатать, я буду использовать его (например, System.out.println("" + i);. Однако я считаю, что это не лучший способ сделать преобразование, так как требуется мысль подумать, что происходит, когда он используется таким образом. Кроме того, если производительность является проблемой, она выглядит медленнее (ниже, а также в других ответах).

Лично я предпочитаю Integer.toString(), так как очевидно, что происходит. String.valueOf() будет моим вторым выбором, поскольку это кажется запутанным (засвидетельствовать комментарии после ответа darioo).

Просто для усмешек:) Я написал классы для тестирования трех методов: "+ i, Integer.toString и String.ValueOf. Каждый тест только что преобразовал int от 1 до 10000 в строки. Затем я запускал каждую команду Linux time пять раз. Integer.toString() был несколько быстрее, чем String.valueOf() один раз, они связаны три раза, а String.valueOf() был быстрее один раз; однако разница была не более чем на пару миллисекунд.

Техника "+ i" была медленнее, чем у каждого теста, кроме одного, когда она была на 1 миллисекунду быстрее, чем Integer.toString() и на 1 миллисекунду медленнее, чем String.valueOf() (очевидно, в том же тесте, где String. valueOf() быстрее, чем Integer.toString()). Хотя обычно это было всего на пару миллисекунд медленнее, был один тест, где он был примерно на 50 миллисекунд медленнее. YMMV.

Существует много способов преобразования целого числа в строку:

1)

Integer.toString(10);

2)

 String hundred = String.valueOf(100); // You can pass an int constant
 int ten = 10;
 String ten = String.valueOf(ten)

3)

String thousand = "" + 1000; // String concatenation

4)

String million = String.format("%d", 1000000)

Существуют различные способы преобразования в строки:

StringBuilder string = string.append(i).toString();
String string = String.valueOf(i);
String string = Integer.toString(i);

Это зависит от того, как вы хотите использовать свою строку. Это может помочь:

String total =  Integer.toString(123) + Double.toString(456.789);

String strI = String.valueOf(i);

String string = Integer.toString(i);

Оба способа правильны.

В основном, на SimonJ. Мне очень не нравится "+ я идиома". Если вы скажете String.valueOf(i), Java преобразует целое число в строку и возвращает результат. Если вы скажете "+", Java создает объект StringBuilder, добавляет к нему пустую строку, преобразует целое число в строку, добавляет его в StringBuilder, а затем преобразует StringBuilder в String. Это много дополнительных шагов. Я полагаю, что если вы это сделаете один раз в большой программе, это не имеет большого значения. Но если вы делаете это все время, вы заставляете компьютер выполнять кучу дополнительной работы и создавать все эти дополнительные объекты, которые затем нужно очистить. Я не хочу фанатично относиться к микро-оптимизации, но я тоже не хочу быть бесполезным.

Существует три способа преобразования в строки

• Строка string = "" + i;
• Строка string = String.valueOf(i);
• Строка string = Integer.toString(i);

Использование "" + я - это самый короткий и простой способ преобразования числа в строку. Это не самый эффективный, но это самый явный ИМХО, и это, как правило, более важно. Чем проще код, тем меньше вероятность ошибки.

Лично я думаю, что "+" действительно выглядит так, как оригинал вопроса плакат утверждает "вонючий". Я использовал много языков OO помимо Java. Если бы этот синтаксис был уместен, то Java просто интерпретировала бы i, не нуждаясь в том, что "по желанию будет преобразовано в строку и сделает это, поскольку тип назначения недвусмыслен, и только одно значение будет передаваться справа, Другой выглядит как" трюк", чтобы обмануть компилятор, плохой mojo, когда рассматриваются разные версии Javac, сделанные другими производителями или с других платформ, если код когда-либо нужно портировать. Черт возьми, мне нужно, чтобы многие другие OOL просто возьмите Typecast: (String) i. winks

Учитывая мой способ обучения и простоту понимания такой конструкции при быстром прочтении кода, я голосую за метод Integer.toString(i). Забывая ns или two в том, как Java реализует вещи в фоновом режиме и String.valueOf(i), этот метод чувствует себя правильно для меня и точно говорит о том, что происходит: у меня есть и Integer, и я хочу, чтобы он преобразован в строку.

Хороший момент, сделанный пару раз, возможно, просто использование StringBuilder впереди - хороший ответ на создание строк, смешанных с текстом и ints или другими объектами, так как это то, что будет использоваться в фоновом режиме в любом случае?

Только мои два цента бросили в уже хорошо оплачиваемый котенок ответов на вопрос Мана... улыбается

ИЗМЕНИТЬ СОБСТВЕННЫЙ ОТВЕТ ПОСЛЕ НЕКОТОРЫХ ОТРАЖЕНИЙ:

Хорошо, хорошо, я думал об этом еще немного, и String.valueOf(i) также отлично подходит, и он говорит: Я хочу String, представляющий значение Integer. lol, английский намного сложнее разобрать, чем Java! Но я оставляю остальную часть своего ответа/комментария... Меня всегда учили использовать наименьший уровень метода/функциональной цепочки, если это возможно, и все еще сохраняют удобочитаемость, поэтому, если String.valueOf вызывает Integer.toString, то зачем использовать целый оранжевый если вы просто все равно очистите его, Хммм?

Чтобы прояснить мой комментарий о StringBuilder, я строю много строк с комбо в основном буквальным текстом и int, и они заканчиваются длинными и уродливыми вызовами вышеупомянутых подпрограмм, вложенных между символами +, так что мне кажется если они становятся объектами SB в любом случае, а метод append имеет перегрузки, может быть, это было бы проще, просто пойти вперед и использовать его... Итак, я думаю, что до 5 центов на этом сейчас, а? лол...

используйте Integer.toString(tmpInt).trim();

Сделайте это просто.

int i = 5;
String number = String.valueOf(i);

Существует много разных типов ватт для преобразования значения Integer в строку

 // for example i =10

  1) String.valueOf(i);//Now it will return "10"  

  2 String s=Integer.toString(i);//Now it will return "10" 

  3) StringBuilder string = string.append(i).toString();

   //i = any integer nuber

  4) String string = "" + i; 

  5)  StringBuilder string = string.append(i).toString();

  6) String million = String.format("%d", 1000000)

Попробуйте простое приведение типов

char c = (char) i;