जावा ArrayList शुरुआत में तत्वों को कैसे जोड़ें

Question

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

क्या किसी के पास कोई सुझाव है?

Comments

आप की तरह मतलब है removeऔर add?

— पीटर लॉरी

arraylist stack queue whateverएक सरणी की शुरुआत में जोड़ने के लिए आप क्या उपयोग कर रहे हैं , सबसे अच्छा बचा जाता है और ऐसा लगता है जैसे आपको एक अलग संग्रह का उपयोग करना चाहिए।

— पीटर लॉरी

सबसे पहले, आपको खुद कुछ बनाना चाहिए। आपने अब तक क्या किया है?

— येगोशिन मैक्सिम

Answer 1

Listविधि है add(int, E), तो आप उपयोग कर सकते हैं:

list.add(0, yourObject);

बाद में आप अंतिम तत्व को हटा सकते हैं:

if(list.size() > 10)
    list.remove(list.size() - 1);

हालाँकि, आप अपनी आवश्यकताओं पर पुनर्विचार करना चाहते हैं या एक अलग डेटा संरचना का उपयोग कर सकते हैं, जैसे Queue

संपादित करें

शायद अपाचे पर एक नज़र है CircularFifoQueue:

CircularFifoQueue एक निश्चित आकार के साथ पहली-पहली पहली कतार में है जो पूर्ण होने पर अपने सबसे पुराने तत्व को बदल देती है।

आप इसे अधिकतम आकार के साथ आरंभ करें:

CircularFifoQueue queue = new CircularFifoQueue(10);

Comments

मैं दस फुट पोल के साथ किसी भी अपाचे पुस्तकालय को नहीं छूता, खासकर जब से अमरूद के संग्रह कक्षाएं मौजूद हैं। अमरूद का इवेक्युइंग्यू एक अच्छा विकल्प हो सकता है।

— DPM

Answer 2

विशिष्ट डाटास्ट्रक्चर का उपयोग करना

विभिन्न डेटा संरचनाएं हैं जो पहले सूचकांक में तत्वों को जोड़ने के लिए अनुकूलित हैं। हालांकि मन, कि अगर आप अपने संग्रह को इनमें से किसी एक में परिवर्तित करते हैं, तो वार्तालाप को संभवतः समय और स्थान की जटिलता की आवश्यकता होगीO(n)

Deque

JDK में वह Dequeसंरचना शामिल है जो जैसी addFirst(e)औरofferFirst(e)

Deque<String> deque = new LinkedList<>();
deque.add("two");
deque.add("one");
deque.addFirst("three");
//prints "three", "two", "one"

विश्लेषण

सम्मिलन का स्थान और समय जटिलता LinkedListनिरंतर ( O(1)) के साथ है। बिग-ओ चीटशीट देखें ।

सूची को उलट देना

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

 Collections.reverse(list);
 list.add(elementForTop);
 Collections.reverse(list);

यदि आप जावा 8 स्ट्रीम का उपयोग करते हैं, तो यह उत्तर आपको रूचि दे सकता है।

विश्लेषण

• समय जटिलता: O(n)
• अंतरिक्ष जटिलता: O(1)

जेडीके कार्यान्वयन को देखते हुए यह एक O(n)समय जटिलता है इसलिए केवल बहुत छोटी सूचियों के लिए उपयुक्त है।

Comments

किसी सूची को दो बार उलट देना। उपरोक्त स्वीकृत समाधान की तुलना में क्या यह एल्गोरिथम के रन समय को एक बड़े अंतर से जोड़ देगा?

— सम्यक उपाध्याय

यह 2n जोड़ता है, इसलिए हाँ, लेकिन अगर आपके पास <50 की सूची है तो आप सबसे आधुनिक मशीनों पर अंतर को बेंचमार्क नहीं कर पाएंगे

— पैट्रिक फेवरे

Answer 3

आप ऐड (इंट इंडेक्स, ई एलिमेंट) पर एक नज़र डाल सकते हैं :

इस सूची में निर्दिष्ट स्थान पर निर्दिष्ट तत्व सम्मिलित करता है। तत्व को वर्तमान में उस स्थिति में स्थानांतरित करता है (यदि कोई हो) और किसी भी बाद के तत्व को दाईं ओर (अपने सूचकांकों में जोड़ता है)।

एक बार जब आप जोड़ते हैं तो आप ArrayList के आकार की जांच कर सकते हैं और अंत में लोगों को हटा सकते हैं।

Answer 4

आप Deque देखना चाह सकते हैं। यह आपको सूची में पहले और अंतिम दोनों मदों तक सीधी पहुंच प्रदान करता है।

Comments

मुझे आश्चर्य है कि आप केवल डेक्स के बारे में बात कर रहे हैं, यह स्पष्ट रूप से सबसे अच्छा इष्टतम समाधान है।

— गिलौम एफ।

Answer 5

आप जो वर्णन कर रहे हैं, वह उपयोग करने के लिए एक उपयुक्त स्थिति है Queue।

चूंकि आप addनए तत्व, और removeपुराने को चाहते हैं । आप अंत में जोड़ सकते हैं, और शुरुआत से हटा सकते हैं। इससे बहुत फर्क नहीं पड़ेगा।

कतार में विधियां हैं add(e)और remove()जो नए तत्व के अंत में जोड़ता है, और क्रमशः पुराने तत्व को शुरू से हटा देता है।

Queue<Integer> queue = new LinkedList<Integer>();
queue.add(5);
queue.add(6);
queue.remove();  // Remove 5

इसलिए, हर बार जब आप एक तत्व जोड़ते हैं, तो आप queueइसे एक removeविधि कॉल के साथ वापस कर सकते हैं।

---

अद्यतन : -

और यदि आप के आकार को ठीकQueue करना चाहते हैं , तो आप एक नज़र डाल सकते हैं: -ApacheCommons#CircularFifoBuffer

से documentation: -

CircularFifoBuffer एक पहले आकार के बफर में एक निश्चित आकार के साथ है जो पूर्ण होने पर अपने सबसे पुराने तत्व को बदल देता है।

Buffer queue = new CircularFifoBuffer(2); // Max size

queue.add(5);
queue.add(6);
queue.add(7);  // Automatically removes the first element `5`

जैसा कि आप देख सकते हैं, जब अधिकतम आकार तक पहुँच जाता है, तो नए तत्व को स्वचालित रूप से जोड़ने से पहला तत्व डाला जाता है।

Answer 6

मुझे लगता है कि कार्यान्वयन आसान होना चाहिए, लेकिन दक्षता के बारे में विचार करते हुए, आपको लिंक्डलिस्ट का उपयोग करना चाहिए, लेकिन कंटेनर के रूप में ArrayList का नहीं। आप निम्न कोड का उल्लेख कर सकते हैं:

import java.util.LinkedList;
import java.util.List;

public class DataContainer {

    private List<Integer> list;

    int length = 10;
    public void addDataToArrayList(int data){
        list.add(0, data);
        if(list.size()>10){
            list.remove(length);
        }
    }

    public static void main(String[] args) {
        DataContainer comp = new DataContainer();
        comp.list = new LinkedList<Integer>();

        int cycleCount = 100000000;

        for(int i = 0; i < cycleCount; i ++){
            comp.addDataToArrayList(i);
        }
    }
}

Answer 7

जावा लिंक्डलीस्ट ऐडफ़र्स्ट (ई ई) और पुश (ई ई) विधि दोनों प्रदान करता है जो सूची के सामने एक तत्व जोड़ते हैं।

https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html#addFirst(E)

Answer 8

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

private List myList = new ArrayList();
private void addItemToList(Object obj){
    if(myList.size()<10){
      myList.add(0,obj);
    }else{
      myList.add(0,obj);
      myList.remove(10);
    }
}

Answer 9

आप सूची विधियों का उपयोग कर सकते हैं, हटा सकते हैं और जोड़ सकते हैं

list.add(lowestIndex, element);
list.remove(highestIndex, element);

Answer 10

इसका उदाहरण लें: -

List<String> element1 = new ArrayList<>();
element1.add("two");
element1.add("three");
List<String> element2 = new ArrayList<>();
element2.add("one");
element2.addAll(element1);

Answer 11

आप उपयोग कर सकते हैं

public List<E> addToListStart(List<E> list, E obj){
list.add(0,obj);
return (List<E>)list;

}

ई को अपने डेटाटाइप के साथ बदलें

यदि सबसे पुराना तत्व हटाना आवश्यक है तो आप जोड़ सकते हैं:

list.remove(list.size()-1); 

वापसी के बयान से पहले। अन्यथा सूची आपकी वस्तु को शुरुआत में जोड़ेगी और सबसे पुराने तत्व को भी बनाए रखेगी।

यह सूची में अंतिम तत्व को हटा देगा।

Answer 12

import java.util.*:
public class Logic {
  List<String> list = new ArrayList<String>();
  public static void main(String...args) {
  Scanner input = new Scanner(System.in);
    Logic obj = new Logic();
      for (int i=0;i<=20;i++) {
        String string = input.nextLine();
        obj.myLogic(string);
        obj.printList();
      }
 }
 public void myLogic(String strObj) {
   if (this.list.size()>=10) {
      this.list.remove(this.list.size()-1);
   } else {
     list.add(strObj); 
   }
 }
 public void printList() {
 System.out.print(this.list);
 }
}

Answer 13

मुझे एक समान समस्या थी, मौजूदा सरणी की शुरुआत में एक तत्व जोड़ने की कोशिश करना, मौजूदा तत्वों को दाईं ओर स्थानांतरित करना और सबसे पुराना एक (सरणी [लंबाई -1]) को त्यागना। मेरा समाधान बहुत अच्छा नहीं हो सकता है लेकिन यह मेरे उद्देश्यों के लिए काम करता है।

 Method:

   updateArray (Element to insert)

     - for all the elements of the Array
       - start from the end and replace with the one on the left; 
     - Array [0] <- Element

सौभाग्य