Java Language
सूचियाँ

परिचय

वाक्य - विन्यास

• ls.add (ई तत्व); // एक तत्व जोड़ता है
• ls.remove (ई तत्व); // एक तत्व को निकालता है
• के लिए (ई तत्व: एलएस) {} // प्रत्येक तत्व पर Iterates
• ls.toArray (नया स्ट्रिंग [lllength]); // स्ट्रिंग्स की सूची को स्ट्रिंग्स की एक सरणी में परिवर्तित करता है
• ls.get (int index); // निर्दिष्ट इंडेक्स पर तत्व देता है।
• लेसेट (इंट इंडेक्स, ई तत्व); // तत्व को एक निर्दिष्ट स्थान पर प्रतिस्थापित करता है।
• ls.isEmpty (); // सही है अगर सरणी में कोई तत्व नहीं है, तो यह गलत है।
• ls.indexOf (ऑब्जेक्ट ओ); // निर्दिष्ट तत्व ओ के पहले स्थान का सूचकांक लौटाता है, या, यदि यह मौजूद नहीं है, तो -1 देता है।
• ls.lastIndexOf (ऑब्जेक्ट ओ); // निर्दिष्ट तत्व ओ के अंतिम स्थान का सूचकांक लौटाता है, या, यदि यह मौजूद नहीं है, तो रिटर्न -1।
• ls.size (); // सूची में तत्वों की संख्या लौटाता है।

टिप्पणियों

List<String> list = new ArrayList<>();
list.add("world");
System.out.println(list.indexOf("world"));      // Prints "0"
// Inserting a new value at index 0 moves "world" to index 1
list.add(0, "Hello");
System.out.println(list.indexOf("world"));      // Prints "1"
System.out.println(list.indexOf("Hello"));      // Prints "0"

एक सामान्य सूची को क्रमबद्ध करना

Collections वर्ग एक सूची को क्रमबद्ध करने के लिए दो मानक स्थैतिक विधियाँ प्रदान करता है:

• sort(List<T> list) उन सूचियों पर लागू होती है जहां T extends Comparable<? super T> , और
• sort(List<T> list, Comparator<? super T> c) किसी भी प्रकार की सूची के लिए लागू है।

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

विचार करें कि हमारे पास वस्तुओं को छाँटने का एक काम है जो निम्न वर्ग के उदाहरण हैं:

public class User {
    public final Long id;
    public final String username;

    public User(Long id, String username) {
        this.id = id;
        this.username = username;
    }

    @Override
    public String toString() {
        return String.format("%s:%d", username, id);
    }
}

Collections.sort(List<User> list) का उपयोग करने के लिए हमें Comparable इंटरफ़ेस को लागू करने के लिए User वर्ग को संशोधित करना होगा। उदाहरण के लिए

public class User implements Comparable<User> {
    public final Long id;
    public final String username;

    public User(Long id, String username) {
        this.id = id;
        this.username = username;
    }

    @Override
    public String toString() {
        return String.format("%s:%d", username, id);
    }

    @Override
    /** The natural ordering for 'User' objects is by the 'id' field. */
    public int compareTo(User o) {
        return id.compareTo(o.id);
    }
}

(एक तरफ: इस तरह के रूप में कई मानक जावा वर्गों String , Long , Integer लागू Comparable इंटरफ़ेस यह उन तत्वों की सूची डिफ़ॉल्ट रूप से sortable बनाता है, और के कार्यान्वयन के सरल करता है। compare या compareTo अन्य वर्गों में।)

ऊपर संशोधन के साथ, हम आसानी से कक्षाओं के प्राकृतिक क्रम के आधार पर User वस्तुओं की एक सूची को सॉर्ट कर सकते हैं। (इस मामले में, हमने परिभाषित किया है कि id वैल्यू के आधार पर ऑर्डर करना है)। उदाहरण के लिए:

List<User> users = Lists.newArrayList(
    new User(33L, "A"),
    new User(25L, "B"),
    new User(28L, ""));
Collections.sort(users);

System.out.print(users);
// [B:25, C:28, A:33]

हालाँकि, मान लीजिए कि हम id बजाय User वस्तुओं को name से क्रमबद्ध करना चाहते थे। वैकल्पिक रूप से, लगता है कि हम इसे लागू करने के लिए वर्ग बदलने में सक्षम नहीं किया गया था Comparable ।

यह वह जगह है जहाँ Comparator तर्क के साथ sort विधि उपयोगी है:

Collections.sort(users, new Comparator<User>() {
    @Override
    /* Order two 'User' objects based on their names. */
    public int compare(User left, User right) {
        return left.username.compareTo(right.username);
    }
});
System.out.print(users);
// [A:33, B:25, C:28]

Collections.sort(users, (l, r) -> l.username.compareTo(r.username));

users.sort((l, r) -> l.username.compareTo(r.username))

एक सूची बनाना

अपनी सूची एक प्रकार देते हुए

एक सूची बनाने के लिए आपको एक प्रकार (किसी भी वर्ग, जैसे String ) की आवश्यकता होती है। यह आपकी List का प्रकार है। List केवल निर्दिष्ट प्रकार की वस्तुओं को संग्रहीत करेगी। उदाहरण के लिए:

List<String> strings;

"string1" , "hello world!" , "goodbye" , आदि, लेकिन यह 9.2 स्टोर नहीं कर सकता है, हालांकि:

List<Double> doubles;

9.2 स्टोर कर सकते हैं, लेकिन "hello world!" ।

अपनी सूची शुरू करना

यदि आप ऊपर की सूचियों में कुछ जोड़ने की कोशिश करते हैं, तो आपको NullPointerException मिल जाएगी, क्योंकि strings और doubles दोनों समान अशक्त होते हैं !

किसी सूची को शुरू करने के दो तरीके हैं:

विकल्प 1: एक वर्ग का उपयोग करें जो सूची को लागू करता है

List एक इंटरफ़ेस है, जिसका अर्थ है कि एक निर्माता नहीं है, बल्कि ऐसी विधियाँ हैं जिन्हें एक वर्ग को ओवरराइड करना चाहिए। ArrayList सबसे अधिक इस्तेमाल List जाने वाली List , हालांकि LinkedList भी आम है। इसलिए हम अपनी सूची इस तरह से शुरू करते हैं:

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

या

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

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

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

विकल्प 2: संग्रह वर्ग का उपयोग करें

Collections क्लास एक List चर के बिना List बनाने के लिए दो उपयोगी तरीके प्रदान करता है:

• emptyList() : एक खाली सूची देता है।
• singletonList(T) : टाइप टी की सूची बनाता है और निर्दिष्ट तत्व जोड़ता है।

और एक विधि जो डेटा को भरने के लिए एक मौजूदा List का उपयोग करती है:

• addAll(L, T...) : पहले निर्दिष्ट पैरामीटर के रूप में पारित सूची में सभी निर्दिष्ट तत्वों को जोड़ता है।

उदाहरण:

import java.util.List;
import java.util.Collections;

List<Integer> l = Collections.emptyList();
List<Integer> l1 = Collections.singletonList(42);
Collections.addAll(l1, 1, 2, 3);

स्थितीय अभिगम संचालन

सूची एपीआई में स्थितिगत अभिगम संचालन के लिए आठ तरीके हैं:

• add(T type)
• add(int index, T type)
• remove(Object o)
• remove(int index)
• get(int index)
• set(int index, E element)
• int indexOf(Object o)
• int lastIndexOf(Object o)

इसलिए, यदि हमारे पास सूची है:

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

और हम तार जोड़ना चाहते थे "नमस्ते दुनिया!" और "अलविदा दुनिया!" यह करने के लिए, हम इसे इस तरह से करेंगे:

strings.add("Hello world!");
strings.add("Goodbye world!");

और हमारी सूची में दो तत्व शामिल होंगे। अब हम कहते हैं कि हम "प्रोग्राम स्टार्टिंग" जोड़ना चाहते थे! सूची में सबसे आगे । हम इसे इस तरह से करेंगे:

strings.add(0, "Program starting!");

नोट: पहला तत्व 0 है।

अब, अगर हम "अलविदा दुनिया" को हटाना चाहते थे! लाइन, हम इसे इस तरह कर सकते हैं:

strings.remove("Goodbye world!");

और अगर हम पहली पंक्ति को हटाना चाहते हैं (जो इस मामले में "प्रोग्राम शुरू करना होगा!", हम इसे इस तरह से कर सकते हैं:

strings.remove(0);

ध्यान दें:

1. जोड़ना और हटाना सूची तत्वों सूची को संशोधित, और यह एक को जन्म दे सकता ConcurrentModificationException यदि सूची समवर्ती दोहराया जा रहा है।

2. तत्वों को जोड़ना और हटाना O(1) या O(N) सकता है सूची वर्ग के आधार पर, उपयोग की जाने वाली विधि, और चाहे आप प्रारंभ में, अंत में या सूची के बीच में एक तत्व जोड़ / निकाल रहे हों।

एक निर्दिष्ट स्थान पर सूची के एक तत्व को पुनः प्राप्त करने के लिए आप E get(int index); उपयोग कर सकते हैं E get(int index); सूची एपीआई की विधि। उदाहरण के लिए:

strings.get(0);

सूची का पहला तत्व लौटाएगा।

आप set(int index, E element); का उपयोग करके किसी भी तत्व को एक निर्दिष्ट स्थान पर बदल सकते हैं set(int index, E element); । उदाहरण के लिए:

strings.set(0,"This is a replacement");

यह स्ट्रिंग को सूची के पहले तत्व के रूप में "यह एक प्रतिस्थापन है" सेट करेगा।

नोट: सेट विधि स्थिति 0 पर तत्व को अधिलेखित कर देगी। यह नई स्ट्रिंग को 0 स्थिति में नहीं जोड़ेगी और पुराने को स्थिति 1 पर धकेल देगी।

int indexOf(Object o); तर्क के रूप में पारित वस्तु की पहली घटना की स्थिति देता है। यदि सूची में ऑब्जेक्ट की कोई घटना नहीं होती है, तो -1 मान लौटाया जाता है। यदि आप कॉल करते हैं तो पिछले उदाहरण की निरंतरता में:

strings.indexOf("This is a replacement")

0 के वापस होने की उम्मीद है क्योंकि हमने अपनी सूची की स्थिति 0 में स्ट्रिंग "यह एक प्रतिस्थापन है" सेट किया है। मामले में जहां int indexOf(Object o); जब सूची में एक से अधिक घटनाएं होती हैं int indexOf(Object o); तब कहा जाता है जैसा कि पहली घटना का सूचकांक वापस आ जाएगा। int lastIndexOf(Object o) कॉल करके आप सूची में अंतिम घटना के सूचकांक को पुनः प्राप्त कर सकते हैं। तो अगर हम एक और जोड़ते हैं "यह एक प्रतिस्थापन है":

strings.add("This is a replacement");
strings.lastIndexOf("This is a replacement");

इस बार 1 लौटाया जाएगा न कि 0;

एक सूची में तत्वों पर फेरबदल

उदाहरण के लिए, हम कहते हैं कि हमारे पास एक स्ट्रिंग प्रकार की सूची है जिसमें चार तत्व हैं: "हैलो,", "कैसे", "आप", "आप?"

प्रत्येक तत्व पर पुनरावृति करने का सबसे अच्छा तरीका एक-प्रत्येक लूप का उपयोग करके है:

public void printEachElement(List<String> list){
    for(String s : list){
        System.out.println(s);
    }
}

जो प्रिंट करेगा:

hello,
how
are
you?

उन सभी को एक ही पंक्ति में मुद्रित करने के लिए, आप स्ट्रिंग स्ट्रिंग का उपयोग कर सकते हैं:

public void printAsLine(List<String> list){
    StringBuilder builder = new StringBuilder();
    for(String s : list){
        builder.append(s);
    }
    System.out.println(builder.toString());
}

प्रिंट होगा:

hello, how are you?

वैकल्पिक रूप से, आप किसी सूची को पुनरावृत्त करने के लिए तत्व अनुक्रमण (जैसे एरिथ लिस्ट से ith सूचकांक में अभिगम तत्व में वर्णित) का उपयोग कर सकते हैं। चेतावनी: यह दृष्टिकोण लिंक की गई सूचियों के लिए अक्षम है।

सूची ए में मौजूद तत्वों को सूची बी से हटाना

मान लीजिए कि आपके पास 2 सूचियाँ A और B हैं, और आप B से उन सभी तत्वों को निकालना चाहते हैं जो आपके पास इस मामले में A में हैं

 List.removeAll(Collection c);

#उदाहरण:

public static void main(String[] args) {
    List<Integer> numbersA = new ArrayList<>();
    List<Integer> numbersB = new ArrayList<>();
    numbersA.addAll(Arrays.asList(new Integer[] { 1, 3, 4, 7, 5, 2 }));
    numbersB.addAll(Arrays.asList(new Integer[] { 13, 32, 533, 3, 4, 2 }));
    System.out.println("A: " + numbersA);
    System.out.println("B: " + numbersB);

    numbersB.removeAll(numbersA);
    System.out.println("B cleared: " + numbersB);
    }

यह प्रिंट होगा

A: [१, ३, ४, 3, ५, २]

बी: [१३, ३२, ५३३, ३, ४, २]

बी क्लियर किया गया: [१३, ३२, ५३३]

2 सूचियों के बीच सामान्य तत्व खोजना

मान लीजिए कि आपके पास दो सूचियाँ हैं: A और B, और आपको उन तत्वों को खोजने की आवश्यकता है जो दोनों सूचियों में मौजूद हैं।

आप इसे केवल List.retainAll() विधि को लागू करके कर सकते हैं।

उदाहरण:

public static void main(String[] args) {
    List<Integer> numbersA = new ArrayList<>();
    List<Integer> numbersB = new ArrayList<>();
    numbersA.addAll(Arrays.asList(new Integer[] { 1, 3, 4, 7, 5, 2 }));
    numbersB.addAll(Arrays.asList(new Integer[] { 13, 32, 533, 3, 4, 2 }));

    System.out.println("A: " + numbersA);
    System.out.println("B: " + numbersB);
    List<Integer> numbersC = new ArrayList<>();
    numbersC.addAll(numbersA);
    numbersC.retainAll(numbersB);

    System.out.println("List A : " + numbersA);
    System.out.println("List B : " + numbersB);
    System.out.println("Common elements between A and B: " + numbersC);

}

पूर्णांक की सूची को स्ट्रिंग की सूची में बदलें

List<Integer> nums = Arrays.asList(1, 2, 3);
List<String> strings = nums.stream()
    .map(Object::toString)
    .collect(Collectors.toList());

अर्थात्:

1. सूची से एक स्ट्रीम बनाएं
2. Object::toString का उपयोग कर प्रत्येक तत्व को मैप करें Object::toString
3. Collectors.toList() का उपयोग करके List में String मान एकत्र करें

ArrayList से एलिमेंट बनाना, जोड़ना और रिमूव करना

ArrayList जावा में इनबिल्ट डेटा संरचनाओं में से एक है। यह एक गतिशील सरणी है (जहां डेटा संरचना के आकार को पहले घोषित करने की आवश्यकता नहीं है) भंडारण तत्वों (ऑब्जेक्ट्स) के लिए।

यह AbstractList वर्ग का विस्तार करता है और List इंटरफ़ेस को लागू करता है। एक ArrayList में डुप्लिकेट तत्व हो सकते हैं जहाँ यह प्रविष्टि क्रम बनाए रखता है। यह ध्यान दिया जाना चाहिए कि वर्ग ArrayList गैर-सिंक्रनाइज़ है, इसलिए ArrayList साथ ArrayList संभालते समय देखभाल की जानी चाहिए। ArrayList यादृच्छिक पहुँच की अनुमति देता है क्योंकि सरणी सूचकांक के आधार पर काम करती है। ArrayList में ArrayList कारण हेरफेर धीमा होता है जो अक्सर तब होता है जब कोई तत्व सरणी सूची से हटा दिया जाता है।

एक ArrayList निम्नानुसार बनाया जा सकता है:

List<T> myArrayList = new ArrayList<>();

जहाँ T ( Generics ) वह प्रकार है जिसे ArrayList अंदर संग्रहीत किया जाएगा।

ArrayList का प्रकार कोई भी वस्तु हो सकती है। प्रकार एक आदिम प्रकार नहीं हो सकता (इसके बजाय उनके आवरण वर्ग का उपयोग करें)।

ArrayList एक तत्व जोड़ने के लिए, add() विधि का उपयोग करें:

myArrayList.add(element);

या एक निश्चित सूचकांक में आइटम जोड़ने के लिए:

myArrayList.add(index, element); //index of the element should be an int (starting from 0)

ArrayList से किसी आइटम को निकालने के लिए, remove() विधि का उपयोग करें:

myArrayList.remove(element);

या एक निश्चित सूचकांक से एक आइटम को हटाने के लिए:

myArrayList.remove(index); //index of the element should be an int (starting from 0)

किसी सूची तत्व का इन-प्लेस प्रतिस्थापन

यह उदाहरण List तत्व को प्रतिस्थापित करने के बारे में है, जबकि यह सुनिश्चित करने के लिए कि प्रतिस्थापन तत्व उसी स्थिति में है जिस तत्व को प्रतिस्थापित किया गया है।

यह इन विधियों का उपयोग करके किया जा सकता है:

• सेट (इंट इंडेक्स, टी टाइप)
• int indexOf (टी प्रकार)

तत्वों पर आधारित एक ArrayList पर विचार करें "प्रोग्राम शुरू!", "हैलो वर्ल्ड!" और "अलविदा दुनिया!"

List<String> strings = new ArrayList<String>();
strings.add("Program starting!");
strings.add("Hello world!");
strings.add("Goodbye world!");

यदि हम उस तत्व के सूचकांक को जानते हैं जिसे हम बदलना चाहते हैं, तो हम बस निम्नानुसार set उपयोग कर सकते हैं:

strings.set(1, "Hi world");

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

int pos = strings.indexOf("Goodbye world!");
if (pos >= 0) {
    strings.set(pos, "Goodbye cruel world!");
}

टिप्पणियाँ:

1. set ऑपरेशन एक ConcurrentModificationException कारण नहीं होगा।
2. set ऑपरेशन ArrayList लिए तेज़ ( O(1) ) है, लेकिन LinkedList लिए धीमा ( O(N) ) है।
3. एक ArrayList या LinkedList पर एक indexOf खोज धीमा ( O(N) ) है।

एक सूची को अस्वीकार्य बनाना

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

List<String> ls = new ArrayList<String>();
List<String> unmodifiableList = Collections.unmodifiableList(ls);

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

List<String> unmodifiableList = Collections.singletonList("Only string in the list");

सूची में वस्तुओं को इधर-उधर करना

संग्रह वर्ग आपको विभिन्न तरीकों का उपयोग करके सूची में वस्तुओं को स्थानांतरित करने की अनुमति देता है (ls सूची है):

एक सूची को उलटना:

Collections.reverse(ls);

किसी सूची में तत्वों की घूमती स्थिति

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

List<String> ls = new ArrayList<String>();
ls.add(" how");
ls.add(" are");
ls.add(" you?");
ls.add("hello,");
Collections.rotate(ls, 1);

for(String line : ls) System.out.print(line);
System.out.println();

यह "हैलो, आप कैसे हैं?"

एक सूची में आसपास के तत्वों में फेरबदल

उपरोक्त समान सूची का उपयोग करके, हम तत्वों को सूची में फेरबदल कर सकते हैं:

Collections.shuffle(ls);

हम इसे एक java.util भी दे सकते हैं। आयामी वस्तु जिसे वह स्पॉट में बेतरतीब ढंग से वस्तुओं का उपयोग करता है:

Random random = new Random(12); 
Collections.shuffle(ls, random);

लागू करने वाली कक्षाएं सूची - पेशेवरों और विपक्ष

List इंटरफ़ेस विभिन्न वर्गों द्वारा कार्यान्वित किया जाता है। उनमें से प्रत्येक के पास अलग-अलग रणनीतियों के साथ इसे लागू करने और विभिन्न पेशेवरों और विपक्षों को प्रदान करने का अपना तरीका है।

कक्षाएं लागू करने वाली सूची

जावा एसई 8 में ये सभी public वर्ग हैं जो java.util.List लागू करते हैं। java.util.List इंटरफ़ेस:

1. सार वर्ग:
   • AbstractList
   • AbstractSequentialList
2. ठोस वर्ग:
   • सारणी सूची
   • AttributeList
   • CopyOnWriteArrayList
   • लिंक्ड सूची
   • RoleList
   • RoleUnresolvedList
   • ढेर
   • वेक्टर

समय की जटिलता में प्रत्येक कार्यान्वयन के पेशेवरों और विपक्ष

सारणी सूची

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

ArrayList सूची इंटरफ़ेस का एक resizable-array कार्यान्वयन है। सरणी में सूची को संग्रहीत करना, सरणी के आकार में हेरफेर करने के लिए ArrayList तरीके ( सूची इंटरफ़ेस को लागू करने के तरीकों के अलावा) प्रदान करता है।

आकार के 100 के साथ पूर्णांक की प्रारंभिक सरणी

List<Integer> myList = new ArrayList<Integer>(100); // Constructs an empty list with the specified initial capacity.

- प्रो:

आकार, isEmpty, मिलता है , सेट , पुनरावृत्ति, और listIterator संचालन निरंतर समय में चलते हैं। इसलिए सूची के प्रत्येक तत्व को प्राप्त करना और स्थापित करना एक ही समय लागत है :

int e1 = myList.get(0);  //   \
int e2 = myList.get(10); //    | => All the same constant cost => O(1)
myList.set(2,10);        //   /

- कान्स:

एक सरणी (स्थिर संरचना) के साथ कार्यान्वित किया जा रहा है, सरणी के आकार पर तत्वों को जोड़ना इस तथ्य के कारण एक बड़ी लागत है कि सभी सरणी के लिए एक नया आवंटन किया जाना चाहिए। हालाँकि, प्रलेखन से :

जोड़ने का संचालन परिशोधित निरंतर समय में चलता है, अर्थात, n तत्वों को जोड़ने के लिए O (n) समय की आवश्यकता होती है

किसी तत्व को निकालने के लिए O (n) समय की आवश्यकता होती है।

AttributeList

आने पर

CopyOnWriteArrayList

आने पर

लिंक्ड सूची

public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

LinkedList एक दोगुनी-लिंक्ड सूची द्वारा एक लिंक की गई डेटा संरचना द्वारा कार्यान्वित किया जाता है जिसमें क्रमिक रूप से लिंक किए गए रिकॉर्ड का एक सेट होता है, जिसे नोड्स कहा जाता है।

इंटेग्रेट के लिंक्डलिस्ट

List<Integer> myList = new LinkedList<Integer>(); // Constructs an empty list.

- प्रो:

सूची के अंत में या अंत तक एक तत्व जोड़ना या निकालना निरंतर समय होता है।

myList.add(10);  // \
myList.add(0,2); //  | => constant time => O(1)
myList.remove(); // /

- CONS: प्रलेखन से :

सूची में अनुक्रमणिका का संचालन सूची को आरंभ या अंत से आगे बढ़ाएगा, जो भी निर्दिष्ट सूचकांक के करीब है।

संचालन जैसे:

myList.get(10);    // \
myList.add(11,25); //  | => worst case done in O(n/2)
myList.set(15,35); // /

RoleList

आने पर

RoleUnresolvedList

आने पर

ढेर

आने पर

वेक्टर

आने पर