Neden Java'da String.Empty yok?

Dize değişmezi her yazdığımda "", dize havuzunda aynı String nesnesine başvurulduğunu anlıyorum .

Ama neden String API bir içermiyor public static final String Empty = "";, bu yüzden referansları kullanabilir String.Emptymiyim?

Derleyici varolan Dizeye başvurmayı bildiğinden ve yeniden kullanım için önceden oluşturulmuş olup olmadığını kontrol etmek zorunda olmadığından, en azından derleme zamanında tasarruf ederdi, değil mi? Ve kişisel olarak, dize değişmezlerinin çoğalmasının, özellikle küçük olanların, çoğu durumda bir "kod kokusu" olduğunu düşünüyorum.

Yani String.Empty arkasında bir Büyük Tasarım Nedeni vardı, ya da dil yaratıcıları sadece görüşlerimi paylaşmadı mı?

String.EMPTY12 karakter ve ""iki karakterdir ve her ikisi de çalışma zamanında bellekte tam olarak aynı örneğe başvurur. String.EMPTYDerleme zamanında neden tasarruf edeceğinden tam olarak emin değilim , aslında bunun ikinci olacağını düşünüyorum.

Özellikle Strings'nin değişmez olduğu düşünüldüğünde, ilk önce boş bir String alabilir ve üzerinde bazı işlemler gerçekleştirebilirsiniz - en iyisi a kullanmak StringBuilder(veya StringBufferiş parçacığı için güvenli olmak istiyorsanız) ve bunu bir String'e dönüştürmek gibi.

Güncelleme
Yorumunuzdan soruya:

Buna ilham veren şey aslında TextBox.setText("");

Uygun sınıfınızda bir sabit sağlamanın tamamen meşru olacağına inanıyorum:

private static final String EMPTY_STRING = "";

Ve sonra kodunuzdaki gibi referans olarak

TextBox.setText(EMPTY_STRING);

Bu şekilde en azından IDE'nizdeki Dizeyi veya benzer bir şeyi doldurmayı unutmak yerine boş bir Dizgi istediğinizi açıkça belirlersiniz.

kullanım org.apache.commons.lang.StringUtils.EMPTY

Boş değerler hakkında endişelenmeden boş dizeyle karşılaştırmak isterseniz, aşağıdakileri yapabilirsiniz.

if ("".equals(text))

Sonuçta en açık olduğuna inandığınız şeyi yapmalısınız. Çoğu programcı "", birinin içine herhangi bir şey koymayı unuttuğu bir dize değil, boş dize anlamına gelir.

Bir performans avantajı olduğunu düşünüyorsanız, bunu test etmelisiniz. Kendiniz için test etmeye değer olduğunu düşünmüyorsanız, gerçekten buna değmeyeceğine dair iyi bir gösterge.

Dil, 15 yıldan fazla bir süre önce tasarlandığında çözülmüş bir sorunu çözmeye çalışmak gibi görünüyor.

Gerçekten bir String.EMPTY sabiti istiyorsanız, projenizde "Sabitler" (örneğin) adlı bir statik statik son sınıf oluşturabilirsiniz. Bu sınıf, boş String de dahil olmak üzere sabitlerinizi koruyacaktır ...

Aynı fikirde, SIFIR, ONE int sabitleri oluşturabilirsiniz ... Tamsayı sınıfında mevcut değildir, ancak yorum yaptığım gibi, yazmak ve okumak bir acı olacaktır:

for(int i=Constants.ZERO; ...) {
    if(myArray.length > Constants.ONE) {
        System.out.println("More than one element");
    }
}

Vb.

Apache StringUtils de bu sorunu giderir.

Diğer seçeneklerin hataları:

• isEmpty () - null güvenli değil. Dize null olursa, bir NPE atar
• length () == 0 - yine null güvenli değil. Beyaz boşluk dizelerini de dikkate almaz.
• BOŞ sabiti ile karşılaştırma - Boşta olmayabilir. Boşluk sorunu

Granted StringUtils, sürüklenecek başka bir kütüphanedir, ancak çok iyi çalışır ve boş zamanlar veya NPE'leri incelikle işlemek için çok fazla zaman ve güç tasarrufu sağlar.

Sadece "dizelerin bellek havuzu tam anlamıyla yeniden kullanılır, dava kapandı" demeyin. Derleyicilerin kaputun altında yaptıkları burada mesele değil. Soru, özellikle alınan oyların sayısı göz önüne alındığında makul.

Bu simetri ile ilgilidir , onsuz API'lerin insanlar için kullanımı daha zordur. İlk Java SDK'ları bu kuralı kötü bir şekilde görmezden geldi ve şimdi biraz geç. İşte başımın üstünde birkaç örnek, "favori" örneğinizde çipleme yapmaktan çekinmeyin:

• BigDecimal.ZERO, ancak AbstractCollection.EMPTY, String.EMPTY yok
• Array.length ancak List.size ()
• List.add (), Set.add () ancak Map.put (), ByteBuffer.put () ve unutmayalım StringBuilder.append (), Stack.push ()

Bütün bu ""değişmezler aynı nesnedir. Neden tüm bu ekstra karmaşıklığı? Yazmak sadece daha uzun ve daha az net (derleyicinin maliyeti minimumdur). Java'nın dizeleri değişmez nesneler olduğu için, muhtemelen bir etkinlik şey dışında aralarında ayrım yapmak için hiçbir zaman ihtiyaç yoktur, ancak boş dize hazır bilgisi ile bu büyük bir sorun değildir.

Gerçekten bir EmptyStringsabit istiyorsanız , kendiniz yapın. Ancak tek yapacağı şey daha ayrıntılı kodları teşvik etmek; Orada olacak asla bunu yaparken herhangi bir yararı.

Noel M'nin söylediklerine eklemek için, bu soruya bakabilirsiniz ve bu cevap sabitin yeniden kullanıldığını gösterir.

http://forums.java.net/jive/message.jspa?messageID=17122

String sabiti her zaman "interned" dir, bu yüzden böyle bir sabite ihtiyaç yoktur.

String s=""; String t=""; boolean b=s==t; // true

Ben her zaman String "" yazarken, String havuzunda aynı String nesnesine başvurduğunu biliyorum.
Böyle bir garanti yok. Ve uygulamanızda buna güvenemezsiniz, karar vermek tamamen jvm'ye kalmış.

ya da dil yaratıcıları görüşlerimi paylaşmadılar mı?
Evet. Bana göre, çok düşük öncelikli bir şey gibi görünüyor.

Geç cevap, ama bence bu konuya yeni bir şeyler ekliyor.

Önceki cevapların hiçbiri orijinal soruyu cevaplamadı. Bazıları bir sabitin eksikliğini haklı çıkarmaya çalışırken, diğerleri sabitin eksikliğiyle başa çıkabilmenin yollarını gösterdi. Ancak hiç kimse sabitin yararı için zorlayıcı bir gerekçe sunmadı, bu yüzden eksikliği hala doğru bir şekilde açıklanmadı.

Bir sabit, bazı kod hatalarının fark edilmemesini önleyeceği için yararlı olacaktır.

"" İçin yüzlerce referans içeren geniş bir kod tabanınız olduğunu varsayalım. Birisi kodu kaydırırken bunlardan birini değiştirir ve "" olarak değiştirir. Böyle bir değişikliğin üretime fark edilmeme olasılığı yüksektir, bu noktada kaynağı tespit etmek zor olacak bir soruna neden olabilir.

Aynı hataya maruz kalırsa EMPTY adında bir kütüphane sabiti olan OTOH, EM PTY gibi bir şey için derleyici hatası oluşturur.

Kendi sabitinizi tanımlamak hala daha iyidir. Birisi hala başlatmayı yanlışlıkla değiştirebilir, ancak geniş kullanımı nedeniyle, böyle bir hatanın etkisinin fark edilmemesi, tek kullanımlık bir durumdaki bir hatadan çok daha zor olacaktır.

Bu, değişmez değerler yerine sabitleri kullanmanın genel avantajlarından biridir. İnsanlar genellikle düzinelerce yerde kullanılan bir değer için sabit kullanmanın, bu değeri tek bir yerde kolayca güncellemenizi sağladığını kabul eder. Daha az sıklıkla kabul edilen şey, bunun aynı zamanda değerin yanlışlıkla değiştirilmesini de engellemesidir, çünkü böyle bir değişiklik her yerde gösterilecektir. Yani, evet, "" EMPTY'den daha kısa, ancak EMPTY'nin kullanımı "" 'dan daha güvenlidir.

Dolayısıyla, orijinal soruya geri dönersek, sadece dil tasarımcılarının muhtemelen sık kullanılan değişmez değerler için sabitler sağlama avantajının farkında olmadıklarını tahmin edebiliriz. Umarım, bir gün Java'ya dize sabitleri eklenir.

İddia edenler için ""ve String.Emptybirbirleriyle değiştirilebilir ya da ""daha iyidir, çok yanlış.

Her seferinde myVariable = "" gibi bir şey yaptığınızda; bir nesnenin örneğini oluşturuyorsunuz. Java'nın String nesnesinin bir EMPTY genel sabiti varsa, "" nesnesinin yalnızca 1 örneği olurdu

Örneğin: -

String.EMPTY = ""; //Simply demonstrating. I realize this is invalid syntax

myVar0 = String.EMPTY;
myVar1 = String.EMPTY;
myVar2 = String.EMPTY;
myVar3 = String.EMPTY;
myVar4 = String.EMPTY;
myVar5 = String.EMPTY;
myVar6 = String.EMPTY;
myVar7 = String.EMPTY;
myVar8 = String.EMPTY;
myVar9 = String.EMPTY;

10 (String.EMPTY dahil 11) 1 nesneye işaret

Veya: -

myVar0 = "";
myVar1 = "";
myVar2 = "";
myVar3 = "";
myVar4 = "";
myVar5 = "";
myVar6 = "";
myVar7 = "";
myVar8 = "";
myVar9 = "";

10 nesneden 10 nesneye

Bu verimsizdir ve büyük bir uygulama boyunca önemli olabilir.

Belki de Java derleyici veya çalışma zamanı tüm "" örneklerini aynı örneğe otomatik olarak gösterecek kadar etkilidir, ancak bu belirlemeyi yapmak için ek işlem yapmayabilir ve bu işlemi gerçekleştirebilir.