generic - ¿Cómo convertir int[] a Integer[] en Java?

generic array creation error java

Question

Soy nuevo en Java y estoy muy confundido.

Tengo un gran conjunto de datos de longitud 4 int[] y quiero contar el número de veces que ocurre cada combinación particular de 4 enteros. Esto es muy similar a contar frecuencias de palabras en un documento.

Quiero crear un Map<int[], double> que asigne cada int [] a un recuento en ejecución a medida que se itera la lista, pero Map no toma los tipos primitivos.

así que hice Map<Integer[], Double>

mis datos se almacenan como una ArrayList<int[]> entonces mi loop debería ser algo así como

ArrayList<int[]> data = ... // load a dataset`
Map<Integer[], Double> frequencies = new HashMap<Integer[], Double>();
for(int[] q : data) {
// **DO SOMETHING TO convert q from int[] to Integer[] so I can put it in the map
if(frequencies.containsKey(q)) {
frequencies.put(q, tfs.get(q) + p);
} else {
frequencies.put(q, p);
}
}

No estoy seguro de qué código necesito en el comentario para hacer que esto funcione para convertir un int[] en un Integer[] . O tal vez estoy fundamentalmente confundido acerca de la forma correcta de hacer esto.

Answer 1

Native Java 8 (una línea)

Con Java 8, int[] se puede convertir a Integer[] fácilmente:

int[] data = {1,2,3,4,5,6,7,8,9,10};
// To boxed array
Integer[] what = Arrays.stream( data ).boxed().toArray( Integer[]::new );
Integer[] ever = IntStream.of( data ).boxed().toArray( Integer[]::new );
// To boxed list
List<Integer> you = Arrays.stream( data ).boxed().collect( Collectors.toList() );
List<Integer> like = IntStream.of( data ).boxed().collect( Collectors.toList() );

Como otros dijeron, Integer[] generalmente no es una buena clave de mapa. Pero en lo que respecta a la conversión, ahora tenemos un código relativamente limpio y nativo.

Answer 2

Usando for-loop regular sin librerías externas:

Convierta int [] a Entero []:

int[] primitiveArray = {1, 2, 3, 4, 5};
Integer[] objectArray = new Integer[primitiveArray.length];
for(int ctr = 0; ctr < primitiveArray.length; ctr++) {
objectArray[ctr] = Integer.valueOf(primitiveArray[ctr]); // returns Integer value
}

Convertir entero [] a int []:

Integer[] objectArray = {1, 2, 3, 4, 5};
int[] primitiveArray = new int[objectArray.length];
for(int ctr = 0; ctr < objectArray.length; ctr++) {
primitiveArray[ctr] = objectArray[ctr].intValue(); // returns int value
}

Answer 3

1. Conversión int [] a entero []

   public static Integer[] toConvertInteger(int[] ids) {
   Integer[] newArray = new Integer[ids.length];
   for (int i = 0; i < ids.length; i++) {
   newArray[i] = Integer.valueOf(ids[i]);
   }
   return newArray;
   }

2. Convertir entero [] a int []

   public static int[] toint(Integer[] WrapperArray) {
   int[] newArray = new int[WrapperArray.length];
   for (int i = 0; i < WrapperArray.length; i++) {
   newArray[i] = WrapperArray[i].intValue();
   }
   return newArray;
   }

Answer 4

¡Funcionó como por arte de magia!

int[] mInt = new int[10];
Integer[] mInteger = new Integer[mInt.length];
List<Integer> wrapper = new AbstractList<Integer>() {
@Override
public int size() {
return mInt.length;
}
@Override
public Integer get(int i) {
return mInt[i];
}
};
wrapper.toArray(mInteger);

Answer 5

En lugar de escribir su propio código, puede usar un IntBuffer para ajustar el int [] existente sin tener que copiar los datos en una matriz Integer.

int[] a = {1,2,3,4};
IntBuffer b = IntBuffer.wrap(a);

IntBuffer implementa comparable para que pueda utilizar el código que ya ha escrito. Formalmente, los mapas comparan las claves de modo que a.equals (b) se usa para decir que dos teclas son iguales, por lo que dos IntBuffers con la matriz 1,2,3, incluso si las matrices están en diferentes ubicaciones de memoria, se dice que son iguales y también lo serán trabaja para tu código de frecuencia.

ArrayList<int[]> data = ... // load a dataset`
Map<IntBuffer, Double> frequencies = new HashMap<IntBuffer, Double>();
for(int[] a : data) {
IntBuffer q = IntBuffer.wrap(a);
if(frequencies.containsKey(q)) {
frequencies.put(q, tfs.get(q) + p);
} else {
frequencies.put(q, p);
}

}

Espero que ayude

Answer 6

Me equivoqué en una respuesta anterior. La solución adecuada es usar esta clase como una clave en el mapa que envuelve el int [] real.

public class IntArrayWrapper {
int[] data;
public IntArrayWrapper(int[] data) {
this.data = data;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
IntArrayWrapper that = (IntArrayWrapper) o;
if (!Arrays.equals(data, that.data)) return false;
return true;
}
@Override
public int hashCode() {
return data != null ? Arrays.hashCode(data) : 0;
}
}

y cambia tu código así:

 Map<IntArrayWrapper, Double > freqs = new HashMap<IntArrayWrapper, Double>();
for (int[] data : datas) {
IntArrayWrapper wrapper = new IntArrayWrapper(data);
if ( freqs.containsKey(wrapper)) {
freqs.put(wrapper, freqs.get(wrapper) + p);
}
freqs.put(wrapper, p);
}

Answer 7

No estoy seguro de por qué necesita un doble en su mapa. En términos de lo que estás tratando de hacer, tienes un int [] y solo quieres contar cuántas veces ocurre cada secuencia. ¿Por qué esto requeriría un doble de todos modos?

Lo que haría sería crear un contenedor para la matriz int con los métodos .equals y .hashCode adecuados para tener en cuenta el hecho de que el objeto int [] en sí no considera los datos en su versión de estos métodos.

public class IntArrayWrapper {
private int values[];
public IntArrayWrapper(int[] values) {
super();
this.values = values;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + Arrays.hashCode(values);
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
IntArrayWrapper other = (IntArrayWrapper) obj;
if (!Arrays.equals(values, other.values))
return false;
return true;
}
}

Y luego use google guava''s multiset, que está destinado exactamente para el recuento de las ocurrencias, siempre que el tipo de elemento que coloque tenga los métodos .equals y .hashCode adecuados.

List<int[]> list = ...;
HashMultiset<IntArrayWrapper> multiset = HashMultiset.create();
for (int values[] : list) {
multiset.add(new IntArrayWrapper(values));
}

Luego, para obtener el conteo de cualquier combinación particular:

int cnt = multiset.count(new IntArrayWrapper(new int[] { 0, 1, 2, 3 }));

Answer 8

Presumiblemente, desea que la clave del mapa coincida con el valor de los elementos en lugar de con la identidad de la matriz. En ese caso, quiere algún tipo de objeto que defina equals y hashCode como era de esperar. Lo más fácil es convertir a una List<Integer> , ya sea una ArrayList o mejor utilizar Arrays.asList . Mejor que eso, puedes introducir una clase que represente los datos (similar a java.awt.Rectangle pero recomiendo hacer que las variables sean privadas, y la clase final también).

Answer 9

Si desea convertir un int[] a un Integer[] , no hay una manera automática de hacerlo en el JDK. Sin embargo, puedes hacer algo como esto:

int[] oldArray;
... // Here you would assign and fill oldArray
Integer[] newArray = new Integer[oldArray.length];
int i = 0;
for (int value : oldArray) {
newArray[i++] = Integer.valueOf(value);
}

Si tiene acceso a la biblioteca Apache lang , entonces puede usar el ArrayUtils.toObject(int[]) como este:

Integer[] newArray = ArrayUtils.toObject(oldArray);

Answer 10

Simplemente use:

public static int[] intArrayToIntegerArray(Integer[] array)
{
int[] g = new int[array.length];
for(int i = 0; i < array.length; i++){
g[i] = array[i];
}
return g;
}

Answer 11

no necesitas int[] es un objeto y se puede usar como clave dentro de un mapa.

Map<int[], Double> frequencies = new HashMap<int[], Double>();

es la definición correcta del mapa de frecuencias.

Esto estuvo mal :-). La solución adecuada también está publicada :-).

Answer 12

Actualización: aunque la siguiente compila, arroja una ArrayStoreException en tiempo de ejecución. Demasiado. Lo dejaré para futuras referencias.

Convertir un int[] , a un Integer[] :

int[] old;
...
Integer[] arr = new Integer[old.length];
System.arraycopy(old, 0, arr, 0, old.length);

Debo admitir que estaba un poco sorprendido de que esto compila, dado que System.arraycopy es de bajo nivel y todo, pero lo hace. Al menos en java7.

Puede convertir de la otra manera con la misma facilidad.