Java에서 int []를 Integer []로 변환하는 방법?

Java에서 int []를 Integer []로 변환하는 방법?

---

나는 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[]일반적으로 좋은 맵 키는 아닙니다. 그러나 변환이 진행되는 한, 우리는 이제 비교적 깨끗하고 원시적 인 코드를 가지고 있습니다.

---

당신이를 변환 할 경우 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);

---

아마도지도의 키가 배열의 정체성 대신 요소의 값과 일치하기를 원할 것입니다. 이 경우 원하는 대로 정의 equals하고 정의하는 객체가 필요합니다 hashCode. 가장 쉬운은로 변환하는 것입니다 List<Integer>어느 쪽, ArrayList또는 더 나은 사용 Arrays.asList. 그보다 데이터를 나타내는 클래스를 도입 할 수 있습니다 (유사 java.awt.Rectangle하지만 변수를 private final로 만들고 클래스를 final로 만드는 것이 좋습니다).

---

외부 라이브러리없이 일반 for-loop 사용 :

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
}

---

나는 이전 답변에서 틀렸다. 올바른 해결책은이 클래스를지도에서 실제 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 []를 정수 []로 변환

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

---

Rather than write your own code you can use an IntBuffer to wrap the existing int[] without having to copy the data into an Integer array

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

IntBuffer implements comparable so you are able to use the code you already have written. Formally maps compare keys such that a.equals(b) is used to say two keys are equal, so two IntBuffers with array 1,2,3 - even if the arrays are in different memory locations - are said to be equal and so will work for your frequency code.

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

}

Hope that helps

---

Not sure why you need a Double in your map. In terms of what you're trying to do, you have an int[] and you just want counts of how many times each sequence occurs? Why would this required a Double anyway?

What I would do is to create a wrapper for the int array with a proper .equals and .hashCode methods to account for the fact that int[] object itself doesn't consider the data in it's version of these 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;
    }

}

And then use google guava's multiset, which is meant exactly for the purpose of counting occurances, as long as the element type you put in it has proper .equals and .hashCode methods.

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

Then, to get the count for any particular combination:

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

---

This worked like a charm!

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

---

Update: Though the below compiles, it throws a ArrayStoreException at runtime. Too bad. I'll let it stay for future reference.

---

Converting an int[], to an Integer[]:

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

I must admit I was a bit surprised that this compiles, given System.arraycopy being lowlevel and everything, but it does. At least in java7.

You can convert the other way just as easily.

---

you don't need. int[] is an object and can be used as a key inside a map.

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

is the proper definition of the frequencies map.

This was wrong :-). The proper solution is posted too :-).

---

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

참고URL : https://stackoverflow.com/questions/880581/how-to-convert-int-to-integer-in-java