जावा में int [] को Integer [] में कैसे कन्वर्ट करें?

Question

मैं जावा के लिए नया हूँ और बहुत उलझन में हूँ।

मेरे पास लंबाई 4 का एक बड़ा डेटासेट है int[]और मैं चाहता हूं कि प्रत्येक बार 4 पूर्णांकों का एक विशेष संयोजन हो। यह एक दस्तावेज़ में शब्द आवृत्तियों को गिनने के समान है।

मैं चाहता हूं Map<int[], double>कि प्रत्येक चल रहे नक्शे में [] एक चल रही गिनती के रूप में सूची के रूप में सूची से अधिक है, लेकिन नक्शा आदिम प्रकार नहीं लेता है।

तो मैंने बनाया 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[]। या शायद मैं ऐसा करने के सही तरीके के बारे में मौलिक रूप से भ्रमित हूं।

Comments

"मैं एक मानचित्र बनाना चाहता हूं <int [], डबल> ... लेकिन मानचित्र आदिम प्रकार नहीं लेता है।" जैसा कि नीचे दिए गए पदों में से एक है, int [] एक आदिम प्रकार नहीं है, इसलिए यह वास्तविक समस्या नहीं है। वास्तविक समस्या यह है कि एलीयर तत्वों की तुलना करने के लिए असमान () को ओवरराइड नहीं करते हैं। उस अर्थ में इंटेगर को परिवर्तित करना [] (जैसा कि आपका शीर्षक कहता है) आपकी मदद नहीं करता है। ऊपर दिए गए कोड में, आवृत्तियों ।containsKey (q) अभी भी आपकी अपेक्षा के अनुरूप काम नहीं करेगी क्योंकि यह तुलना करने के लिए। असमान () का उपयोग करता है। वास्तविक समाधान यहां सरणियों का उपयोग नहीं करना है।

— newacct

एक और जवाब के साथ स्पैम नहीं करना चाहते हैं, लेकिन ध्यान देने योग्य है कि अब इस बारे में एक प्रलेखन उदाहरण है।

— मुरैनिक

Answer 1

देशी जावा 8 (एक पंक्ति)

जावा 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[]आमतौर पर एक अच्छा नक्शा कुंजी नहीं है। लेकिन जहां तक ​​रूपांतरण होता है, हमारे पास अब अपेक्षाकृत स्वच्छ और देशी कोड है।

Comments

इस बीच यह सही तरीका है। यदि आपको एक सूची के रूप में इंटेगर-एरे की आवश्यकता है, तो आप लिख सकते हैं:List<Integer> list = IntStream.of(q).boxed().collect(Collectors.toList());

— aw-think

Integer[]मैं वास्तव में वाक्य रचना का उपयोग करके सुझाव देने के लिए परिवर्तित करूंगा: Integer[] boxed = IntStream.of(unboxed).boxed().toArray();@NwDx

— YoYo

@JoD। हां, वह काम करता है। लेकिन फिर भी IntStream.ofकॉल करता Arrays.streamहै। मुझे लगता है कि यह व्यक्तिगत प्राथमिकता के लिए नीचे आता है - मैं एक ओवरराइड फ़ंक्शन को प्राथमिकता देता हूं, कुछ अधिक स्पष्ट वर्ग का उपयोग करते हुए प्यार करते हैं।

— विन्नी

यह एक पागल लेकिन महान समाधान है! धन्यवाद!

— रुगल

@VijayChavda नया संदर्भ , जिसे विधि संदर्भ कहा जाता है , को 2014 में Java 8 के साथ लैम्ब्डा ( JSR 335 पार्ट C ) के हिस्से के रूप में पेश किया गया था । इसका मतलब है the "new" method (constructor) of the Integer[] class।

— शीप

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

यदि आपके पास अपाचे लैंग लाइब्रेरी तक पहुंच है , तो आप ArrayUtils.toObject(int[])इस तरह से विधि का उपयोग कर सकते हैं :

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

Comments

पाश के लिए एक बुरा तरीका है।

— जेम्स बेवर

यह प्रत्येक के लिए पूरी तरह से सामान्य है ... मैं बुरा हिस्सा नहीं देखता हूं।

— दहका

@Dahaka, valueअनुक्रमणिका चर के होते हुए , पुनरावृति का उपयोग करने में घबराहट iहोती है।

— lcn

@, मैं देख सकता हूं कि कुछ लोग उस शैली को क्यों पसंद नहीं करेंगे, लेकिन क्या यह इतना अवांछनीय है कि यह गंदा हो?

— एडी

@icn, @ डाहाका: नास्टनेस यह है कि जब से आप पहले से ही एक इन्क्रीमेंटिंग इंडेक्स वैरिएबल का उपयोग कर रहे हैं, तो प्रत्येक के लिए, एक का उपयोग करने की कोई आवश्यकता नहीं है; यद्यपि यह कोड में सुंदर और सरल दिखता है, पर्दे के पीछे जो अनावश्यक ओवरहेड को शामिल करता है। एक पारंपरिक for (int i...)लूप यहां अधिक कुशल होगा।

— डाइसकॉग

Answer 3

संभवत: आप सरणी की पहचान के बजाय तत्वों के मूल्य पर मिलान करने के लिए मानचित्र की कुंजी चाहते हैं। उस मामले में आप किसी तरह की वस्तु चाहते हैं जो परिभाषित करे equalsऔर hashCodeजैसा कि आप उम्मीद करेंगे। सबसे आसान List<Integer>या तो एक ArrayListया बेहतर उपयोग में बदलना है Arrays.asList। इससे बेहतर है कि आप एक वर्ग पेश कर सकते हैं जो डेटा का प्रतिनिधित्व करता है (इसी तरह java.awt.Rectangleलेकिन मैं चर को अंतिम रूप देने की सिफारिश करता हूं, और वर्ग का अंतिम भी)।

Comments

ओह, यहाँ एक सरणी रूपांतरण प्रश्न है, बस दूसरे तरीके के आसपास: stackoverflow.com/questions/564392/…

— टॉम हॉल्टिन -

Answer 4

बाहरी पुस्तकालयों के बिना नियमित रूप से लूप का उपयोग करना:

कन्वर्ट इंट [] को इंटेगर []:

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[] 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 5

मैं पिछले उत्तर में गलत था। इस समाधान का उपयोग वास्तविक इंट [] को लपेटने वाले नक्शे में एक कुंजी के रूप में इस वर्ग का उपयोग करना है।

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

Comments

मैं कक्षा को अंतिम और निजी क्षेत्र को अंतिम बनाता हूँ। कंस्ट्रक्टर (क्लोन) में सरणी की एक रक्षात्मक प्रतिलिपि बनाएं। और सिर्फ Arrays.equals से मान लौटाएं बजाय बयान कि अजीब है। अच्छा होगा।

— टॉम हॉल्टिन -

ओह और null डेटा के लिए कंस्ट्रक्टर (शायद कॉलिंग क्लोन) से एक एनपीई फेंक दें, और हैशकोड में चेक न करें।

— टॉम हॉल्टिन -

यह सही है .. लेकिन समान, हैशकोड के लिए कोड IDEA :-) द्वारा निर्मित है। यह सही ढंग से काम करता है।

— मिहाई टॉडर

Answer 6

1. पूर्णांक में परिवर्तित करें []

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

Comments

ऑटोबॉक्सिंग के कारण यह गलत है। 1 उदाहरण में आप बस कर सकते हैं newArray[i] = ids[i];और 2 में एक newArray[i] = WrapperArray[i]:)

— ईल ली

Answer 7

अपना स्वयं का कोड लिखने के बजाय, आप एक IntBuffer का उपयोग करके मौजूदा int [] को एक Intex सरणी में डेटा की प्रतिलिपि बनाए बिना कर सकते हैं।

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

IntBuffer तुलनात्मक लागू करता है ताकि आप पहले से लिखे गए कोड का उपयोग कर सकें। औपचारिक रूप से नक्शे कुंजियों की तुलना करते हैं जैसे कि a .equals (b) का उपयोग दो कुंजियों को बराबर कहने के लिए किया जाता है, इसलिए 1,2,3 सरणी वाले दो IntBuffers - भले ही सरणियाँ अलग-अलग मेमोरी लोकेशन में हों - समान और ऐसा ही कहा जाएगा अपने आवृत्ति कोड के लिए काम करते हैं।

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 सरणी के लिए एक आवरण बनाया जाए। andhashCode तरीकों को इस तथ्य के लिए ध्यान में रखें कि 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 अमरूद की मल्टीसेट का उपयोग करें, जो कि वास्तव में घटित होने वाली गणनाओं के उद्देश्य से है, जब तक कि आपके द्वारा इसमें डाले गए तत्व प्रकार में उचित। असमान और .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 }));

Comments

यह IntArrayWrapperनिश्चित int[]रूप से हैश कुंजी के रूप में एक सरणी का उपयोग करने के लिए सही दृष्टिकोण है , लेकिन यह उल्लेख किया जाना चाहिए कि इस तरह का एक प्रकार पहले से ही मौजूद है ... आप इसे सरणी को लपेटने के लिए उपयोग कर सकते हैं और न केवल यह है hashCodeऔर equals, यह तुलनीय भी है।

— होल्गर

Answer 9

अद्यतन: हालांकि नीचे संकलन, यह ArrayStoreExceptionरनटाइम पर फेंकता है। बहुत बुरा। मैं इसे भविष्य में संदर्भ के लिए रहने दूंगा।

---

एक में परिवर्तित int[]करने के लिए Integer[]:

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

मुझे स्वीकार करना चाहिए कि मैं थोड़ा हैरान था कि यह संकलन, System.arraycopyलोवेल और सब कुछ दिया जा रहा है, लेकिन यह करता है। कम से कम जावा 7 में।

आप दूसरे तरीके को भी आसानी से बदल सकते हैं।

Comments

जब यह काम नहीं करता है, तो मुझे इस जवाब को "संदर्भ के लिए" रखने में बहुत महत्व नहीं है। System.arraycopy () के लिए प्रलेखन यह भी बताता है कि यह इस उद्देश्य के लिए काम नहीं करेगा।

— ज़ीरो 3

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

Comments

हाय तुनकी, क्या आप कृपया मेरे लिए उपरोक्त कोड की खोज कर सकते हैं? जब मैं डीबगर के माध्यम से चलाता हूं, तो मैं देखता हूं कि आकार और विधि को स्वचालित रूप से कॉल किया जाता है, अर्थात बाहर उन्हें विस्फोटक रूप से कहा जाता है !! ऐसा कैसे?! क्या आप समझा सकते हैं?

— 5

Answer 11

कन्वर्ट इंट [] को इंटेगर []:

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

Answer 12

आपको जरूरत नहीं है int[]एक वस्तु है और एक नक्शे के अंदर एक कुंजी के रूप में इस्तेमाल किया जा सकता है।

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

आवृत्तियों के नक्शे की उचित परिभाषा है।

यह गलत था :-)। उचित समाधान भी :-) पोस्ट किया गया है।

Comments

आपके उत्तर के लिए बहुत धन्यवाद, मैंने पहली बार यह कोशिश की और यह ठीक संकलित है, लेकिन ऐसा लगता है frequencies.containsKey(q)कि हमेशा गलत होगा भले putही मैंने एक ही सरणी दो बार की हो - क्या यहां कुछ गड़बड़ है जिसमें जावा की समानता के साथ समानता की परिभाषा शामिल है?]

(संकेत, (नया int [0])। बराबर (नया int [0]) गलत है; (नया ArrayList <Integer> ())। बराबर (नया ArrayList <String> ()) सत्य है

— Tom Hawtin - dealline

बुरा विचार, क्योंकि सरणी तुलना संदर्भ समानता पर आधारित है । इसीलिए Arrays.equals () मौजूद है ...

— sleske

अरे नहीं :-)। मुझे उम्मीद थी कि मैं सही था। घोषणा सही है लेकिन संदर्भ समानता की बात के कारण शब्दार्थ गलत है।

— मिहाई टोडर

Answer 13

बस उपयोग करें:

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