Comment convertir int [] en Integer [] en Java?
Je suis nouveau sur Java et très confus.
J'ai un grand jeu de données de longueur 4 int[] et je veux compter le nombre de fois que chaque combinaison particulière de 4 nombres entiers se produit. Ceci est très similaire au comptage des fréquences Word dans un document.
Je veux créer un Map<int[], double> qui mappe chaque int [] à un nombre en cours d'exécution lorsque 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 au commentaire pour que ce travail convertisse un int[] à un Integer[]. Ou peut-être suis-je fondamentalement confus quant à la bonne façon de procéder.
Natif Java 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 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 ça:
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 méthode ArrayUtils.toObject(int[]) comme ceci:
Integer[] newArray = ArrayUtils.toObject(oldArray);
Utiliser des boucles for normales 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 un entier [] en 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
}
Vous voulez probablement que la clé de la carte corresponde à la valeur des éléments plutôt qu'à l'identité du tableau. Dans ce cas, vous voulez une sorte d’objet qui définit equals et hashCode comme vous le souhaiteriez. Le plus simple 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 rendre les variables privées final et la classe final également).
Je me suis trompé dans une réponse précédente. La solution appropriée consiste à utiliser cette classe en tant que clé dans la carte qui enveloppe l'int [] réelle.
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);
}
Convertir int [] en 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; }Convertir un entier [] 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; }
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 Integer.
int[] a = {1,2,3,4};
IntBuffer b = IntBuffer.wrap(a);
IntBuffer implémente comparable afin que vous puissiez utiliser le code que vous avez déjà écrit. Les cartes formelles comparent les clés telles 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 mémoire différents - sont dits égaux et travaillez 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 ça t'as aidé
Vous ne savez 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 aurait-il nécessité un double de toute façon?
Ce que je voudrais faire est de créer un wrapper pour le tableau int avec les méthodes appropriées .equals et .hashCode afin de prendre en compte le fait que l'objet int [] ne considère pas les données contenues 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;
}
}
Ensuite, utilisez le multiset de google guava, qui est conçu précisément pour compter les occurrences, à condition que le type d'élément que vous avez inséré 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 de toute combinaison particulière:
int cnt = multiset.count(new IntArrayWrapper(new int[] { 0, 1, 2, 3 }));
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);
pdate: Bien que la compilation ci-dessous soit compilée, elle lance un ArrayStoreException à l'exécution. Dommage. Je vais le laisser rester pour référence future.
Conversion d'un int[], à un Integer[]:
int[] old;
...
Integer[] arr = new Integer[old.length];
System.arraycopy(old, 0, arr, 0, old.length);
Je dois avouer que je suis un peu surpris que cela compile, étant donné System.arraycopy être de bas niveau et tout, mais c'est le cas. Au moins en Java7.
Vous pouvez tout aussi facilement convertir l'autre sens.