Как конвертировать int [] в Integer [] в Java?

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

родной 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

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

Преобразовать целое число [] в 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 4

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

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

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

2. Преобразовать целое число [] в 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 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);
    }

}

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

Answer 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, который предназначен именно для подсчета вхождений, при условии, что тип элемента, который вы в него вставили, имеет надлежащие методы .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

Это сработало как шарм!

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

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

---

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

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

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

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