> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud3-introducion-a-programacion-orientada-a-obxectos/clases-da-api-de-java/clases-envolventes-de-tipos-primitivos.md).
# Clases envolventes de tipos primitivos
En Java, **cada tipo de dato primitivo ten unha clase correspondente**, que se coñece como a súa *wrapper class* ou clase envolvente. Estas clases permiten que os tipos primitivos se traten como obxectos, o que é **útil** en varias situacións, como **nas coleccións** (por exemplo, listas ou mapas) **onde se requiren obxectos**. A continuación, preséntoche unha relación entre os tipos primitivos de Java e as súas clases envolventes correspondentes:
| **Tipo Primitivo** | **Clase Envolvente** |
| -------------------------------------- | ---------------------------------------- |
| `byte` | `Byte` |
| `short` | `Short` |
| `int` | `Integer`:copy: |
| `long` | `Long` |
| `float` | `Float` |
| `double`:copy: | `Double`:copy: |
| `char` | `Character`:copy: |
| `boolean`:copy: | `Boolean`:copy: |
## Autoboxing e unboxing
O *autoboxing* e o *unboxing* son procesos que permiten converter automaticamente entre tipos primitivos e as súas clases envolventes, o que facilita a manipulación destes datos en contextos que requiren obxectos.
***Autoboxing*** ocorre cando **un valor primitivo é automaticamente convertido na súa clase envolvente**. Isto é útil cando precisas traballar con obxectos en vez de tipos primitivos, como ao engadir elementos a unha colección `List` que só admite obxectos.
```java
int numeroPrimitivo = 5;
// Java automaticamente converte o primitivo 'int' nun 'Integer'
Integer numeroEnvolto = numeroPrimitivo;
System.out.println(numeroEnvolto); // Saída: 5
```
No exemplo anterior, `numeroPrimitivo`:copy: é automaticamente convertido nun obxecto de tipo `Integer`:copy:.
***Unboxing*** é o proceso inverso: a **conversión dun obxecto dunha clase envolvente ao seu tipo primitivo correspondente**. Isto ocorre cando precisas usar un valor envolto en operacións que requiren tipos primitivos.
```java
Integer numeroEnvolto = 10;
// Java automaticamente extrae o valor primitivo do obxecto 'Integer'
int numeroPrimitivo = numeroEnvolto;
System.out.println(numeroPrimitivo); // Saída: 10
```
## Cando utilizar clases envolventes
Nestes casos deberías utilizar clases envolventes en lugar de tipos primitivos
* **Traballo con Coleccións (Listas, Mapas, etc.)**: As clases envolventes son necesarias cando traballas con coleccións en Java, como `ArrayList`:copy:, `HashMap`:copy:, etc., que non poden conter tipos primitivos. Neste caso, debes usar `Integer`:copy:, `Double`:copy:, `Boolean`:copy:, etc.
* **Necesidade de características avanzadas**: As clases envolventes proporcionan métodos adicionais que os tipos primitivos non teñen. Por exemplo, a clase `Integer`:copy: ten o método `Integer.parseInt()`:copy:, e `Double`:copy: ten `Double.isNaN()`:copy: para comprobar se un número non é un número (NaN).
* **Valores Nulos**: Os tipos primitivos non poden ter valores nulos, mentres que as clases envolventes si. Isto é útil se precisas representar un valor non inicializado ou descoñecido. Por exemplo, unha variable `Integer`:copy: pode ser `null`, mentres que un `int` non.
```java
int maximo = Integer.MAX_VALUE;
int minimo = Integer.MIN_VALUE;
System.out.println(maximo);
int primero = Integer.compare(7,4); //1
int iguales = Integer.compare(4,4); //0
int segundo = Integer.compare(2,5); //-1
String numero = "12345";
int num = Integer.valueOf(numero);
System.out.println(3+num); //12348
Integer.valueOf("abc"); //NumberFormatException
```
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://educacion.gitbook.io/programacion/ud3-introducion-a-programacion-orientada-a-obxectos/clases-da-api-de-java/clases-envolventes-de-tipos-primitivos.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.