Native Java 8 (one line)

Question

我的数据集长4:<代码>int[,而且我想计算每组4个例的合并数。这与在一份文件中计算字数非常相似。

我想创设一个<代码>Map<int[], Double>,其中每一条都以滚动数字标示,因为清单已经更新,但地图确实没有采用原始类型。

因此,我作了<代码>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 (one line)

可通过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() );

As others stated, Integer[] is usually not a good map key. But as far as conversion goes, we now have a relatively clean and native code.

Answer 2

如果您想将<代码>int[]转换成Integer[],则在联合K中就没有自动转换。然而,你可以这样做:

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.tos.Object(int([])。类似方法:

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

Answer 3

<<>Convert int[] to 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 4

Using regular for-loop without external libraries:

<<>Convert int[] to 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

或许,你希望地图的关键能够与这些要素的价值相匹配,而不是组合的特性。在这种情况下,你希望能像你所期望的那样,确定<代码>等于<>/代码>和<代码>hashCode的某种物体。最好改为<代码>List<Integer>,要么改为ArrayList,要么更好使用Arrays.asList。更不用说,你可以引入一个数据表示的类别(类似于java.awt.Rectangle,但我建议使变数成为私人最终变量,而类别也是最后的)。

Answer 6

适当的解决办法是将这一类别作为总结实际内容的地图的关键。

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 7

Convert int[] to 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;
 }

Convert Integer[] to 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 8

您不必写自己的法典,就可使用IntBuffer来总结现有的斜体,而不必将数据复制成一个Integer阵列:

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

IntBuffer Implements comparable,因此,你能够使用你已经撰写的法典。形式上,地图比较了关键因素,即a. 当量(b)用于说两个钥匙是平等的,因此,2个印地标有1 2,3个阵列——即使阵列位于不同的记忆地点——据说是平等的,因此将努力制定你的频率标准。

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

就像一个harm!

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 10

虽然下文汇编了数据,但它在运行时间投下了<条码>。

更改<代码>int[]至Integer[]:

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

我必须承认我有点惊讶这个编译，考虑到System.arraycopy是低级别的一切，但它确实这样做。至少在Java 7中是这样的。

你们可以很容易地转换另一种方式。

Answer 11

我不敢肯定,为什么你们的地图上需要一刀切。就你试图做些什么而言,你有一席之地,而你只是想估计每轮发生多少次。为什么需要双向?

我将为中型阵列打一个包裹,其中要有适当的等同和......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;
    }

}

然后使用谷歌古瓦·的多采,这完全是为了计算事件的发生,只要你在其中提出的要素类型有适当的平衡和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 12

乱伦是一种原始现象。 Primitives可能不接受无效并具有违约价值。因此,要接受努尔语,你需要使用包裹类内格。

<><>>

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

Option 2: You can use any data structure that use wrapper class Integer

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

Native Java 8 (one line)

Using regular for-loop without external libraries:

友情链接