Tại sao == so sánh với Integer.valueOf (Chuỗi) cho kết quả khác nhau cho 127 và 128?

Tôi không biết tại sao các dòng mã này trả về các giá trị khác nhau:

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

Đầu ra là:

true
false
true

Tại sao cái thứ nhất trở lại truevà cái thứ hai trở lại false? Có điều gì khác biệt mà tôi không biết giữa 127và 128không? (Tất nhiên tôi biết rằng 127< 128.)

Ngoài ra, tại sao người thứ ba trở lại true?

Tôi đã đọc câu trả lời của câu hỏi này , nhưng tôi vẫn không hiểu làm thế nào nó có thể trở lại truevà tại sao mã trong dòng thứ hai trở lại false.

Có một sự khác biệt nổi bật ở đây.

valueOfđang trả về một Integerđối tượng, có thể có các giá trị của nó được lưu trong khoảng từ -128 đến 127. Đây là lý do tại sao giá trị đầu tiên trả về true- nó được lưu trong bộ nhớ cache - và giá trị thứ hai trả về false- 128 không phải là giá trị được lưu trong bộ nhớ cache, do đó bạn nhận được hai Integertrường hợp riêng biệt .

Điều quan trọng cần lưu ý là bạn đang so sánh các tham chiếu với Integer#valueOfvà nếu bạn đang so sánh một giá trị lớn hơn những gì bộ đệm hỗ trợ, thì nó sẽ không đánh giá được true, ngay cả khi các giá trị được phân tích tương đương (trong trường hợp: Integer.valueOf(128) == Integer.valueOf(128) :). Bạn phải sử dụng equals()thay thế.

parseInt đang trở lại nguyên thủy int . Đây là lý do tại sao giá trị thứ ba trả về true- 128 == 128được đánh giá, và tất nhiên , true.

Bây giờ, một chút công bằng xảy ra để tạo ra kết quả thứ ba đó true:

• Một chuyển đổi unboxing xảy ra đối với toán tử tương đương bạn đang sử dụng và các kiểu dữ liệu bạn có - cụ thể là intvà Integer. Bạn đang nhận được một Integertừ valueOfphía bên tay phải, tất nhiên.

• Sau khi chuyển đổi, bạn đang so sánh hai intgiá trị nguyên thủy . So sánh xảy ra đúng như bạn mong đợi đối với người nguyên thủy, vì vậy bạn kết thúc việc so sánh 128và 128.

Các Integerlớp học có một bộ nhớ cache tĩnh, mà các cửa hàng 256 đặc biệt Integerđối tượng - một cho tất cả các giá trị trong khoảng -128 và 127. Với ý nghĩ đó, hãy xem xét sự khác biệt giữa ba.

new Integer(123);

Điều này (rõ ràng) làm cho một Integerđối tượng hoàn toàn mới .

Integer.parseInt("123");

Điều này trả về một intgiá trị nguyên thủy sau khi phân tích cú pháp String.

Integer.valueOf("123");

Điều này phức tạp hơn những người khác. Nó bắt đầu bằng cách phân tích cú pháp String. Sau đó, nếu giá trị nằm trong khoảng từ -128 đến 127, nó sẽ trả về đối tượng tương ứng từ bộ đệm tĩnh. Nếu giá trị nằm ngoài phạm vi này, thì nó sẽ gọi new Integer()và chuyển vào giá trị, để bạn có được một đối tượng mới.

Bây giờ, hãy xem xét ba biểu thức trong câu hỏi.

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

Điều này trả về true, bởi vì Integergiá trị của nó là 127 được lấy hai lần từ bộ đệm tĩnh và so với chính nó. Chỉ có một Integerđối tượng liên quan, vì vậy điều này trở lại true.

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

Điều này trả về false, vì 128 không có trong bộ đệm tĩnh. Vì vậy, một cái mới Integerđược tạo ra cho mỗi bên của sự bình đẳng. Vì có hai Integerđối tượng khác nhau và ==đối với các đối tượng chỉ trả về truenếu cả hai bên là cùng một đối tượng, điều này sẽ xảy ra false.

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

Đây là so sánh intgiá trị nguyên thủy 128 ở bên trái, với một Integerđối tượng mới được tạo ở bên phải. Nhưng vì không có ý nghĩa gì khi so sánh intvới một Integer, Java sẽ tự động bỏ hộp Integertrước khi thực hiện so sánh; Vì vậy, cuối cùng bạn so sánh một intvới một int. Vì 128 nguyên thủy bằng chính nó, điều này trả về true.

Hãy quan tâm đến việc trả lại giá trị từ các phương pháp này. Phương thức valueOf trả về một thể hiện Integer:

public static Integer valueOf(int i)

Các parseInt trở về phương pháp nguyên giá trị (kiểu nguyên thủy):

public static int parseInt(String s) throws NumberFormatException

Giải thích để so sánh:

Để tiết kiệm bộ nhớ, hai phiên bản của các đối tượng trình bao bọc, sẽ luôn là == khi các giá trị nguyên thủy của chúng giống nhau:

• Boolean
• Byte
• Ký tự từ \ u0000 đến \ u007f (7f là 127 ở dạng thập phân)
• Ngắn và Số nguyên từ -128 đến 127

Khi == được sử dụng để so sánh một nguyên thủy với một trình bao bọc, trình bao bọc sẽ được mở ra và so sánh sẽ là nguyên thủy so với nguyên thủy.

Trong tình huống của bạn (theo các quy tắc trên):

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

Biểu thức này so sánh các tham chiếu đến cùng một đối tượng vì nó chứa giá trị Integer trong khoảng từ -128 đến 127 nên nó trả về true.

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

Biểu thức này so sánh các tham chiếu đến các đối tượng khác nhau vì chúng chứa các giá trị Integer không nằm trong <-128, 127> nên nó trả về false.

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

Biểu thức này so sánh giá trị nguyên thủy (phía bên trái) và tham chiếu đến đối tượng (phía bên phải) vì vậy phía bên phải sẽ không được bao bọc và loại nguyên thủy của anh ta sẽ được so sánh với bên trái để nó quay trở lại true.

Các đối tượng Integer lưu trữ giữa -128 và 127 trên 256 Integer

Bạn không nên so sánh các tham chiếu đối tượng với == hoặc ! = . Bạn nên sử dụng . bằng (..) thay vào đó, hoặc tốt hơn - sử dụng int nguyên thủy thay vì Integer.

parseInt : Phân tích đối số chuỗi dưới dạng số nguyên thập phân đã ký. Tất cả các ký tự trong chuỗi phải là chữ số thập phân, ngoại trừ ký tự đầu tiên có thể là dấu trừ ASCII '-' ('\ u002D') để biểu thị giá trị âm. Giá trị nguyên được kết quả được trả về, chính xác như thể đối số và cơ số 10 được đưa ra làm đối số cho phương thức parseInt (java.lang.String, int).

Trả về một đối tượng Integer giữ giá trị được trích xuất từ ​​Chuỗi được chỉ định khi được phân tích cú pháp với cơ số được cung cấp bởi đối số thứ hai. Đối số đầu tiên được hiểu là đại diện cho một số nguyên đã ký trong cơ số được chỉ định bởi đối số thứ hai, chính xác như thể các đối số được đưa cho phương thức parseInt (java.lang.String, int). Kết quả là một đối tượng Integer đại diện cho giá trị nguyên được chỉ định bởi chuỗi.

tương đương với

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

cơ số - cơ số được sử dụng để giải thích s

vì vậy nếu bạn bằng Integer.valueOf()số nguyên giữa

-128 đến 127 nó trả về đúng trong điều kiện của bạn

cho lesser than-128 và greater than127 nó mang lạifalse

Để bổ sung cho các câu trả lời nhất định, cũng lưu ý những điều sau:

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

Mã này cũng sẽ in: false

Như người dùng Jay đã tuyên bố trong một nhận xét cho câu trả lời được chấp nhận, phải cẩn thận khi sử dụng toán tử ==trên các đối tượng, ở đây bạn đang kiểm tra xem cả hai tham chiếu có giống nhau không, bởi vì chúng là các đối tượng khác nhau, mặc dù chúng đại diện cho cùng giá trị. Để so sánh các đối tượng, bạn nên sử dụng equals phương thức thay thế:

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

Điều này sẽ in: true

Bạn có thể hỏi, nhưng tại sao dòng đầu tiên được in true? . Kiểm tra mã nguồn cho Integer.valueOfphương thức, bạn có thể thấy như sau:

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

Nếu param là một số nguyên nằm giữa IntegerCache.low(mặc định là -128) và IntegerCache.high(được tính trong thời gian chạy với giá trị tối thiểu 127) thì một đối tượng được cấp phát trước (được lưu trong bộ nhớ cache) được trả về. Vì vậy, khi bạn sử dụng 127 làm tham số, bạn sẽ nhận được hai tham chiếu đến cùng một đối tượng được lưu trong bộ nhớ cache và trueso sánh các tham chiếu.