Soy nuevo en Java y estoy muy confundido.

Tengo un gran conjunto de datos de longitud 4 int[]y quiero contar la cantidad 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 continuo a medida que la lista se repite, pero Map no toma tipos primitivos.

entonces hice Map<Integer[], Double>

mis datos se almacenan como un ArrayList<int[]>modo, mi ciclo 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 que esto funcione para convertir un int[]a un Integer[]. O tal vez estoy fundamentalmente confundido acerca de la forma correcta de hacer esto.

Java 8 nativo (una línea)

Con Java 8, int[]se puede convertir 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 han dicho, 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 forma 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 lang de Apache , puede usar el ArrayUtils.toObject(int[])método de esta manera:

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

Presumiblemente, desea que la clave del mapa coincida con el valor de los elementos en lugar de la identidad de la matriz. En ese caso, desea algún tipo de objeto que defina equalsy hashCodecomo era de esperar. Lo más fácil es convertir a un uso List<Integer>, ya sea uno ArrayListo mejor Arrays.asList. Mejor que eso, puede introducir una clase que represente los datos (similar a, java.awt.Rectanglepero recomiendo que las variables sean privadas finales y la clase final también).

Usando for-loop regular sin bibliotecas externas:

Convierta int [] a Integer []:

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
}

Me equivoqué en una respuesta anterior. La solución adecuada es usar esta clase como 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);
    }

1. Convierta int [] a Integer []

   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 herramientas comparables para que pueda usar el código que ya ha escrito. Formalmente, los mapas comparan claves de manera que a.equals (b) se usa para decir que dos claves son iguales, por lo que dos IntBuffers con 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

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 es 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í mismo 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 el multiset de google guava, que tiene el propósito exacto de contar las ocurrencias, siempre que el tipo de elemento que ingrese 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 recuento de cualquier combinación particular:

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

Actualización: aunque se compila a continuación, arroja un ArrayStoreExceptionen tiempo de ejecución. Demasiado. Dejaré que se quede para futuras referencias.

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

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

Debo admitir que me sorprendió un poco que esto se compila, dado que System.arraycopyes de bajo nivel y todo, pero lo hace. Al menos en java7.

Puede convertir a la inversa con la misma facilidad.

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

Convierta int [] a Integer []:

    import java.util.Arrays;
    ...

    int[] aint = {1,2,3,4,5,6,7,8,9,10};
    Integer[] aInt = new Integer[aint.length];

    Arrays.setAll(aInt, i -> aint[i]);

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 adecuada del mapa de frecuencias.

Esto estaba mal :-). La solución adecuada también se publica :-).

Simplemente use:

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