Ik ben nieuw op Java en erg in de war.

Ik heb een grote dataset met een lengte van 4 int[]en ik wil het aantal keren tellen
dat elke bepaalde combinatie van 4 gehele getallen voorkomt. Dit lijkt erg op het tellen van woordfrequenties in een document.

Ik wil een Map<int[], double>maken die elke int[] toewijst aan een lopende telling terwijl de lijst wordt herhaald, maar Map accepteert geen primitieve typen.

dus maakte ik Map<Integer[], Double>

mijn gegevens worden opgeslagen als een ArrayList<int[]>dus mijn lus zou zoiets moeten zijn als

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

Ik weet niet zeker welke code ik nodig heb bij de opmerking om dit te laten werken om een int[]naar een Integer[]te converteren. Of misschien ben ik fundamenteel in de war over de juiste manier om dit te doen.

Antwoord 1, autoriteit 100%

Native Java 8 (één regel)

Met Java 8 kan int[]eenvoudig worden geconverteerd naar Integer[]:

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

Zoals anderen al zeiden, is Integer[]meestal geen goede kaartsleutel.
Maar wat conversie betreft, hebben we nu een relatief schone en native code.

Antwoord 2, autoriteit 37%

Als je een int[]naar een Integer[]wilt converteren, is er geen geautomatiseerde manier om dit in de JDK te doen. U kunt echter zoiets als dit doen:

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

Als u toegang heeft tot de Apache lang-bibliotheek, kunt u de ArrayUtils.toObject(int[])methode als volgt:

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

Antwoord 3, autoriteit 4%

Gewone for-loop gebruiken zonder externe bibliotheken:

Converteer int[] naar 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
}

Integer[] converteren naar 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
}

Antwoord 4, autoriteit 4%

Converteer int[] naar Integer[]:

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

Antwoord 5, autoriteit 4%

Vermoedelijk wilt u dat de sleutel van de kaart overeenkomt met de waarde van de elementen in plaats van de identiteit van de array. In dat geval wil je een soort object dat equalsen hashCodedefinieert zoals je zou verwachten. Het gemakkelijkst is om te converteren naar een List<Integer>, ofwel een ArrayListof beter Arrays.asListte gebruiken. Beter dan dat kun je een klasse introduceren die de gegevens vertegenwoordigt (vergelijkbaar met java.awt.Rectanglemaar ik raad aan om de variabelen privé definitief te maken, en de klasse ook definitief).

Antwoord 6, autoriteit 3%

1. Converteer int[] naar 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. Geheel getal[] converteren naar 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;
   }
   

Antwoord 7, autoriteit 3%

Ik had het mis in een eerder antwoord. De juiste oplossing is om deze klasse te gebruiken als een sleutel in de kaart die de eigenlijke int[] omhult.

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

en verander je code als volgt:

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

Antwoord 8, autoriteit 2%

In plaats van uw eigen code te schrijven, kunt u een IntBuffer gebruiken om de bestaande int[] in te pakken zonder de gegevens naar een geheel getal te hoeven kopiëren

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

Intbuffer implementeert vergelijkbaar, zodat u de code kunt gebruiken die u al hebt geschreven. Formeel Kaarten Vergelijk de toetsen zodanig dat A.-equals (b) wordt gebruikt om te zeggen dat twee sleutels gelijk zijn, dus twee intbuffers met array 1,2,3 – zelfs als de arrays op verschillende geheugenlocaties zijn – ze zijn gezegd dat ze gelijk zijn Werk voor uw frequentiecode.

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

}

Ik hoop dat dat helpt

9

Niet zeker waarom u een dubbele in uw kaart nodig hebt. In termen van wat je probeert te doen, heb je een int [] en wil je gewoon tellingen van hoe vaak elke reeks optreedt? Waarom zou dit toch een dubbel nodig hebben?

Wat ik zou doen is een wikkel maken voor de INT-array met een juiste .equals en .hashcode-methoden om rekening te houden met het feit dat Int [] -object zelf de gegevens in de versie van deze methoden niet overweegt.

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

Gebruik vervolgens de multiset van Google Guava, die precies bedoeld is om voorkomens te tellen, zolang het elementtype dat u erin plaatst de juiste .equals- en .hashCode-methoden heeft.

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

Vervolgens, om de telling voor een bepaalde combinatie te krijgen:

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

Antwoord 10

Update:hoewel het onderstaande compileert, genereert het tijdens runtime een ArrayStoreException. Jammer. Ik laat het staan voor toekomstig gebruik.

Een int[]converteren naar een Integer[]:

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

Ik moet toegeven dat ik een beetje verbaasd was dat dit compileert, aangezien System.arraycopylowlevel is en zo, maar dat doet het wel. In java7 tenminste.

Je kunt de andere kant net zo gemakkelijk converteren.

Antwoord 11

Dit werkte als een tierelier!

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

12

Gebruik gewoon:

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