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

Question

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

Set myset = new HashSet()

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

Comments

सूची के लिए javadoc पर। "सभी ज्ञात कार्यान्वयन कक्षाएं: AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector"

— KitsuneYMG

यह प्रश्न "जावा क्रिएट लिस्ट" के लिए शीर्ष गूगल हिट्स में से एक है और इसमें उत्तरों का बहुत ही उपयोगी सेट है, इसलिए मेरे लिए एक उचित पर्याप्त प्रश्न जैसा प्रतीत होता है :-)

— जोसेफ

यह अच्छे सवालों के साथ एक अच्छा सवाल है। स्टैक ओवरफ्लो के उद्देश्यों में से एक प्रोग्रामिंग प्रश्नों के लिए किसी प्रकार का विहित उत्तर तैयार करना है, कम से कम साइट के संस्थापकों के अनुसार। तो कृपया भविष्य में इस प्रकार के पोस्ट को वोट करने से बचने की कोशिश करें, यदि आप प्रलोभन का विरोध कर सकते हैं।

— अंडोलेग्स

Answer 1

List myList = new ArrayList();

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

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

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

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

Comments

ध्यान दें कि ArrayList एकमात्र प्रकार की सूची नहीं है - और, प्रश्न के संबंध में, HashSet एकमात्र प्रकार का सेट नहीं है।

— स्लिम

मुझे आश्चर्य है कि किसी ने उल्लेख नहीं किया है कि आप सूची को लागू करने वाले सभी वर्गों की एक निश्चित सूची प्राप्त करने के लिए जावा दस्तावेज़ में सूची इंटरफ़ेस देख सकते हैं: docs.oracle.com/javase/7/docs/api/java/util /List.html

— डेविड मेसन

यदि आप एक आईडीई का उपयोग करते हैं तो आप आमतौर पर वहां एक प्रकार की पदानुक्रम देख सकते हैं, जो अधिक सुविधाजनक हो सकता है। ग्रहण में डिफ़ॉल्ट शॉर्टकट F4 है, और IDEA में यह Ctrl + H है।

— डेविड मेसन

जो मैं समझता हूं कि आप C # MSDN

— JohnOborne

दूसरे स्पष्ट प्रकार के तर्क <MyType> को जावा 7 और 8 के लिए बस <> से बदला जा सकता है

— Jannik

Answer 2

इसके अतिरिक्त, यदि आप एक ऐसी सूची बनाना चाहते हैं जिसमें चीजें हैं (हालांकि यह निश्चित आकार होगा):

List<String> messages = Arrays.asList("Hello", "World!", "How", "Are", "You");

Comments

चेतावनी यह है कि इस प्रकार की सूची (asList () द्वारा लौटाई गई) अपरिवर्तनीय है।

— एवरोम

@ एवरन - गलत: यह केवल निश्चित आकार है: आप आकार को बदल नहीं सकते हैं, लेकिन आप सामग्री को बदल सकते हैं (कैविएट का

— कोना

बहुत बढ़िया। संक्षिप्त होने के लिए धन्यवाद।

— आर क्लेवेन

यदि सूची में केवल एक ही चीज़ है, तो मैं Arrays.asList () के बजाय Collections.singletonList () का उपयोग करता हूं। (लेकिन, मुझे लगता है, मुझे पता नहीं क्यों।)

— माइक

@ मायक अगर आपको पता नहीं है तो फिर arrays.aslist पर क्यों चिपके रहते हैं

— bharal

Answer 3

मुझे संक्षेप में बताएं और कुछ जोड़ें:

JDK

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

अमरूद

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

Comments

Ints.asListएक अपरिवर्तनीय सूची नहीं बनाता है, लेकिन एक निश्चित आकार की सूची दिए गए सरणी के सरणी (यानी यह समर्थन करता है List.set(int, Object)) द्वारा समर्थित है । "चरित्रों की अपरिवर्तनीय सूची" का दूसरा उदाहरण या तो अपरिवर्तनीय नहीं है (मैं उस पंक्ति को हटा दूंगा)।

— Xaerxess

जेनरिक का उपयोग नहीं करना किसी भी डेवलपर के लिए वास्तव में "अच्छा" उदाहरण बनाता है जो इसे पढ़ेगा।

— नैटिक्स

Answer 4

जावा 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<Integer> immutableList = List.of(1, 2);

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

जावा 10 में

स्थानीय परिवर्तनीय प्रकार का प्रयोग :

var list1 = List.of(1, 2);

var list2 = new ArrayList<>(List.of(3, 4));

var list3 = new ArrayList<String>();

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

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

जावा 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!

Comments

नमस्ते, क्या आप कृपया सुझाव दे सकते हैं कि मैं इन अंतरों और जावा के विकास को कहां सीख सकता हूं? बहुत दिलचस्प लगता है!

— शिव

Answer 5

सबसे पहले पढ़ा यह है, तो पढ़ इस और इस । 10 में से 9 बार आप उन दो कार्यान्वयनों में से एक का उपयोग करेंगे।

वास्तव में, बस Sun's Guide to the Collections फ्रेमवर्क पढ़ें ।

Comments

मैं "10 में से 8 बार भी जोड़ूंगा" आप ArrayList का उपयोग करेंगे, सिर्फ इसलिए कि यह केवल 10. में से 9.9 बार में कोई फर्क नहीं पड़ता है

— जोकिम सॉयर

जब आप केवल वास्तव में सिरों की परवाह करते हैं तो लिंक्डलिस्ट शब्दबद्ध रूप से उपयुक्त होता है।

— एडम जास्कविज़

अगर आप सिर्फ उन पर पुनरावृत्ति करने जा रहे हैं, तो लिंक्डलिस्ट उत्कृष्ट हैं। मेरे लिए, ऐसा लगता है जैसे लिंक की गई सूचियां अधिक सुरुचिपूर्ण हैं, लेकिन शायद यह सिर्फ इसलिए है क्योंकि मैंने जावा से पहले लिस्प सीखा था।

— कार्ल

@ कर्लप सहमत। मैं कहूंगा कि यह ArrayList और LinkedList के बीच लगभग 50/50 है, और जवाब हमेशा संचालन की जटिलता के बारे में नहीं है; अधिक बार यह बस हाथ में समस्या के लिए सही लगता है।

— एडम जास्कविज़

मैंने लगभग हमेशा इस्तेमाल किया ArrayList। यदि मैं केवल एक सूची के सिरों के साथ काम कर रहा हूं, तो यह एक छल (या कतार) है और मैं ArrayDequeकार्यान्वयन का उपयोग करता हूं । कारण यह है कि भले ही सरणी-आधारित कार्यान्वयन है हो सकता है खाली स्लॉट पर कुछ स्मृति बर्बाद (जब मैं आवश्यक क्षमता का अनुमान नहीं लगा सकते हैं), छोटे संग्रहों के लिए इस एक लिंक की गई सूची में सभी नोड उदाहरणों में से भूमि के ऊपर के बराबर है है ( या छल)। और बदले में, मुझे यादृच्छिक अभिगम मिलता है। क्या अद्वितीय लाभ LinkedListप्रदान करता है ?

— इरिकसन

Answer 6

//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());

Answer 7

जावा 7 के बाद से आपके पास जेनेरिक इंस्टेंस क्रिएशन के लिए टाइप इंक्वायरी है , इसलिए असाइनमेंट के दायीं ओर जेनेरिक मापदंडों को डुप्लिकेट करने की कोई आवश्यकता नहीं है:

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

एक निश्चित आकार की सूची के रूप में परिभाषित किया जा सकता है:

List<String> list = Arrays.asList("foo", "bar");

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

List<String> list = ImmutableList.of("foo", "bar");

Comments

मेरे पास इस घोषणा सूची के बारे में एक प्रश्न है <string> सूची = Arrays.asList ("फू", "बार"); मैं सोच रहा हूँ कि क्या घोषणा में सूची एक वस्तु है?

Answer 8

सूची सिर्फ सेट के रूप में एक इंटरफ़ेस है ।

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

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

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

Answer 9

Listकी तरह एक अंतरफलक है Setऔर है ArrayListऔर LinkedListके रूप में सामान्य प्रयोजन कार्यान्वयन ।

हम सूची इस प्रकार बना सकते हैं:

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

हम एक निश्चित आकार की सूची भी बना सकते हैं:

List<String> list = Arrays.asList("A", "B", "C");

हम लगभग हमेशा कार्यान्वयन के ArrayListविरोध का उपयोग करेंगे LinkedList:

1. LinkedList वस्तुओं के लिए बहुत सारे स्थान का उपयोग करता है और जब हमारे पास बहुत सारे तत्व होते हैं तो बुरी तरह से प्रदर्शन करता है।
2. किसी भी अनुक्रमित ऑपरेशन में LinkedListO (1) की तुलना में O (n) समय की आवश्यकता होती है ArrayList।
3. अधिक जानकारी के लिए इस लिंक को देखें।

Arrays.asListऊपर बनाई गई सूची को संरचनात्मक रूप से संशोधित नहीं किया जा सकता है लेकिन इसके तत्वों को अभी भी संशोधित किया जा सकता है।

जावा 8

डॉक्टर के अनुसार , विधि Collections.unmodifiableListनिर्दिष्ट सूची का एक अपरिवर्तनीय दृश्य लौटाती है। हम इसे प्राप्त कर सकते हैं:

Collections.unmodifiableList(Arrays.asList("A", "B", "C"));

जावा ९

मामले में हम जावा 9 का उपयोग कर रहे हैं :

List<String> list = List.of("A", "B");

जावा 10

यदि हम जावा 10 में हैं, तो यह विधि Collectors.unmodifiableListजावा 9 में वास्तव में मौजूद अपरिवर्तनीय सूची का एक उदाहरण लौटाएगी । बनाम जावा 10 में अंतर के बारे में अधिक जानकारी के लिए इस उत्तर को जांचें ।Collections.unmodifiableListCollectors.unmodifiableList

Answer 10

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

Answer 11

List list = new ArrayList();

या जेनेरिक के साथ

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

आप निश्चित रूप से किसी भी प्रकार के चर जैसे कि इंटेगर के साथ स्ट्रिंग को बदल सकते हैं।

Answer 12

एक उदाहरण:

List somelist = new ArrayList();

आप सूची के लिए javadoc को देख सकते हैं और Listजावा एपीआई के साथ शामिल किए गए इंटरफ़ेस के सभी ज्ञात कार्यान्वयन कक्षाएं पा सकते हैं।

Answer 13

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

import com.google.common.collect.Lists;

// ...

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

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

Varargs initialization और initializing from a के लिए ओवरलोड हैं Iterable<T> ।

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

Answer 14

List<Object> nameOfList = new ArrayList<Object>();

आप आयात करने की आवश्यकता Listहै और ArrayList।

Answer 15

जावा 8 के साथ एक ही काम करने के लिए अधिक विकल्प, बेहतर नहीं, बदतर नहीं, बस अलग और यदि आप सूचियों के साथ कुछ अतिरिक्त काम करना चाहते हैं, तो स्ट्रीम आपको अधिक विकल्प (फ़िल्टर, मानचित्र, कम करना, आदि) प्रदान करेंगे।

List<String> listA = Stream.of("a", "B", "C").collect(Collectors.toList());
List<Integer> listB = IntStream.range(10, 20).boxed().collect(Collectors.toList());
List<Double> listC = DoubleStream.generate(() -> { return new Random().nextDouble(); }).limit(10).boxed().collect(Collectors.toList());
LinkedList<Integer> listD = Stream.iterate(0, x -> x++).limit(10).collect(Collectors.toCollection(LinkedList::new));

Answer 16

जावा 9 के साथ, आप एक अपरिवर्तनीय बनाने के लिए निम्नलिखित करने में सक्षम हैं List:

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

List<Integer> mutableList = new ArrayList<>(immutableList);

Answer 17

एक विकल्प के रूप में आप यहां डबल ब्रेस इनिशियलाइज़ेशन का उपयोग कर सकते हैं:

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

Comments

यह एक महंगा ऑपरेशन है। आप यहां ऐरेलेस्ट का एक अनाम उपवर्ग बना रहे हैं।

— विक्रम बोदीचेरला

@VikramBodicherla मैं सहमत हूँ। यह सिंटैक्स चीनी के बारे में अधिक है।

— क्रोधित_गोपाल

Answer 18

सेट और सूची बनाने के कई तरीके हैं। हैशसेट और एरियर लिस्ट इसके दो उदाहरण हैं। इन दिनों संग्रह के साथ जेनरिक का उपयोग करना भी काफी आम है। मेरा सुझाव है कि आपके पास उन पर एक नज़र है

यह जावा के निर्मित संग्रह के लिए एक अच्छा परिचय है। http://java.sun.com/javase/6/docs/technotes/guides/collections/overview.html

Answer 19

List arrList = new ArrayList();

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

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

arrList.add("one");

आप लिंक्डलिस्ट का उपयोग करें।

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

Answer 20

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

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

आप आदिम सूचियों का उपयोग करके ऑटो-बॉक्सिंग से बच सकते हैं। यहां बताया गया है कि आप इंट लिस्ट कैसे बनाएंगे:

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

नोट: मैं एक्लिप्स कलेक्शंस के लिए कमिट हूं।

Answer 21

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

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

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

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

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

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

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

Comments

आप उपयोग कर सकते हैं Arrays.asList("Male", "Female")।

— जॉनी

Answer 22

इसे इस्तेमाल करे:

List<String> messages = Arrays.asList("bla1", "bla2", "bla3");

या:

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

Answer 23

यदि आपको एक एकल इकाई के साथ क्रमबद्ध, अपरिवर्तनीय सूची की आवश्यकता है, जिसका आप उपयोग कर सकते हैं:

List<String> singList = Collections.singletonList("stackoverlow");

Answer 24

के रूप में जावा में सरणी सूची की घोषणा की तरह है

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable  

वहाँ कई तरह से आप जावा में सरणी सूची बना सकते हैं और आरंभ कर सकते हैं।

 1) List list = new ArrayList();

 2) List<type> myList = new ArrayList<>();

 3) List<type> myList = new ArrayList<type>();

 4) Using Utility class

    List<Integer> list = Arrays.asList(8, 4);
    Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

 5) Using static factory method

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


 6) Creation and initializing at a time

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



 Again you can create different types of list. All has their own characteristics

 List a = new ArrayList();
 List b = new LinkedList();
 List c = new Vector(); 
 List d = new Stack(); 
 List e = new CopyOnWriteArrayList();