Comment convertir int[] en Integer[] en Java ?

Question

Je suis nouveau dans le domaine de Java et je suis très confus.

J'ai un grand ensemble de données de longueur 4 int[] et je veux compter le nombre de fois que chaque combinaison particulière de 4 entiers se produit. C'est très similaire au comptage de la fréquence des mots dans un document.

Je veux créer un Map<int[], double> qui fait correspondre chaque int[] à un compte courant au fur et à mesure que la liste est itérée, mais Map ne prend pas les types primitifs.

Alors j'ai fait Map<Integer[], Double> .

Mes données sont stockées en tant que ArrayList<int[]> donc ma boucle devrait être quelque chose comme :

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

Je ne suis pas sûr du code dont j'ai besoin dans le commentaire pour que cela fonctionne afin de convertir un fichier de type int[] à un Integer[] . Ou peut-être suis-je fondamentalement confus quant à la bonne façon de procéder.

Answer 1

La bonne solution est d'utiliser cette classe comme une clé dans la carte contenant les int[] réels.

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

Et changez votre code comme ceci :

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 2

1. Convertir int[] en 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 Integer[] en 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 3

Plutôt que d'écrire votre propre code, vous pouvez utiliser un IntBuffer pour envelopper les int[] existants sans avoir à copier les données dans un tableau Integer :

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

IntBuffer implémente comparable Vous pouvez donc utiliser le code que vous avez déjà écrit. Formellement, les maps comparent les clés de telle sorte que a.equals(b) est utilisé pour dire que deux clés sont égales, donc deux IntBuffers avec les tableaux 1,2,3 - même si les tableaux sont dans des emplacements mémoire différents - sont dits égaux et donc fonctionneront pour votre code de fréquence.

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

Answer 4

Je ne sais pas pourquoi vous avez besoin d'un double dans votre carte. En termes de ce que vous essayez de faire, vous avez un int[] et vous voulez juste compter le nombre de fois que chaque séquence se produit( ?). Pourquoi cela nécessiterait-il un Double de toute façon ?

Je créerais un wrapper pour le tableau int avec des méthodes .equals et .hashCode appropriées pour tenir compte du fait que l'objet int[] lui-même ne prend pas en compte les données dans sa version de ces méthodes.

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

}

Et ensuite utiliser Google Guava Le multiset de l'utilisateur, qui est conçu exactement pour compter les occurrences, tant que le type d'élément que vous y placez possède les méthodes .equals et .hashCode appropriées.

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

Ensuite, pour obtenir le compte pour une combinaison particulière :

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

Answer 5

Cela a marché comme un charme !

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