Saya baru ke Jawa dan sangat bingung.

Saya memiliki dataset besar dengan panjang 4 int[]dan saya ingin menghitung berapa kali setiap kombinasi 4 bilangan bulat terjadi. Ini sangat mirip dengan menghitung frekuensi kata dalam dokumen.

Saya ingin membuat Map<int[], double>yang memetakan setiap int [] ke jumlah yang sedang berjalan karena daftar diulangi, tetapi Peta tidak menggunakan tipe primitif.

jadi saya membuat Map<Integer[], Double>

data saya disimpan ArrayList<int[]>jadi loop saya harus seperti ini

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

Saya tidak yakin kode apa yang saya butuhkan di komentar untuk membuat pekerjaan ini untuk mengkonversi int[]menjadi Integer[]. Atau mungkin saya pada dasarnya bingung tentang cara yang tepat untuk melakukan ini.

Native Java 8 (satu baris)

Dengan Java 8, int[]dapat dikonversi dengan Integer[]mudah:

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

Seperti yang dinyatakan orang lain, Integer[]biasanya bukan kunci peta yang baik. Namun sejauh konversi berjalan, kami sekarang memiliki kode asli dan relatif bersih.

Jika Anda ingin mengonversikan int[]ke Integer[], tidak ada cara otomatis untuk melakukannya di JDK. Namun, Anda dapat melakukan sesuatu seperti ini:

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

Jika Anda memiliki akses ke perpustakaan lang Apache , maka Anda dapat menggunakan ArrayUtils.toObject(int[])metode seperti ini:

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

Agaknya Anda ingin kunci peta cocok dengan nilai elemen, bukan identitas array. Dalam hal ini Anda menginginkan semacam objek yang mendefinisikan equalsdan hashCodeseperti yang Anda harapkan. Cara termudah adalah mengonversi menjadi List<Integer>, baik ArrayListpenggunaan atau lebih baik Arrays.asList. Lebih baik dari itu Anda bisa memperkenalkan kelas yang mewakili data (mirip dengan java.awt.Rectangletetapi saya sarankan membuat variabel pribadi akhir, dan kelas juga final).

Menggunakan for-loop reguler tanpa perpustakaan eksternal:

Konversi int [] ke 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
}

Konversikan Integer [] ke 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
}

Saya salah dalam jawaban sebelumnya. Solusi yang tepat adalah dengan menggunakan kelas ini sebagai kunci dalam peta yang membungkus int aktual [].

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

dan ubah kode Anda seperti ini:

   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. Konversi int [] ke 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. Konversi Integer [] ke 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;
   }

Daripada menulis kode Anda sendiri, Anda dapat menggunakan IntBuffer untuk membungkus int [] yang ada tanpa harus menyalin data ke dalam array Integer

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

IntBuffer mengimplementasikan sebanding sehingga Anda dapat menggunakan kode yang sudah Anda tulis. Peta secara formal membandingkan kunci sehingga a.equals (b) digunakan untuk mengatakan dua kunci sama, sehingga dua IntBuffers dengan array 1,2,3 - bahkan jika array berada di lokasi memori yang berbeda - dikatakan sama dan akan bekerja untuk kode frekuensi Anda.

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

}

Semoga itu bisa membantu

Tidak yakin mengapa Anda membutuhkan Dobel di peta Anda. Dalam hal apa yang Anda coba lakukan, Anda memiliki int [] dan Anda hanya ingin menghitung berapa kali setiap urutan terjadi? Mengapa ini membutuhkan Double?

Apa yang akan saya lakukan adalah membuat pembungkus untuk array int dengan .equals dan .hashCode metode yang tepat untuk menjelaskan fakta bahwa objek int [] itu sendiri tidak mempertimbangkan data dalam versi metode ini.

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

}

Dan kemudian gunakan multiset google jambu, yang dimaksudkan tepat untuk tujuan penghitungan kejadian, selama jenis elemen yang Anda masukkan di dalamnya memiliki metode .eash dan .hashCode yang tepat.

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

Lalu, untuk mendapatkan hitungan untuk kombinasi tertentu:

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

Pembaruan: Meskipun kompilasi di bawah ini, ia melempar ArrayStoreExceptionpada saat runtime. Sangat buruk. Saya akan membiarkannya untuk referensi di masa mendatang.

Mengubah sebuah int[], menjadi Integer[]:

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

Saya harus mengakui bahwa saya sedikit terkejut bahwa ini dikompilasi, diberikan System.arraycopy tingkat rendah dan segalanya, tetapi ternyata demikian. Setidaknya dalam java7.

Anda dapat mengonversi cara lain dengan mudah.

Ini bekerja seperti pesona!

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

Konversi int [] ke 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]);

kamu tidak perlu int[]adalah objek dan dapat digunakan sebagai kunci di dalam peta.

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

adalah definisi yang tepat dari peta frekuensi.

Ini salah :-). Solusi yang tepat diposting juga :-).

Cukup gunakan:

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