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




arrays type-conversion (24)

जैसा कि सभी ने कहा था यह ऐसा करेगा

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

और सरणी बनाने का सामान्य नवीनतम तरीका अवलोकन योग्य है

अवलोकनयोग्य सूची : एक सूची जो श्रोताओं को होने पर परिवर्तनों को ट्रैक करने की अनुमति देती है।

जावा एसई के लिए आप कोशिश कर सकते हैं

FXCollections.observableArrayList(new Element(1), new Element(2), new Element(3));

यह ओरेकल डॉक्स के अनुसार है

अवलोकन योग्य ऐरेलिस्ट () एक नई खाली अवलोकन सूची बनाता है जिसे एक सरणीसूची द्वारा समर्थित किया जाता है। अवलोकन योग्य ऐरेलिस्ट (ई ... आइटम) इसमें जोड़े गए आइटमों के साथ एक नई अवलोकन योग्य सरणी सूची बनाता है।

जावा 9 अपडेट करें

जावा 9 में भी यह थोड़ा आसान है:

List<String> list = List.of("element 1", "element 2", "element 3");

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

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

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

ArrayList<Element> arraylist = ???;

आप इसे जावा 8 में स्ट्रीम के साथ भी कर सकते हैं।

 List<Element> elements = Arrays.stream(array).collect(Collectors.toList()); 

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

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

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


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

ऐसा करने का सबसे आसान तरीका निम्नलिखित कोड जोड़ना है। आजमाया और परखा गया।

String[] Array1={"one","two","three"};
ArrayList<String> s1= new ArrayList<String>(Arrays.asList(Array1));

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

  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 संदर्भ ले सकते हैं


(पुराना धागा, लेकिन केवल 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 लिए एक सुपर प्रकार भी है


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

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 का उपयोग करना पसंद है। लेकिन अगर यह फिट नहीं है, या आप इसे महसूस नहीं करते हैं, तो बस इसके बजाय एक और सुरुचिपूर्ण रेखा लिखें।


दिया हुआ:

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

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

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

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

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

एक अन्य जावा 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);
    }
}

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


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

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

Java 9 आप इसका उपयोग कर सकते हैं:

List<String> list = List.of("Hello", "World", "from", "Java");
List<Integer> list = List.of(1, 2, 3, 4, 5);

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

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

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

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

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

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

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

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

सुनिश्चित करें कि myArray T के समान प्रकार है। उदाहरण के लिए, यदि आप int सरणी से List<Integer> बनाने की कोशिश करते हैं तो आपको एक कंपाइलर त्रुटि मिल जाएगी।


दिया हुआ:

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

उपयोग:

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

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

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

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

यदि सरणी एक आदिम प्रकार का है, तो दिए गए उत्तर काम नहीं करेंगे। लेकिन चूंकि जावा 8 आप इसका उपयोग कर सकते हैं:

int[] array = new int[5];
Arrays.stream(array).boxed().collect(Collectors.toList());

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

मान लें कि आपके पास 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 की सूची प्रतिनिधित्व पर अधिक।


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

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

एक और अपडेट, लगभग वर्ष 2014 समाप्त हो रहा है, आप इसे जावा 8 के साथ भी कर सकते हैं:

ArrayList<Element> arrayList = Stream.of(myArray).collect(Collectors.toCollection(ArrayList::new));

कुछ पात्र सहेजे जाएंगे, अगर यह सिर्फ एक List हो सकती है

List<Element> list = Stream.of(myArray).collect(Collectors.toList());




type-conversion