Conversión de una matriz de primitivas en una matriz de contenedores en Java

Solución:

Apache Commons

Apache Commons / Lang tiene una clase ArrayUtils que define estos métodos.

• Todos los métodos llamados toObject(...)
  convertir de matriz primitiva a matriz contenedora
• Todos llamados toPrimitive(...) convertir de matriz de objetos de envoltura a matriz primitiva

Ejemplo:

final int[]     original        = new int[] { 1, 2, 3 };
final Integer[] wrappers        = ArrayUtils.toObject(original);
final int[]     primitivesAgain = ArrayUtils.toPrimitive(wrappers);
assert Arrays.equals(original, primitivesAgain);

---

Guayaba

Pero luego diría que las matrices de primitivas envueltas no son muy útiles, por lo que es posible que desee echar un vistazo a Guava, que proporciona Listas de todos los tipos numéricos, respaldadas por matrices primitivas:

List<Integer> intList = Ints.asList(1,2,3,4,5);
List<Long> longList   = Longs.asList(1L,2L,3L,4L,5L);
// etc.

Lo bueno de estas colecciones respaldadas por matrices es que

1. son vistas en vivo (es decir, las actualizaciones de la matriz cambian la lista y viceversa)
2. los objetos de envoltura solo se crean cuando es necesario (por ejemplo, al iterar la Lista)

Ver: Guayaba explicada / Primitivos

---

Java 8

Por otro lado, con lambdas / streams de Java 8, puede hacer que estas conversiones sean bastante simples sin usar bibliotecas externas:

int[] primitiveInts = {1, 2, 3};
Integer[] wrappedInts = Arrays.stream(primitiveInts)
                              .boxed()
                              .toArray(Integer[]::new);
int[] unwrappedInts = Arrays.stream(wrappedInts)
                             .mapToInt(Integer::intValue)
                             .toArray();
assertArrayEquals(primitiveInts, unwrappedInts);

double[] primitiveDoubles = {1.1d, 2.2d, 3.3d};
Double[] wrappedDoubles = Arrays.stream(primitiveDoubles)
                                .boxed()
                                .toArray(Double[]::new);
double[] unwrappedDoubles = Arrays.stream(wrappedDoubles)
                                  .mapToDouble(Double::doubleValue)
                                  .toArray();

assertArrayEquals(primitiveDoubles, unwrappedDoubles, 0.0001d);

Tenga en cuenta que la versión de Java 8 funciona para int, long y double, pero no para byte, ya que Arrays.stream () solo tiene sobrecargas para int[], long[], double[] o un objeto genérico T[].

Tienes que recorrer tu matriz.

---

Actualizado después de la respuesta de @seanizer:

Básicamente el toObject(byte[] array) El método hará el bucle por ti:

public static Byte[] toObject(byte[] array) {
    if (array == null) {
        return null;
    } else if (array.length == 0) {
        return EMPTY_BYTE_OBJECT_ARRAY;
    }
    final Byte[] result = new Byte[array.length];
    for (int i = 0; i < array.length; i++) {
        result[i] = new Byte(array[i]);
    }
    return result;
}

Y a menos que realmente use la biblioteca commons lang, simplemente debe reutilizar este método y evitar una dependencia inútil (en mi humilde opinión).

Solo para sugerir una alternativa, con Guava puede usar una de las utilidades de tipo primitivo, como Bytes o Ints para crear un List del tipo de envoltorio:

byte[] bytes = ...
List<Byte> byteList = Bytes.asList(bytes);

En lugar de recorrer y convertir cada byte, estos métodos en realidad crean una lista respaldada por la matriz dada. Si realmente necesitas un Byte[], esto obviamente no le da directamente lo que necesita (aunque puede obtenerlo usando .toArray(new Byte[bytes.length]) por supuesto). Sin embargo, las colecciones son muy superiores a las matrices de objetos y deben preferirse cuando sea posible.

---

---

Utiliza Nuestro Buscador