Ответ 1

Собственная 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[] обычно не является хорошим ключом карты. Но что касается конверсии, теперь у нас есть относительно чистый и собственный код.

Ответ 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);

Ответ 3

Предположительно, вы хотите, чтобы ключ к карте соответствовал значению элементов, а не идентификатору массива. В этом случае вам нужен какой-то объект, который определяет equals и hashCode, как и следовало ожидать. Проще всего преобразовать в List<Integer>, либо ArrayList, либо лучше использовать Arrays.asList. Лучше, чем вы можете ввести класс, который представляет данные (похожие на java.awt.Rectangle, но я рекомендую сделать переменные private final, а также final final).

Ответ 4

Я ошибся в предыдущем ответе. Правильное решение состоит в том, чтобы использовать этот класс в качестве ключа в карте, обертывающей фактический 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);
    }

Ответ 5

Использование регулярного цикла 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
}

Ответ 6

• Преобразование 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;
  }
  

• Преобразовать 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;
  }
  

Ответ 7

Вместо написания собственного кода вы можете использовать IntBuffer для обертывания существующего int [] без необходимости копировать данные в массив Integer

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

IntBuffer реализует сопоставимые данные, поэтому вы можете использовать код, который вы уже написали. Формально сопоставляет ключи сравнения так, что a.equals(b) используется, чтобы сказать, что два ключа равны, поэтому два IntBuffers с массивом 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);
    }

}

Надеюсь, что поможет

Ответ 8

Не уверен, зачем вам нужна двойная карта. С точки зрения того, что вы пытаетесь сделать, у вас есть int [], и вам просто нужно подсчитывать, сколько раз происходит каждая последовательность? Зачем это требовало двойного в любом случае?

Что бы я сделал, это создать оболочку для массива int с правильными методами .equals и .hashCode, чтобы учесть тот факт, что сам объект 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 }));

Ответ 9

Обновление: Несмотря на то, что ниже компилируется, он запускает ArrayStoreException во время выполнения. Очень жаль. Я позволю ему остаться в будущем.

Преобразование int[], в Integer[]:

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

Я должен признать, что я был немного удивлен, что это компилируется, если System.arraycopy является низким уровнем и всем, но это так. По крайней мере, в java7.

Вы можете конвертировать другой способ так же легко.

Ответ 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);

Ответ 11

вам не нужно. int[] является объектом и может использоваться как ключ внутри карты.

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

- правильное определение отображения частот.

Это было неправильно:-). Правильное решение также опубликовано: -).

Ответ 12

Просто используйте:

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