¿Cómo convertir int a Integer en Java?

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 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

mis datos se almacenan como una ArrayList entonces mi loop debería ser algo así como

 ArrayList data = ... // load a dataset` Map frequencies = new HashMap(); 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.

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 you = Arrays.stream( data ).boxed().collect( Collectors.toList() ); List 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.

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); 

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 , 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).

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 freqs = new HashMap(); for (int[] data : datas) { IntArrayWrapper wrapper = new IntArrayWrapper(data); if ( freqs.containsKey(wrapper)) { freqs.put(wrapper, freqs.get(wrapper) + p); } freqs.put(wrapper, p); } 

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 } 
  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; } 

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 data = ... // load a dataset` Map frequencies = new HashMap(); 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

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 list = ...; HashMultiset 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 })); 

Actualización: aunque la siguiente comstack, 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 comstack, 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.

¡Funcionó como por arte de magia!

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

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

 Map frequencies = new HashMap(); 

es la definición correcta del mapa de frecuencias.

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

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; }