Wrapper Classes · Classes Wrapper
| English | Português |
|---|---|
| wrapper class/ˈræpə klæs/ | classe wrapper |
| autoboxing/ˌɔːtəʊˈbɒksɪŋ/ | autoboxing |
| unboxing/ʌnˈbɒksɪŋ/ | unboxing |
Boxing a primitive
- Some Java structures (like
ArrayList) hold objects, not primitives. - A wrapper class 包装类 wraps a primitive in an object:
Integerwrapsint,Doublewrapsdouble. Integer boxed = Integer.valueOf(5);puts theint5inside an object.- Wrappers let primitives live where only objects are allowed.
Envolvendo um primitivo
- Algumas estruturas Java (como
ArrayList) armazenam objetos, não primitivos. - Uma classe wrapper 包装类 envolve um primitivo em um objeto:
Integerenvolveint,Doubleenvolvedouble. Integer boxed = Integer.valueOf(5);coloca oint5dentro de um objeto.- Wrappers permitem que primitivos vivam onde apenas objetos são permitidos.
Autoboxing and unboxing
- Java converts automatically — autoboxing 自动装箱 and unboxing 自动拆箱.
Integer x = 5;autoboxes5;int y = x;unboxes it back.- So
list.add(5)works even though the list holdsIntegerobjects. - You rarely write
Integer.valueOfby hand — autoboxing does it.
Autoboxing e unboxing
- Java converte automaticamente — autoboxing 自动装箱 e unboxing 自动拆箱.
Integer x = 5;autoboxes5;int y = x;unboxes de volta.- Então
list.add(5)funciona mesmo que a lista contenha objetosInteger. - Você raramente escreve
Integer.valueOfmanualmente — o autoboxing faz isso.
Why ArrayList needs them
ArrayList<Integer>holdsIntegerobjects, because generics require a reference type.- You can't write
ArrayList<int>— primitives aren't objects. - Autoboxing lets you add and read plain
ints conveniently. Double,Boolean, etc. play the same role for their primitives.
Por que ArrayList precisa deles
ArrayList<Integer>contém objetosInteger, porque genéricos exigem um tipo de referência.- Você não pode escrever
ArrayList<int>— primitivos não são objetos. - Autoboxing permite adicionar e ler primitivos
ints convenientemente. Double,Boolean, etc. desempenham o mesmo papel para seus primitivos.
Compare wrappers with equals
- Two
Integerobjects should be compared with.equals(), not==. ==compares references;.equals()compares the wrapped values.- (Java caches small Integers, so
==sometimes seems to work — don't rely on it.) - The same "use
.equals()for objects" rule fromStringapplies here.
Comparar wrappers com equals
- Dois objetos
Integerdevem ser comparados com.equals(), não==. ==compara referências;.equals()compara os valores envolvidos.- (Java cacheia Integers pequenos, então
==às vezes parece funcionar — não conte com isso.) - A mesma regra "use
.equals()para objetos" deStringaplica-se aqui.
Wrappers are objects, so compare their values with .equals(), not ==. == tests reference identity; for two Integer objects with the same value it can be false. And you can't parameterize a collection with a primitive — it's ArrayList<Integer>, never ArrayList<int>. Autoboxing bridges the gap so you can still add plain ints.
Wrappers são objetos, então compare seus valores com .equals(), não com ==. == testa identidade de referência; para dois objetos Integer com o mesmo valor, pode ser false. E você não pode parametrizar uma coleção com um primitivo — é ArrayList<Integer>, nunca ArrayList<int>. Autoboxing pontua a lacuna para que você ainda possa adicionar primitivos ints.
Wrappers with an ArrayList:
ArrayList<Integer> nums = new ArrayList<Integer>();nums.add(5);— theint5is autoboxed into anInteger.int first = nums.get(0);— theIntegeris unboxed back toint.
Wrappers com um ArrayList:
ArrayList<Integer> nums = new ArrayList<Integer>();nums.add(5);— oint5é autoboxed em umInteger.int first = nums.get(0);— oIntegeré unboxed de volta paraint.
A wrapper class (Integer, Double, Boolean) wraps a primitive in an object so it can go where objects are required — like an ArrayList<Integer> (you can't write ArrayList<int>). Autoboxing and unboxing convert automatically. Compare wrapper objects with .equals(), not ==.
Uma classe wrapper (Integer, Double, Boolean) envolve um primitivo em um objeto para que ele possa ir onde objetos são necessários — como uma ArrayList<Integer> (você não pode escrever ArrayList<int>). Autoboxing e unboxing convertem automaticamente. Compare objetos wrappers com .equals(), não ==.
Autoboxing and unboxing · Autoboxing e unboxing
int ↔ Integer conversions happen automatically. · Conversões int ↔ Integer ocorrem automaticamente.
Which wrapper class wraps an int? · Qual classe wrapper envolve um int?
Integer wraps int; Double wraps double. · Integer envolve int; Double envolve double.
Why must an ArrayList of ints be declared ArrayList
You can't write ArrayList
Two Integer objects should be compared with... · Dois objetos Integer devem ser comparados com...
Wrappers are objects — use .equals() for their values. · Wrappers são objetos — use .equals() para seus valores.
In nums.add(5), the int 5 is automatically boxed into an Integer (autoboxing). · Em nums.add(5), o int 5 é automaticamente boxingado em um Integer (autoboxing).
Autoboxing converts the primitive to a wrapper object. · Autoboxing converte o primitivo em um objeto wrapper.
A class that wraps a primitive in an object is a ___ class (one word). · Uma classe que envolve um primitivo em um objeto é uma classe ___ (uma palavra).
Integer, Double, Boolean are wrapper classes. · Integer, Double, Boolean são classes wrapper.