Java'da Dizelerin Değişmezliği

Aşağıdaki örneği ele alalım.

String str = new String();

str  = "Hello";
System.out.println(str);  //Prints Hello

str = "Help!";
System.out.println(str);  //Prints Help!

Şimdi, Java'da, String nesneleri değiştirilemez. Sonra nasıl nesneye str"Yardım!" Bu, Java'daki dizelerin değişmezliğiyle çelişmiyor mu? Birisi bana değişmezliğin tam kavramını açıklayabilir mi?

Düzenle:

Tamam. Şimdi anlıyorum, ama sadece bir takip sorusu. Aşağıdaki kod hakkında:

String str = "Mississippi"; 
System.out.println(str); // prints Mississippi 

str = str.replace("i", "!"); 
System.out.println(str); // prints M!ss!ss!pp! 

Bu, iki nesnenin yeniden yaratıldığı ("Mississippi" ve "M! Ss! Ss! Pp!") Ve referansın yöntemden strsonra farklı bir nesneye işaret ettiği anlamına replace()mı geliyor?

strbir nesne değil, bir nesneye referanstır. "Hello"ve "Help!"iki ayrı Stringnesnedir. Böylece, str işaret bir dize. Sen ne değiştirebilir işaret o değil olanı, işaret .

Bu kodu alın, örneğin:

String s1 = "Hello";
String s2 = s1;
// s1 and s2 now point at the same string - "Hello"

Şimdi, bunun değerini etkileyecek ¹ yapabileceğimiz hiçbir şey yok . Aynı nesneye atıfta bulunurlar - dizes1s2"Hello" - ancak bu nesne değişmezdir ve bu nedenle değiştirilemez.

Eğer böyle bir şey yaparsak:

s1 = "Help!";
System.out.println(s2); // still prints "Hello"

Burada bir nesneyi değiştirip referansı değiştirme arasındaki farkı görüyoruz. s2başlangıçta s1işaret etmek için ayarladığımız aynı nesneyi gösteriyor. Ayar s1için "Help!"sadece değiştirir başvuru yaparken, Stringbaşlangıçta değişmeden kalıntıları sevk nesne.

Dizeleri ise olduğumuzu değişken, biz böyle bir şey yapabileceğini:

String s1 = "Hello";
String s2 = s1;
s1.setCharAt(1, 'a'); // Fictional method that sets character at a given pos in string
System.out.println(s2); // Prints "Hallo"

OP'nin düzenlemesine yanıt vermek için düzenleyin:

Eğer bakarsak String.Replace için kaynak kodu (Char, char) - Bunu görebiliyorum (JDK kurulum dizinindeki src.zip da mevcuttur yanlısı bir ipucu şey gerçekten nasıl çalıştığını merak zaman orada bakmaktır) Ne yapar şudur:

• oldCharGeçerli dizede bir veya daha fazla örnek varsa , geçerli dizenin tüm örneklerinin oldCharyerini aldığı bir kopyasını oluşturun newChar.
• Eğer oldChargeçerli dize bulunmaz, güncel dize döndürür.

Evet, "Mississippi".replace('i', '!')yeni bir Stringnesne yaratır . Yine, aşağıdakiler geçerlidir:

String s1 = "Mississippi";
String s2 = s1;
s1 = s1.replace('i', '!');
System.out.println(s1); // Prints "M!ss!ss!pp!"
System.out.println(s2); // Prints "Mississippi"
System.out.println(s1 == s2); // Prints "false" as s1 and s2 are two different objects

Şimdilik ödeviniz değiştirirseniz yukarıdaki kodun ne yaptığını görmek s1 = s1.replace('i', '!'); hiç s1 = s1.replace('Q', '!');:)

¹ Aslında, bir mutasyona dizeleri (ve diğer sabit nesneler) mümkün. Yansıma gerektirir ve çok, çok tehlikelidir ve programı gerçekten yok etmekle ilgilenmediğiniz sürece asla kullanılmamalıdır.

strReferans veren nesne değişebilir, ancak gerçek Stringnesnelerin kendileri değişemez .

StringDizeyi içeren nesneleri "Hello"ve "Help!"dolayısıyla bunlar değiştirilemez olması onların değerlerini değiştiremez.

StringNesnelerin değişmezliği, nesneye işaret eden referansların değişemeyeceği anlamına gelmez.

Birinin strbaşvurunun değişmesini önleyebilmesinin bir yolu, başvuruyu şu şekilde bildirmektir final:

final String STR = "Hello";

Şimdi, diğer bir atamak için çalışıyor Stringiçin STRbir derleme hatasına neden olur.

Light_handle Cup Size'i okumanızı öneririm - Değişkenler ve Değerler Arası Lütfen (Kupa Boyutu devam) hakkında bir hikaye . Bu, yukarıdaki yazıları okurken çok yardımcı olacaktır.

Onları okudun mu? Evet. İyi.

String str = new String();

Bu, "" adlı yeni bir "uzaktan kumanda" oluşturur strve bunu değere new String()(veya "") ayarlar .

örneğin, bellekte bu oluşturur:

str --- > ""

str  = "Hello";

Bu daha sonra uzaktan kumandayı " str" değiştirir, ancak orijinal dizeyi değiştirmez "".

örneğin, bellekte bu oluşturur:

str -+   ""
     +-> "Hello"

str = "Help!";

Bu daha sonra uzaktan kumandayı " str" değiştirir, ancak orijinal dizeyi değiştirmez"" veya uzaktan kumandanın o anda işaret ettiği nesneyi değiştirmez.

örneğin, bellekte bu oluşturur:

str -+   ""
     |   "Hello"
     +-> "Help!"

Bazı parçalara ayıralım

String s1 = "hello";

Bu Deyim, örneğin Sabit Dize Havuzu'nda merhaba ve işgal alanı içeren bir dize oluşturur ve bunu s1 referans nesnesine atar

String s2 = s1;

Bu ifade yeni s2 referansına aynı dize merhaba atar

         __________
        |          |
s1 ---->|  hello   |<----- s2
        |__________| 

Her iki referans da aynı dizeyi işaret ediyor, bu nedenle aşağıdaki gibi aynı değeri çıktılayın.

out.println(s1);    // o/p: hello
out.println(s2);    // o/p: hello

Gerçi dize olan değişmez böylece, atama mümkün olabilmektedir s1 şimdi yeni değer ifade edecektir yığını .

s1 = "stack";    
         __________
        |          |
s1 ---->|  stack   |
        |__________|

Ama merhaba işaret eden s2 nesnesi olduğu gibi olacak.

         __________
        |          |
s2 ---->|  hello   |
        |__________|

out.println(s1);    // o/p: stack
out.println(s2);    // o/p: hello

Dize değişmez olduğu için Java Virtual Machine, s1 dizesini yöntemiyle değiştirmemize izin vermez . Havuzdaki tüm yeni String nesnelerini aşağıdaki gibi oluşturur.

s1.concat(" overflow");

                 ___________________
                |                   |
s1.concat ----> |  stack overflow   |
                |___________________|

out.println(s1);    // o/p: stack
out.println(s2);    // o/p: hello
out.println(s1.concat); // o/p: stack overflow

Dize değiştirilebiliyorsa, çıktının

out.println(s1);    // o/p: stack overflow

Şimdi, String'in neden değiştirilecek concat () gibi yöntemlere sahip olduğuna şaşırabilirsiniz . Snippet'i takip etmek karışıklığınızı giderir.

s1 = s1.concat(" overflow");

Burada dizenin değiştirilmiş değerini s1 referansına geri atarız .

         ___________________
        |                   |
s1 ---->|  stack overflow   |
        |___________________|


out.println(s1);    // o/p: stack overflow
out.println(s2);    // o/p: hello

Bu nedenle Java, String'in son sınıf olmasına karar verdi. Aksi takdirde herkes, dizenin değerini değiştirebilir ve değiştirebilir. Umarım bu biraz yardımcı olur.

İlk başvurulan dize nesnesi strdeğiştirilmedi, yaptığınız tek şey stryeni bir dize nesnesine başvurmaktı.

Dize değişmeyecek, referans değişecektir. Değişmezliği alan kavramıyla karıştırıyorsunuz final. Bir alan finalatandıktan sonra atanırsa, yeniden atanamaz.

Sorunuzun değiştirme kısmıyla ilgili olarak şunu deneyin:

String str = "Mississippi"; 
System.out.println(str); //Prints Mississippi 

String other = str.replace("i", "!"); 
System.out.println(str); //still prints Mississippi 
System.out.println(other);  // prints M!ss!ss!pp!

Java bunu görmezden gelmeye çalışsa da, strbir göstergeden başka bir şey değildir. Bu, ilk yazdığınızda işaret eden str = "Hello";bir nesne oluşturduğunuz anlamına gelir str. strYazarak yeniden atadığınızda str = "Help!";, yeni bir nesne oluşturulur ve eski "Hello"nesne, java bunu hissettiğinde toplanır.

Değişmezlik, somutlaştırılmış bir nesnenin değerinin değişemeyeceğini, asla "Merhaba" ifadesini "Yardım!"

Str değişkeni bir nesneye başvurudır, str'ye yeni bir değer atadığınızda, başvurduğu nesnenin değerini değiştirmezsiniz, farklı bir nesneye başvurursunuz.

String sınıfı değiştirilemez ve değiştirilemez nesnenin değerini değiştiremezsiniz. Ancak Dize durumunda, dize değerini değiştirirseniz, dize havuzunda yeni dize oluşturur ve dize başvurunuz bu değere eskisine göre değil. bu nedenle dize değişmezdir. Örnek verelim,

String str = "Mississippi";  
System.out.println(str); // prints Mississippi 

bir dize "Mississippi" oluşturur ve şimdi String Mississippi'yi işaret edecek şekilde String havuzuna ekler.

str = str.replace("i", "!");  
System.out.println(str); // prints M!ss!ss!pp! 

Ancak yukarıdaki işlemden sonra, bir başka dize "M! Ss! Ss! Pp!" ve String havuzuna eklenecektir. ve şimdi str Mississippi'yi değil, M! ss! ss! pp!

böylece dize nesnesinin değerini değiştirdiğinizde, bir nesne daha oluşturur ve dize havuzuna ekler.

Bir örnek daha verelim

String s1 = "Hello"; 
String s2 = "World"; 
String s = s1 + s2;

bu üç satırın üstünde dize havuzuna üç dize nesnesi eklenir.
1) Merhaba
2) Dünya
3) HelloWorld

kullanın:

String s = new String("New String");
s.concat(" Added String");
System.out.println("String reference -----> "+s); // Output: String reference -----> New String

Burada görüyorsanız concatorijinal dize değiştirmek için yöntemi, yani, "Yeni String" bir string "Added String" ile kullanın, ama yine de önceki gibi çıktı var, bu nedenle nesnenin referansını değiştiremezsiniz kanıtlıyor ancak StringBuilder sınıfına göre bu işlemi yaparsanız çalışacaktır. Aşağıda listelenmiştir.

StringBuilder sb = new StringBuilder("New String");
sb.append(" Added String");
System.out.println("StringBuilder reference -----> "+sb);// Output: StringBuilder reference -----> New String Added String

Linus Tolvards'ın dediği gibi:

Konuşma ucuz. Bana kodu göster

Şuna bir bak:

public class Test{
    public static void main(String[] args){

        String a = "Mississippi";
        String b = "Mississippi";//String immutable property (same chars sequence), then same object

        String c = a.replace('i','I').replace('I','i');//This method creates a new String, then new object
        String d = b.replace('i','I').replace('I','i');//At this moment we have 3 String objects, a/b, c and d

        String e = a.replace('i','i');//If the arguments are the same, the object is not affected, then returns same object

        System.out.println( "a==b? " + (a==b) ); // Prints true, they are pointing to the same String object

        System.out.println( "a: " + a );
        System.out.println( "b: " + b );

        System.out.println( "c==d? " + (c==d) ); // Prints false, a new object was created on each one

        System.out.println( "c: " + c ); // Even the sequence of chars are the same, the object is different
        System.out.println( "d: " + d );

        System.out.println( "a==e? " + (a==e) ); // Same object, immutable property
    }
}

Çıktı

a==b? true
a: Mississippi
b: Mississippi
c==d? false
c: Mississippi
d: Mississippi
a==e? true

İki şeyi hatırlayın:

• Yeni bir yöntem (c & d vakaları) işleyen ve yaratan bir yöntem uygulayana kadar dizeler değişmezdir.
• Her iki parametre de aynı ise, Replace yöntemi aynı String nesnesini döndürür

Java dize değişmezliğini nasıl kırılacağını merak edenler için ...

kod

import java.lang.reflect.Field;

public class StringImmutability {
    public static void main(String[] args) {
        String str1 = "I am immutable";
        String str2 = str1;

        try {
            Class str1Class = str1.getClass();
            Field str1Field = str1Class.getDeclaredField("value");

            str1Field.setAccessible(true);
            char[] valueChars = (char[]) str1Field.get(str1);

            valueChars[5] = ' ';
            valueChars[6] = ' ';

            System.out.println(str1 == str2);
            System.out.println(str1);
            System.out.println(str2);           
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}

Çıktı

true
I am   mutable
I am   mutable

Dize olan değişmez . Bu, yalnızca referansı değiştirebileceğimiz anlamına gelir .

String a = "a";
System.out.println("String a is referencing to "+a); // Output: a

a.concat("b");
System.out.println("String a is referencing to "+a); // Output: a

a = a.concat("b");
System.out.println("String a has created a new reference and is now referencing to "+a); // Output: ab

Java'da nesnelere genellikle referanslarla erişilir. Kod parçanızda str ilk olarak "Hello" (otomatik oluşturulan bir nesne veya sabit havuzdan getirilmiş ) için atanmış bir referanstır ve daha sonra başka bir nesne "Yardım!" aynı referansa. Dikkat edilmesi gereken nokta, referansın aynı ve değiştirilmiş olmasıdır, ancak nesneler farklıdır. Kodunuzda bir şey daha var üç nesneye eriştiniz,

1. New String () öğesini çağırdığınızda.
2. "Merhaba" atadığınızda.
3. "Yardım!"

Yeni String () çağrıldığında, string havuzunda olsa bile yeni bir nesne oluşturulur, bu nedenle genellikle kullanılmamalıdır. Yeni String () öğesinden oluşturulan bir dizeyi dize havuzuna koymak için intern()yöntemi deneyebilirsiniz .

Umarım bu yardımcı olur.

Söyleyebileceğim değişkenlik, String'in kendisini değiştirememenizdir. Diyelim ki değeri "abc" olan String x'iniz var. Şimdi String'i değiştiremezsiniz, yani "abc" içindeki hiçbir karakteri / karakterleri değiştiremezsiniz.

Dize'deki herhangi bir karakteri / karakterleri değiştirmeniz gerekiyorsa, bir karakter dizisi kullanabilir ve onu değiştirebilir veya StringBuilder kullanabilirsiniz.

String x = "abc";
x = "pot";
x = x + "hj";
x = x.substring(3);
System.out.println(x);

char x1[] = x.toCharArray();
x1[0] = 's';
String y = new String(x1);
System.out.println(y);

Çıktı:

hj
sj

Ya da deneyebilirsiniz:

public class Tester
{
public static void main(String[] args)
{
 String str = "Mississippi"; 
 System.out.println(str); // prints Mississippi 
 System.out.println(str.hashCode());

 str = str.replace("i", "!"); 
 System.out.println(str); // prints M!ss!ss!pp! 
 System.out.println(str.hashCode());
 }
 }

Bu, karma kodun nasıl değiştiğini gösterecektir.

Dize değişmezdir, nesnenin kendisini değiştiremeyeceğiniz anlamına gelir, ancak nesneye yapılan başvuruyu değiştirebilirsiniz. A = "ty" olarak adlandırdığınızda, aslında a'nın başvurusunu String değişmezi "ty" tarafından oluşturulan yeni bir nesneye değiştirmiş olursunuz. Bir nesnenin değiştirilmesi, alanlarından birini değiştirmek için yöntemlerini kullanmak anlamına gelir (veya alanlar geneldir ve nihai değildir, böylece yöntemlerle erişilmeden dışarıdan güncellenebilir), örneğin:

Foo x = new Foo("the field");
x.setField("a new field");
System.out.println(x.getField()); // prints "a new field"

Değişmez bir sınıfta (son olarak bildirildi, miras yoluyla değiştirmeyi önlemek için) (yöntemleri alanlarını değiştiremez ve alanlar her zaman özeldir ve son olarak önerilir), örneğin String, geçerli Dize'yi değiştiremezsiniz, ancak yeni bir Dize döndürebilir, yani:

String s = "some text";
s.substring(0,4);
System.out.println(s); // still printing "some text"
String a = s.substring(0,4);
System.out.println(a); // prints "some"

Burada değişmezlik, örneğin başka bir referansı gösterebileceği, ancak dizenin orijinal içeriğinin orijinal referansta değiştirilmeyeceği anlamına gelir. Verdiğiniz ilk örnekle açıklayayım. İlk str "Merhaba" u işaret ediyor. İkinci kez "Yardım!" Burada str "Yardım!" ve "Hello" dizesinin referansı kaybolur ve bunu geri alamayız.

Aslında str, mevcut içeriği değiştirmeye çalıştığında başka bir yeni dize oluşturulur ve str bu referansı göstermeye başlar. Bu nedenle orijinal referanstaki dizgenin değiştirilmediğini, ancak referansta güvenli olduğunu ve nesnenin farklı referansı işaret etmeye başladığını ve değişmezliğin korunduğunu görüyoruz.

Cevap için çok geç, ancak Java'da String sınıfının yazarından kısa bir mesaj koymak istedi

Dizeler sabittir; değerleri oluşturulduktan sonra değiştirilemez. Dize arabellekleri değiştirilebilir dizeleri destekler. Dize nesneleri değiştirilemez olduğu için paylaşılabilirler.

Bu belgeden, dizeyi değiştiren her şeyin farklı nesne (yeni veya interned ve eski olabilir) döndürdüğü elde edilebilir. Bununla ilgili çok ince olmayan ipucu, işlev imzasından gelmelidir. Bir düşünün, 'Neden bir nesne üzerinde işlev yerine durum yerine bir nesne döndürdüler?'.

public String replace(char oldChar, char newChar) 

Ayrıca bu davranışı açık hale getiren bir kaynak daha (işlev belgelerini değiştirme)

Bu dizedeki tüm oldChar örneklerini newChar ile değiştirerek oluşan yeni bir dize döndürür.

Kaynak: https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#replace(char,%20char)

• yazar Lee Boynton
• yazar Arthur van Hoff
• yazar Martin Buchholz
• yazar Ulf Zibis

Kaynak: JavaDoc of String.

Object string - methodlarının kendisi "değişmez" olarak yapılır. Bu eylem hiçbir değişiklik oluşturmaz: "letters.replace (" bbb "," aaa ");"

Ancak veri atamak, Dizeler içeriğindeki değişikliklerin değişmesine neden olur:

    letters = "aaa";
    letters=null;
    System.out.println(letters);
    System.out.println(oB.hashCode());
    System.out.println(letters);
    letters = "bbbaaa";
    System.out.println(oB.hashCode());
    System.out.println(letters);

// Object dizesinin hashcode'u değişmez.

Eğer HELLOsizin String sonra değiştiremezsiniz HELLOiçin HILLO. Bu özelliğe değişmezlik özelliği denir.

HELLO String'i işaret etmek için birden fazla pointer String değişkeniniz olabilir.

Ancak HELLO char Array ise HELLO'yu HILLO olarak değiştirebilirsiniz. Örneğin,

char[] charArr = 'HELLO';
char[1] = 'I'; //you can do this

Programlama dillerinin değişken veri değişkenleri vardır, böylece anahtar, değer çiftinde anahtar olarak kullanılabilir.

Basit bir örnekle açıklarım

herhangi bir karakter dizisini göz önünde bulundurun: örneğin char a [] = {'h', 'e', ​​'l', 'l', 'o'}; ve bir dize: String s = "merhaba";

karakter dizisinde diziyi yineleyerek yalnızca son üç harfi yazdırma gibi işlemler yapabiliriz; ancak dizede yeni String nesnesi yapmamız ve gerekli alt dizeyi kopyalamamız gerekir ve adresi yeni dize nesnesinde olacaktır.

Örneğin

***String s="hello";
String s2=s.substrig(0,3);***

böylece s2 "hel" olacaktır;

Değişmez ve Nihai olarak Java dizesi, değiştirilemeyeceği veya değiştirilemeyeceği anlamına gelir:

Dava 1:

class TestClass{  
 public static void main(String args[]){  
   String str = "ABC";  
   str.concat("DEF");  
   System.out.println(str);  
 }  
} 

Çıktı: ABC

Sebep: Nesne referansı str değişmez aslında havuzda olan ve hiç referansı olmayan (yani kaybolan) yeni bir nesne "DEF" oluşturulur.

Durum 2:

class TestClass{  
 public static void main(String args[]){  
   String str="ABC";  
   str=str.concat("DEF");  
   System.out.println(str);  
 }  
}  

Çıktı: ABCDEF

Sebep: Bu durumda str artık yeni bir nesneye "ABCDEF" atıfta bulunmaktadır, bu nedenle ABCDEF'i yazdırmaktadır, yani önceki "ABC" str nesnesi referans olmadan havuzda kaybolmaktadır.

Dize değişmez olduğu için, işlevin döndürülen değerini string.so'ya sormazsanız, değişiklik olmaz. Sorunuzda swap işlevi döndürülen değeri s olarak atayın.

s = takas (s, n1, n2); sonra s dizesinin değeri değişecektir.

Ben de bazı permütasyonlar dize almak için program yazarken değişmeyen değer alıyordum (Her ne kadar tüm permütasyonlar vermese de bu örneğin sorunuzu cevaplamak için)

İşte bir örnek.

> import java.io.*;  public class MyString { public static void
> main(String []args)throws IOException {  BufferedReader br=new
> BufferedReader(new InputStreamReader(System.in));  String
> s=br.readLine().trim(); int n=0;int k=0;  while(n!=s.length()) {
> while(k<n){  swap(s,k,n); System.out.println(s); swap(s,k,n); k++; }
> n++; } }  public static void swap(String s,int n1,int n2) { char temp;
> temp=s.charAt(n1); StringBuilder sb=new StringBuilder(s);
> sb.setCharAt(n1,s.charAt(n2)); sb.setCharAt(n2,temp); s=sb.toString();
> } }

ama i yukarıdaki koddan dizenin izin verilen değerlerini alma değildi. Bu yüzden dizeye takas işlevinin döndürülen değerini atadı ve dizenin değişen değerleri aldım. Döndürülen değeri atadıktan sonra dizenin izin verilen değerlerini aldım.

/import java.util.*; import java.io.*; public class MyString { public static void main(String []args)throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 
String s=br.readLine().trim(); int n=0;int k=0; 
while(n!=s.length()){ while(k<n){ s=swap(s,k,n); 
System.out.println(s); s=swap(s,k,n); k++; } n++; } } 
public static String swap(String s,int n1,int n2){
char temp; temp=s.charAt(n1); StringBuilder sb=new StringBuilder(s); sb.setCharAt(n1,s.charAt(n2)); sb.setCharAt(n2,temp); s=sb.toString(); return s; } }

    public final class String_Test {

    String name;
    List<String> list=new ArrayList<String>();

    public static void main(String[] args) {

        String_Test obj=new String_Test();
        obj.list.add("item");//List will point to a memory unit- i.e will have one Hashcode value #1234

        List<String> list2=obj.list; //lis1 also will point to same #1234

        obj.list.add("new item");//Hashcode of list is not altered- List is mutable, so reference remains same, only value in that memory location changes

        String name2=obj.name="Myname"; // name2 and name will point to same instance of string -Hashcode #5678
        obj.name = "second name";// String is Immutable- New String HAI is created and name will point to this new instance- bcoz of this Hashcode changes here #0089

        System.out.println(obj.list.hashCode());
        System.out.println(list2.hashCode());
        System.out.println(list3.hashCode());

        System.out.println("===========");
        System.out.println(obj.name.hashCode());
        System.out.println(name2.hashCode());
    }
}

Üretecek böyle bir şey koymak

1419358369 1419358369

103056 65078777

Değişmez nesnenin amacı, bir kez atandığında değerinin değiştirilmemesidir. Uygulamaya göre her değiştirmeye çalıştığınızda yeni nesne döndürür. Not: Bundan kaçınmak için string yerine stringbuffer kullanılabilir.

Son sorunuza :: u bir referans olacak, ve dize havuzunda 2 dizeleri .. referans m! Ss! Ss! Pp!