Я новичок в 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[]. Или, может быть, я в корне не понимаю, как сделать это правильно.

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

Если вы хотите преобразовать a int[]в a 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);

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

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

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

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

1. Конвертировать 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;
   }

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

Вместо того, чтобы писать свой собственный код, вы можете использовать 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);
    }

}

надеюсь, это поможет

Не уверен, почему вам нужен двойник на вашей карте. С точки зрения того, что вы пытаетесь сделать, у вас есть 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 }));

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

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

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

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

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

Это работает как шарм!

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

Преобразуйте int [] в 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]);

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

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

является правильным определением карты частот.

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

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

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