Как преобразовать из int в String?

Я работаю над проектом, где все преобразования от int до String выполняются следующим образом:

int i = 5;
String strI = "" + i;

Я не знаком с Java. Является ли эта обычная практика или что-то не так, как я полагаю?

ОТВЕТЫ

Ответ 1

Обычными способами могут быть Integer.toString(i) или String.valueOf(i).

Конкатенация будет работать, но она нетрадиционная и может быть неприятным запахом, поскольку она предполагает, что автор не знает об этих двух методах выше (что еще они могут не знать?).

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

StringBuilder sb = new StringBuilder();
sb.append("");
sb.append(i);
String strI = sb.toString();

во время компиляции. Он немного менее эффективен (sb.append() заканчивается вызовом Integer.getChars(), что в любом случае было бы Integer.toString()), но оно работает.

Чтобы ответить на комментарий Гродригеса: ** Нет, компилятор не оптимизирует пустую строку в этом случае - посмотрите:

[email protected]:~$ cat TestClass.java
public class TestClass {
  public static void main(String[] args) {
    int i = 5;
    String strI = "" + i;
  }
}
[email protected]:~$ javac TestClass.java && javap -c TestClass
Compiled from "TestClass.java"
public class TestClass extends java.lang.Object{
public TestClass();
  Code:
   0:    aload_0
   1:    invokespecial    #1; //Method java/lang/Object."<init>":()V
   4:    return

public static void main(java.lang.String[]);
  Code:
   0:    iconst_5
   1:    istore_1

Инициализировать StringBuilder:

   2:    new    #2; //class java/lang/StringBuilder
   5:    dup
   6:    invokespecial    #3; //Method java/lang/StringBuilder."<init>":()V

Добавить пустую строку:

   9:    ldc    #4; //String
   11:    invokevirtual    #5; //Method java/lang/StringBuilder.append:
(Ljava/lang/String;)Ljava/lang/StringBuilder;

Добавить целое число:

   14:    iload_1
   15:    invokevirtual    #6; //Method java/lang/StringBuilder.append:
(I)Ljava/lang/StringBuilder;

Извлечь финальную строку:

   18:    invokevirtual    #7; //Method java/lang/StringBuilder.toString:
()Ljava/lang/String;
   21:    astore_2
   22:    return
}

Там предложение и текущая работа по изменению этого поведения, нацеленная на JDK 9.

Ответ 2

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

String strI = Integer.toString(i);

Ответ 3

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

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

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

Ответ 4

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

"" + i

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

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

Integer.toString(i)

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

String.valueOf(i)

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

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

Ответ 5

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

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

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

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

Ответ 6

Выражение

"" + 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)

Ответ 7

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

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

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

Ответ 8

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

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

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

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

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

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

Ответ 9

Эта методика преподавалась на уровне бакалавриата, начиная с класса 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.

Ответ 10

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

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

Ответ 11

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

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

Ответ 12

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

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)

Ответ 13

String strI = String.valueOf(i);

String string = Integer.toString(i);

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

Ответ 14

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

Ответ 15

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

Ответ 16

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

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

Ответ 17

Лично я думаю, что "+" действительно выглядит так, как оригинал вопроса плакат утверждает "вонючий". Я использовал много языков 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 центов на этом сейчас, а? лол...

Ответ 18

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

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

Ответ 19

Существует много разных типов ватт для преобразования значения 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)

Ответ 20

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

Ответ 21

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

char c = (char) i;