Java natif 8 (une ligne)

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

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 dit, Integer[] n'est habituellement pas une bonne clé de carte. Mais en ce qui concerne la conversion, nous avons maintenant un code relativement propre et natif.

si vous voulez convertir un int[] en un Integer[] , il n'y a pas de méthode automatisée pour 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 , alors vous pouvez utiliser la méthode ArrayUtils.toObject(int[]) comme ceci:

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

vous voulez probablement 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 equals et hashCode comme vous vous y attendiez. Le plus facile est de convertir en un List<Integer> , soit un ArrayList ou mieux utiliser Arrays.asList . Mieux que cela, vous pouvez introduire une classe qui représente les données (similaire à java.awt.Rectangle mais je recommande de faire les variables privé final, et la classe final trop.)

j'avais tort dans une réponse précédente. La bonne solution est d'utiliser cette classe comme une clé dans la carte d'emballage le réel 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);
    }

utilisant la boucle régulière sans bibliothèques externes:

convertir int [] en 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 Integer[] 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. Convertir en int[] pour 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[] 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;
   }
   

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

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

intbuffer met en œuvre comparables de sorte que vous êtes en mesure d'utiliser le code que vous avez déjà écrit. Les cartes comparent formellement les clés de telle sorte que A. equals (b) est utilisé pour dire que deux clés sont égales, donc deux IntBuffers avec le tableau 1,2,3-même si les tableaux sont dans des emplacements de 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);
    }

}

L'espoir qui aide

Je ne sais pas pourquoi vous avez besoin d'un Double dans votre carte. En ce qui concerne 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écessiterait-il un Double de toute façon?

ce que je ferais est de créer un wrapper pour le tableau int avec un bon .d'égal à égal et .les méthodes hashCode 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 utiliser le multiset de google guava, qui est destiné exactement dans le but de compter les occurences, aussi longtemps que le type d'élément que vous mettez dedans il a APPROPRIÉ .d'égal à égal et .les méthodes hashCode.

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

ensuite, pour obtenir le compte pour n'importe quelle combinaison particulière:

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

Update: malgré les compilations ci-dessous, il lance un ArrayStoreException à l'exécution. Trop mauvais. 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 ce compile, étant donné que System.arraycopy est peu élevé et tout, mais il le fait. Au moins à java7.

vous pouvez convertir l'autre de façon 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);

vous n'avez pas besoin. int[] est un objet, et peut être utilisé comme une clé, une carte.

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

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

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

utilisation simple:

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