İnt'den String'e nasıl dönüştürebilirim?

Ben gelen tüm dönüşümler bir proje üzerinde çalışıyorum intTo Stringböyle yapılır:

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

Java'ya aşina değilim.

Bu normal bir uygulama mı yoksa sanırım yanlış bir şey mi?

Normal yollar Integer.toString(i)veya olur String.valueOf(i).

Birleştirme işe yarayacaktır, ancak alışılmadık bir durumdur ve yazarın yukarıdaki iki yöntem hakkında bilmediğini önerdiği için kötü bir koku olabilir (başka ne bilmiyor olabilirler?).

Java, yayınladığınız kodu çeviren dizelerle (+ belgelere bakın ) kullanıldığında + operatör için özel desteğe sahiptir :

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

derleme zamanında. Biraz daha az verimlidir ( sonuçta sb.append()arama Integer.getChars(), bu Integer.toString()zaten ne yapardı), ama işe yarıyor.

Grodriguez'ın yorumuna cevap vermek için: ** Hayır, derleyici bu durumda boş dizeyi optimize etmez - bak:

simon@lucifer:~$ cat TestClass.java
public class TestClass {
  public static void main(String[] args) {
    int i = 5;
    String strI = "" + i;
  }
}
simon@lucifer:~$ 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'ı başlatın:

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

Boş dizeyi ekleyin:

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

Tamsayıyı ekleyin:

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

Son dizeyi çıkarın:

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

Orada bir öneri JDK 9 için hedeflenmektedir Bu davranışı değiştirmek için çalışmaları devam eden.

Kabul edilebilir, ama hiç böyle bir şey yazmadım. Bunu tercih ederim:

String strI = Integer.toString(i);

Bu iyi bir yol değil.

İnt'ten dizeye dönüştürme yaparken bu kullanılmalıdır:

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

Sadece optimizasyon değil ¹ . Sevmiyorum

"" + i

çünkü gerçekten ne yapmak istediğimi ifade etmiyor ² .

(Boş) dizeye bir tam sayı eklemek istemiyorum. Bir tamsayıyı dizeye dönüştürmek istiyorum:

Integer.toString(i)

Ya da, tercih ettiğim değil, ancak birleştirme işleminden daha iyi, bir nesnenin dize temsilini (tamsayı) alın:

String.valueOf(i)

^{1. Döngülerde olduğu gibi çok sık çağrılan kod için, optimizasyon da birleştirme kullanmamanın bir noktasıdır .}

^{2. Bu, içinde veya gibi gerçek birleştirme kullanımı için geçerli değildir.System.out.println("Index: " + i); String id = "ID" + i;}

Bir çok giriş üniversitesi dersi bu tarzı öğretiyor gibi görünüyor, iki nedenden dolayı (benim tecrübeme göre):

• Sınıfların veya yöntemlerin anlaşılmasını gerektirmez. Genellikle bu, “sınıf” kelimesinden hiç bahsedilmeden, hatta yöntem çağrılarından önce öğretilir. Yani böyle bir şey kullanmak String.valueOf(…)öğrencileri karıştırır.

• Aslında, bu bizim için satıldı - O “operatör aşırı yükleme” bir resmidir (Java özel operatör aşırı yüklenmesini mümkün olmadığından, burada küçük harikası) deyimsel Aşırı yüklü operatörü.

Bu yüzden ya didaktik zorunluluktan doğabilir (bunun sadece kötü bir öğreti olduğunu iddia etsem de) ya da Java'da gösterilmesi oldukça zor olan bir prensibi göstermek için kullanılabilir.

İfade

"" + i

derivasyonlarında dize dönüştürme ait içalışma zamanında. İfadenin genel türü String. iönce bir Integernesneye ( new Integer(i)) dönüştürülür , sonra String.valueOf(Object obj)çağrılır. Yani eşdeğer

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

Açıkçası, bu sadece String.valueOf(new Integer(i))aynı sonucu üretecek olan aramaktan biraz daha az performans .

Bunun avantajı, ""+iyazmanın daha kolay / hızlı olması ve bazı insanların okumasının daha kolay olduğunu düşünebilmesidir. Daha derin bir problemi göstermediği için bir kod kokusu değildir.

(Referans: JLS 15.8.1 )

Şahsen, bu kodda kötü bir şey görmüyorum.

Bir int değerini günlüğe kaydetmek istediğinizde oldukça kullanışlıdır ve kaydedici yalnızca bir dizeyi kabul eder. Dize kabul eden bir yöntemi çağırmanız gerektiğinde böyle bir dönüşüm uygun olduğunu söyleyebilirim, ancak bir int değeri var.

Integer.toStringVeya arasındaki seçim gelince String.valueOf, hepsi bir zevk meselesi.
... Ve dahili olarak, yöntemi bu arada String.valueOfçağırır Integer.toString. :)

Farkında olduğum diğer bir yol da Integersınıftan:

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

Somut bir örnek (gerçi ihtiyacın olduğunu düşünmezdim):

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

Örneğin, diğer ilkel tipler için de çalışır Double.toString.

Daha fazla ayrıntı için buraya bakın.

Bu teknik, on yıl önce devraldığım lisans düzeyinde Java sınıfına giriş dersinde öğretildi. Bununla birlikte, IIRC'nin, String ve Integer sınıf yöntemlerine henüz ulaşmadığımızı not etmeliyim.

Teknik basit ve hızlı yazılır. Yaptığım tek şey bir şey yazdırmaksa, onu kullanacağım (örneğin System.out.println("" + i);. Ancak, dönüşüm yaparken en iyi yol olmadığını düşünüyorum, çünkü kullanıldığında neler olup bittiğini anlamanın bir saniyesi gerekiyor Ayrıca, performans bir sorunsa, daha yavaş görünüyor (daha aşağıda ve diğer cevaplarda).

Şahsen, ne olduğu açık olduğu için Integer.toString () 'i tercih ederim. String.valueOf (), kafa karıştırıcı gibi göründüğü için ikinci seçimim olurdu (darioo'nun cevabından sonra yorumlara tanık olun).

Sadece sırıtmalar için :) Üç tekniği test etmek için sınıflar yazdım: "" + i, Integer.toString ve String.ValueOf. Her test, 1'den 10000'e kadar olan dizeleri Dizelere dönüştürdü. Sonra her birini Linux zaman komutundan beş kez geçirdim . Integer.toString () bir kez String.valueOf () 'den biraz daha hızlıydı, üç kez bağladılar ve String.valueOf () bir kez daha hızlıydı; ancak, fark asla birkaç milisaniyeden fazla olmamıştır.

"" + İ tekniği, Integer.toString () 'den 1 milisaniye daha hızlı ve String.valueOf ()' den 1 milisaniye daha yavaş olduğunda, biri hariç her testte her ikisinden de daha yavaştı (açıkça String.valueOf () Integer.toString () 'den daha hızlıydı. Genellikle sadece birkaç milisaniye daha yavaş olsa da, yaklaşık 50 milisaniye daha yavaş olduğu bir test vardı. YMMV .

Dizelere dönüştürmenin çeşitli yolları vardır:

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

Dizenizi nasıl kullanmak istediğinize bağlıdır. Bu yardımcı olabilir:

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

Çoğunlukla SimonJ'de aynen. "" + İ deyiminden gerçekten hoşlanmıyorum. String.valueOf (i) derseniz, Java tamsayıyı bir dizeye dönüştürür ve sonucu döndürür. "" + İ derseniz, Java bir StringBuilder nesnesi oluşturur, buna boş bir dize ekler, tamsayıyı bir dizeye dönüştürür, bunu StringBuilder'a ekler, sonra StringBuilder'ı bir String'e dönüştürür. Bu çok fazla ek adım. Herhalde büyük bir programda yaparsanız, önemli değil. Ancak bunu her zaman yapıyorsanız, bilgisayarı bir sürü ekstra iş yapmaya ve daha sonra temizlenmesi gereken tüm bu ekstra nesneleri yaratmaya başlıyorsunuz. Mikro optimizasyon konusunda fanatik olmak istemiyorum, ama anlamsızca savurgan olmak da istemiyorum.

String strI = String.valueOf(i);

String string = Integer.toString(i);

Her iki yol da doğrudur.

Bir tamsayıyı dizeye dönüştürmenin birçok yolu vardır:

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)

Dizelere dönüştürmenin üç yolu vardır

1. String string = "" + i;
2. String string = String.valueOf(i);
3. String string = Integer.toString(i);

"" + İ kullanmak, bir sayıyı dizeye dönüştürmenin en kısa ve basit yoludur. En verimli değil, ama en açık IMHO'dur ve genellikle daha önemlidir. Kod ne kadar basit olursa, hata yapma olasılığınız o kadar az olur.

Şahsen ben "" + ben orijinal soru posteri "koklamak" olarak görünüyor düşünüyorum. Java dışında birçok OO dili kullandım. Eğer bu sözdiziminin uygun olması isteniyorsa, Java i'yi "" bir dizeye dönüştürülmek istediği gibi tek başına yorumlayacak ve hedef türü açık olduğu ve sağda yalnızca tek bir değer sağlanacağı için yapacaktır. . Diğeri, kodun taşınması gerekiyorsa, diğer üreticiler tarafından veya diğer platformlardan yapılan Javac'ın farklı sürümleri göz önüne alındığında, derleyiciyi kandırmak için bir 'numara' gibi görünüyor, kötü mojo. typecast atın:. (string) i winks

Öğrenme yolum göz önüne alındığında ve diğerleri kodunu hızlı bir şekilde okurken böyle bir yapıyı anlama kolaylığı için Integer.toString (i) yöntemi için oy. Java'nın String.valueOf (i) ve arka plandaki şeyleri nasıl uyguladığına dair bir veya iki unutmak bu yöntem bana doğru geliyor ve tam olarak ne olduğunu söylüyor: Ben ve Integer ve ben bir String'e dönüştürülmesini diliyorum.

Birkaç kez yapılan iyi bir nokta, belki de sadece StringBuilder'ı ön tarafta kullanmak, metin ve ints veya diğer nesnelerden oluşan Dizeleri oluşturmaya iyi bir cevaptır, çünkü zaten arka planda ne kullanılacağı doğru mu?

Mans sorusunun cevaplarının zaten iyi ödenmiş kedisine atılan sadece iki sentim ... gülümsüyor

BAZI YANSIMA SONRASI KENDİ CEVAPIMI DÜZENLE:

Tamam, Tamam, bu biraz daha düşünüyordum ve String.valueOf (i) de mükemmel bir şekilde iyi diyor: Ben bir tamsayı değerini temsil eden bir dize istiyorum. lol, İngilizce Java ayrıştırmak çok daha zor! Ama, cevabım / yorumumun geri kalanını bırakıyorum ... Mümkünse her zaman bir yöntem / fonksiyon zincirinin en düşük seviyesini kullanmam öğretildi ve String.valueOf Integer.toString'i çağırıyorsa neden hala turuncu Eğer yine de soyacaksan, Hmmm?

StringBuilder hakkındaki yorumumu açıklığa kavuşturmak için, çoğunlukla gerçek metin ve int'lerin kombinasyonları ile çok sayıda dizeler oluşturuyorum ve + 'lar arasında gömülü olan yukarıda belirtilen rutinlere yapılan çağrılarla uzun ve çirkinleşiyorlar. SB yine de nesneler ve append yöntemi aşırı yükleme var sadece devam ve kullanmak daha temiz olabilir ... Yani sanırım şimdi bu bir 5 sent kadar, ha? lol ...

kullanım Integer.toString(tmpInt).trim();

Basit örnek oluşturmayı deneyin

char c = (char) i;