Fatal编程技术网
  • java/
  • 如何在Java中将int[]转换为整数[]？

如何在Java中将int[]转换为整数[]？

java arrays generics collections

如何在Java中将int[]转换为整数[]？,java,arrays,generics,collections,Java,Arrays,Generics,Collections,我是Java新手，非常困惑 我有一个长度为4的大型数据集int[]，我想计算次数 4个整数的每个特定组合都会出现。这与计算文档中的词频非常相似 我想创建一个Map，当列表被迭代时，它将每个int[]映射到一个正在运行的计数，但Map不接受基元类型 所以我制作了Map 我的数据存储为ArrayList，因此我的循环应该类似 ArrayList<int[]> data = ... // load a dataset` Map<Integer[], Double> frequ

我是Java新手，非常困惑

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

我想创建一个
Map
，当列表被迭代时，它将每个int[]映射到一个正在运行的计数，但Map不接受基元类型

所以我制作了
Map

我的数据存储为
ArrayList
，因此我的循环应该类似

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

ArrayList数据=…//加载数据集`
映射频率=新HashMap（）；
for（int[]q:data）{
//**做些事情将q从int[]转换为Integer[]，这样我就可以把它放在地图上
中频（频率：千分之一）{
放（q，tfs，get（q）+p）；
}否则{
频率。put（q，p）；
}
}
我不确定我在评论中需要什么代码来将
int[]
转换为
Integer[]
。或者我根本不知道该怎么做。

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

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

Map frequencies=newhashmap（）；
是频率图的正确定义

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

如果您想将
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);
}

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

   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);
    }
如果您有权访问库，则可以使用以下方法：

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

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

   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);
    }
您可能希望映射的键与元素的值匹配，而不是与数组的标识匹配。在这种情况下，您需要一种对象，它可以像您所期望的那样定义
等于
和
hashCode
。最简单的方法是转换为
列表
，或者转换为
数组列表
，或者更好地使用
数组。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;
        }
    }


并按如下方式更改代码：


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



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



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



Map freqs=newhashmap（）；
对于（int[]数据：数据）{
IntArrayWrapper包装器=新的IntArrayWrapper（数据）；
if（频率容器（包装器））{
freqs.put（wrapper，freqs.get（wrapper）+p）；
}
频率放置（包装器，p）；
}

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


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


IntBuffer实现了Compariable，因此您可以使用已经编写的代码。正式映射比较键，这样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);
    }



ArrayList数据=…//加载数据集`
映射频率=新HashMap（）；
for（int[]a:数据）{
IntBuffer q=IntBuffer.wrap（a）；
中频（频率：千分之一）{
放（q，tfs，get（q）+p）；
}否则{
频率。put（q，p）；
}


}


希望这有助于更新：
尽管下面的代码经过编译，但在运行时会抛出一个
ArrayStoreException
。太糟糕了。我会留着作为将来的参考



将
int[]
转换为
整数[]
：


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


我必须承认，考虑到
System.arraycopy
是低级别的，而且什么都有，我对它的编译感到有点惊讶，但它确实做到了。至少在java7中是这样


你也可以很容易地用另一种方式转换。
不知道为什么你的地图上需要一个双人。就您试图做的事情而言，您有一个int[]，您只需要计算每个序列发生的次数？无论如何，为什么这需要一个双人床呢


我将用一个适当的.AdALS和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;
    }

}



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


然后使用google guava的multiset，这完全是为了计算发生率，只要您在其中输入的元素类型具有适当的.equals和.hashCode方法


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

}



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


使用不带外部库的常规for循环：

将int[]转换为整数[]：


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[] 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
}



    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[]primitiveArray={1,2,3,4,5}；
Integer[]objectArray=新整数[primitiveArray.length]；
对于（int-ctr=0；ctr

将整数[]转换为整数[]：


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[] 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
}



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



Integer[]objectArray={1,2,3,4,5}；
int[]primitiveArray=new int[objectArray.length]；
对于（int-ctr=0；ctr
Native 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() );



int[]数据={1,2,3,4,5,6,7,8,9,10}；
//装箱数组
整数[]what=Arrays.stream（data.boxed（）.toArray（整数[]::new）；
整数[]ever=IntStream.of（data）.boxed（）.toArray（整数[]::new）；
//装箱单
List you=Arrays.stream（data.boxed（）.collect（Collectors.toList（））；
List like=IntStream.of（data.boxed（）.collect（Collectors.toList（））；


正如其他人所说，
Integer[]
通常不是一个好的映射键。
但就转换而言，我们现在有了一个相对干净的本地代码


  • 将int[]转换为整数[]
    

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

    

    public静态整数[]到convertineger（int[]id）{
整数[]新数组=新整数[ids.length]；
for（int i=0；i