Como converter int para Integer em Java?

Eu sou novo em Java e muito confuso.

Eu tenho um grande dataset de comprimento 4 int[] e quero contar o número de vezes que cada combinação particular de 4 inteiros ocorre. Isso é muito semelhante à contagem de frequências de palavras em um documento.

Eu quero criar um Map que mapeia cada int [] para uma contagem em execução à medida que a lista é iterada, mas o Map não toma tipos primitivos.

então fiz Map

meus dados são armazenados como um ArrayList então meu loop deve ser algo como

 ArrayList data = ... // load a dataset` Map frequencies = new HashMap(); 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); } } 

Eu não tenho certeza do código que eu preciso no comentário para fazer este trabalho para converter um int[] para um Integer[] . Ou talvez eu esteja fundamentalmente confuso sobre o jeito certo de fazer isso.

Java nativo 8 (uma linha)

Com o Java 8, int[] pode ser convertido para Integer[] facilmente:

 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 you = Arrays.stream( data ).boxed().collect( Collectors.toList() ); List like = IntStream.of( data ).boxed().collect( Collectors.toList() ); 

Como outros afirmaram, Integer[] geralmente não é uma boa chave de mapa. Mas no que diz respeito à conversão, agora temos um código relativamente limpo e nativo.

Se você quiser converter um int[] para um Integer[] , não há uma maneira automatizada de fazer isso no JDK. No entanto, você pode fazer algo assim:

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

Se você tiver access à biblioteca Apache lang , poderá usar o ArrayUtils.toObject(int[]) desta forma:

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

Provavelmente você deseja que a chave do mapa corresponda ao valor dos elementos, em vez da identidade da matriz. Nesse caso, você quer algum tipo de object que defina equals e hashCode como você esperaria. O mais fácil é converter para um List , um ArrayList ou melhor usar Arrays.asList . Melhor que isso, você pode introduzir uma class que represente os dados (semelhante a java.awt.Rectangle mas eu recomendo tornar as variables ​​private final e a class final também).

Eu estava errado em uma resposta anterior. A solução adequada é usar essa class como uma chave no mapa que envolve o int [] real.

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

e mude seu código assim:

  Map freqs = new HashMap(); for (int[] data : datas) { IntArrayWrapper wrapper = new IntArrayWrapper(data); if ( freqs.containsKey(wrapper)) { freqs.put(wrapper, freqs.get(wrapper) + p); } freqs.put(wrapper, p); } 

Usando loop for regular sem bibliotecas externas:

Converter int [] em inteiro []:

 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 } 

Converter Integer [] para 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 } 
  1. Converte int [] para 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. Converte Integer [] para 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; } 

Em vez de escrever seu próprio código, você pode usar um IntBuffer para envolver o int [] existente sem precisar copiar os dados em um array Integer

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

IntBuffer implementa comparáveis, assim você é capaz de usar o código que você já escreveu. Formalmente, os mapas comparam chaves que e.equals (b) é usado para dizer que duas chaves são iguais, então dois IntBuffers com array 1,2,3 – mesmo se as matrizes estiverem em locais de memory diferentes – são iguais e assim trabalhe para o seu código de frequência.

 ArrayList data = ... // load a dataset` Map frequencies = new HashMap(); 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); } 

}

espero que ajude

Não sei por que você precisa de um Double no seu mapa. Em termos do que você está tentando fazer, você tem um int [] e você só quer contar quantas vezes cada seqüência ocorre? Por que isso exigiria um Double de qualquer maneira?

O que eu faria seria criar um wrapper para a matriz int com os methods .equals e .hashCode apropriados para considerar o fato de que o object int [] em si não considera os dados em sua versão desses methods.

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

E então use o multiset do google goava, que é exatamente para o propósito de contar ocorrências, contanto que o tipo de elemento que você colocou nele tenha os methods .equals e .hashCode apropriados.

 List list = ...; HashMultiset multiset = HashMultiset.create(); for (int values[] : list) { multiset.add(new IntArrayWrapper(values)); } 

Então, para obter a contagem de qualquer combinação específica:

 int cnt = multiset.count(new IntArrayWrapper(new int[] { 0, 1, 2, 3 })); 

Update: Embora o abaixo compila, ele lança um ArrayStoreException em tempo de execução. Que pena. Eu vou deixar ficar para referência futura.


Convertendo um int[] para um Integer[] :

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

Eu devo admitir que fiquei um pouco surpreso que isso compila, dado que System.arraycopy é de baixo nível e tudo mais, mas funciona. Pelo menos em java7.

Você pode converter a outra maneira com a mesma facilidade.

Isso funcionou como um encanto!

 int[] mInt = new int[10]; Integer[] mInteger = new Integer[mInt.length]; List wrapper = new AbstractList() { @Override public int size() { return mInt.length; } @Override public Integer get(int i) { return mInt[i]; } }; wrapper.toArray(mInteger); 

você não precisa. int[] é um object e pode ser usado como uma chave dentro de um mapa.

 Map frequencies = new HashMap(); 

é a definição adequada do mapa de frequências.

Isso estava errado :-). A solução adequada é postada também :-).

Simplesmente use:

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