Livello 29. Risposte alle domande dell'intervista sull'argomento del livello

Che è successo autoboxing?

L'autoboxing è un meccanismo per inizializzare implicitamente oggetti di classi wrapper (Byte, Short, Character, Integer, Long, Float, Double) con i valori dei corrispondenti tipi primitivi originali (rispettivamente, , , , , , , byte, short) char, intsenza uso longesplicito del costruttore della classe.floatdouble

L'autoboxing si verifica quando una primitiva viene assegnata direttamente a una classe wrapper (utilizzando l' =operatore " ") o quando una primitiva viene passata nei parametri di un metodo (come una "classe wrapper"). Sia le variabili di tipo primitivo che le costanti in fase di compilazione (letterali e final-primitive) possono essere inserite automaticamente in "classi wrapper". In questo caso, i letterali devono essere sintatticamente corretti per inizializzare una variabile del tipo primitivo originale.

L'autoboxing delle variabili di tipo primitivo richiede una corrispondenza esatta del tipo della primitiva originale, il tipo della "classe wrapper". Ad esempio, il tentativo di inserire automaticamente una variabile di tipo bytein Short, senza prima effettuare un cast esplicito, byte->shortcauserà un errore di compilazione.

L'autoboxing delle costanti di tipo primitivo consente limiti di corrispondenza più ampi. In questo caso, il compilatore è in grado di eseguire in anticipo l'estensione/restringimento implicito dei tipi primitivi. La trasformazione avviene in due fasi:

1. espansione implicita (restringimento) del tipo primitivo originale al tipo primitivo corrispondente alla classe wrapper (per la conversione int->Byte, prima il compilatore si restringe implicitamente inta byte)

2. autopacking di una primitiva nella "classe wrapper" appropriata (il compilatore autopacks byte->Byte). tuttavia, in questo caso ci sono due ulteriori restrizioni:

• l'assegnazione di una primitiva a un "wrapper" può essere eseguita solo utilizzando l' =operatore " " (non è possibile passare tale primitiva ai parametri del metodo senza un cast esplicito del tipo)

• il tipo dell'operando di sinistra non deve essere più vecchio di Character, il tipo dell'operando di destra non deve essere più vecchio di int, (è consentita l'estensione/restrizione byte <-> short, byte <-> char, short <-> char
  e solo il restringimento byte <- int, short <- int, char <- int, tutte le altre opzioni richiedono un cast esplicito del tipo)

Una caratteristica aggiuntiva delle "classi wrapper" intere create dalle costanti di autoboxing nell'intervallo -128 +127 è che vengono memorizzate nella cache dalla JVM. Pertanto, tali wrapper con gli stessi valori saranno riferimenti a un oggetto.

Perché viene utilizzato autoboxing?

Cito la conferenza:

Come ricorderete, Java ha entrambi i tipi ereditati dalla classe Objecte dai tipi primitivi. Ma, come si è scoperto, cose così convenienti come raccolte e generici possono funzionare solo con tipi ereditati da Object.

Alternative autoboxing?

Non ho trovato una risposta, ma l'ho pubblicata su StackOverFlow .

Sulla base di questa discussione, sembra che un'alternativa autoboxingad `a sia l'uso dei tipi primitivi, poiché l'uso di autoboxing`a riduce le prestazioni. Conclusione: utilizzare autoboxingsolo dove necessario.

È stato scritto un articolo su Autoboxing: Autoboxing: trappole e vantaggi

Tipi wrapper per tipi primitivi mutableo immutable?

Immutable, poiché anche gli oggetti primitivi immutable. Per lavorare con Mutableun tipo c'è una classe MutableInteger, ecc.

Come vengono ridotti i tipi primitivi alle loro controparti non primitive?

A questa e alle successive domande viene data una risposta adeguata in questo articolo: Autopacking e decompressione in Java

Questa è la conclusione da ciò: l'autoboxing è un meccanismo per la conversione nascosta di tipi di dati primitivi nelle corrispondenti classi wrapper (oggetti). Il compilatore utilizza il metodo valueOf()per convertire i tipi primitivi in ​​oggetti e i metodi IntValue(), doubleValue()ecc., per ottenere tipi primitivi dall'oggetto (ovvero la conversione inversa). Autoboxing converte il tipo booleano booleanin Boolean, bytein Byte, charin Character, floatin Float, intin Integer, longin Long, shortin Short. Il disimballaggio avviene nella direzione opposta.

Come vengono convertiti i tipi non primitivi in ​​primitivi?

Risposto sopra.

Come si confrontano i tipi primitivi e non primitivi?

La conferenza ne discute in dettaglio, ma ho scoperto che diciamo la stessa cosa, ma con parole diverse.

In Java, ci sono due modi per confrontare gli oggetti per verificarne l'uguaglianza ==e il metodo equals().

== используется для примитивных типов. Для an objectов «==» это исключительно сравнение ссылок. Для остальных случаев нужно использовать метод equals(). Кроме того метод hashCode() служит (в теории) для той же цели. Хорошим тоном считается, если вы переопределor equals() и hashCode(). После инициализации неких an objectов a и b должно выполняться правило:

Если выражение a.equals(b) вернет true, то a.hashCode() должен быть equals b.hashCode().

Всегда ли создается новый an object при операции autoboxing?

Это в лекциях есть:

Когда мы присваиваем переменной типа Integer meaning типа int, при этом вызывается метод Integer.valueOf: функция valueOf не всегда создает новый an object типа Integer. Она кэширует значения от -128 до 127.

Если передаваемое meaning выходит за эти пределы, то новый an object создается, а если нет, то нет.

Если мы пишем new Integer(), то гарантированно создается новый an object. Если мы вызываем Integer.valueOf(), явно or при autoboxing, то этот метод может вернуть для нас How новый an object, так и отдать an object из кэша, если переданное число лежит в диапазоне от -128 до 127.

Как работает кэширование при операции autoboxing?

Ответил в вопросе выше, на всякий случай создал вопрос на StackOverFlow, но там отвечают тоже самое

Для Howих типов и/or значений работает кэширование?

В восьмом вопросе. Если у кого – то есть соображения на тему трех последних вопросов, то напишите в комментариях.