Je suis nouveau sur Java et 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. Ceci est très similaire au comptage des fréquences de mots dans un document.

Je veux créer un Map<int[], double>qui mappe chaque int [] à un décompte 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 comme un 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 de ce code que je dois au commentaire à faire ce travail pour convertir un int[]à un Integer[]. Ou peut-être que je suis fondamentalement confus quant à la bonne façon de procéder.

Java 8 natif (une ligne)

Avec Java 8, int[]peut être converti Integer[]facilement en:

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

Comme d'autres l'ont indiqué, ce Integer[]n'est généralement pas une bonne clé de carte. Mais en ce qui concerne la conversion, nous avons maintenant un code relativement propre et natif.

Si vous souhaitez convertir un int[]en un Integer[], il n'existe pas de moyen automatisé de le faire dans le JDK. Cependant, vous pouvez faire quelque chose comme ceci:

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 vous avez accès à la bibliothèque Apache lang , vous pouvez utiliser la ArrayUtils.toObject(int[])méthode comme celle-ci:

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

Vraisemblablement, vous voulez que la clé de la carte corresponde à la valeur des éléments au lieu de l'identité du tableau. Dans ce cas, vous voulez une sorte d'objet qui définit equalset hashCodecomme vous vous en doutez. Le plus simple est de convertir en une List<Integer>, une ArrayListou une meilleure utilisation Arrays.asList. Mieux que cela, vous pouvez introduire une classe qui représente les données (similaire java.awt.Rectanglemais je recommande de rendre les variables privées finales, et la classe finale aussi).

Utilisation de la boucle for régulière sans bibliothèques externes:

Convertissez un entier [] en un entier []:

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 un entier [] en un entier []:

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
}

J'avais tort dans une réponse précédente. La bonne solution consiste à utiliser cette classe comme clé dans la carte encapsulant le véritable int [].

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

1. Convertir un entier [] en un entier []

   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 un entier [] en un entier []

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

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

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

IntBuffer implémente des outils comparables afin que vous puissiez utiliser le code que vous avez déjà écrit. Mappe formellement les clés de comparaison telles que a.equals (b) est utilisé pour dire que deux clés sont égales, donc deux IntBuffers avec un tableau 1,2,3 - même si les tableaux sont dans des emplacements de mémoire différents - sont dits égaux et le sera travailler 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);
    }

}

J'espère que cela pourra aider

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 combien de fois chaque séquence se produit? Pourquoi cela nécessitait-il un Double de toute façon?

Ce que je ferais est de créer un wrapper pour le tableau int avec les méthodes .equals et .hashCode appropriées pour tenir compte du fait que l'objet int [] lui-même ne considère pas 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 puis utilisez le multiset de google guava, qui est destiné exactement à compter les occurrences, à condition que le type d'élément que vous y mettez ait 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 décompte d'une combinaison particulière:

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

Mise à jour: bien que ce qui suit compile, il lance un ArrayStoreExceptionà l'exécution. Dommage. Je vais le laisser pour référence future.

Conversion d'un int[], en un Integer[]:

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

Je dois admettre que j'ai été un peu surpris que cela compile, System.arraycopyétant donné le niveau inférieur et tout, mais c'est le cas. Au moins en java7.

Vous pouvez convertir dans l'autre sens tout aussi facilement.

Cela a fonctionné 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);

Convertissez un entier [] en un entier []:

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

vous n'en avez pas besoin. int[]est un objet et peut être utilisé comme clé à l'intérieur d'une carte.

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

est la bonne définition de la carte des fréquences.

C'était faux :-). La bonne solution est également affichée :-).

Utilisez simplement:

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