ทำไมการเปรียบเทียบ == กับ Integer.valueOf (String) จึงให้ผลลัพธ์ที่แตกต่างกันสำหรับ 127 และ 128

ฉันไม่รู้ว่าเพราะเหตุใดบรรทัดโค้ดเหล่านี้จึงส่งกลับค่าที่ต่างกัน:

System.out.println(Integer.valueOf("127")==Integer.valueOf("127"));
System.out.println(Integer.valueOf("128")==Integer.valueOf("128"));
System.out.println(Integer.parseInt("128")==Integer.valueOf("128"));

ผลลัพธ์คือ:

true
false
true

ทำไมคนแรกถึงกลับมาtrueและคนที่สองกลับมาfalse? มีอะไรที่แตกต่างที่ฉันไม่รู้ระหว่าง127และ128? (แน่นอนฉันรู้ว่า127< 128.)

นอกจากนี้ทำไมหนึ่งในสามกลับมาtrue?

ฉันได้อ่านคำตอบของคำถามนี้แล้ว แต่ฉันยังไม่เข้าใจว่ามันจะกลับมาได้trueอย่างไรและทำไมโค้ดในบรรทัดที่สองจึงกลับfalseมา

มีความแตกต่างที่โดดเด่นที่นี่

valueOfกำลังส่งคืนIntegerวัตถุซึ่งอาจมีค่าของแคชระหว่าง -128 ถึง 127 นี่คือสาเหตุที่ค่าแรกส่งคืนtrue- มันถูกแคช - และค่าที่สองส่งคืนfalse- 128 ไม่ใช่ค่าแคชดังนั้นคุณจึงได้รับสองIntegerอินสแตนซ์แยกกัน.

มันเป็นสิ่งสำคัญที่จะต้องทราบว่าคุณกำลังเปรียบเทียบอ้างอิงด้วยInteger#valueOfและถ้าคุณกำลังเปรียบเทียบค่าที่มีขนาดใหญ่กว่าสิ่งแคชสนับสนุนก็จะไม่ได้ประเมินtrueถึงแม้ว่าค่าแจงเทียบเท่า (กรณีในจุด: Integer.valueOf(128) == Integer.valueOf(128)) คุณต้องใช้equals()แทน

parseIntintจะกลับมาดั้งเดิม นี่คือเหตุผลที่ผลตอบแทนที่คุ้มค่าที่สามtrue- การประเมินและเป็นของหลักสูตร128 == 128true

ทีนี้พอใช้ไปสักหน่อยเพื่อให้ได้ผลลัพธ์ที่สามtrue:

• แปลง unboxing เกิดขึ้นเกี่ยวกับการดำเนินการความเท่าเทียมที่คุณกำลังใช้และประเภทข้อมูลที่คุณมี - คือและint Integerคุณได้รับIntegerจากvalueOfบนด้านขวามือของหลักสูตร

• หลังจากการแปลงคุณกำลังเปรียบเทียบintค่าดั้งเดิมสองค่า เปรียบเทียบเกิดขึ้นเช่นเดียวกับที่คุณจะคาดหวังให้ส่วนที่เกี่ยวกับวิทยาการเพื่อให้คุณลมขึ้นเปรียบเทียบและ128128

Integerชั้นมีแคชแบบคงที่ร้านค้า 256 พิเศษIntegerวัตถุ - หนึ่งสำหรับค่าระหว่าง -128 และ 127 โดยที่ในใจทุกพิจารณาแตกต่างระหว่างทั้งสาม

new Integer(123);

สิ่งนี้ (ชัด) ทำให้Integerวัตถุใหม่เอี่ยม

Integer.parseInt("123");

นี้ส่งกลับค่าดั้งเดิมหลังจากแยกintString

Integer.valueOf("123");

นี่มันซับซ้อนกว่าตัวอื่น ๆ Stringมันเริ่มต้นปิดโดยการแยก จากนั้นหากค่าอยู่ระหว่าง -128 ถึง 127 จะส่งคืนวัตถุที่สอดคล้องกันจากแคชแบบสแตติก หากค่าอยู่นอกช่วงนี้จะเรียกใช้new Integer()และส่งผ่านค่าเพื่อให้คุณได้รับวัตถุใหม่

ทีนี้ลองพิจารณาสามสำนวนในคำถาม

Integer.valueOf("127")==Integer.valueOf("127");

สิ่งนี้จะคืนค่าจริงเนื่องจากIntegerค่าที่มีคือ 127 จะถูกดึงสองครั้งจากแคชแบบสแตติกและเปรียบเทียบกับตัวมันเอง มีเพียงIntegerวัตถุเดียวที่เกี่ยวข้องดังนั้นการส่งคืนtrueนี้

Integer.valueOf("128")==Integer.valueOf("128");

ผลตอบแทนนี้falseเพราะ 128 ไม่ได้อยู่ในแคชแบบคงที่ ดังนั้นใหม่Integerถูกสร้างขึ้นสำหรับแต่ละด้านของความเท่าเทียมกัน เนื่องจากมีแตกต่างกันสองIntegerวัตถุและ==วัตถุที่ส่งกลับเฉพาะถ้าทั้งสองฝ่ายมีวัตถุเดียวกันนี้เป็นไปได้truefalse

Integer.parseInt("128")==Integer.valueOf("128");

นี่เป็นการเปรียบเทียบintค่าดั้งเดิม128 ทางด้านซ้ายกับIntegerวัตถุที่สร้างขึ้นใหม่ทางด้านขวา แต่เนื่องจากมันไม่สมเหตุสมผลที่จะเปรียบเทียบintกับ an Integer, Java จะทำการ unbox โดยอัตโนมัติIntegerก่อนทำการเปรียบเทียบ; ดังนั้นคุณจะจบลงเมื่อเทียบไปยังint intตั้งแต่ดั้งเดิม 128 trueเท่ากับตัวเองผลตอบแทนนี้

ดูแลค่าที่ส่งคืนจากวิธีการเหล่านี้ valueOfวิธีการส่งกลับอินสแตนซ์จำนวนเต็ม:

public static Integer valueOf(int i)

parseIntวิธีการผลตอบแทนที่คุ้มค่าจำนวนเต็ม (ชนิดดั้งเดิม):

public static int parseInt(String s) throws NumberFormatException

คำอธิบายสำหรับการเปรียบเทียบ:

เพื่อบันทึกหน่วยความจำสองอินสแตนซ์ของวัตถุตัวห่อหุ้มจะเป็น == เสมอเมื่อค่าดั้งเดิมของพวกเขาเหมือนกัน:

• บูลีน
• ไบต์
• อักขระจาก \ u0000 ถึง \ u007f (7f คือ 127 ในหน่วยทศนิยม)
• สั้นและจำนวนเต็มจาก -128 ถึง 127

เมื่อ == ถูกใช้เพื่อเปรียบเทียบแบบดั้งเดิมกับ wrapper นั้น wrapper จะไม่ถูกแยกออกและการเปรียบเทียบจะเป็นแบบดั้งเดิมกับแบบดั้งเดิม

ในสถานการณ์ของคุณ (ตามกฎข้างต้น):

Integer.valueOf("127")==Integer.valueOf("127")

สำนวนนี้เปรียบเทียบอ้างอิงถึงวัตถุเดียวกันเพราะมันมีค่าจำนวนเต็มระหว่าง -128 และ 127 trueเพื่อให้มันกลับ

Integer.valueOf("128")==Integer.valueOf("128")

สำนวนนี้เปรียบเทียบการอ้างอิงไปยังวัตถุที่แตกต่างกันเพราะพวกเขามีค่าจำนวนเต็มไม่ได้อยู่ใน <-128, 127> falseดังนั้นจึงผลตอบแทน

Integer.parseInt("128")==Integer.valueOf("128")

สำนวนนี้เปรียบเทียบค่าดั้งเดิม (ด้านซ้ายมือ) และการอ้างอิงถึงวัตถุ (ด้านขวามือ) trueด้านขวามือดังนั้นจะยังไม่ได้เปิดและชนิดดั้งเดิมของเขาจะนำมาเปรียบเทียบกับที่เหลือจึงเป็นผลตอบแทน

วัตถุจำนวนเต็มเก็บแคชระหว่าง -128 ถึง 127 จาก 256 จำนวนเต็ม

คุณไม่ควรเปรียบเทียบอ้างอิงวัตถุที่มี==หรือ! = คุณควรใช้ เท่ากับ (.. )แทนหรือดีกว่า - ใช้ int ดั้งเดิมแทนที่จะเป็นจำนวนเต็ม

parseInt : แยกวิเคราะห์อาร์กิวเมนต์สตริงเป็นจำนวนเต็มฐานสิบที่ลงนามแล้ว อักขระในสตริงทั้งหมดต้องเป็นตัวเลขทศนิยมยกเว้นว่าอักขระตัวแรกอาจเป็น ASCII ลบเครื่องหมาย '-' ('\ u002D') เพื่อระบุค่าลบ ค่าจำนวนเต็มที่เป็นผลลัพธ์จะถูกส่งกลับเหมือนกับอาร์กิวเมนต์และ radix 10 ถูกกำหนดเป็นอาร์กิวเมนต์ไปยังเมธอด parseInt (java.lang.String, int)

valueOf ส่งคืนวัตถุจำนวนเต็มที่เก็บค่าที่แยกออกมาจากสตริงที่ระบุเมื่อวิเคราะห์ด้วยค่าฐานที่กำหนดโดยอาร์กิวเมนต์ที่สอง อาร์กิวเมนต์แรกถูกตีความว่าเป็นตัวแทนจำนวนเต็มที่ลงนามใน Radix ที่ระบุโดยอาร์กิวเมนต์ที่สองเช่นเดียวกับถ้าอาร์กิวเมนต์ได้รับการกำหนดให้กับวิธี parseInt (java.lang.String, int) ผลลัพธ์ที่ได้คือวัตถุจำนวนเต็มที่แสดงถึงค่าจำนวนเต็มที่ระบุโดยสตริง

เทียบเท่ากับ

new Integer(Integer.parseInt(s, radix))

radix - radix ที่จะใช้ในการตีความ s

ดังนั้นถ้าคุณเท่ากับInteger.valueOf()จำนวนเต็มภายใน

-128 ถึง 127 มันจะคืนค่าจริงในสภาพของคุณ

สำหรับ lesser than-128 และgreater than127 มันให้false

เพื่อเสริมคำตอบที่ได้รับให้จดบันทึกสิ่งต่อไปนี้ด้วย:

public class Test { 
    public static void main(String... args) { 
        Integer a = new Integer(129);
        Integer b = new Integer(129);
        System.out.println(a == b);
    }
}

รหัสนี้จะพิมพ์ด้วย: false

เนื่องจากผู้ใช้Jayได้อ้างสิทธิ์ในข้อคิดเห็นสำหรับคำตอบที่ยอมรับต้องใช้ความระมัดระวังเมื่อใช้โอเปอเรเตอร์==กับวัตถุที่นี่คุณกำลังตรวจสอบว่าการอ้างอิงทั้งสองเหมือนกันซึ่งไม่ได้เนื่องจากพวกมันเป็น objets ที่แตกต่างกัน ค่าเดียวกัน ในการเปรียบเทียบวัตถุคุณควรใช้equals วิธีการแทน:

Integer a = new Integer(128);
Integer b = new Integer(128);
System.out.println(a.equals(b));

สิ่งนี้จะพิมพ์: true

คุณอาจถามแต่ทำไมพิมพ์บรรทัดแรกtrue? . ตรวจสอบซอร์สโค้ดของInteger.valueOfเมธอดคุณสามารถดูสิ่งต่อไปนี้:

public static Integer valueOf(String s) throws NumberFormatException {
    return Integer.valueOf(parseInt(s, 10));
}

public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

หากพารามิเตอร์เป็นจำนวนเต็มระหว่างIntegerCache.low(ค่าเริ่มต้นถึง -128) และIntegerCache.high(คำนวณที่รันไทม์ที่มีค่าต่ำสุด 127) ดังนั้นวัตถุที่ถูกจัดสรรล่วงหน้า (แคช) จะถูกส่งคืน ดังนั้นเมื่อคุณใช้ 127 เป็นพารามิเตอร์คุณจะได้รับการอ้างอิงสองครั้งไปยังวัตถุแคชเดียวกันและรับtrueการเปรียบเทียบการอ้างอิง