Gabay sa Klase ng Java Integer

Sa artikulong ito ay pag-uusapan natin ang tungkol sa klase ng Integer. Isaalang-alang natin ang mga tanong na ito:

• ano ang mga klase ng wrapper;
• autopacking/unpacking ng mga primitives;
• pagpapatakbo ng klase ng Integer, mga pamamaraan at mga constant nito.

Mga klase ng wrapper ng mga primitive na uri

Tulad ng alam mo, ang Java ay may iba't ibang uri ng data, na maaaring nahahati sa dalawang bloke:

• primitive;
• sanggunian.

Mayroong ilang mga primitive na uri ng data sa Java:

• integers - byte, maikli, int, mahaba;
• mga numero ng floating point (real) - lumutang, doble;
• lohikal na uri ng data - boolean;
• uri ng data ng character - char.

Ang bawat primitive na uri ng data ay may sariling klase ng wrapper. Isang uri ng data ng sanggunian na bumabalot sa primitive na nakababatang kapatid nito sa isang Java object. Nasa ibaba ang mga primitive na uri ng data at ang kanilang mga kaukulang klase ng wrapper: Sa praktikal na kahulugan, ang mga primitive at ang kanilang mga klase ng wrapper ay may maraming pagkakatulad. Karamihan sa mga operasyon ay ginagawa nang magkapareho. Gayunpaman, ang mga klase ng wrapper ay may ilang mga katangian na hindi katangian ng mga primitive. Una, may mga klase: kapag nagtatrabaho sa mga klase ng wrapper, nagtatrabaho kami sa mga bagay. Pangalawa (lahat ng sumusunod ay sumusunod mula sa unang punto), ang mga bagay na ito ay maaaring null. Pangatlo, ang mga klase ng wrapper ay nagbibigay ng ilang mga constant at pamamaraan na nagpapadali sa pagtatrabaho sa isang partikular na uri ng data. Sa artikulong ito, susuriin nating mabuti ang pagtatrabaho sa klase ng Integer.

Ang Integer

Ang Integer class ay isang wrapper class ng primitive type int. Naglalaman ang klase na ito ng isang field ng uri ng int. Bilang isang klase ng wrapper, ang Integer ay nagbibigay ng iba't ibang mga pamamaraan para sa pagtatrabaho sa mga ints, pati na rin ang isang bilang ng mga pamamaraan para sa pag-convert ng int sa String at String sa int. Sa ibaba ay titingnan natin ang iba't ibang halimbawa ng pagtatrabaho sa klase. Magsimula tayo sa paglikha. Ang pinakakaraniwang ginagamit (at pinakamadaling gamitin) ay ang sumusunod na opsyon sa paggawa:

Integer a = 3;

Iyon ay, ang initialization ng isang Integer variable sa kasong ito ay katulad ng initialization ng isang int variable. Bukod dito, ang isang Integer variable ay maaaring masimulan sa halaga ng isang int variable:

int i = 5;
Integer x = i;
System.out.println(x); // 5

Sa kaso sa itaas, ang autopacking ay nangyayari nang tahasan. Pag-uusapan natin ang higit pa tungkol dito sa ibaba. Bilang karagdagan sa mga pagpipilian sa pagsisimula na nakalista sa itaas, ang isang variable na Integer ay maaaring malikha tulad ng iba pang mga bagay, gamit ang isang constructor at ang bagong keyword:

Integer x = new Integer(25);
System.out.println(x);

Gayunpaman, mas matagal ang pagsusulat at mas matagal ang pagbabasa, kaya ang opsyong ito ay hindi gaanong karaniwan. Magagawa mo ang lahat gamit ang mga variable na Integer na magagawa mo sa mga variable na int. Maaari silang maging: Gayunpaman, sa lahat ng ito, kailangan mong maging maingat at tandaan na ang Integer ay isang uri ng data ng sanggunian, at ang isang variable ng ganitong uri ay maaaring null. Sa kasong ito (kung ang variable ay null), ito ay mas mahusay na pigilin ang sarili mula sa arithmetic operations (at anumang iba pa kung saan null ay hindi bode na rin). Narito ang isang halimbawa:

Integer a = null;
Integer b = a + 1; // Здесь мы упадем с "Exception in thread "main" java.lang.NullPointerException"
System.out.println(b);

Karamihan sa mga operasyon ng paghahambing ay isinasagawa sa parehong paraan tulad ng sa primitive na uri int:

Integer a = 1;
Integer b = 2;

System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <= b);

Output:

false
false
true
true

Ang operasyon ng paghahambing ng dalawang Integer variable ay namumukod-tangi. At ang punto dito ay ang Integer ay isang uri ng data ng sanggunian, at ang mga variable nito ay nag-iimbak ng mga sanggunian sa mga halaga, at hindi ang mga halaga mismo (mga bagay). Ang mga pagpapakita ng katotohanang ito ay maaaring maobserbahan kapag isinasagawa ang sumusunod na fragment ng code:

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);

System.out.println(a == b); // true
System.out.println(a == c); // false

Ang resulta ng unang pagkakapantay-pantay ay magiging totoo, at ang pangalawa ay magiging mali. Nangyayari ito dahil sa unang kaso, naghahambing kami ng dalawang variable ("a" at "b") na nag-iimbak ng mga sanggunian sa parehong bagay. At sa pangalawang kaso, naghahambing kami ng dalawang variable na tumutukoy sa dalawang magkaibang mga bagay (kapag nilikha namin ang variable na "c" lumikha kami ng isang bagong bagay). Magbigay tayo ng isa pang kawili-wiling halimbawa:

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a == b); // true
System.out.println(x == y); // false

Tulad ng nakikita natin, ang resulta ng unang paghahambing ay totoo, at ang resulta ng pangalawa ay mali. Ito ay tungkol sa pag-cache. Ang lahat ng mga integer sa hanay mula -128 hanggang 127 kasama (maaaring ipasadya ang mga halagang ito) ay naka-cache. Kaya kapag gumawa kami ng bagong variable at italaga ito ng isang integer na halaga sa pagitan ng -128 at 127, hindi kami gumagawa ng bagong object, ngunit sa halip ay nagtatalaga kami ng variable ng isang reference sa isang nilikha na object sa cache. Ngayon, alam ang katotohanang ito, ang halimbawa sa itaas ay hindi mukhang napakamistikal. Ang mga variable na a at b ay tumutukoy sa parehong bagay - isang bagay mula sa cache. At sa panahon ng pagsisimula ng mga variable na x at y, lumikha kami ng isang bagong bagay sa bawat oras, at ang mga variable na ito ay nag-imbak ng mga sanggunian sa iba't ibang mga bagay. At tulad ng alam mo, inihahambing ng operator ng == ang mga halaga ng mga variable, at ang mga halaga ng mga variable na sanggunian ay mga sanggunian. Upang tumpak na suriin ang pagkakapantay-pantay sa pagitan ng dalawang variable na Integer, dapat mong gamitin (gaano man ito kawalang-halaga) ang katumbas na paraan. Isulat muli natin ang halimbawa sa itaas:

Integer a = 1;
Integer b = 1;

Integer x = 2020;
Integer y = 2020;

System.out.println(a.equals(b)); // true
System.out.println(x.equals(y)); // true

Autopacking at pag-unpack ng Integer

Ano ang auto packing at unpacking? Kapag lumilikha ng mga bagong variable ng Integer, ginamit namin ang sumusunod na konstruksyon:

Integer a = 2020;

Sa ganitong paraan lumikha kami ng bagong object nang hindi ginagamit ang bagong key operator. Posible ito salamat sa mekanismo ng autopacking ng primitive type int. Ang reverse procedure ay nangyayari kapag nagtatalaga ng primitive int variable sa value ng isang Integer reference variable:

Integer a = 2020;
int x = a;

Sa kasong ito, mukhang itinalaga namin ang reference (ibig sabihin, ang reference sa object ay ang halaga ng variable na "a") sa isang primitive variable. Ngunit sa katunayan, salamat sa mekanismo ng auto-unpacking, ang value na 2020 ay isinulat sa variable na "x". Ang auto-packing/unpacking ay isang pangkaraniwang phenomenon sa Java. Kadalasan ito ay nangyayari nang mag-isa, kung minsan kahit na walang kaalaman ng programmer. Ngunit kailangan mo pa ring malaman ang tungkol sa hindi pangkaraniwang bagay na ito. Mayroon kaming isang kawili-wiling artikulo sa paksang ito sa Javarush .

Integer class constants

Ang klase ng Integer ay nagbibigay ng iba't ibang mga constant at pamamaraan para sa pagtatrabaho sa mga integer. Sa seksyong ito, susuriin natin ang ilan sa mga ito sa pagsasanay. Magsimula tayo sa mga constants. Ipinapakita ng talahanayan sa ibaba ang lahat ng mga constant ng klase: Tingnan natin ang mga halaga ng lahat ng mga constant na ito sa pamamagitan ng pagpapatakbo ng sumusunod na code:

public static void main(String[] args) {
        System.out.println(Integer.SIZE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.TYPE);
}

Bilang resulta, nakukuha namin ang sumusunod na output:

32
4
2147483647
-2147483648
int

Mga pamamaraan ng klase ng Integer

Ngayon tingnan natin ang mga pinakaginagamit na pamamaraan ng klase ng Integer. Kaya, ang mga "nangungunang" ay pinamumunuan ng mga pamamaraan para sa pag-convert ng isang numero mula sa isang string, o pag-convert ng isang string mula sa isang numero. Magsimula tayo sa pag-convert ng string sa isang numero. Ang parseInt na paraan ay ginagamit para sa mga layuning ito , ang lagda ay nasa ibaba:

• 
  static int parseInt(String s)

Ang pamamaraang ito ay nagko-convert ng String sa int. Ipakita natin kung paano gumagana ang pamamaraang ito:

int i = Integer.parseInt("10");
System.out.println(i); // 10

Kung hindi posible ang conversion—halimbawa, nagpasa kami ng isang salita sa parseInt na paraan—isang NumberFormatException ang ihahagis. Ang parseInt(String s) na paraan ay may sobrang kargang kapatid:

• 
  static int parseInt(String s, int radix)

Kino-convert ng paraang ito ang parameter s sa int. Ang parameter ng radix ay nagpapahiwatig kung saang sistema ng numero ang numero sa s ay orihinal na isinulat, na dapat i-convert sa int. Mga halimbawa sa ibaba:

System.out.println(Integer.parseInt("0011", 2)); // 3
System.out.println(Integer.parseInt("10", 8));   // 8
System.out.println(Integer.parseInt("F", 16));   // 15

Ang mga pamamaraan ng parseInt ay nagbabalik ng isang primitive na uri ng data int. Ang mga paraang ito ay may analogue - ang valueOf method . Ang ilang mga pagkakaiba-iba ng paraang ito ay tumawag lamang ng parseInt sa loob. Ang pagkakaiba mula sa parseInt ay ang resulta ng valueOf ay magiging isang Integer, hindi isang int. Isaalang-alang natin sa ibaba ang lahat ng mga opsyon para sa pamamaraang ito at isang halimbawa kung paano ito gumagana:

• static Integer valueOf(int i) - nagbabalik ng Integer na ang value ay i;
• static Integer valueOf(String s) - katulad ng parseInt(String s), ngunit ang resulta ay Integer;
• static Integer valueOf(String s, int radix) - katulad ng parseInt(String s, int radix), ngunit ang resulta ay Integer.

Mga halimbawa:

int a = 5;
Integer x = Integer.valueOf(a);
Integer y = Integer.valueOf("20");
Integer z = Integer.valueOf("20", 8);

System.out.println(x); // 5
System.out.println(y); // 20
System.out.println(z); // 16

Tiningnan namin ang mga pamamaraan na nagbibigay-daan sa iyong i-convert ang String sa int/Integer. Ang reverse procedure ay nakakamit gamit ang toString method . Maaari mong tawagan ang paraan ng toString sa anumang bagay na Integer at makuha ang representasyon ng string nito:

Integer x = 5;
System.out.println(x.toString()); // 5

Gayunpaman, dahil sa ang katunayan na ang paraan ng toString ay madalas na tinatawag na implicitly sa mga bagay (halimbawa, kapag nagpapadala ng isang bagay sa console para sa pag-print), ang paraang ito ay bihirang ginagamit nang tahasan ng mga developer. Mayroon ding static na paraan saString, na kumukuha ng int parameter at kino-convert ito sa isang representasyon ng string. Halimbawa:

System.out.println(Integer.toString(5)); // 5

Gayunpaman, tulad ng non-static na paraan ng toString, ang paggamit ng isang static na paraan ay tahasang bihira. Ang mas kawili-wiling ay ang static na paraan saString, na tumatagal ng 2 integer na mga parameter:

• static String toString(int i, int radix) - iko-convert ang i sa isang representasyon ng string sa sistema ng radix number.

Halimbawa:

System.out.println(Integer.toString(5, 2)); // 101

Ang klase ng Integer ay may ilang mga pamamaraan para sa paghahanap ng maximum/minimum ng dalawang numero:

• static int max(int ​​​​a, int b) ay magbabalik ng pinakamalaking halaga sa mga naipasa na variable;
• static int min(int a, int b) ay magbabalik ng pinakamaliit na halaga sa mga naipasa na variable.

Mga halimbawa:

int x = 4;
int y = 40;

System.out.println(Integer.max(x,y)); // 40
System.out.println(Integer.min(x,y)); // 4

Konklusyon

Sa artikulong ito, tiningnan namin ang klase ng Integer. Napag-usapan namin kung anong klase ito at kung ano ang mga klase ng wrapper. Tiningnan namin ang klase mula sa praktikal na pananaw. Tumingin kami sa mga halimbawa ng mga pagpapatakbo ng aritmetika, kabilang ang mga pagpapatakbo ng paghahambing. Tiningnan namin ang mga intricacies ng paghahambing ng dalawang Integer variable, at sinuri ang konsepto ng mga naka-cache na bagay. Binanggit din namin ang phenomenon ng auto-packing/unpacking ng mga primitive na uri ng data. Bilang karagdagan, nagawa naming tingnan ang ilang mga pamamaraan ng klase ng Integer, pati na rin ang ilang mga constant. Nagbigay sila ng mga halimbawa ng pag-convert ng mga numero mula sa isang sistema ng numero patungo sa isa pa.

Takdang aralin

1. Pag-aralan kung ano ang iba pang mga pamamaraan ng klase ng Integer (maaari mong pag-aralan ang mga ito sa website na may opisyal na dokumentasyon ), isulat sa mga komento kung alin sa mga pamamaraan na iyong pinag-aralan (hindi kasama ang mga ibinigay sa artikulo) ay pinaka-kapaki-pakinabang sa iyong opinyon ( gagamitin mo nang madalas). At magbigay din ng mga dahilan para sa iyong opinyon.

   PS Walang tamang sagot dito, ngunit ang aktibidad na ito ay magbibigay-daan sa iyo na mas mapag-aralan ang klase.

2. Lutasin ang isang maliit na simpleng problema upang pagsama-samahin ang materyal.

   Mayroon kaming dalawang numero:

   1100001001 - sa binary number system
   33332 - sa quinary number system

   Ito ay kinakailangan, gamit lamang ang mga pamamaraan ng klase ng Integer, upang matukoy ang maximum sa dalawang ibinigay na mga numero, at pagkatapos ay ipakita ang pagkakaiba sa pagitan ng maximum at minimum na halaga sa ternary number system.

3. I-convert ang maximum na posibleng halaga ng Integer sa octal number system at ipakita ang bilang ng mga digit sa resultang numero (bilangin ang numero sa programmatically).