我是Java新手，非常困惑。

我有一个长度为4的大型数据集，int[]我想计算4个整数的每个特定组合出现的次数。这与计算文档中的单词频率非常相似。

我想创建一个Map<int[], double>将每个int []映射到正在运行的计数的列表，但是列表不使用原始类型。

所以我做了 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[]。也许我从根本上对正确的方法感到困惑。

本机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[]通常不是一个好的地图关键字。但是就转换而言，我们现在有了一个相对干净的本机代码。

如果要将转换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);

大概您希望映射的键匹配元素的值而不是数组的标识。在这种情况下，您需要某种可以定义equals并hashCode符合您期望的对象。最简单的就是转换为List<Integer>，无论是一个ArrayList或更好地利用Arrays.asList。更好的是，您可以引入一个表示数据的类（类似于，java.awt.Rectangle但我建议将变量设置为final final，并将类也设置为final）。

使用不带外部库的常规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
}

我在先前的回答中错了。正确的解决方案是使用此类作为包装实际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);
    }

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

无需编写自己的代码，您可以使用IntBuffer来包装现有的int []，而不必将数据复制到Integer数组中

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

IntBuffer实现了可比的功能，因此您可以使用已经编写的代码。正式地映射比较键，以便使用a.equals（b）表示两个键相等，因此，即使数组位于不同的内存位置，两个具有数组1,2,3的IntBuffer也被称为相等，因此将为您的频率代码工作。

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

}

希望能有所帮助

不确定为什么在地图中需要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;
    }

}

然后使用google guava的多重集（multiset），其确切目的是为了计算出现次数，只要您放入其中的元素类型具有适当的.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 }));

更新：尽管下面的代码可以编译，但ArrayStoreException在运行时会引发A。太糟糕了。我将其留作以后参考。

将转换int[]为Integer[]：

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

我必须承认，考虑到System.arraycopy它是底层的，一切都会编译，对此我感到有些惊讶，但是确实如此。至少在java7中。

您可以轻松地进行其他转换。

这就像一个魅力！

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

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

你不需要 int[]是一个对象，可以用作地图内的键。

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

是频率图的正确定义。

这是错误的:-)。正确的解决方案也发布了:-)。

只需使用：

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