Detalyadong mga klase ng wrapper

1. Integerklase

Integeray mabuti din dahil ito ay isang klase, na nangangahulugan na maaari itong magkaroon ng mga patlang at pamamaraan. At, siyempre, mayroon sila. Marami sa kanila — dose-dosenang mga ito. Dito natin isasaalang-alang ang mga pinakapangunahing.

Ang Integerklase ay may dalawang field na naglalaman ng maximum at minimum na posibleng mga halaga ng inturi:

Integer.MAX_VALUE

Integer.MIN_VALUE

Minsan gusto mong italaga ang pinakamaliit o pinakamalaking posibleng inthalaga sa isang variable. Upang maiwasan ang pagkalat ng iyong code sa hindi maintindihan na mga constant, maaari mong isulat ito nang napakalinaw tulad ng sumusunod:

int min = Integer.MIN_VALUE;

min == 0x80000000

Ang Integerklase ay mayroon ding ilang mga kawili-wiling pamamaraan. Nandito na sila:

String Integer.toHexString(int)

String Integer.toBinaryString(int)

String Integer.toOctalString(int)

Integer Integer.valueOf(int i)

Integer Integer.parseInt(String)

Naranasan mo dati ang static Integer.parseInt()na pamamaraan. Alalahanin natin kung paano ito gumagana:

int name = Integer.parseInt(string);

Kung ang isang string na naglalaman ng isang numero (mga digit lamang) ay ipapasa sa parseInt()pamamaraan, ito ay mag-parse ng string at ibabalik ang numerong nilalaman nito.

Ang iba pang mga pamamaraan ay kapaki-pakinabang din. Halimbawa, ang ilan sa kanila ay maaaring mag-convert ng isang naipasa na numero sa isang string na naglalaman ng binary, octal o hexadecimal na representasyon ng numero.

2. Doubleklase

Sa pangkalahatan, ang Doubleklase ay katulad ng Integerklase, tanging ito ay bumabalot ng isang doublekaysa sa isang int. Mayroon din itong mga larangan at pamamaraan na magiging interesante sa atin. Isaalang-alang ang ilan sa mga ito:

Ang Doubleklase ay may anim na kawili-wiling larangan:

double Double.NEGATIVE_INFINITY

double Double.POSITIVE_INFINITY

int Double.MIN_EXPONENT

int Double.MAX_EXPONENT

double Double.MIN_VALUE

double Double.MAX_VALUE

Infinity

Kung hahatiin mo -1.0sa 0.0, makakakuha ka ng negatibong infinity. Kung hahatiin mo 1.0sa 0.0, makakakuha ka ng positibong infinity. Hindi lamang maaari mong hatiin ang isang doublesa pamamagitan ng zero, ngunit maaari mo ring gamitin ito upang iimbak ang resulta ng mga operasyong ito.

Exponent ng adouble

Ang pag-unawa sa exponent ay madali. Sa panloob, ang isang double ay binubuo ng isang mantissa at isang exponent. Ngunit dito ang halaga ng exponent ay hindi , ngunit . Kaya, kung ang exponent ay tumaas ng , ang kabuuang halaga ng numero ay doble.10x2x1

MIN_EXPONENT == -1024, na nangangahulugang , na tinatayang katumbas ng2-102410-308

At siyempre, ang Doubleklase ay may mga kagiliw-giliw na pamamaraan:

String Double.toHexString(double)

boolean Double.isInfinite(double)

boolean Double.isNaN(double)

Double Double.valueOf(double)

Double Double.parseDouble(String)

Kapansin-pansin, mayroong isang isInfinite()paraan na nagbabalik truekung ang naipasa na numero ay positibo o negatibong infinity.

Ang isNaN()pamamaraan ay magkatulad — sinusuri nito kung ang naipasa na numero ay NaN( Not-a-Number , isang espesyal na pare-pareho na nagsasaad ng hindi natukoy na halaga).

3. Characterklase

Ang Characterklase ay kawili-wili lalo na para sa malaking bilang ng mga static na pamamaraan ng utility na nagbibigay-daan sa iyong suriin kung ang mga character ay nabibilang sa iba't ibang kategorya.

Mga halimbawa

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)

Ang isang tampok ng mga pamamaraang ito ay gumagana ang mga ito sa lahat ng kilalang alpabeto: Ang mga numerong Arabe ay inuri bilang mga digit, atbp.

4. Booleanklase

Ang Booleanuri ay halos kapareho ng booleanuri. Ang mga pagkakaiba ay minimal.

Sa ibaba ay nagpapakita kami ng pinasimpleng bersyon ng Booleanklase:

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);
   }
}

Ang Booleanuri ay may dalawang constants (dalawang field):

Boolean.TRUE

true

Boolean.FALSE

false

Maaari kang makipagtulungan sa kanila sa parehong paraan na nagtatrabaho ka sa booleanuri:

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)

Gumagana ang autoboxing dito. Nangangahulugan iyon na maaari mong gamitin ang ganitong uri sa parehong paraan tulad ng booleanuri — walang mga pitfalls na dapat bantayan.

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();

At narito ang isang paghahambing ng booleanat Booleanmga uri:

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)

Kung talagang kailangan mo ng isang independiyenteng Booleanbagay, kailangan mong likhain ito nang tahasan:

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)

Isa pang halimbawa, kung saan gagamit tayo ng Booleanloob ng isang if:

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

Ito ay mag-compile, ngunit hindi ito gagana!

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

5. Pag-cache ng mga halaga sa panahon ng autoboxing

Mayroong ilang mga pitfalls na nauugnay sa mga uri ng integer wrapper.

Tulad ng alam mo na, kung ihahambing natin ang isang intat isang Integer, ang Integeray na-convert sa isang int:

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

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

Kung ihahambing mo ang dalawang Integerbagay sa isa't isa, hindi sila mako-convert sa ints:

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 == cat , ngunit , dahil kapag nagkukumpara tayo at naghahambing tayo ng mga sanggunian. Na kung ano talaga ang inaasahan natin.b == ca != bab

Sorpresa

Ngunit kung papalitan natin 500ng 100, magkakaroon tayo ng ganap na kakaibang resulta:

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

Ang isyu dito ay ang isang bagong Integerbagay ay hindi palaging aktwal na nilikha sa panahon ng autoboxing . Ang mga bagay ay naka-cache para sa mga halaga -128sa pamamagitan ng 127inclusive.

Ang Integerklase ay may nakatagong array na nag-iimbak ng mga bagay: Integer(-128), Integer(-127), ... Integer(126),Integer(127)

Kung magsulat ka Integer x = 128, pagkatapos ay ang proseso ng autoboxing ay lumilikha ng isang bagong bagay, ngunit kung ikaw ay sumulat Integer x = 127, pagkatapos ay ang proseso ng autoboxing ay kinukuha ang umiiral na bagay mula sa cache (mula sa array).

Kung hindi mo nais na ang Integerbagay ay magmula sa cache, kakailanganin mong likhain ito nang tahasan sa pamamagitan ng pagsulat:Integer x = new Integer(127);

Ang lahat ng uri ng wrapper ay may ganitong cache: Integer, Long, Byte, Short, Boolean. Para sa Booleanuri, ang mga ito TRUEat FALSEmga halaga ay parehong pare-pareho, kaya mahalagang naka-cache din ang mga ito.