java - सरणी से ArrayList बनाएँ




arrays type-conversion (20)

मेरे पास एक सरणी है जिसे प्रारंभ किया गया है:

Element[] array = {new Element(1), new Element(2), new Element(3)};

मैं इस सरणी को ArrayList क्लास की ऑब्जेक्ट में कनवर्ट करना चाहता हूं।

ArrayList<Element> arraylist = ???;

एक अन्य जावा 8 समाधान (मैंने बड़े सेट के बीच जवाब खो दिया होगा। यदि हां, तो माफी माँगती है)। यह एक ArrayList बनाता है (एक सूची के विपरीत) यानी तत्वों को हटा सकते हैं

package package org.something.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Junk {

    static <T> ArrayList<T>  arrToArrayList(T[] arr){
        return Arrays.asList(arr)
            .stream()
            .collect(Collectors.toCollection(ArrayList::new));
    }

    public static void main(String[] args) {
        String[] sArr = new String[]{"Hello", "cruel", "world"};
        List<String> ret = arrToArrayList(sArr);
        // Verify one can remove an item and print list to verify so
        ret.remove(1);
        ret.stream()
            .forEach(System.out::println);
    }
}

आउटपुट है ...
नमस्ते
विश्व


जावा 9

जावा 9 में , आप List.of बनाने के लिए स्थैतिक फैक्ट्री विधि की List उपयोग कर सकते हैं। निम्नलिखित की तरह कुछ:

List<Element> elements = List.of(new Element(1), new Element(2), new Element(3));

यह तीन तत्वों वाली एक immutable सूची लौटाएगा। यदि आप एक परिवर्तनीय सूची चाहते हैं, तो उस सूची को ArrayList निर्माता को पास करें:

new ArrayList<>(List.of(// elements vararg))

जेईपी 26 9: संग्रह के लिए सुविधा फैक्टरी तरीके

जेईपी 26 9 जावा कलेक्शन एपीआई के लिए कुछ सुविधा फैक्ट्री विधियों को प्रदान करता है। ये अपरिवर्तनीय स्थैतिक फैक्ट्री विधियां जावा 9 और बाद में List , Set और Map इंटरफेस में बनाई गई हैं।


आप Arrays.asList (arrayObj) की सहायता से आसानी से ऐसा कर सकते हैं;

Element[] array = {new Element(1), new Element(2), new Element(3)};
ArrayList<Element> arraylist =Arrays.asList(array);

आप इसे जावा 8 में निम्नानुसार कर सकते हैं

ArrayList<Element> list = (ArrayList<Element>)Arrays.stream(array).collect(Collectors.toList());

आप विभिन्न विधियों का उपयोग करके परिवर्तित कर सकते हैं

  1. List<Element> list = Arrays.asList(array);

  2. List<Element> list = new ArrayList();
    Collections.addAll(list, array);

  3. Arraylist list = new Arraylist();
    list.addAll(Arrays.asList(array));

अधिक जानकारी के लिए आप http://javarevisited.blogspot.in/2011/06/converting-array-to-arraylist-in-java.html संदर्भ ले सकते हैं


आपको शायद एक सूची की आवश्यकता है, एक ArrayList नहीं। उस स्थिति में आप बस कर सकते हैं:

List<Element> arraylist = Arrays.asList(array);

एक और आसान तरीका है कि प्रत्येक लूप के लिए सरणी से सभी तत्वों को एक नए ऐरेलिस्ट में जोड़ना है।

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

for(Element e : array)
    list.add(e);

एक और तरीका (हालांकि अनिवार्य रूप से new ArrayList(Arrays.asList(array)) बराबर new ArrayList(Arrays.asList(array)) समाधान प्रदर्शन के अनुसार:

Collections.addAll(arraylist, array);

चूंकि यह प्रश्न बहुत पुराना है, यह मुझे आश्चर्यचकित करता है कि किसी ने अभी तक सबसे सरल रूप का सुझाव नहीं दिया है:

List<Element> arraylist = Arrays.asList(new Element(1), new Element(2), new Element(3));

जावा 5 के अनुसार, Arrays.asList() एक varargs पैरामीटर लेता है और आपको सरणी को स्पष्ट रूप से बनाने की आवश्यकता नहीं है।


जावा 8 के बाद से बदलने का एक आसान तरीका है:

public static <T> List<T> fromArray(T[] array) {
    return Arrays.stream(array).collect(toList());
}

दिया हुआ:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

उपयोग:

List<Element> listArray = Arrays.asList(array);

दिया हुआ:

Element[] array = new Element[] { new Element(1), new Element(2), new Element(3) };

सबसे आसान जवाब करना है:

List<Element> list = Arrays.asList(array);

यह ठीक काम करेगा। लेकिन कुछ चेतावनी:

  1. सूची के रूप में सूचीबद्ध सूची में निश्चित आकार है । इसलिए, यदि आप अपने कोड में लौटाई गई सूची से तत्वों को जोड़ने या निकालने में सक्षम होना चाहते हैं, तो आपको इसे एक नए ArrayList में लपेटना होगा। अन्यथा आपको एक UnsupportedOperationException प्राप्त होगा।
  2. asList() से लौटाई गई सूची मूल सरणी द्वारा समर्थित है। यदि आप मूल सरणी को संशोधित करते हैं, तो सूची भी संशोधित की जाएगी। यह आश्चर्यजनक हो सकता है।

भले ही इस प्रश्न के कई पूर्ण लिखित उत्तर हैं, मैं अपने इनपुट जोड़ दूंगा।

मान लें कि आपके पास Element[] array = { new Element(1), new Element(2), new Element(3) };

निम्नलिखित तरीकों से नई ArrayList बनाया जा सकता है

ArrayList<Element> arraylist_1 = new ArrayList<>(Arrays.asList(array));
ArrayList<Element> arraylist_2 = new ArrayList<>(
    Arrays.asList(new Element[] { new Element(1), new Element(2), new Element(3) }));

// Add through a collection
ArrayList<Element> arraylist_3 = new ArrayList<>();
Collections.addAll(arraylist_3, array);

और वे ArrayList के सभी संचालन का बहुत अच्छा समर्थन करते हैं

arraylist_1.add(new Element(4)); // or remove(): Success
arraylist_2.add(new Element(4)); // or remove(): Success
arraylist_3.add(new Element(4)); // or remove(): Success

लेकिन निम्नलिखित परिचालन केवल एक ArrayList की सूची दृश्य देता है और वास्तविक ArrayList नहीं।

// Returns a List view of array and not actual ArrayList
List<Element> listView_1 = (List<Element>) Arrays.asList(array);
List<Element> listView_2 = Arrays.asList(array);
List<Element> listView_3 = Arrays.asList(new Element(1), new Element(2), new Element(3));

इसलिए, कुछ ArrayList संचालन करने की कोशिश करते समय वे त्रुटि देंगे

listView_1.add(new Element(4)); // Error
listView_2.add(new Element(4)); // Error
listView_3.add(new Element(4)); // Error

सरणी link की सूची प्रतिनिधित्व पर अधिक।


यदि तुम प्रयोग करते हो :

new ArrayList<T>(Arrays.asList(myArray));

आप दो सूचियां बना सकते हैं और भर सकते हैं! बड़ी सूची में दो बार भरना ठीक वही है जो आप नहीं करना चाहते हैं क्योंकि प्रत्येक बार क्षमता को विस्तारित करने की आवश्यकता होने पर यह एक और Object[] सरणी बना देगा।

सौभाग्य से Arrays.asList(a[]) कार्यान्वयन तेज़ है और Arrays.asList(a[]) बहुत अच्छी तरह से किया जाता है। यह Arrays.ArrayList नामक एक प्रकार का ऐरेलिस्ट बनाता है जहां ऑब्जेक्ट [] डेटा सीधे सरणी पर इंगित करता है।

// in Arrays
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}
//still in Arrays, creating a private unseen class
private static class ArrayList<E>

    private final E[] a;    
    ArrayList(E[] array) {
        a = array; // you point to the previous array
    }
    ....
}

खतरनाक पक्ष यह है कि यदि आप प्रारंभिक सरणी बदलते हैं, तो आप सूची बदलते हैं! क्या आप वाकई चाहते हैं? शायद हाँ शायद ना।

यदि नहीं, तो सबसे समझने योग्य तरीका यह करना है:

ArrayList<Element> list = new ArrayList<Element>(myArray.length); // you know the initial capacity
for (Element element : myArray) {
    list.add(element);
}

या जैसा कि @glglgl कहा गया है, आप एक और स्वतंत्र ArrayList बना सकते हैं:

new ArrayList<T>(Arrays.asList(myArray));

मुझे Collections , Arrays , या Guava का उपयोग करना पसंद है। लेकिन अगर यह फिट नहीं है, या आप इसे महसूस नहीं करते हैं, तो बस इसके बजाय एक और सुरुचिपूर्ण रेखा लिखें।


सवाल के अनुसार जावा 1.7 का उपयोग कर जवाब है:

ArrayList<Element> arraylist = new ArrayList<Element>(Arrays.<Element>asList(array));

हालांकि यह हमेशा इंटरफ़ेस का उपयोग बेहतर है:

List<Element> arraylist = Arrays.<Element>asList(array);

हम आसानी से एक सरणी को ArrayList परिवर्तित कर सकते हैं। हम एक सूची से दूसरी सूची में सामग्री की प्रतिलिपि बनाने के उद्देश्य से संग्रह इंटरफ़ेस की addAll() विधि का उपयोग करते हैं।

 Arraylist arr = new Arraylist();
 arr.addAll(Arrays.asList(asset));

(पुराना धागा, लेकिन केवल 2 सेंट क्योंकि कोई भी गुवा या अन्य libs और कुछ अन्य विवरण का उल्लेख नहीं है)

यदि आप कर सकते हैं, तो अमरूद का प्रयोग करें

यह गुवा मार्ग को इंगित करने लायक है, जो इन शेंगेनियों को बहुत सरल बनाता है:

प्रयोग

एक अपरिवर्तनीय सूची के लिए

copyOf() क्लास और इसके of() और copyOf() फैक्ट्री विधियों का उपयोग करें (तत्व शून्य नहीं हो सकते हैं) :

List<String> il = ImmutableList.of("string", "elements");  // from varargs
List<String> il = ImmutableList.copyOf(aStringArray);      // from array

एक परिवर्तनीय सूची के लिए

Lists वर्ग और इसकी newArrayList() फैक्ट्री विधियों का उपयोग करें:

List<String> l1 = Lists.newArrayList(anotherListOrCollection);    // from collection
List<String> l2 = Lists.newArrayList(aStringArray);               // from array
List<String> l3 = Lists.newArrayList("or", "string", "elements"); // from varargs

उदाहरण के लिए, अन्य वर्गों में अन्य डेटा संरचनाओं के लिए समान विधियों को भी ध्यान दें।

क्यों अमरूद?

सामान्य आकर्षण टाइप-सुरक्षा के लिए जेनेरिक के कारण अव्यवस्था को कम करना हो सकता है, क्योंकि गुवा कारखाने के तरीकों के उपयोग से अधिकांश समय अनुमानित किए जाने की अनुमति मिलती है। हालांकि, इस तर्क में कम पानी है क्योंकि जावा 7 नए हीरे ऑपरेटर के साथ आया था।

लेकिन यह एकमात्र कारण नहीं है (और जावा 7 अभी तक हर जगह नहीं है): शॉर्टंड सिंटैक्स भी बहुत आसान है, और जैसा कि ऊपर देखा गया है, विधियों के प्रारंभकर्ता, अधिक अभिव्यक्ति कोड लिखने की अनुमति देते हैं। आप एक जावा कॉल में करते हैं जो वर्तमान जावा संग्रह के साथ 2 लेता है।

यदि आप नहीं कर सकते ...

एक अपरिवर्तनीय सूची के लिए

JDK की Arrays क्लास और इसकी asList() फ़ैक्टरी विधि का उपयोग करें, Collections.unmodifiableList() साथ लपेटा गया asList() Collections.unmodifiableList() :

List<String> l1 = Collections.unmodifiableList(Arrays.asList(anArrayOfElements));
List<String> l2 = Collections.unmodifiableList(Arrays.asList("element1", "element2"));

ध्यान दें कि asList() लिए लौटाया गया प्रकार एक ठोस ArrayList कार्यान्वयन का उपयोग कर एक List , लेकिन यह java.util.ArrayList नहीं है । यह एक आंतरिक प्रकार है, जो एक ArrayList अनुकरण करता है लेकिन वास्तव में सीधे पारित सरणी का संदर्भ देता है और इसे "लिखना" बनाता है (संशोधन सरणी में दिखाई देता है)।

यह किसी List को विस्तारित करने के तरीके से कुछ List एपीआई तरीकों के माध्यम से संशोधनों को रोकता है (इसलिए, तत्व जोड़ना या निकालना असमर्थित है), हालांकि यह तत्वों को ओवरराइड करने के लिए set() करने की अनुमति देता है। इस प्रकार यह सूची वास्तव में अपरिवर्तनीय नहीं है और asList() को कॉल asList() साथ लपेटा जाना चाहिए।

यदि आपको एक परिवर्तनीय सूची की आवश्यकता है तो अगला चरण देखें।

एक परिवर्तनीय सूची के लिए

उपरोक्त के समान, लेकिन वास्तविक java.util.ArrayList साथ लपेटा:

List<String> l1  = new ArrayList<String>(Arrays.asList(array));    // Java 1.5 to 1.6
List<String> l1b = new ArrayList<>(Arrays.asList(array));          // Java 1.7+
List<String> l2  = new ArrayList<String>(Arrays.asList("a", "b")); // Java 1.5 to 1.6
List<String> l2b = new ArrayList<>(Arrays.asList("a", "b"));       // Java 1.7+

शैक्षणिक उद्देश्यों के लिए: गुड ओल 'मैनुअल वे

// for Java 1.5+
static <T> List<T> arrayToList(final T[] array) {
  final List<T> l = new ArrayList<T>(array.length);

  for (final T s : array) {
    l.add(s);
  }
  return (l);
}

// for Java < 1.5 (no generics, no compile-time type-safety, boo!)
static List arrayToList(final Object[] array) {
  final List l = new ArrayList(array.length);

  for (int i = 0; i < array.length; i++) {
    l.add(array[i]);
  }
  return (l);
}

एक सरणी को एक ऐरेलिस्ट में बदलने के लिए, डेवलपर्स अक्सर ऐसा करते हैं:

List<String> list = Arrays.asList(arr);// this is wrong way..

Arrays.asList() एक Arrays.asList() जो private static class inside Arrays एक private static class inside Arrays , यह java.util.ArrayList क्लास नहीं है। The java.util.Arrays.ArrayList क्लास set(), get(), contains() विधियों में है, लेकिन तत्व जोड़ने के लिए कोई तरीका नहीं है, इसलिए इसका आकार ठीक हो गया है। असली ऐरेलिस्ट बनाने के लिए, आपको यह करना होगा:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

ArrayList का कन्स्ट्रक्टर एक संग्रह प्रकार स्वीकार कर सकता है, जो java.util.Arrays.ArrayList लिए एक सुपर प्रकार भी है


// Guava
import com.google.common.collect.ListsLists
...
List<String> list = Lists.newArrayList(aStringArray); 

new ArrayList<>(Arrays.asList(array))




type-conversion