Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Qual è la trappola 128

Diamo prima un'occhiata a un pezzo di codice

		int a0=127;
        int a1=127;
        Integer a2=127;
        Integer a3=127;
        System.out.println(a0==a1);  // 1、运行结果是true
        System.out.println(a0==a2);  // 2、运行结果是true
        System.out.println(a2==a3);  // 3、运行结果是true
        System.out.println(a2.equals(a0)); // 注意这里必须是包装类的a2才能使用equals，a0不能使用
                                           // 4、运行结果是true
        System.out.println(a2.equals(a3)); // 5、运行结果是true
        System.out.println("-----------------------------");

        int b0=200;
        int b1=200;
        Integer b2=200;
        Integer b3=200;
        System.out.println(b0==b1);	// 6、运行结果是true
        System.out.println(b0==b2);	// 7、运行结果是true
        System.out.println(b2==b3);// 8、运行结果是false
        System.out.println(b2.equals(b0)); // 9、运行结果是true
        System.out.println(b2.equals(b3)); // 10、运行结果是true
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• Il risultato della corsa è quello che mi aspettavo?
  Infatti, l'ottavo risultato consecutivo è la cosiddetta trappola 128.

• La trap Java 128 si riferisce a: quando il valore salvato dalla classe di incapsulamento dei dati di tipo base è maggiore o uguale a 128, l'indirizzo di ciascuna classe non è uguale.Non deve essere 128 per apparire.

  Per dirla semplicemente: quando è inferiore o uguale a 127 e maggiore o uguale a -128, il valore che viene automaticamente inquadrato è il valore che esiste allo stesso indirizzo. Quando è maggiore di 127, il valore che è automaticamente boxed non è lo stesso. Cioè, finché l'intervallo non è [-128,127], l'utilizzo di == risulterà falso. Se viene utilizzato uguale, il risultato sarà vero. E sebbene il valore non sia nell'intervallo corrente, se viene utilizzato Integer, verrà automaticamente unboxed, quindi non ci sarà alcun problema di trap 128, quindi la settima esecuzione è vera;

Perché appare la trappola 128?

Visualizza il codice sorgente

	/**解释精简一部分后
     * This method will always cache values in the range -128 to 127
     */
	public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
1
2
3
4
5
6
7
8

illustrare:
1. Il valore di IntegerCache.low è -128 e il valore di IntegerCache.high è 127.
2. Nel metodo valueOf di Integer, viene memorizzato un array di cache, che equivale a una cache, che va da -128 a 127 con intervallo chiuso.
3. Quando il valore preso è compreso tra [-128, 127], il valore restituito è il valore definito nell'array IntegerCache.cache e non è necessario creare un nuovo oggetto.
4. Quando il valore non è compreso nell'intervallo, è necessario creare un nuovo oggetto. Il nuovo oggetto == è l'indirizzo del giudizio, che è falso è uguale al valore dell'oggetto giudicato, che è vero;

Cose da notare quando si affronta la trappola 128

• Se l'oggetto viene creato da nuovo (come mostrato di seguito), non ci sarà alcuna trappola 128. (Ciò comporta il disimballaggio e l'imballaggio automatico, scriverò un'introduzione qui più tardi)
  Il motivo è che gli indirizzi di memoria degli oggetti prodotti da new sono diversi e gli oggetti confrontati non sono gli stessi.

	Integer k1 = new Integer(100);
    Integer k2 = new Integer(100);
    System.out.println(k1==k2);  // 运行结果false
    System.out.println(k1.equals(k2)); // 运行结果true
1
2
3
4

• Quando confronti i valori, puoi utilizzare il metodo uguale

---

---

Documentazione di riferimento:
Italiano: https://blog.csdn.net/niu_8865/article/details/110791911
Italiano: https://blog.csdn.net/DianLanHong/article/details/119617352
Italiano: https://blog.csdn.net/Yangyeon_/article/details/135611919