Java Dizeleri: "String s = new String (" silly ");"

Java öğrenen bir C ++ adamıyım. Etkili Java okuyorum ve bir şeyler kafamı karıştırdı. Asla böyle kod yazmamayı söylüyor:

String s = new String("silly");

Çünkü gereksiz Stringnesneler yaratır . Ancak bunun yerine şu şekilde yazılmalıdır:

String s = "No longer silly";

Tamam, şimdiye kadar iyi ... Ancak, bu sınıf verildiğinde:

public final class CaseInsensitiveString {
    private String s;
    public CaseInsensitiveString(String s) {
        if (s == null) {
            throw new NullPointerException();
        }
        this.s = s;
    }
    :
    :
}

CaseInsensitiveString cis = new CaseInsensitiveString("Polish");
String s = "polish";

1. İlk ifade neden uygun? Olmamalı

   CaseInsensitiveString cis = "Polish";

2. Yukarıdaki ifadenin uygun olmasını nasıl CaseInsensitiveStringsağlarım String(genişletme olsun veya olmasın String)? String hakkında, onu böyle birebir olarak geçirebilmeyi uygun kılan nedir? Anladığım kadarıyla Java'da "kopya yapıcı" kavramı yok mu?

Stringdilin özel yerleşik bir sınıfıdır. Bu içindir Stringsınıfın sadece dediğini kaçınmalıdır hangi

String s = new String("Polish");

Çünkü literal "Polish"zaten yazı tipindedir Stringve fazladan gereksiz bir nesne yaratıyorsunuz. Diğer herhangi bir sınıf için

CaseInsensitiveString cis = new CaseInsensitiveString("Polish");

yapılacak doğru (ve bu durumda yalnızca) şeydir.

Birebir form kullanmanın ana faydasının (yani, new String ("foo") yerine "foo") tüm String değişmez değerlerinin VM tarafından "dahil edilmesi" olduğuna inanıyorum. Başka bir deyişle, aynı dizeyi oluşturan diğer herhangi bir kod yeni bir örnek oluşturmak yerine havuzlanmış String'i kullanacak şekilde bir havuza eklenir.

Örnek olarak, aşağıdaki kod ilk satır için doğru, ikincisi için yanlış yazdıracaktır:

System.out.println("foo" == "foo");
System.out.println(new String("bar") == new String("bar"));

Dizeler javada biraz özel olarak işlenir, değişmezler, bu nedenle referans sayma ile ele alınmaları güvenlidir.

Eğer yazarsan

String s = "Polish";
String t = "Polish";

daha sonra s ve t aslında aynı nesneye başvurur ve s == t true değerini döndürür, okunan nesneler için "==" için "aynı nesnedir" (veya olabilir, yine de, bunun bir parçası olup olmadığından emin değilim gerçek dil spesifikasyonu veya sadece derleyici uygulamasının bir detayı - bu yüzden belki buna güvenmek güvenli değildir).

Eğer yazarsan

String s = new String("Polish");
String t = new String("Polish");

sonra s! = t (çünkü açıkça yeni bir dize oluşturdunuz), ancak s.equals (t) true değerini döndürse de (çünkü string bu davranışı equals'a ekler).

Yazmak istediğin şey

CaseInsensitiveString cis = "Polish";

çalışamaz çünkü alıntıların nesneniz için bir tür kısa devre kurucusu olduğunu düşünüyorsunuz, aslında bu yalnızca eski java.lang.Strings için çalışıyor.

String s1="foo";

literal havuza girecek ve s1 referans alacaktır.

String s2="foo";

bu sefer "foo" değişmezinin StringPool'da zaten mevcut olup olmadığını kontrol edecek, böylece s2 aynı değişmez değeri gösterecektir.

String s3=new String("foo");

Önce StringPool'da "foo" değişmezi oluşturulacak, ardından string arg yapıcısı aracılığıyla String Object oluşturulacak, yani yeni operatör aracılığıyla nesne oluşturma nedeniyle öbek içinde "foo" olacak ve sonra s3 onu referans gösterecektir.

String s4=new String("foo");

s3 ile aynı

yani System.out.println(s1==s2);// **true** due to literal comparison.

ve System.out.println(s3==s4);// **false** due to object

karşılaştırma (s3 ve s4, yığın içinde farklı yerlerde oluşturulur)

StringURL'ler Java'da özeldir - değişmezdirler ve dize sabitleri otomatik olarak String nesnelere .

Örneğinizin SomeStringClass cis = "value"başka herhangi bir sınıfa başvurmasının bir yolu yok .

Uzatamazsınız String, çünkü olarak bildirilir final, yani alt sınıflara izin verilmez.

Java dizgileri ilginç. Görünüşe göre yanıtlar bazı ilginç noktaları kapsıyor. İşte benim iki sentim.

dizeler değişmezdir (onları asla değiştiremezsiniz)

String x = "x";
x = "Y"; 

• İlk satır, "x" dize değerini içerecek bir x değişkeni yaratacaktır. JVM, dize değerleri havuzuna bakacak ve "x" var mı diye bakacak, varsa, x değişkenini ona işaret edecek, yoksa, onu yaratacak ve sonra atamayı yapacak.
• İkinci satır, "x" referansını kaldıracak ve dize değerleri havuzunda "Y" nin var olup olmadığına bakacaktır. Varsa atayacak, yoksa önce yaratacak, sonra atayacak. Dize değerleri kullanıldıkça veya kullanılmadıkça, dize değerleri havuzundaki bellek alanı geri kazanılacaktır.

dizi karşılaştırmaları, karşılaştırdığınız şeye bağlıdır

String a1 = new String("A");

String a2 = new String("A");

• a1 eşit değil a2
• a1ve a2nesne referanslarıdır
• String açıkça bildirildiğinde, yeni örnekler yaratılır ve bunların referansları aynı olmayacaktır.

Bence büyük küçük harf duyarlı sınıfı kullanmaya çalışırken yanlış yoldasınız. Dizeleri rahat bırakın. Gerçekten önemsediğiniz şey, değerleri nasıl görüntülediğiniz veya karşılaştırdığınızdır. Dizeyi biçimlendirmek veya karşılaştırmalar yapmak için başka bir sınıf kullanın.

yani

TextUtility.compare(string 1, string 2) 
TextUtility.compareIgnoreCase(string 1, string 2)
TextUtility.camelHump(string 1)

Sınıfı oluşturduğunuz için, karşılaştırmaların istediğinizi yapmasını sağlayabilirsiniz - metin değerlerini karşılaştırın.

Yapamazsın. Java'da çift tırnak içindeki şeyler, derleyici tarafından özel olarak Dizeler olarak tanınır ve ne yazık ki bunu geçersiz kılamazsınız (veya uzatamazsınız java.lang.String- ilan edilir final).

Sorunuzu yanıtlamanın en iyi yolu, sizi "Dize sabit havuzu" ile tanıştırmaktır. Java dizgesinde nesneler değişmezdir (yani değerleri başlatıldıktan sonra değiştirilemez), bu nedenle bir dizi nesnesini düzenlerken, eski nesnenin sadece "dizge" adı verilen özel bir bellekte yüzdüğü yeni bir düzenlenmiş dize nesnesi oluşturursunuz. sabit havuz ". tarafından yeni bir dizgi nesnesi oluşturmak

String s = "Hello";

havuzda yalnızca bir dize nesnesi oluşturacak ve s başvurusu buna başvuracaktır, ancak

String s = new String("Hello");

iki dize nesnesi oluşturursunuz: biri havuzda, diğeri yığın içinde. referans öbek içindeki nesneye başvurur.

- CaseInsensitiveString'in String gibi davranmasını nasıl sağlarım, böylece yukarıdaki ifade tamam olur (String genişletme ile ve olmadan)? String hakkında, onu böyle bire bir aktarabilmeyi uygun kılan nedir? Anladığım kadarıyla Java'da "kopya yapıcı" kavramı yok değil mi?

İlk noktadan yeterince söylendi. "Lehçe" değişmez bir dizedir ve CaseInsentiviveString sınıfına atanamaz.

Şimdi ikinci nokta hakkında

Yeni değişmez değerler oluşturamasanız da, bu kitabın ilk maddesini "benzer" bir yaklaşım için takip edebilirsiniz, böylece aşağıdaki ifadeler doğrudur:

    // Lets test the insensitiveness
    CaseInsensitiveString cis5 = CaseInsensitiveString.valueOf("sOmEtHiNg");
    CaseInsensitiveString cis6 = CaseInsensitiveString.valueOf("SoMeThInG");

    assert cis5 == cis6;
    assert cis5.equals(cis6);

İşte kod.

C:\oreyes\samples\java\insensitive>type CaseInsensitiveString.java
import java.util.Map;
import java.util.HashMap;

public final class CaseInsensitiveString  {


    private static final Map<String,CaseInsensitiveString> innerPool 
                                = new HashMap<String,CaseInsensitiveString>();

    private final String s;


    // Effective Java Item 1: Consider providing static factory methods instead of constructors
    public static CaseInsensitiveString valueOf( String s ) {

        if ( s == null ) {
            return null;
        }
        String value = s.toLowerCase();

        if ( !CaseInsensitiveString.innerPool.containsKey( value ) ) {
             CaseInsensitiveString.innerPool.put( value , new CaseInsensitiveString( value ) );
         }

         return CaseInsensitiveString.innerPool.get( value );   
    }

    // Class constructor: This creates a new instance each time it is invoked.
    public CaseInsensitiveString(String s){
        if (s == null) {
            throw new NullPointerException();
         }         
         this.s = s.toLowerCase();
    }

    public boolean equals( Object other ) {
         if ( other instanceof CaseInsensitiveString ) {
              CaseInsensitiveString otherInstance = ( CaseInsensitiveString ) other;
             return this.s.equals( otherInstance.s );
         }

         return false;
    }


    public int hashCode(){
         return this.s.hashCode();
    }

// "assert" anahtar kelimesini kullanarak sınıfı test edin

    public static void main( String [] args ) {

        // Creating two different objects as in new String("Polish") == new String("Polish") is false
        CaseInsensitiveString cis1 = new CaseInsensitiveString("Polish");
        CaseInsensitiveString cis2 = new CaseInsensitiveString("Polish");

        // references cis1 and cis2 points to differents objects.
        // so the following is true
        assert cis1 !=  cis2;      // Yes they're different
        assert cis1.equals(cis2);  // Yes they're equals thanks to the equals method

        // Now let's try the valueOf idiom
        CaseInsensitiveString cis3 = CaseInsensitiveString.valueOf("Polish");
        CaseInsensitiveString cis4 = CaseInsensitiveString.valueOf("Polish");

        // References cis3 and cis4 points to same  object.
        // so the following is true
        assert cis3 == cis4;      // Yes they point to the same object
        assert cis3.equals(cis4); // and still equals.

        // Lets test the insensitiveness
        CaseInsensitiveString cis5 = CaseInsensitiveString.valueOf("sOmEtHiNg");
        CaseInsensitiveString cis6 = CaseInsensitiveString.valueOf("SoMeThInG");

        assert cis5 == cis6;
        assert cis5.equals(cis6);

        // Futhermore
        CaseInsensitiveString cis7 = CaseInsensitiveString.valueOf("SomethinG");
        CaseInsensitiveString cis8 = CaseInsensitiveString.valueOf("someThing");

        assert cis8 == cis5 && cis7 == cis6;
        assert cis7.equals(cis5) && cis6.equals(cis8);
    }

}

C:\oreyes\samples\java\insensitive>javac CaseInsensitiveString.java


C:\oreyes\samples\java\insensitive>java -ea CaseInsensitiveString

C:\oreyes\samples\java\insensitive>

Yani, CaseInsensitiveString nesnelerinin dahili bir havuzunu oluşturun ve ilgili örneği oradan geri döndürün.

Bu şekilde "==" operatörü true değerini döndürür , aynı değeri temsil eden iki nesne başvurusu için değerini .

Bu, benzer nesneler çok sık kullanıldığında ve maliyet yaratmanın pahalı olduğu durumlarda kullanışlıdır.

Dize sınıfı dokümantasyonu, sınıfın kullandığını belirtir. bir iç havuz

Sınıf tamamlanmadı, CharSequence arayüzünü uygularken nesnenin içeriğini incelemeye çalıştığımızda bazı ilginç sorunlar ortaya çıkıyor, ancak bu kod Kitap'taki o öğenin nasıl uygulanabileceğini gösterecek kadar iyidir.

İnternalPool nesnesini kullanarak, referansların serbest bırakılmadığına ve dolayısıyla çöp toplama yapılamayacağına ve çok sayıda nesne oluşturulursa bunun bir sorun haline gelebileceğine dikkat etmek önemlidir.

Yoğun olarak kullanıldığından ve havuz yalnızca "interned" nesneden oluştuğundan String sınıfı için çalışır.

Boolean sınıfı için de işe yarar, çünkü yalnızca iki olası değer vardır.

Ve son olarak, Tamsayı sınıfındaki valueOf (int) 'nin -128 ila 127 int değerleriyle sınırlı olmasının nedeni de budur .

İlk örneğinizde, "aptalca" bir String oluşturuyorsunuz ve daha sonra bunu bir parametre olarak başka bir String'in kopya yapıcısına geçiriyorsunuz, bu da birinciyle aynı olan ikinci bir String yapar. Java Dizeleri değişmez olduğu için (C dizgilerine alışkın insanları sık sık sokan bir şey), bu gereksiz bir kaynak israfıdır. Bunun yerine ikinci örneği kullanmalısınız çünkü birkaç gereksiz adımı atlar.

Bununla birlikte, String değişmezi bir CaseInsensitiveString değildir, bu nedenle son örneğinizde istediğinizi yapamazsınız. Ayrıca, C ++ 'da yapabileceğiniz gibi bir döküm operatörünü aşırı yüklemenin bir yolu yoktur, bu nedenle tam anlamıyla istediğiniz şeyi yapmanın bir yolu yoktur. Bunun yerine, bunu sınıfınızın yapıcısına bir parametre olarak iletmelisiniz. Tabii ki, muhtemelen sadece String.toLowerCase () kullanırım ve onunla işim biter.

Ayrıca, CaseInsensitiveString'iniz CharSequence arabirimini ve muhtemelen Serializable ve Comparable arabirimleri uygulamalıdır. Elbette, Comparable'ı uygularsanız, equals () ve hashCode () öğelerini de geçersiz kılmalısınız.

Sırf Stringsınıfınızda söz sahibi olmanız, yerleşik Stringsınıfın tüm özel özelliklerini edindiğiniz anlamına gelmez .

CaseInsensitiveStringa Stringiçermesine rağmen bir değildir String. Bir Stringedebi örneğin "örnek" sadece atanabilir String.

CaseInsensitiveString ve String farklı nesnelerdir. Yapamazsın:

CaseInsensitiveString cis = "Polish";

çünkü "Lehçe" bir String'dir, CaseInsensitiveString değildir. String, CaseInsensitiveString String'i uzattıysa, o zaman iyi olacaksınız, ancak açıkçası değil.

Ve buradaki inşaat için endişelenmeyin, gereksiz nesneler yapmayacaksınız. Yapıcının koduna bakarsanız, tüm yaptığı, ilettiğiniz dizgeye bir başvuru depolamaktır. Fazladan hiçbir şey oluşturulmamaktadır.

String s = new String ("foobar") durumunda farklı bir şey yapıyor. Önce "foobar" değişmez dizesini oluşturuyorsunuz, ardından ondan yeni bir dizge oluşturarak bir kopyasını oluşturuyorsunuz. Bu kopyayı oluşturmanıza gerek yok.

yazmak dedikleri zaman

String s = "Silly";

onun yerine

String s = new String("Silly");

Yukarıdaki ifadelerin her ikisi de bir String nesnesi oluşturduğundan, ancak yeni String () sürümü iki String nesnesi oluşturduğundan, bir String nesnesi oluştururken bunu ifade ederler: biri yığın içinde ve diğeri dize sabit havuzunda. Bu nedenle daha fazla bellek kullanıyor.

Ama yazdığın zaman

CaseInsensitiveString cis = new CaseInsensitiveString("Polish");

Bunun yerine bir String oluşturmuyorsunuz, CaseInsensitiveString sınıfının bir nesnesini oluşturuyorsunuz. Bu nedenle yeni operatörü kullanmanız gerekir.

Eğer doğru anladıysam, sorunuza neden doğrudan bir değer atayarak bir nesne oluşturamayacağımız anlamına gelir, onu java'da bir Wrapper of String sınıfıyla sınırlamayalım.

Sadece şunu söyleyeyim, tamamen Nesne Yönelimli Programlama dillerinin bazı yapıları vardır ve tek başına yazıldıklarında tüm harflerin doğrudan verilen türde bir nesneye dönüştürülebileceğini söyler.

Bu tam olarak, yorumlayıcı 3'ü görürse bunun bir Tamsayı nesnesine dönüştürüleceği anlamına gelir, çünkü tamsayı bu tür değişmez değerler için tanımlanan türdür.

Eğer yorumlayıcı 'a' gibi tek tırnak içinde herhangi bir şey görürse, bu doğrudan karakter tipi bir nesne yaratacaktır, dil onun için varsayılan yazı karakteri nesnesini tanımladığı için bunu belirtmenize gerek yoktur.

Benzer şekilde, yorumlayıcı "" içinde bir şey görürse, varsayılan türünün bir nesnesi, yani dizge olarak değerlendirilecektir. Bu, arka planda çalışan bazı yerel koddur.

Bu cevabın ipucunu aldığım MIT video konferans kursu 6.00 sayesinde.

Java'da "metin" sözdizimi java.lang.String sınıfının bir örneğini oluşturur. Görev:

String foo = "text";

kopya kurucu gerektirmeyen basit bir atamadır.

MyString bar = "text";

MyString sınıfı java.lang.String veya java.lang.String'in süper sınıfı olmadığı için yaptığınız şey yasa dışıdır.

İlk olarak, String'den genişleyen bir sınıf oluşturamazsınız, çünkü String son bir sınıftır. Ve java, Dizeleri diğer sınıflardan farklı şekilde yönetir, böylece yalnızca String ile yapabilirsiniz

String s = "Polish";

Ama sınıfınıza göre kurucuyu çağırmalısınız. Yani, bu kod iyi.

Java'nın Copy yapıcılarına sahip olduğunu eklemeliyim ...

Bu, argümanla aynı türde bir nesneye sahip sıradan bir kurucu.

JDK'nın çoğu sürümünde iki sürüm aynı olacaktır:

String s = new String ("aptal");

String s = "Artık saçma değil";

Dizeler değişmez olduğundan, derleyici dizge sabitlerinin bir listesini tutar ve yeni bir tane yapmaya çalışırsanız, önce dizenin önceden tanımlanmış olup olmadığını kontrol eder. Bu durumda, var olan değişmez dizgeye bir başvuru döndürülür.

Açıklığa kavuşturmak için - "String s =" dediğinizde, yığın üzerinde yer kaplayan yeni bir değişken tanımlıyorsunuz - o zaman "Artık aptal değil" mi yoksa yeni String ("aptal") mı diyorsunuz, tam olarak aynı şey oluyor - yeni sabit dize uygulamanızda derlenir ve buna referans işaret eder.

Burada farkı görmüyorum. Ancak değişmez olmayan kendi sınıfınız için bu davranış önemsizdir ve kurucunuzu aramalısınız.

GÜNCELLEME: Yanılmışım! Aşağı oylama ve eklenen yoruma dayanarak bunu test ettim ve anlayışımın yanlış olduğunu anladım - yeni String ("Aptal") gerçekten mevcut olanı yeniden kullanmak yerine yeni bir dizi yaratıyor. Bunun neden olacağından emin değilim (faydası nedir?) Ama kod kelimelerden daha yüksek sesle konuşuyor!

String, yeni Sring parçası olmadan bunları oluşturabileceğiniz özel sınıflardan biridir.

aynı

int x = y;

veya

char c;

Java'daki Strings'in değişmez ve büyük / küçük harfe duyarlı olması temel bir yasadır.

 String str1 = "foo"; 
 String str2 = "foo"; 

Hem str1 hem de str2 aynı String nesnesine aittir, "foo", b'coz Java, StringPool'daki Strings'i yönetir, bu nedenle yeni bir değişken aynı String'e başvurursa, StringPool'da bulunan aynı alerady'yi atamak yerine başka bir tane oluşturmaz. .

 String str1 = new String("foo"); 
 String str2 = new String("foo");

Burada hem str1 hem de str2 farklı Nesnelere aittir, b'coz new String () yeni bir String Object'i zorla oluşturur.

Java, kodunuzda kullandığınız her dize değişmezi için bir String nesnesi oluşturur. Ne zaman ""kullanılırsa kullanılsın, aramakla aynıdır new String().

Dizeler, ilkel veriler gibi "hareket eden" karmaşık verilerdir. Dize değişmezleri, ilkel değişmez değerler gibi davransak da aslında nesnelerdir 6, 6.0, 'c',. Dolayısıyla, String "değişmezi" "text"değeri olan yeni bir String nesnesi döndürür char[] value = {'t','e','x','t}. Bu nedenle arama

new String("text"); 

aslında aramaya benzer

new String(new String(new char[]{'t','e','x','t'}));

Umarım buradan ders kitabınızın neden bu kadar gereksiz olduğunu anlayabilirsiniz.

Referans için, String'in uygulaması şu şekildedir: http://www.docjar.com/html/api/java/lang/String.java.html

Okumak eğlenceli ve biraz fikir verebilir. Kod çok profesyonel ve kurallara uygun bir kod gösterdiğinden, yeni başlayanların okuması ve anlamaya çalışması da harikadır.

Başka bir iyi referans, Strings'deki Java eğitimidir: http://docs.oracle.com/javase/tutorial/java/data/strings.html