რა მოხდება Java-ში, როდესაც შევადარებთ Integer a = 127 და int b = 127, ასევე Integer a1 = 128 და int b1 = 128? ახსენით, რატომ იქნება შედარების შედეგები განსხვავებული.

შედარებისას Integer a = 127 და int b = 127, შედეგი იქნება true, რადგან ავტოობოქსინგის (autoboxing) შედეგად int b ობიექტად გარდაიქმნება Integer-ად და ასევე 127 მნიშვნელობა მდებარეობს Integer-ის კეშირებულ ობიექტთა დიაპაზონში (ნაგულისხმევად -128-დან 127-მდე). Java იყენებს ობიექტების პულს ამ მნიშვნელობებისთვის, ამიტომ a და ავტოობოქსირებული b ბმულები ერთსა და იმავე ობიექტზე მიუთითებენ.

თუ შევადარებთ Integer a1 = 128 და int b1 = 128, შედეგი იქნება false, რადგან b1 ასევე ავტომატურად ობიექტად გარდაიქმნება Integer-ად, მაგრამ 128 მნიშვნელობა არ შედის კეშირებულ მნიშვნელობათა დიაპაზონში. შედეგად, ავტოობოქსინგის დროს ახალი Integer ობიექტი იქმნება b1-ისთვის. a1 და ავტოობოქსირებული b1 ბმულები მიუთითებენ სხვადასხვა ობიექტზე მყარად, მიუხედავად იმისა, რომ მათი მნიშვნელობები ერთნაირია.

ობიექტების ობიექტების მნიშვნელობების შედარებისთვის (მაგალითად, Integer), საჭიროა გამოიყენოთ equals() მეთოდი.

// მნიშვნელობების შედარება
Integer a = 127;
int b = 127;
System.out.println(a == b); // true (ავტოობოქსინგი და კეშირება)
System.out.println(a.equals(b)); // true (მნიშვნელობების შედარება)

Integer a1 = 128;
int b1 = 128;
System.out.println(a1 == b1); // false (ავტოობოქსინგი, მაგრამ კეშირება არ ხდება)
System.out.println(a1.equals(b1)); // true (მნიშვნელობების შედარება)

Integer a2 = new Integer(127); // ახალი ობიექტის შექმნა, მიუხედავად კეშირების
Integer a3 = new Integer(127);
System.out.println(a2 == a3); // false (სხვადასხვა ობიექტი)
System.out.println(a2.equals(a3)); // true (მნიშვნელობების შედარება)

ამრიგად, == შედარებს ობიექტების ბმულებს, ხოლო პრიმიტიული ტიპებისა და ობიექტების მნიშვნელობების შედარებისთვის საჭიროა გამოიყენოთ equals() მეთოდი. კეშირებული Integer დიაპაზონში [-128, 127], == შედეგი შეიძლება განსხვავდებოდეს მნიშვნელობების მიხედვით.