Java.lang.Integer Class

Ang mga uri ng data ng Java ay maaaring nahahati sa dalawang bloke: primitive at reference (mga klase). Mayroong ilang mga primitive na uri ng data sa Java, tulad ng mga integer ( byte , short , int , long ), floating point numbers ( float , double ), logical data type ( boolean ) at character data type ( char ). Marahil ay alam mo na na ang bawat primitive na uri ng data ay may sariling klase ng wrapper. Isang uri ng data ng sanggunian na "nagbabalot" o nagpapalit ng primitive nitong kapatid sa isang Java object. Ang Integer ay isang klase ng wrapper para sa primitive bro nito na pinangalanang int. Ang ibig sabihin ng integer sa Ingles ay isang buong numero. Maaari silang maging positibo, negatibo o 0. Sa kasamaang palad, ang Integer sa Java ay hindi nangangahulugang anumang buong numero. Ang integer sa java ay isang buong numero na umaangkop sa 32 bits. Kung gusto mo ng mas malaking numero maaari kang gumamit ng mga Java Long na numero. Mayroon silang 64 bits sa kanilang pagtatapon. Kung ikaw ay hindi pinalad na kailangan ng mas malaking bilang ng Java na sakop mo ng BigInteger .

Nagtatrabaho sa Integer

Bilang isang klase ng wrapper, ang Integer ay nagbibigay ng iba't ibang mga pamamaraan para sa pagtatrabaho sa int , pati na rin ang isang bilang ng mga pamamaraan para sa pag-convert ng int sa String at String sa int . Ang klase ay may dalawang constructor:

• public Integer(int i) , kung saan ang i ay isang primitive na halaga upang simulan. Ang isang ito ay lumilikha ng isang bagay na Integer na sinimulan ng int na halaga.

• public Integer(String s) throws NumberFormatException . Narito ang s ay isang string na representasyon ng int value. Ang constructor na ito ay lumilikha ng isang Integer object na sinimulan ng int value na ibinigay ng string representation.

Paglikha ng integer na bagay

Mayroong iba't ibang mga pagpipilian sa paglikha ng object ng Integer . Ang isa sa mga pinakakaraniwang ginagamit ay ang pinakamadali. Narito ang isang halimbawa:

Integer myInteger = 5;

Ang initialization ng Integer variable sa kasong ito ay katulad ng initialization ng primitive int variable. Sa pamamagitan ng paraan maaari mong simulan ang isang Integer variable na may halaga ng isang int . Narito ang isang halimbawa:

int myInt = 5;
Integer myInteger = myInt;
System.out.println(myInteger);

Ang output dito ay: Sa katunayan, dito natin mapapansin ang auto-packing. Maaari din tayong lumikha ng isang bagay na Integer tulad ng anumang iba pang mga bagay gamit ang isang constructor at bagong keyword:

Integer myInteger = new Integer(5);

Magagawa mo ang variable na Integer katulad ng sa int (idagdag, ibawas, i-multiply, hatiin, dagdagan, bawasan). Gayunpaman, mahalagang tandaan na ang Integer ay isang uri ng data ng sanggunian, at ang isang variable ng ganitong uri ay maaaring null. Sa kasong ito, mas mahusay na pigilin ang mga naturang operasyon.

Integer myInteger1  = null;
Integer myInteger2 = myInteger1 + 5;

Dito makakakuha tayo ng exception:

Integer class constants

Ang klase ng Integer ay nagbibigay ng iba't ibang mga constant at pamamaraan para sa pagtatrabaho sa mga integer. Nandito na sila:

• SIZE ay nangangahulugang ang bilang ng mga bit sa dalawang-digit na sistema ng numero na inookupahan ng uri ng int

• Ang BYTES ay ang bilang ng mga byte sa dalawang-digit na sistema ng numero na inookupahan ng uri ng int

• Ang MAX_VALUE ay ang maximum na halaga na maaaring hawakan ng uri ng int

• Ang MIN_VALUE ay ang pinakamababang halaga na maaaring hawakan ng uri ng int

• Ang TYPE ay nagbabalik ng isang object ng uri ng Class mula sa uri ng int

Integer class na pinaka-kapaki-pakinabang na mga pamamaraan

Ngayon tingnan natin ang mga pinakaginagamit na pamamaraan ng klase ng Integer . Ang pinakasikat sa kanila, sa palagay ko, ay mga pamamaraan para sa pag-convert ng isang numero mula sa isang String , o vice versa.

• static int parseInt(String s) ang pamamaraang ito ay nagko-convert ng String sa int . Kung hindi posible ang conversion, itatapon ang NumberFormatException .

• static int parseInt(String s, int radix) ang pamamaraang ito ay nagko-convert din ng s parameter sa isang int . Ang parameter ng radix ay nagpapahiwatig na ang mga sistema ng numero ay orihinal na isinulat.

Bilang karagdagan sa parseInt , mayroon ding katulad na paraan ng valueOf sa ilang mga variation. Gayunpaman, ang resulta ng valueOf ay Integer , at ang parseInt ay int .

• static Integer valueOf(int i) ay nagbabalik ng isang Integer na ang halaga ay i ;

• static Integer valueOf(String s) ay gumagana tulad ng parseInt(String s) , ngunit ang resulta ay Integer , hindi int ;

• static Integer valueOf(String s, int radix) ay gumagana katulad ng parseInt(String s, int radix) , ngunit ang resulta ay isang Integer , hindi isang int .

Mayroon bang anumang problema sa klase ng Integer? Ay oo meron...

Kaya mayroong dalawang uri para sa mga integer (na magkasya sa 32 bits) sa Java: int at Integer . Upang maunawaan ang mga detalye ng bawat isa sa kanila, kailangan nating malaman ang sumusunod tungkol sa modelo ng memorya ng JVM: lahat ng iyong idineklara ay naka-imbak alinman sa Stack Memory (JVM Stack partikular para sa bawat Thread), o Heap Space. Ang mga primitive na uri ( int , long , float , boolean , double , char , byte , atbp) ay naka-imbak sa Stack memory. Lahat ng Objects at arrays ay naka-store sa Heap Space. Ang mga sanggunian sa mga bagay na ito at mga array na kailangan para sa mga pamamaraan ay naka-imbak sa Stack. Kaya. Bakit tayo nagmamalasakit? Well, nakikita mo, ang Stack ay mas maliit kaysa sa Heap (isang con), ngunit ito ay mas mabilis na maglaan ng mga halaga sa Stack, kaysa sa Heap (isang pro). Magsimula tayo sa isang primitive na uri int . Ito ay tumatagal ng eksaktong 32 bits. Iyon ay 32/8=4 bytes. Dahil ito ay isang primitive na uri. Ngayon, isaalang-alang natin ang Integer . Ito ay isang bagay, na may dagdag na overhead at mga pagkakahanay. Gumamit ako ng library jol upang sukatin ang laki nito:

public static void main(String[] args) {
 	System.out.println(ClassLayout.parseInstance(Integer.valueOf(1)).toPrintable());
}

at ito pala ay umabot ng 16 bytes: Ano?! Iyan ay 4 na beses na higit pang memorya! Ngunit huwag tayong tumigil doon. Bilang mga developer ng Java, hindi kami karaniwang humihinto sa paggamit ng isang integer. Ang gusto talaga natin ay gumamit ng marami sa kanila. Parang in a sequence. Halimbawa, sa isang array. O isang Listahan. Ang mga array ay iniimbak sa Heap, tulad ng mga Listahan. Kaya, ang paglalaan ay dapat tumagal ng humigit-kumulang sa parehong dami ng oras. tama? Ngunit paano kung kailangan nating maglaan ng higit pang memorya? Suriin natin kung gaano kalaki ang espasyo ng isang array ng 1000 primitive int values:

public static void main(String[] args) {
    	int[] array = new int[1000];
    	for (int i = 0; i < 1000; i++) array[i] = i;                System.out.println(ClassLayout.parseInstance(array).toPrintable());
}

At ang resulta ay 4016 bytes: OK, iyon ay may katuturan, kung isasaalang-alang ang isang solong int ay tumatagal ng 4 na bait. Paano ang tungkol sa isang ArrayList<Integer> ng isang 1000 Integer ? Tignan natin:

public static void main(String[] args) {
	List<Integer> list = new ArrayList<>(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
      System.out.println(GraphLayout.parseInstance(list).toFootprint());
}

At ang resulta ay 20040 bytes (muli, 4 na beses pa!): Kaya, ang ArrayList<Integer> ay tumatagal ng 4 na beses na mas maraming espasyo sa memorya. Hindi maganda yun. Ngunit gayon pa man, mas madali ang Mga Listahan dahil maaari tayong magdagdag at magtanggal ng mga elemento! Oh Java... Bakit kailangan mong i-box ang lahat?! Ngunit, nakakalimutan ko, ang Java ay mahusay, at ang kadakilaan nito ay nakasalalay sa kasaganaan ng mga open source na aklatan na magagamit natin! Isa na rito ang Trove4j. Mayroon itong TIntArrayList na panloob ay mayroong int[] data. Sukatin natin ang laki nito:

public static void main(String[] args) {
	TIntList list = new TIntArrayList(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
	System.out.println(GraphLayout.parseInstance(list).toFootprint());
}

At ang resulta ay 4040 bytes (halos kapareho lang ng int[] !): Kaya, sa huli, maaari nating makuha ang pinakamahusay sa parehong mundo! Mga listahan ng mga integer na kumukuha ng 4 na beses na mas kaunting espasyo. At hindi ito nagsasangkot ng mga integer na pagkakataon. Tanging int s. Kaming mga Java dev ay talagang nagmamalasakit sa memorya... Ngunit nagmamalasakit din kami sa pagganap. Mayroong magandang microbenchmarking library na may katamtamang pangalan na jmh na nagbibigay-daan sa amin na sukatin ang pagganap ng code. Ihambing muna natin ang pagganap ng pagkalkula ng kabuuan ng dalawang random na integer, naka-box, o hindi: Ang configuration para sa jmh ay ang mga sumusunod:

benchmark {
	configurations {
    	main {
        	warmups = 5 // number of warmup iterations
        	iterations = 50 // number of iterations
        	iterationTime = 500 // time in seconds per iteration
        	iterationTimeUnit = "ns" // time unit for iterationTime

Ang mga benchmark:

private static final Random random = new Random();

@Benchmark
public int testPrimitiveIntegersSum() {
	int a = random.nextInt();
	int b = random.nextInt();
	return a + b;
}

@Benchmark
public Integer testBoxedIntegersSum() {
	Integer a = random.nextInt();
	Integer b = random.nextInt();
	return a + b;
}

Ang mga resulta: Kaya, sa karaniwan, ang alokasyon, at kabuuan ng mga primitive na ints ay higit sa dalawang beses na mas mabilis kaysa sa mga naka-box na Integer. Ngayon, ihambing natin ang pagganap ng paglikha at pagkalkula ng kabuuan ng mga koleksyon (o mga array ng 1000 ints ng Integers):

@Benchmark
public int testPrimitiveArray() {
	int[] array = new int[1000];
	for (int i = 0; i < 1000; i++) array[i] = i;
	int sum = 0;
	for (int x : array) sum += x;
	return sum;
}
11933.545 ops/s [Average]


@Benchmark
public int testBoxesArray() {
	Integer[] array = new Integer[1000];
	for (int i = 0; i < 1000; i++) array[i] = i;
	int sum = 0;
	for (int x : array) sum += x;
	return sum;
}
2733.312 ops/s [Average]


@Benchmark
public int testList() {
	List<Integer> list = new ArrayList<>(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
	int sum = 0;
	for (int x : list) sum += x;
	return sum;
}
2086.379 ops/s [Average]


@Benchmark
public int testTroveIntList() {
	TIntList list = new TIntArrayList(1000);
	for (int i = 0; i < 1000; i++) list.add(i);
	int sum = 0;
	for (int i = 0; i < 1000; i++) sum += list.get(i);
	return sum;
}
5727.979 ops/s [Average]

Ang mga resulta: primitives array ay higit sa 4 na beses na mas mabilis kaysa sa array ng boxed values ​​( Integer s); halos anim na beses na mas mabilis kaysa sa ArrayList ng mga naka-box na halaga ( Integer s); at dalawang beses nang mas mabilis kaysa sa isang TIntArrayList (na talagang nagpapalamuti ng hanay ng mga primitive na ints). Samakatuwid, kung kailangan mo ng data-structure upang mag-imbak ng isang koleksyon ng mga halaga ng integer, at ang laki nito ay hindi magbabago, gumamit ng int[] ; kung magbabago ang laki — baka gusto mong gamitin ang tove4j library na may TIntArrayList . At narito ang pagtatapos ng aking sanaysay kung saan ipinapaliwanag ko ang mga kahinaan ng paggamit ng uri ng Integer . Mayroong ilang mga kawili-wiling static na pamamaraan ng Integer , na dapat kong pag-usapan bago ako matapos. public static Integer getInteger(String nm, int val) ay hindi ginagawa kung ano ang maaaring isipin ng isa, ngunit kinukuha ang isang Integer na halaga ng isang ari-arian ng system. Val ang default kung sakaling hindi nakatakda ang property na ito. pampublikong static na String toBinaryString(int i) ay nagbabalik ng String na may binary na representasyon ng isang numero. May mga pamamaraan para sa pagkuha ng isang based-16 ( toHexString ) at based-8 ( toOctalString ) na mga representasyon. Mayroong isang paraan upang mai-parse ang isang String sa isang int . Kahit na ang string ay isang non-10 radix based na representasyon. Narito ang ilang mga halimbawa: Integer.parseInt("-FF", 16) ay nagbabalik -255 Integer.parseInt("+42", 10) ay nagbabalik ng 42 Integer.parseInt("1100110", 2) ay nagbabalik ng 102