java - जावा में एक नई सूची कैसे बनाएं




11 Answers

List myList = new ArrayList();

या जेनेरिक के साथ (जावा 8 या बाद में)

List<MyType> myList = new ArrayList<>();

या जेनेरिक (पुराने जावा संस्करण) के साथ

List<MyType> myList = new ArrayList<MyType>();

हम एक Set बनाते हैं:

Set myset = new HashSet()

हम जावा में एक List कैसे बना सकते हैं?




मुझे संक्षेप में जोड़ने और कुछ जोड़ने दो:

JDK

1. new ArrayList<String>();
2. Arrays.asList("A", "B", "C")

Guava

1. Lists.newArrayList("Mike", "John", "Lesly");
2. Lists.asList("A","B", new String [] {"C", "D"});

अपरिवर्तनीय सूची

1. Collections.unmodifiableList(new ArrayList<String>(Arrays.asList("A","B")));
2. ImmutableList.builder()                                      // Guava
            .add("A")
            .add("B").build();
3. ImmutableList.of("A", "B");                                  // Guava
4. ImmutableList.copyOf(Lists.newArrayList("A", "B", "C"));     // Guava

खाली अपरिवर्तनीय सूची

1. Collections.emptyList();
2. Collections.EMPTY_LIST;

अक्षरों की सूची

1. Lists.charactersOf("String")                                 // Guava
2. Lists.newArrayList(Splitter.fixedLength(1).split("String"))  // Guava

इंटीजर की सूची

Ints.asList(1,2,3);                                             // Guava



//simple example creating a list form a string array

String[] myStrings = new String[] {"Elem1","Elem2","Elem3","Elem4","Elem5"};

List mylist = Arrays.asList(myStrings );

//getting an iterator object to browse list items

Iterator itr= mylist.iterator();

System.out.println("Displaying List Elements,");

while(itr.hasNext())

  System.out.println(itr.next());



List बस Set रूप में एक इंटरफ़ेस है।

हैशसेट की तरह एक सेट का कार्यान्वयन है जिसमें प्रदर्शन / लुकअप / प्रदर्शन को हटाने के संबंध में कुछ गुण हैं, ArrayList एक सूची का बेयर कार्यान्वयन है।

यदि आप संबंधित इंटरफेस के लिए प्रलेखन पर एक नज़र डालते हैं तो आपको "सभी ज्ञात कार्यान्वयन कक्षाएं" मिलेंगी और आप तय कर सकते हैं कि आपकी आवश्यकताओं के लिए कौन सा उपयुक्त है।

संभावना है कि यह ArrayList




जावा 8 में

निश्चित आकार की एक गैर-खाली सूची बनाने के लिए (जैसे जोड़, निकालें, इत्यादि समर्थित नहीं हैं):

List<Integer> list = Arrays.asList(1, 2); // but, list.set(...) is supported

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

List<Integer> list = new ArrayList<>(Arrays.asList(3, 4));

जावा 9 में

एक नई List.of(...) का उपयोग करना List.of(...) स्थैतिक कारखाने के तरीके:

List<Integer> immutableList = List.of(1, 2);

List<Integer> mutableList = new ArrayList<>(List.of(3, 4));

और सर्वोत्तम प्रथाओं का पालन करें ...

कच्चे प्रकार का प्रयोग न करें

जावा 5 के बाद से, जेनेरिक भाषा का हिस्सा रहा है - आपको उनका उपयोग करना चाहिए:

List<String> list = new ArrayList<>(); // Good, List of String

List list = new ArrayList(); // Bad, don't do that!

इंटरफेस के लिए कार्यक्रम

उदाहरण के लिए, List इंटरफ़ेस में प्रोग्राम:

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

के बजाय:

ArrayList<Double> list = new ArrayList<>(); // This is a bad idea!



कभी-कभी - लेकिन केवल बहुत ही कम - एक नई ऐरेलिस्ट के बजाय, आप एक नई लिंक्डलिस्ट चाहते हैं। ArrayList के साथ शुरू करें और यदि आपके पास प्रदर्शन समस्याएं और सबूत हैं कि सूची समस्या है, और उस सूची में बहुत कुछ जोड़ना और हटाना - तो पहले नहीं - एक लिंक्डलिस्ट पर स्विच करें और देखें कि चीजें बेहतर हैं या नहीं। लेकिन मुख्य में, ArrayList के साथ छड़ी और सब ठीक हो जाएगा।




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

import com.google.common.collect.Lists;

// ...

List<String> strings = Lists.newArrayList();

List<Integer> integers = Lists.newLinkedList();

Iterable<T> प्रारंभिकरण के लिए अधिभार हैं और एक Iterable<T> से प्रारंभ करना।

इन तरीकों का लाभ यह है कि आपको जेनेरिक पैरामीटर को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है जैसा कि आप कन्स्ट्रक्टर के साथ करेंगे - कंपाइलर इसे चर के प्रकार से अनुमानित करेगा।




List arrList = new ArrayList();

बेहतर है कि आप नीचे दिए गए अनुसार जेनिक्स का उपयोग करें:

List<String> arrList = new ArrayList<String>();

arrList.add("one");

आप LinkedList का उपयोग करें।

List<String> lnkList = new LinkedList<String>();



एक विकल्प के रूप में आप डबल ब्रेस प्रारंभिकरण का उपयोग कर सकते हैं:

List<String> list = new ArrayList<String>(){{
add("a");
add("b");
}};



ग्रहण संग्रह का उपयोग करके आप इस तरह की एक सूची बना सकते हैं:

List<String> list1 = Lists.mutable.empty();
List<String> list2 = Lists.mutable.of("One", "Two", "Three");

यदि आप एक अपरिवर्तनीय सूची चाहते हैं:

ImmutableList<String> list3 = Lists.immutable.empty();
ImmutableList<String> list4 = Lists.immutable.of("One", "Two", "Three");

आप आदिम सूचियों का उपयोग कर ऑटो-मुक्केबाजी से बच सकते हैं। यहां बताया गया है कि आप int सूचियां कैसे बनायेंगे:

MutableIntList list5 = IntLists.mutable.empty();
MutableIntList list6 = IntLists.mutable.of(1, 2, 3);

ImmutableIntList list7 = IntLists.immutable.empty();
ImmutableIntList list8 = IntLists.immutable.of(1, 2, 3);

सभी 8 प्राइमेटिव्स के लिए वेरिएंट हैं।

MutableLongList longList       = LongLists.mutable.of(1L, 2L, 3L);
MutableCharList charList       = CharLists.mutable.of('a', 'b', 'c');
MutableShortList shortList     = ShortLists.mutable.of((short) 1, (short) 2, (short) 3);
MutableByteList byteList       = ByteLists.mutable.of((byte) 1, (byte) 2, (byte) 3);
MutableBooleanList booleanList = BooleanLists.mutable.of(true, false);
MutableFloatList floatList     = FloatLists.mutable.of(1.0f, 2.0f, 3.0f);
MutableDoubleList doubleList   = DoubleLists.mutable.of(1.0, 2.0, 3.0);

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




निम्नलिखित कुछ तरीके हैं जिन्हें आप सूचियां बना सकते हैं।

  • यह निश्चित आकार के साथ एक सूची तैयार करेगा, तत्वों को जोड़ना / निकालना संभव नहीं है, यह एक java.lang.UnsupportedOperationException फेंक देगा यदि आप ऐसा करने का प्रयास करते हैं।

    List<String> fixedSizeList = Arrays.asList(new String[] {"Male", "Female"});


  • निम्न संस्करण एक साधारण सूची है जहां आप किसी भी तत्व को जोड़ / हटा सकते हैं।

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


  • जावा में LinkedList बनाने का तरीका यह है कि, यदि आपको सूची में तत्वों के लगातार सम्मिलन / हटाने की आवश्यकता है, तो आपको ArrayList बजाय LinkedList उपयोग करना चाहिए

    List<String> linkedList = new LinkedList<>();




Related