एक एग्रीलिस्ट को कैसे इंटिजर्स से आदिम इंट सरणी में कनवर्ट करना है?

Question

मैं कोड के निम्नलिखित टुकड़े के साथ इंटीग्रेट ऑब्जेक्ट्स वाले एक ArrayList को आदिम int [] में बदलने की कोशिश कर रहा हूं, लेकिन यह संकलन समय त्रुटि फेंक रहा है। क्या जावा में परिवर्तित करना संभव है?

List<Integer> x =  new ArrayList<Integer>();
int[] n = (int[])x.toArray(int[x.size()]);

Comments

नहीं एक सटीक उस सवाल का नकल (हालांकि नहीं बहुत दूर या तो)

— Jonik

हां, यह एक ArrayList है, "डुप्लिकेट" एक सामान्य सरणी के बारे में है।

— स्कॉट मैकइंटायर

यदि आपको आदिम List<Integer> x = new ArrayList<Integer>(); Integer[] n = x.toArray(new Integer[0]);

— चींटियों की

वस्तुओं की एक सरणी को उनके आदिम प्रकारों की एक सरणी

— cellepo

Answer 1

आप परिवर्तित कर सकते हैं, लेकिन मुझे नहीं लगता कि ऐसा कुछ भी है जो इसे स्वचालित रूप से करने के लिए बनाया गया है:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    for (int i=0; i < ret.length; i++)
    {
        ret[i] = integers.get(i).intValue();
    }
    return ret;
}

(ध्यान दें कि यह NullPointerException को फेंक देगा यदि या तो integersकोई तत्व इसके भीतर है या नहीं null।)

संपादित करें: टिप्पणियों के अनुसार, आप सूची के साथ खराब लागत से बचने के लिए सूची पुनरावृत्ति का उपयोग करना चाह सकते हैं LinkedList:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    Iterator<Integer> iterator = integers.iterator();
    for (int i = 0; i < ret.length; i++)
    {
        ret[i] = iterator.next().intValue();
    }
    return ret;
}

Comments

यह बेहतर हो सकता है कि सूची के इट्रेटर (प्रत्येक के लिए) का उपयोग करके इसे बेहतर बनाया जाए ताकि उन सूचियों पर प्रदर्शन हिट से बचा जा सके जिनकी पहुंच ओ (1) नहीं है।

— मैथ्यू विलिस

@ मैथ्यू: हाँ, संभवतः - एक विकल्प के रूप में देने के लिए संपादित करेंगे।

— जॉन स्कीट

आप इस तथ्य का भी उपयोग कर सकते हैं कि ArrayList इम्प्लीमेंट्स Iterable (कलेक्शन इनहेरिटेंस के माध्यम से) और करते हैं: for (int n: पूर्णांक) {ret [काउंटर ++] = n; } ... और प्रारंभिक काउंटर = 0 प्रारंभ करें;

— गार्डर

जावा 8 में अब बहुत आसान है:integers.stream().mapToInt(Integer::valueOf).toArray

— मनीष पटेल

Answer 2

यदि आप उपयोग कर रहे हैं जावा-8 ऐसा करने का एक और तरीका भी है।

int[] arr = list.stream().mapToInt(i -> i).toArray();

यह क्या करता है:

• Stream<Integer>सूची से प्राप्त करना
• IntStreamप्रत्येक तत्व को स्वयं (पहचान फ़ंक्शन) की मैपिंग द्वारा प्राप्त करना , intप्रत्येक Integerवस्तु द्वारा मूल्य पकड़ को अनबॉक्स करना (जावा 5 के बाद से स्वचालित रूप से किया जाता है)
• intफोन करके सरणी प्राप्त करनाtoArray

आप intValueविधि संदर्भ के माध्यम से भी स्पष्ट रूप से कॉल कर सकते हैं , अर्थात:

int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

यह भी उल्लेखनीय है कि आप ए NullPointerExceptionnull सूची में कोई संदर्भ होने पर आप । इसे इस तरह से स्ट्रीम पाइपलाइन में एक फ़िल्टरिंग स्थिति जोड़कर आसानी से बचा जा सकता है:

                       //.filter(Objects::nonNull) also works
int[] arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray();

उदाहरण:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
int[] arr = list.stream().mapToInt(i -> i).toArray(); //[1, 2, 3, 4]

list.set(1, null); //[1, null, 3, 4]
arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray(); //[1, 3, 4]

Comments

मैं देख रहा हूं कि इसका उपयोग doubleप्रकारों के लिए किया जा सकता है ; क्या floatप्रकार के लिए कोई समकक्ष नहीं है ?

— code_dredd

विस्तृत विवरण द्वारा जावा 8 का लाभ देखा।

— यूजीन

और यही कारण है कि जावा 8+ स्ट्रीम एपीआई सुंदर है।

— प्रणव ए।

Answer 3

Google अमरूद

Google अमरूद कॉल करके ऐसा करने का एक अच्छा तरीका प्रदान करता है Ints.toArray।

List<Integer> list = ...;
int[] values = Ints.toArray(list);

Comments

मुझे लगता है कि यह मेरे लिए जवाब होगा - मैं किसी भी दिन कॉपी-पेस्ट फ़ंक्शन पर एक पुस्तकालय ले जाऊंगा .. विशेष रूप से एक पुस्तकालय जो एक सभ्य आकार की परियोजना की संभावना पहले से ही उपयोग करता है। मुझे उम्मीद है कि इस उत्तर को भविष्य में अधिक वोट और दृश्यता मिलेगी।

— सीन कोनॉली

Answer 4

Apache Commons में एक ArrayUtils क्लास है, जिसमें toPrimitive () का तरीका है जो ठीक यही करता है।

import org.apache.commons.lang.ArrayUtils;
...
    List<Integer> list = new ArrayList<Integer>();
    list.add(new Integer(1));
    list.add(new Integer(2));
    int[] intArray = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));

हालांकि, जैसा कि जॉन ने दिखाया, बाहरी पुस्तकालयों का उपयोग करने के बजाय अपने आप से ऐसा करना बहुत आसान है।

Comments

ध्यान दें कि यह दृष्टिकोण अनुक्रम की दो पूर्ण प्रतियां बना देगा: एक पूर्णांक [] ऐरे द्वारा बनाया गया है, और एक इंट [] पुष्ट के अंदर बनाया गया है। जॉन से अन्य उत्तर केवल एक सरणी बनाता है और भरता है। यदि आपके पास बड़ी सूची है, तो कुछ पर विचार करना और प्रदर्शन महत्वपूर्ण है।

— पैराक्वाट

मैंने ArrayUtils बनाम शुद्ध जावा और छोटी सूचियों (<25 तत्वों) का उपयोग करके प्रदर्शन को मापा, शुद्ध जावा 100 गुना से अधिक तेज है। 3k तत्वों के लिए शुद्ध जावा अभी भी लगभग 2 गुना तेज है ... (ArrayList <Integer> -> int [])

— Oskar Lund

@ अपरकट और ऑस्कर लंड जो वास्तव में सही नहीं है। हां, प्रदान किया गया कोड दो सरणियों का निर्माण करेगा, लेकिन यह दृष्टिकोण नहीं करता है। इस कोड में समस्या तर्क के रूप में एक शून्य लंबाई सरणी का उपयोग है। ArrayList.toArray स्रोत कोड से पता चलता है कि अगर सामग्री फिट होगा, मूल सरणी इस्तेमाल किया जाएगा। मुझे लगता है कि एक निष्पक्ष तुलना में आप इस पद्धति को अधिक कुशल (यदि अधिक नहीं) और निश्चित रूप से बनाए रखने के लिए कम कोड पाएंगे।

— शॉन कॉनॉली

पुनश्च: एक अच्छा संबंधित पोस्ट

— शॉन कॉनॉली

Waht नए Integer का उद्देश्य है [0]?

— एडम ह्यूजेस

Answer 5

मेरा मानना ​​है कि सूची के इट्रेटर का उपयोग करना एक बेहतर विचार है, क्योंकि list.get(i)सूची के कार्यान्वयन के आधार पर खराब प्रदर्शन हो सकता है:

private int[] buildIntArray(List<Integer> integers) {
    int[] ints = new int[integers.size()];
    int i = 0;
    for (Integer n : integers) {
        ints[i++] = n;
    }
    return ints;
}

Answer 6

डॉलर का उपयोग करना काफी सरल होना चाहिए:

List<Integer> list = $(5).toList(); // the list 0, 1, 2, 3, 4  
int[] array = $($(list).toArray()).toIntArray();

मैं मध्यवर्ती toArray()कॉल को हटाने के लिए DSL में सुधार करने की योजना बना रहा हूं

Comments

अरे, मैं कहना चाहता था कि मैंने पहले डॉलर नहीं देखा था, लेकिन मैं निश्चित रूप से अपने अगले प्रोजेक्ट पर कोशिश कर रहा हूं। यह एक छोटी बात है, आप वहां जा रहे हैं, अच्छे काम को जारी रखें :)

— बार्टेंड वेंडेंड्रिएसेप 15'11

Answer 7

यह मेरे लिए अच्छा काम करता है :)

Https://www.techiedelight.com/convert-list-integer-array-int/ पर मिला

import java.util.Arrays;
import java.util.List;

class ListUtil
{
    // Program to convert list of integer to array of int in Java
    public static void main(String args[])
    {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        int[] primitive = list.stream()
                            .mapToInt(Integer::intValue)
                            .toArray();

        System.out.println(Arrays.toString(primitive));
    }
}

Answer 8

यह मुझे आश्चर्यचकित करता है कि हम जब भी पूरी तरह से अच्छी, अच्छी तरह से उपयोग की जाने वाली लाइब्रेरी जैसे कि अपाचे कॉमन्स को पहले से ही समस्या का समाधान करते हैं, तो एक-तरफा कस्टम तरीकों को प्रोत्साहित करते हैं। हालांकि समाधान तुच्छ है, अगर बेतुका नहीं है, तो दीर्घकालिक रखरखाव और पहुंच के कारण इस तरह के व्यवहार को प्रोत्साहित करना गैर-जिम्मेदाराना है।

बस अपाचे कॉमन्स के साथ जाओ

Comments

मैं पिछले टिप्पणीकार से सहमत हूं। न केवल आप अपाचे कॉमन्स में घसीटते हैं, बल्कि यह आसानी से एक बड़ी संख्या में सकर्मक निर्भरता में बदल जाता है, जिसमें घसीटने की भी जरूरत होती है, हाल ही में मैं कोड की एक पंक्ति की जगह पर निर्भरता के एक अद्भुत # को दूर कर सकता था :-( निर्भरता महंगा और इस तरह का मूल कोड लिखना अच्छा अभ्यास है

— पीटर क्रिएन्स

@PeterKriens से सहमत हैं। यदि कुछ भी है, तो गलती इसके मानक डेटा प्रकारों में इस तरह के साधारण रूपांतरणों का समर्थन नहीं करने के लिए जावा में है

— एडम ह्यूजेस

Answer 9

यदि आप ग्रहण संग्रह का उपयोग कर रहे हैं , तो आप collectInt()ऑब्जेक्ट कंटेनर से एक आदिम इंट कंटेनर में स्विच करने के लिए विधि का उपयोग कर सकते हैं ।

List<Integer> integers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
MutableIntList intList =
  ListAdapter.adapt(integers).collectInt(i -> i);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intList.toArray());

यदि आप अपने ArrayListको a में बदल सकते हैं FastList, तो आप एडॉप्टर से छुटकारा पा सकते हैं।

Assert.assertArrayEquals(
  new int[]{1, 2, 3, 4, 5},
  Lists.mutable.with(1, 2, 3, 4, 5)
    .collectInt(i -> i).toArray());

नोट: मैं ग्रहण संग्रहों के लिए एक कमिटेटर हूं।

Answer 10

जावा 8:

int[] intArr = Arrays.stream(integerList).mapToInt(i->i).toArray();

Answer 11

Arrays.setAll ()

    List<Integer> x = new ArrayList<>(Arrays.asList(7, 9, 13));
    int[] n = new int[x.size()];
    Arrays.setAll(n, x::get);

    System.out.println("Array of primitive ints: " + Arrays.toString(n));

आउटपुट:

आदिम चींटियों की सरणी: [in, ९, १३]

की एक सरणी के लिए एक ही काम करता है longया doubleहै, लेकिन की सरणियों के लिए नहीं boolean, char, byte, shortया float। यदि आपको वास्तव में बहुत बड़ी सूची मिली है, तो एक parallelSetAllविधि भी है जिसका उपयोग आप कर सकते हैं।

मेरे लिए यह काफी अच्छा और पर्याप्त है कि मैं एक बाहरी पुस्तकालय प्राप्त नहीं करना चाहता और न ही इसके लिए धाराओं का उपयोग कर सकता हूं।

दस्तावेज़ लिंक: Arrays.setAll(int[], IntUnaryOperator)

Answer 12

आप बस इसे एक सरणी में कॉपी कर सकते हैं:

int[] arr = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

बहुत फैंसी नहीं; लेकिन, हे, यह काम करता है ...

Answer 13

एक बहुत ही सरल एक-लाइन समाधान है:

Integer[] i = arrlist.stream().toArray(Integer[]::new);

Answer 14

यह कोड खंड मेरे लिए काम कर रहा है, इसे आज़माएं:

Integer[] arr = x.toArray(new Integer[x.size()]);

ArrayList का उल्लेख इस तरह किया जाना चाहिए:

ArrayList<Integer> list = new ArrayList<>();

Comments

हैलो बस एक सौम्य अनुस्मारक कि ओपी एक आदिम सरणी एक वस्तु सरणी नहीं चाहता है।

— OLIVER.KOO

आदिम int नहीं आवरण Integer!

— बार्टजिला

Answer 15

   List<Integer> list = new ArrayList<Integer>();

    list.add(1);
    list.add(2);

    int[] result = null;
    StringBuffer strBuffer = new StringBuffer();
    for (Object o : list) {
        strBuffer.append(o);
        result = new int[] { Integer.parseInt(strBuffer.toString()) };
        for (Integer i : result) {
            System.out.println(i);
        }
        strBuffer.delete(0, strBuffer.length());
    }

Comments

यह उत्तर काम नहीं करता है, यह कई तत्वों के बजाय एक तत्व के साथ एक सरणी देता है।

— रहस्यपूर्ण

एक स्ट्रिंगर का उपयोग क्यों करें? क्यों Integer को एक String और फिर एक Integer में और फिर एक int में और फिर एक Integer में फिर से कन्वर्ट करें? इसमें एक तत्व के साथ एक सरणी का उपयोग क्यों करें, और उस एकल-तत्व सरणी पर लूप क्यों होता है जब इसमें सिर्फ एक तत्व होता है? बाहरी लूप में ऑब्जेक्ट्स के लिए इंटेगर को क्यों डाला? यहाँ बहुत सारे सवाल हैं। क्या @CodeMadness सिर्फ एक ट्रोल खाता है?

— विक्टर ज़मानियन

Answer 16

Integer[] arr = (Integer[]) x.toArray(new Integer[x.size()]);

arrसामान्य की तरह पहुंच int[]।

Comments

यह इस प्रश्न का उत्तर नहीं देता है, यह प्रश्न आदिम प्रकार (int) में परिवर्तित होने के बारे में था

— Asaf