A csomagolóórák részletesen

1. Integerosztály

Integerabban is jó, hogy egy osztály, ami azt jelenti, hogy lehetnek benne mezők és metódusok. És természetesen vannak benne. Sokan közülük – több tucatnyian. Itt a legalapvetőbbeket vesszük figyelembe.

Az Integerosztálynak két mezője van, amelyek a típus maximális és minimális lehetséges értékét tartalmazzák int:

Integer.MAX_VALUE

Integer.MIN_VALUE

Néha a lehető legkisebb vagy legnagyobb értéket szeretné hozzárendelni integy változóhoz. Annak elkerülése érdekében, hogy a kód értelmezhetetlen állandókkal zsúfolt legyen, ezt nagyon egyértelműen leírhatja a következőképpen:

int min = Integer.MIN_VALUE;

min == 0x80000000

Az Integerosztálynak van néhány érdekes módszere is. Itt vannak:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Korábban találkozott a statikus Integer.parseInt()módszerrel. Emlékezzünk vissza, hogyan működik:

int name = Integer.parseInt(string);

Ha egy számot (csak számjegyeket) tartalmazó karakterláncot adunk át a parseInt()metódusnak, akkor elemzi a karakterláncot, és visszaadja a benne lévő számot.

A többi módszer is hasznos. Például egyesek képesek egy átadott számot a szám bináris, oktális vagy hexadecimális reprezentációját tartalmazó karakterláncsá alakítani.

2. Doubleosztály

Általánosságban elmondható, hogy az Doubleosztály hasonló az osztályhoz, csak egy nem egy -et Integerburkol . Vannak olyan területei és módszerei is, amelyek érdekelni fognak minket. Nézzünk meg néhányat közülük:doubleint

Az Doubleosztálynak hat érdekes területe van:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

végtelenség

Ha osztod -1.0-vel 0.0, negatív végtelent kapsz. Ha osztod 1.0-vel 0.0, pozitív végtelent kapsz. Nem csak osztható doublenullával, hanem tárolhatja is a műveletek eredményét.

Kitevője adouble

A kitevő megértése egyszerű. Belsőleg a kettős egy mantisszából és egy kitevőből áll. De itt a kitevő értéke nem , hanem . Így ha a kitevő -val nő , akkor a szám összértéke megduplázódik.10x2x1

MIN_EXPONENT == -1024, ami azt jelenti , , ami megközelítőleg egyenlő2-102410-308

És persze az Doubleosztálynak vannak érdekes módszerei:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Érdekes módon van egy isInfinite()módszer, amely akkor tér vissza true, ha az átadott szám pozitív vagy negatív végtelen.

A isNaN()módszer hasonló – ellenőrzi, hogy az átadott szám-e NaN( Not-a-Number , egy speciális állandó, amely meghatározatlan értéket jelez).

3. Characterosztály

Az Characterosztály elsősorban a nagyszámú statikus segédprogramja miatt érdekes, amelyek segítségével ellenőrizhető, hogy a karakterek különböző kategóriákhoz tartoznak-e.

Példák

Character.isAlphabetic(int)

Character.isLetter(char)

Character.isDigit(char)

Character.isSpaceChar(char)

Character.isWhitespace(char)

Character.isLowerCase(char)

Character.isUpperCase(char)

Character.toLowerCase(char)

Character.toUpperCase(char)

Ezeknek a módszereknek az a sajátossága, hogy az összes ismert ábécével működnek: az arab számokat számjegyekként osztályozzák stb.

4. Booleanosztály

A Booleantípus gyakorlatilag megegyezik a booleantípussal. A különbségek minimálisak.

Az alábbiakban az osztály egyszerűsített változatát mutatjuk be Boolean:

class Boolean
{
   public static final Boolean TRUE = new Boolean(true);
   public static final Boolean FALSE = new Boolean(false);

   private final boolean value;

   public Boolean(boolean value)
   {
      this.value = value;
   }

   public boolean booleanValue()
   {
      return value;
   }

   public static Boolean valueOf(boolean value)
   {
      return (value ? TRUE : FALSE);
   }
}

A Booleantípusnak két állandója van (két mező):

Boolean.TRUE

true

Boolean.FALSE

false

Ugyanúgy dolgozhat velük, mint a típussal boolean:

if (Boolean.TRUE)
{
}

Boolean a = Boolean.TRUE;
boolean b = Boolean.TRUE;
boolean c = true;

Boolean a = Boolean.TRUE;
Boolean b = Boolean.TRUE;
if (a == b)

Az autobox itt remekül működik. Ez azt jelenti, hogy ezt a típust ugyanúgy használhatja, mint a booleantípust – nincsenek csapdák, amelyekre figyelni kell.

Boolean a = true;
Boolean b = true;
Boolean c = false;
boolean d = a;

Boolean a = Boolean.valueOf(true);
Boolean b = Boolean.valueOf(true);
Boolean c = Boolean.valueOf(false);
boolean d = a.booleanValue();

booleanÉs itt a és a típusok összehasonlítása Boolean:

boolean a = true;
Boolean b = true; // b will be equal to Boolean.TRUE
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // true (compared by reference, but they point to the same object)

Ha valóban szüksége van egy független Booleanobjektumra, akkor kifejezetten létre kell hoznia azt:

boolean a = true;
Boolean b = new Boolean(true); // New Boolean object
Boolean c = true; // c will be equal to Boolean.TRUE

a == b; // true (compared by value)
a == c; // true (compared by value)
b == c; // false (compared by reference, and they point to different objects)

BooleanMég egy példa, ahol egy belsőt használunk if:

Boolean less = (2 < 3);
if (less)
{
   ...
}

Ez lefordítja, de nem megy!

Boolean less = null;
if (less)
{
   ...
}

5. Értékek gyorsítótárazása az automatikus dobozolás során

Van néhány buktató az egész szám burkoló típusaival kapcsolatban.

Amint azt már tudod, ha összehasonlítunk egy -t intés egy -t Integer, akkor a -t Integeregy -re alakítjuk int:

int a = 5;
Integer b = 5;
if (a == b)
{
   ...
}

int a = 5;
Integer b = Integer.valueOf(5);
if (a == b.intValue())
{
   ...
}

Ha összehasonlít két Integerobjektumot egymással, akkor azok nem konvertálódnak ints-re:

Integer a = 500;
Integer b = 500;
int c = 500;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

false
true
true

a == cés , de , mert amikor összehasonlítunk és összehasonlítunk hivatkozásokat. Amit lényegében elvárunk.b == ca != bab

Meglepetés

De ha lecseréljük 500-ra 100, akkor teljesen más eredményt kapunk:

Integer a = 100;
Integer b = 100;
int c = 100;

System.out.println(a == b); // Compared by reference
System.out.println(a == c);
System.out.println(b == c);

true
true
true

A probléma itt az, hogy az automatikus dobozolás során nem mindig jön létre új Integerobjektum . Az objektumok gyorsítótárazottan tárolják az értékeket a befogadáson -128keresztül 127.

Az Integerosztálynak van egy rejtett tömbje, amely objektumokat tárol: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Ha ír Integer x = 128, akkor az autoboxing folyamat létrehoz egy új objektumot, de ha ír Integer x = 127, akkor az autoboxing folyamat lekéri a meglévő objektumot a gyorsítótárból (a tömbből).

Ha nem szeretné, hogy az Integerobjektum a gyorsítótárból származzon, akkor kifejezetten létre kell hoznia a következő írással:Integer x = new Integer(127);

Minden burkolótípus rendelkezik ilyen gyorsítótárral: Integer, Long, Byte, Short, Boolean. BooleanA típus esetében mind az értéke, TRUEmind FALSEaz értéke állandó, tehát lényegében gyorsítótárban is vannak.