String Literal/String new

Chyba tu: https://stackoverflow.com/questions/3297867/difference-between-string-object-and-string-literal jest to dobrze opisane.

Nie, jak Utworzysz nowy, taki sam string literal, to Masz dwa takie same obiekty(będą sobie równe, == zwróci true), a jak Utworzysz nowy taki sam, za pomocą new, to, będziesz miał nową referencję do tego samego obiektu (== zwróci false, natomiast isEqual() zwróci true).

lion137 napisał(a):

Nie, jak Utworzysz nowy, taki sam string literal, to Masz dwa takie same obiekty(będą sobie równe, == zwróci true), a jak Utworzysz nowy taki sam, za pomocą new, to, będziesz miał nową referencję do tego samego obiektu (== zwróci false, natomiast isEqual() zwróci true).

Tak ja to wiem. Wiem co zwróci kiedy false, a kiedy true, nie o to mi chodziło.

Napiszę jeszcze raz to co w PS2.
Gdy tworzę String za pomocą new to tworzą się dwa obiekty w String Poolu oraz w "Non-Poolu" czyli w heapie, ale poza StringPoolem.
Gdy stworzę później za pomocą String Literal obiekt o takie samej wartości co przedtem za pomocą new to już się nie utworzy obiekt w StrinPoolu, tylko referencja będzie wskazywać na ten obiekt, który został już utworzony za pomocą new. Jeżeli nie było takiej wartości, to tworzy się nowy obiekt.

Inna sytuacja:
Gdy stworzę najpierw za pomocą String Literal obiekt typu String, to wskakuje on do SP.
Gdy stworzę później obiekt typu string o tej samej wartości, to stworzy się tylko jeden obiekt w non-poolu.

Inna sytuacja:
Tworzę String literal, później kolejny, kolejny, to mam jeden obiekt w String poolu. Gdy później stworzę obiekt za pomocą new o takiej samej wartości czyli .equals()==true to stworzy się tylko jeden obiekt, czyli w sumie będą dwa.
Czy to co napisałem się zgadza? Jeżeli nie to w którym miejscu nie?

To w takim razie pytanie było źle zformułowane, albo ja się wyraziłem nie precyzyjnie. Jak Tworzysz literał, to Dostajesz nowy immutable string w SP, do którego referencją jest jego nazwa; tę referencję mozna zmienić,natomiast sam obiekt jest immutable, czyli, jak Przypiszesz do niego inną referencję, to dalej wskazuje ona na ten sam obiekt. W przypadku tworzenia za pomocą new, teoretycznie tworzymy dwa różne obiekty, ale może są optymalizowane, przez jakieś cashe czy coś, nie wiem. Acha, nie tworzymy dwóch obiektów, jeden obiekt reference type.

lion137 napisał(a):

W przypadku tworzenia za pomocą new, teoretycznie tworzymy dwa różne obiekty, ale może są optymalizowane, przez jakieś cashe czy coś, nie wiem. Acha, nie tworzymy dwóch obiektów, jeden obiekt reference type.

Tworzymy te dwa różne obiekty, ale referencje ma do tego z non-poola. Tak wyczytałem na internecie. Czyli zgadza się to co napisałeś. Zapomniałem o tym wspomnieć w poście. Aczkolwiek nie rozumiem czy coś co ja napisałem jest złego, czy nie.

Moim zdaniem String a = new String("a") jest dokładnie tym samym co:

String temp = "a"; // tutaj wyciągamy stringa z puli stringów
String a = new String(temp); // tutuaj tworzymy nowy obiekt na stercie

Gdzie temp jest unikalną nazwą.

Wibowit napisał(a):

Moim zdaniem String a = new String("a") jest dokładnie tym samym co:

Kopiuj

String temp = "a";
String a = new String(temp);

Gdzie temp jest unikalną nazwą.

Zwraca ten sam hashcode.
Mnie bardziej chodzi o ten StringPool i tę stertę.
Czekam aż ktoś zweryfikuje ten post https://4programmers.net/Forum/1570318 Aczkolwiek zapomniałem dopisać jak @lion137 słusznie zauważył, że gdy użyjemy new to tworzą sie dwa obiekty, ale referencja jest do tego poza StringPoolem.

Jeszcze wczoraj bym powiedział, że new tworzy jeden obiekt tylko na stercie, a ja chce to wiedzieć na 100% a nie połowicznie.

Napiszę innymi słowami: w String a = new String("a"); będzie tyle samo alokacji na stercie i stringów w puli co w instrukcjach String temp = "a"; i String a = new String(temp); razem wziętych. To, że dodasz lub usuniesz sobie zmienną lokalną w żaden sposób nie wpłynie na to co pojawi się na stercie czy w puli (aczkolwiek dodatkowe zmienne referencyjne wpływają na działanie GC, ale to już inna bajka). Możesz sobie więc rozbić złożone instrukcje na mniejsze, używające zmiennych lokalnych i analizować te prostsze instrukcje.

Przykład ze złożonymi instrukcjami:

String a = new String(new String("a"));
String b = new String("b");
String a2 = "a";
String a3 = new String(a);

Po rozbiciu na mniejsze mamy:

// rozbijamy: String a = new String(new String("a"));
String temp1 = "a"; // pierwsze wystąpienie literału "a" - dodajemy do string puli
String temp2 = new String(temp1); // nowy obiekt na stercie poza pulą
String a = new String(temp2); // nowy obiekt na stercie poza pulą
// rozbijamy: String b = new String("b");
String temp3 = "b"; // pierwsze wystąpienie literału "b" - dodajemy do string puli
String b = new String(temp3); // nowy obiekt na stercie poza pulą
// rozbijamy: String a2 = "a";
String a2 = "a"; // kolejne wystąpienie literału "a" - jest już w string puli, więc nie dodajemy
// rozbijamy: String a3 = new String(a);
String a3 = new String(a); // nowy obiekt na stercie poza pulą

Wibowit napisał(a):

Napiszę innymi słowami: w String a = new String("a"); będzie tyle samo alokacji na stercie i stringów w puli co w instrukcjach String temp = "a"; i String a = new String(temp);

Tak, będzie tyle samo.
String a = new String("a"); tworzy dwa obiekty, referencje ma do non-poola.
Drugi przypadek.
Najpierw String temp = "a"; tworzy obiekt w StringPoolu, później String a = new String(temp); tworzy obiekt w non-poolu czyli w stercie poza StringPoolem.

Tak?

Tak. W obu przypadkach a wskazuje na obiekt poza pulą. W obu przypadkach tworzymy tyle samo obiektów, czy to tych poza pulą czy w puli.

Wibowit napisał(a):

Tak. W obu przypadkach a wskazuje na obiekt poza pulą. W obu przypadkach tworzymy tyle samo obiektów, czy to tych poza pulą czy w puli.

No i to już pisałem w tym poście wszystko https://4programmers.net/Forum/1570318 , ale nieważne :D
Dzięki za upewnienie się, że dobrze rozumiem.

Normalnie dwa stringi "aa" odnoszą się do tego samego obiektu. Jeśli stworzysz go inaczej, np new String("aa") albo "a" + "a" to wtedy będą się odnosić do innego, chyba że je zinternujesz albo same się zinternują

String one = "aa";
String two = "aa";                  // same  ==

String three = new String("aa");    // different  .equals()
String four = three.intern();       // same again  == 

String five = "a" + "a";            // different  .equals()
String six = five.intern();         // same again  ==