Szám (egész, hosszú, bájt)

"Mivel a fejlesztők kitalálhattak olyan osztályokat, amelyek számokat írnak le, úgy döntöttek, hogy kreatívak lesznek, mint az igazi fejlesztők."

"Először is kitaláltak egy absztrakt számosztályt, amelyből a Byte, a Short, az Integer, a Long, a Float és a Double származik. Vannak olyan metódusai, amelyek segítenek a számok más numerikus típusokká alakításában."

int intValue()

long longValue()

float floatValue()

double doubleValue()

byte byteValue()

short shortValue()

"Helyes. Végül is nem írhatod ezt:"

Long x = 100000;
Integer y = (Integer) x;

"Igen, ezek a típusok nem primitívek. Ezért használjuk a Number osztály metódusait:"

Long x = 100000;
Integer y = x.intValue();

"De még mindig meg kell fontolni néhány dolgot. Mivel az egész szám nem int, az egész objektumok nem hasonlíthatók össze a klasszikus «==» operátorral."

int x = 500;
int y = 500;
x == y; //true

Integer x = 500;
Integer y = 500;
x == y; //false
x.equals(y); //true

– Pontosan. Valahogy ez nem jutott eszembe azonnal.

– De van több is.

– Rövidre zárod az áramköreimet! Mi van még?

"Amikor int értéket rendelünk egy Integer változóhoz, az Integer.valueOf metódust hívják:"

Integer x = 5;

Integer x = Integer.valueOf(5);

– Igen, ezt már a fenti példából is megértettem.

"A valueOf függvény azonban nem mindig hoz létre új Integer objektumot."

– Ó, mit értesz azon, hogy „nem mindig”?

"-128 és 127 közötti értékeket gyorsítótáraz."

Integer x = 300;
Integer y = 300;
Integer z = 300;

Integer x = Integer.valueOf(300);
Integer y = Integer.valueOf(300);
Integer z = Integer.valueOf(300);

Integer x = 100;
Integer y = 100;
Integer z = 100;

Integer x = Integer.valueOf(100);
Integer y = Integer.valueOf(100);
Integer z = Integer.valueOf(100);

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = 10;
Integer t = 10;

Integer x = new Integer(10)
Integer y = new Integer(10)
Integer z = Integer.valueOf(10);
Integer t = Integer.valueOf(10);

"Más szóval a helyzet a következő:

1)  Ha azt írjuk, hogy «new Integer()», akkor garantáltan új objektumot kapunk.

2)  Ha az Integer.valueOf() függvényt explicit módon vagy autoboxon keresztül hívjuk, akkor a metódus egy új objektumot vagy egy gyorsítótárazott objektumot adhat vissza, ha a szám argumentum -128 és 127 közötti tartományban van.

"Mi olyan szörnyű abban a módszerben, amely visszaad egy objektumot a gyorsítótárból?"

"Szó sincs róla. Csak tudnod kell, hogy néha, amikor nem számítasz rá, a tárgyak egyenlőek lehetnek. Minden, ami egyenlő, bonyolult. Ha összehasonlítunk egy primitívet egy nem primitívvel, akkor primitívként hasonlítjuk össze őket:"

int x = 300;
Integer y = 300;
Integer z = 300;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references)

int x = 100;
Integer y = 100;
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //true (comparison based on references; they point to the same object)

int x = 100;
Integer y = new Integer(100);
Integer z = 100;

x == y; //true (comparison based on primitive value)
x == z; //true (comparison based on primitive value)
y == z; //false (comparison based on references; they point to different objects)

– Remek... És hogyan fogom mindezt megjegyezni?

"Nem kell ezt megjegyezni. Csak meg kell értened, hogyan van ez az egész megszervezve, és mi történik valójában, amikor egy primitív és annak nem primitív megfelelője kerül szóba."

"Azt javaslom, hogy nézd meg az Integer osztály metódusait is. Van benne jó néhány jó és hasznos módszer. Még egyet is elég gyakran használtál."

"Igen, emlékszem. Integer.parseInt();"