Java teori i praksis

I følge Java teorien sammenlinger == primitive på deres værdi og Objecter på Objectet.
Det vil siget at fx. to int med samme værdi vil give :
int1==int2 = true.
To forskellige Objecter med samme indhold vil derimod give :
O1==O2 = false. Objecter bør derfor sammenlignes med deres .equals() metode : O1.equals(O2).

Strings er specielle Objecter fordi java "memorymanageren" bruger samme String Object til at gemme to eller flere ens Strings, dette spare memory. Det vil sige at Strings godt kan sammenlignes med == selvom Strings er Objecter.

Nogle klasiske eksempler :
ex1 ---------------------------------
String s1 = "test1";
String s2 = s1;
System.out.println( s1==s2 )
--------------------------------------
printer selvfølgilig : true

ex2 ---------------------------------
String s1 = "test1";
String s2 = "test1";
System.out.println( s1==s2 )
--------------------------------------
printer : true

Sjove eksempler :
ex3----------------------------------
Vector v = new Vector();
v.add("test0");
v.add("test1");
v.add("test2");
v.add("test3");
v.add("test4");
for(int i=0;i<v.size();++i)
{
if( "test1" == v.elementAt(i) )
System.out.println(""+i);
}
--------------------------------------
printer : 1

ex4----------------------------------
Vector v = new Vector();
for(int i=0;i<5;++i)
v.add( "test"+i );

for(int i=0;i<v.size();++i)
{
if( "test1" == v.elementAt(i) )
System.out.println(""+i);
}
--------------------------------------
printer : INGEN TING


Please forklare mig dette ?

Uden at have testet det, lang tid siden jeg har leget med Java.
Prøv at typecaste dit output fra vektoren.

if( "test1" == (String)v.elementAt(i) )

Vectoren i Java indeholder Objekter af klassen "object" og man kan ikke sammenligne et object med indholdet af en streng.
I Java 1.5 kan man bruge generic types, eller hvad nu hedder, så vil return typen være det samme som det man opbevarer i vectoren.

"test" og "test1" bliver lavet til literaler, og tilføjet til en pool af compileren. Det betyder at alle steder hvor der i koden står "test" og "test1" vil den genbruge de tidligere instancer.

Men, hvergang du skriver new eller på anden måde laver en ny String instans, så bliver der lavet en der _ikke_ ligger i poolen. Det kan ikke betale sig at lede efter en eksisterende fremfor at lave en ny på kørselstidspunktet.

Dvs. at:

String s1 = "test";
String s2 = "test";
System.out.pritnln(s1 == s2); //true

mens

String s1 = new ("test");
String s2 = new ("test");
System.out.pritnln(s1 == s2); // false

På samme måde laver du en ny instans på kørselstidspunktet når du skriver "test" + i, så den altså ikke har samme reference som den i poolen.

Grunden til den nye instans er, at String er immutable, og en instans altså ikke kan ændre værdi. Hvis man ønsker en ny værdi, laver man en ny instans med den nye værdi.

Du kan genbruge instanser fra poolen vha. intern() metoden på String. intern() metoden vil lede i poolen efter en der ligner, og returnere denne hvis det lykkes. Ellers returnerer den bare den oprindelige String.

String s1 = new ("test");
String s2 = new ("test");
System.out.pritnln(s1.intern() == s2.intern()); // true

Håber det forklarede det.

/henrik

#2 == kigger ikke på indholdet af strengen, den kigger på om bojecterne er de samme, det betyder derfor ingen ting, om man laver classcast eller ej.

#3 Tak - God forklaring.
Nogle tests :
--------------------------------------------
Vector v = new Vector();
for(int i=0;i<5;++i)
v.add( ("test"+i).intern() );

for(int i=0;i<v.size();++i)
{
if( "test1" == v.elementAt(i) )
System.out.println( ""+i );
}
--------------------------------------------
printer : 1

--------------------------------------------
Vector v = new Vector();
for(int i=0;i<5;++i)
v.add( ("test"+i).intern() );

String s1 = "tes";
String s2 = "t1";

for(int i=0;i<v.size();++i)
{
if( s1+s2 == v.elementAt(i) )
System.out.println( ""+i );
}
--------------------------------------------
printer : INGEN TING

--------------------------------------------
Vector v = new Vector();
for(int i=0;i<5;++i)
v.add( ("test"+i).intern() );

String s1 = "tes";
String s2 = "t1";

for(int i=0;i<v.size();++i)
{
if( (s1+s2).intern() == v.elementAt(i) )
System.out.println( ""+i );
}
--------------------------------------------
printer : 1

Tak igen du har forenet teori og praksis. Jeg hadder når det ikke hænger sammen - specielt indenfor programerring ;-)

geeks! :p



(keder mig p[ arbejde)