如何在Java中将int[]转换为Integer[] ?

我刚接触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[]。或者我根本不知道正确的方法是什么。

251104 次浏览
小开

你不需要它。int[]是一个对象，可以用作映射中的键。

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

是频率映射的正确定义。

这是错误的:-)。正确的解决方案也贴出来了:-)。

小开

如果你想将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朗库，那么你可以像这样使用ArrayUtils.toObject(int[])方法:

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

假设您希望映射的键根据元素的值匹配，而不是数组的标识。在这种情况下，你需要某种类型的对象，如你所期望的那样定义equals和hashCode。最简单的是转换为List<Integer>，或者ArrayList，或者更好地使用Arrays.asList。更好的方法是引入一个表示数据的类(类似于java.awt.Rectangle，但我建议将变量设置为private final，类也设置为final)。

小开

正确的解决方案是使用这个类作为包装实际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);
}
小开

不用自己写代码，你可以使用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);
}
}
小开

尽管下面的代码进行了编译，但它在运行时抛出ArrayStoreException。

将int[]转换为Integer[]:

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

我必须承认，鉴于System.arraycopy是低级别的，我对这个编译有点惊讶，但它确实如此。至少在Java 7中是这样。

你可以用另一种方式转换。

小开

我不知道为什么你的地图上需要一个Double。就您正在尝试做的事情而言，您有一个int[]，您只想要每个序列出现的次数(?)。为什么这需要双份?

我将使用适当的.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;
}


}

然后使用谷歌番石榴的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 }));
小开

在没有外部库的情况下使用常规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
}
小开

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

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

这招真是妙不可言!

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是一个原语。原语不能接受空值，只能有默认值。因此，要接受Null，您需要使用包装器类Integer。

选项1:

int[] nos = { 1, 2, 3, 4, 5 };
Integer[] nosWrapped = Arrays.stream(nos)
.boxed()
.toArray(Integer[]::new);
nosWrapped[5] = null // can store null

<强>选项2: 可以使用任何使用包装器类Integer

的数据结构 
int[] nos = { 1, 2, 3, 4, 5 };
List<Integer> = Arrays.asList(nos)

提交答案