webentwicklung-frage-antwort-db.com.de

Wie konvertiert man int [] in Integer [] in Java?

Ich bin neu in Java und sehr verwirrt.

Ich habe einen großen Datensatz mit der Länge 4 int[] Und möchte zählen, wie oft jede bestimmte Kombination von 4 Ganzzahlen vorkommt. Dies ist dem Zählen von Word-Häufigkeiten in einem Dokument sehr ähnlich.

Ich möchte einen Map<int[], double> Erstellen, der jedes int [] einer laufenden Anzahl zuordnet, während die Liste durchlaufen wird, aber Map akzeptiert keine primitiven Typen.

also habe ich Map<Integer[], Double>

meine Daten werden als ArrayList<int[]> gespeichert, so dass meine Schleife ungefähr so ​​aussehen sollte

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

Ich bin nicht sicher, welchen Code ich im Kommentar benötige, damit dies funktioniert, um einen int[] In einen Integer[] Umzuwandeln. Oder vielleicht bin ich von Grund auf verwirrt über den richtigen Weg, dies zu tun.

142
John

Native Java 8 (eine Zeile)

Mit Java 8, int[] Kann einfach in Integer[] Konvertiert werden:

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

Wie bereits erwähnt, ist Integer[] Normalerweise kein guter Kartenschlüssel. Was die Konvertierung angeht, haben wir jetzt einen relativ sauberen und nativen Code.

153
Sheepy

Wenn Sie einen int[] In einen Integer[] Konvertieren möchten, gibt es im JDK keine automatisierte Möglichkeit, dies zu tun. Sie können jedoch Folgendes tun:

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

Wenn Sie Zugriff auf die Bibliothek Apache lang haben, können Sie die Methode ArrayUtils.toObject(int[]) folgendermaßen verwenden:

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

Verwenden der regulären for-Schleife ohne externe Bibliotheken:

Konvertiere int [] in 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
}

Ganzzahl [] in int [] umwandeln:

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
}
8
silver

Möglicherweise möchten Sie, dass der Schlüssel für die Karte mit dem Wert der Elemente und nicht mit der Identität des Arrays übereinstimmt. In diesem Fall möchten Sie eine Art Objekt, das equals und hashCode wie erwartet definiert. Am einfachsten ist die Konvertierung in einen List<Integer>, Entweder in einen ArrayList oder besser in einen Arrays.asList. Besser als das können Sie eine Klasse einführen, die die Daten repräsentiert (ähnlich wie Java.awt.Rectangle, Aber ich empfehle, die Variablen private final und die class final zu machen).

Ich habe mich in einer früheren Antwort geirrt. Die richtige Lösung besteht darin, diese Klasse als Schlüssel in der Map zu verwenden, die das tatsächliche int [] umschließt.

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

und ändere deinen Code wie folgt:

   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);
    }
6
Mihai Toader
  1. Konvertiere int [] in 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. Ganzzahl [] in int [] konvertieren

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

Anstatt Ihren eigenen Code zu schreiben, können Sie den vorhandenen int [] mit einem IntBuffer umbrechen, ohne die Daten in ein Integer-Array kopieren zu müssen

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

IntBuffer implementiert vergleichbare, so dass Sie den Code verwenden können, den Sie bereits geschrieben haben. Formell vergleichen Maps Schlüssel so, dass a.equals (b) verwendet wird, um zu sagen, dass zwei Schlüssel gleich sind, sodass zwei IntBuffers mit Array 1,2,3 - selbst wenn sich die Arrays an verschiedenen Speicherorten befinden - als gleich gelten arbeite für deinen Frequenzcode.

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

}

Hoffentlich hilft das

3
Chris

Nicht sicher, warum Sie ein Double in Ihrer Map benötigen. In Bezug auf das, was Sie versuchen, haben Sie ein int [] und möchten nur wissen, wie oft jede Sequenz auftritt? Warum sollte dies überhaupt ein Double erfordern?

Was ich tun würde, ist, einen Wrapper für das int-Array mit den richtigen .equals- und .hashCode-Methoden zu erstellen, um die Tatsache zu berücksichtigen, dass das int [] -Objekt selbst die Daten in seiner Version dieser Methoden nicht berücksichtigt.

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

}

Verwenden Sie dann das Multiset von Google Guava, das genau zum Zählen von Vorkommen gedacht ist, sofern der von Ihnen eingegebene Elementtyp über die richtigen .equals- und .hashCode-Methoden verfügt.

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

So ermitteln Sie die Anzahl für eine bestimmte Kombination:

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

Das hat wie ein Zauber gewirkt!

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);
2
Itamar Borges

pdate: Obwohl das Folgende kompiliert wird, wirft es zur Laufzeit ein ArrayStoreException. Schade. Ich lasse es für zukünftige Referenz bleiben.


Konvertieren eines int[] In einen Integer[]:

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

Ich muss zugeben, dass ich ein bisschen überrascht war, dass dies kompiliert wird, da System.arraycopy Niedrig ist und alles, aber es funktioniert. Zumindest in Java7.

Genauso einfach können Sie auch andersherum konvertieren.

1
Thomas Ahle