Native Java 8（一行）

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

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

正如其他人所说，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

据推测，您希望地图的键匹配元素的值而不是数组的标识。在这种情况下，您需要某种定义equals和hashCode的对象，如您所料。最简单的方法是转换为List<Integer>，ArrayList或更好地使用Arrays.asList。更好的是你可以引入一个代表数据的类（类似于java.awt.Rectangle，但我建议将变量设为private final，并将类设置为final）。

Answer 4

使用没有外部库的常规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 5

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

将int []转换为Integer []

WriteLine(ConsoleColor, ConsoleColor, String)

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

Answer 7

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

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 8

不确定为什么在地图中需要Double。就你要做的事情来说，你有一个int []而你只想要计算每个序列出现的次数？为什么这需要Double呢？

我要做的是使用正确的.equals和.hashCode方法为int数组创建一个包装器，以解释int []对象本身不考虑这些方法的版本中的数据这一事实。 / p>

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

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

这就像一个魅力！

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 11

将int []转换为Integer []：

struct SplashScreen: View {
    @State private var isActive = false
    let login = LoginScreen()
    let color = Color.init("black_1")

    var body: some View {
        NavigationView {
            VStack(alignment: .center) {
                Image("logo")
                NavigationLink(destination: login,
                               isActive: $isActive,
                               label: { EmptyView() })
            }
            .background(color)
            .onAppear(perform: {
                self.gotoLoginScreen(time: 2.5)
            })
        }
    }

    func gotoLoginScreen(time: Double) {
        DispatchQueue.main.asyncAfter(deadline: .now() + Double(time)) {
            self.isActive = true
        }
    }
}

Answer 12

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

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

是频率图的正确定义。

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

Answer 13

只需使用：

public static int[] intArrayToIntegerArray(Integer[] array)
    {
        int[] g = new int[array.length];
        for(int i = 0; i < array.length; i++){
            g[i] = array[i];
        }
        return g;
    }

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

13 个答案:

Native Java 8（一行）

使用没有外部库的常规for循环：