如何在 Java 中將 int[] 轉換為 Integer[]？

Question

我是 Java 新手，非常困惑。

我有一個長度為 4 int[]的大型數據集，我想計算 4 個整數的每個特定組合出現的次數。 這與計算文檔中的詞頻非常相似。

我想創建一個Map<int[], double>在迭代列表時將每個 int[] 映射到運行計數，但 Map 不采用原始類型。

所以我做了Map<Integer[], Double>

我的數據存儲為ArrayList<int[]>所以我的循環應該是這樣的

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

我不確定在注釋中需要什么代碼才能將int[]轉換為Integer[] 。 或者也許我從根本上對正確的方法感到困惑。

Answer 1

原生 Java 8（一行）

使用 Java 8， int[]可以輕松轉換為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() );

正如其他人所說， Integer[]通常不是一個好的映射鍵。 但就轉換而言，我們現在有一個相對干凈的原生代碼。

Answer 2

如果要將int[]轉換為Integer[] ，則在 JDK 中沒有自動執行此操作的方法。 但是，您可以執行以下操作：

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

如果您有權訪問Apache lang庫，則可以使用ArrayUtils.toObject(int[])方法，如下所示：

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

Answer 3

使用沒有外部庫的常規 for 循環：

將 int[] 轉換為 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[] 轉換為 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
}

Answer 4

將 int[] 轉換為 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]);

Answer 5

大概您希望映射的鍵匹配元素的值而不是數組的標識。 在這種情況下，您需要某種像您期望的那樣定義equals和hashCode的對象。 最簡單的方法是轉換為List<Integer> ，或者是ArrayList或者更好地使用Arrays.asList 。 比這更好的是，您可以引入一個表示數據的類（類似於java.awt.Rectangle但我建議將變量設為私有 final，類也是 final）。

Answer 6

1. 將 int[] 轉換為 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. 將 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; }

Answer 7

我在之前的回答中錯了。 正確的解決方案是使用此類作為包裝實際 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;
        }
    }

並像這樣更改您的代碼：

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

Answer 8

您可以使用 IntBuffer 包裝現有的 int[] 而不必編寫自己的代碼，而不必將數據復制到 Integer 數組中

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

IntBuffer 實現了可比較的，因此您可以使用您已經編寫的代碼。 正式映射比較鍵，這樣 a.equals(b) 用於表示兩個鍵相等，因此兩個具有數組 1,2,3 的 IntBuffers - 即使數組位於不同的內存位置 - 被稱為相等，因此將為您的頻率代碼工作。

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

}

希望有幫助

Answer 9

更新：雖然下面的編譯，它在運行時拋出一個ArrayStoreException 。 太糟糕了。 我會留着以備將來參考。

---

將int[]轉換為Integer[] ：

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

我必須承認我對這個編譯有點驚訝，因為System.arraycopy是低級的，但它確實如此。 至少在java7中。

您可以同樣輕松地轉換另一種方式。

Answer 10

不知道為什么你的地圖中需要一個 Double 。 就您要執行的操作而言，您有一個 int[] 並且您只想計算每個序列出現的次數？ 為什么這需要一個 Double 呢？

我要做的是使用適當的 .equals 和 .hashCode 方法為 int 數組創建一個包裝器，以說明 int[] 對象本身不考慮這些方法版本中的數據這一事實。

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

}

然后使用谷歌番石榴的多重集，這正是為了計數出現的目的，只要您放入其中的元素類型具有適當的 .equals 和 .hashCode 方法。

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

然后，要獲取任何特定組合的計數：

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

Answer 11

這就像一個魅力！

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

Answer 12

你不需要。 int[]是一個對象，可以用作地圖中的鍵。

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

是頻率圖的正確定義。

這是錯誤的:-)。 也發布了正確的解決方案:-)。

Answer 13

只需使用：

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