एक ऐरेलिस्ट को उलटने का सबसे सरल तरीका क्या है?

Question

इस ArrayList को उल्टा करने का सबसे सरल तरीका क्या है?

ArrayList<Integer> aList = new ArrayList<>();

//Add elements to ArrayList object
aList.add("1");
aList.add("2");
aList.add("3");
aList.add("4");
aList.add("5");

while (aList.listIterator().hasPrevious())
  Log.d("reverse", "" + aList.listIterator().previous());

Answer 1

Collections.reverse(aList);

उदाहरण ( संदर्भ ):

ArrayList aList = new ArrayList();
//Add elements to ArrayList object
aList.add("1");
aList.add("2");
aList.add("3");
aList.add("4");
aList.add("5");
Collections.reverse(aList);
System.out.println("After Reverse Order, ArrayList Contains : " + aList);

Comments

@ AgarwalShankar मुझे एक त्रुटि की आवश्यकता है ArrayList पाया शून्य। क्या मैं कुछ भूल रहा हूँ।

— सागर देवांग

@ सागरडंगांगा सूची जगह पर उलट है, वापस नहीं।

— कैरिजनेट

Collections.reverse (सूची); मैंने इसे एक एंड्रॉइड प्रोजेक्ट में इस्तेमाल किया, ठीक काम करता है।

— दामिर वेरेवेक

Answer 2

सबसे सरल तरीका नहीं है, लेकिन यदि आप पुनरावृत्ति के प्रशंसक हैं, तो आपको ArrayList को उलटने के लिए निम्नलिखित विधि में रुचि हो सकती है:

public ArrayList<Object> reverse(ArrayList<Object> list) {
    if(list.size() > 1) {                   
        Object value = list.remove(0);
        reverse(list);
        list.add(value);
    }
    return list;
}

या गैर-पुनरावर्ती:

public ArrayList<Object> reverse(ArrayList<Object> list) {
    for(int i = 0, j = list.size() - 1; i < j; i++) {
        list.add(i, list.remove(j));
    }
    return list;
}

Comments

मैं गलत हो सकता हूं, लेकिन आपके गैर-पुनरावर्ती उदाहरण में, int jप्रत्येक पुनरावृत्ति के साथ अद्यतन नहीं होता है ? आप इसे आरंभ करते हैं, j = list.size() - 1लेकिन मुझे नहीं लगता कि प्रत्येक पुनरावृत्ति के साथ अद्यतित होने का आरंभिक खंड for loopयह करता है?

— टोनी चैन

@ टर्बो को प्रत्येक पुनरावृत्ति के साथ अद्यतन करने की आवश्यकता नहीं है। इसे ArrayList के अंतिम इंडेक्स में आरंभीकृत किया जाता है और अंतिम तत्व तक पहुंचने के लिए उपयोग किया जाता है। लूप के लिए अंतिम तत्व हटा दिया जाता है और इंडेक्स i में डाला जाता है; जब तक यह ArrayList में अंतिम से अंतिम स्थिति तक नहीं पहुंच जाता, तब तक मुझे वेतन वृद्धि दी जाती है।

— टोड

हां, लेकिन दूसरी पुनरावृत्ति पर, आप IndexOutOfBoundsExceptionतब से नहीं मिलेंगे जब से आप j(मूल ArrayList के अंतिम सूचकांक) को एक्सेस करने की कोशिश कर रहे हैं, लेकिन आपने पहले ही उस इंडेक्स पर ऑब्जेक्ट हटा दिया है?

— टोनी चैन

क्षमा करें, बस कोड चला, निश्चित रूप से काम करता है। मैं भूल गया कि add()अन्य तत्वों को सरणी के नीचे धकेलता हूं , इसलिए सरणी अनिवार्य रूप से एक स्थिर आकार रहता है। दिलचस्प समाधान, धन्यवाद!

— टोनी चैन

इसके अलावा, बस जिज्ञासु लेकिन आप कैसे पुनरावर्ती विधि के साथ आए? मुझे नहीं लगता कि ऐसा कुछ है जो मैं आमतौर पर सोचता हूं।

— टोनी चैन

Answer 3

यहाँ चाल "रिवर्स" को परिभाषित कर रही है। कोई जगह में सूची को संशोधित कर सकता है, रिवर्स ऑर्डर में एक कॉपी बना सकता है, या रिवर्स ऑर्डर में एक दृश्य बना सकता है।

सबसे सरल तरीका, सहज रूप से बोलना है Collections.reverse:

Collections.reverse(myList);

यह विधि सूची में जगह को संशोधित करती है । यही है, Collections.reverseसूची लेता है और अपने तत्वों को अधिलेखित करता है, पीछे कोई अपरिवर्तित प्रतिलिपि नहीं छोड़ता है। यह कुछ उपयोग मामलों के लिए उपयुक्त है, लेकिन दूसरों के लिए नहीं; इसके अलावा, यह माना जाता है कि सूची संशोधित है। यदि यह स्वीकार्य है, तो हम अच्छे हैं।

---

यदि नहीं, तो कोई रिवर्स ऑर्डर में कॉपी बना सकता है :

static <T> List<T> reverse(final List<T> list) {
    final List<T> result = new ArrayList<>(list);
    Collections.reverse(result);
    return result;
}

यह दृष्टिकोण काम करता है, लेकिन सूची में दो बार पुनरावृति की आवश्यकता होती है। कॉपी कंस्ट्रक्टर ( new ArrayList<>(list)) सूची पर निर्भर करता है, और ऐसा ही करता है Collections.reverse। हम इस पद्धति को केवल एक बार पुन: व्यवस्थित करने के लिए लिख सकते हैं, यदि हम इतने इच्छुक हों:

static <T> List<T> reverse(final List<T> list) {
    final int size = list.size();
    final int last = size - 1;

    // create a new list, with exactly enough initial capacity to hold the (reversed) list
    final List<T> result = new ArrayList<>(size);

    // iterate through the list in reverse order and append to the result
    for (int i = last; i >= 0; --i) {
        final T element = list.get(i);
        result.add(element);
    }

    // result now holds a reversed copy of the original list
    return result;
}

यह अधिक कुशल है, लेकिन अधिक क्रिया भी है।

वैकल्पिक रूप से, हम जावा 8 के streamएपीआई का उपयोग करने के लिए उपरोक्त को फिर से लिख सकते हैं , जो कुछ लोगों को ऊपर की तुलना में अधिक संक्षिप्त और सुपाठ्य लगता है:

static <T> List<T> reverse(final List<T> list) {
    final int last = list.size() - 1;
    return IntStream.rangeClosed(0, last) // a stream of all valid indexes into the list
        .map(i -> (last - i))             // reverse order
        .mapToObj(list::get)              // map each index to a list element
        .collect(Collectors.toList());    // wrap them up in a list
}

nb। कि Collectors.toList()परिणाम सूची के बारे में बहुत कुछ की गारंटी देता है बनाता है। यदि आप यह सुनिश्चित करना चाहते हैं कि परिणाम ArrayList के रूप में वापस आए, तो Collectors.toCollection(ArrayList::new)इसके बजाय उपयोग करें ।

---

तीसरा विकल्प उलटे क्रम में एक दृश्य बनाना है । यह एक अधिक जटिल समाधान है, और आगे पढ़ने / अपने स्वयं के प्रश्न के योग्य है। अमरूद की सूची # रिवर्स विधि एक व्यवहार्य प्रारंभिक बिंदु है।

"सरलतम" कार्यान्वयन चुनना पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है।

Answer 4

अतिरिक्त ArrayList या ऐड () और हटाने () विधियों के संयोजन का उपयोग किए बिना समाधान। यदि आप एक बड़ी सूची को उल्टा करना चाहते हैं तो दोनों पर नकारात्मक प्रभाव पड़ सकता है।

 public ArrayList<Object> reverse(ArrayList<Object> list) {

   for (int i = 0; i < list.size() / 2; i++) {
     Object temp = list.get(i);
     list.set(i, list.get(list.size() - i - 1));
     list.set(list.size() - i - 1, temp);
   }

   return list;
 }

Answer 5

ArrayList<Integer> myArray = new ArrayList<Integer>();

myArray.add(1);
myArray.add(2);
myArray.add(3);

int reverseArrayCounter = myArray.size() - 1;

for (int i = reverseArrayCounter; i >= 0; i--) {
    System.out.println(myArray.get(i));
}

Answer 6

पुनरावर्ती तरीके से एक ArrayList को उलटना और तत्वों को जोड़ने के लिए एक नई सूची बनाए बिना:

   public class ListUtil {

    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("1");
        arrayList.add("2");
        arrayList.add("3");
        arrayList.add("4");
        arrayList.add("5");
        System.out.println("Reverse Order: " + reverse(arrayList));

    }

    public static <T> List<T> reverse(List<T> arrayList) {
        return reverse(arrayList,0,arrayList.size()-1);
    }
    public static <T> List<T> reverse(List<T> arrayList,int startIndex,int lastIndex) {

        if(startIndex<lastIndex) {
            T t=arrayList.get(lastIndex);
            arrayList.set(lastIndex,arrayList.get(startIndex));
            arrayList.set(startIndex,t);
            startIndex++;
            lastIndex--;
            reverse(arrayList,startIndex,lastIndex);
        }
        return arrayList;
    }

}

Answer 7

बस अगर हम जावा 8 का उपयोग कर रहे हैं , तो हम स्ट्रीम का उपयोग कर सकते हैं। ArrayList यादृच्छिक अभिगम सूची है और हम रिवर्स ऑर्डर में तत्वों की एक धारा प्राप्त कर सकते हैं और फिर इसे एक नए में इकट्ठा कर सकते हैं ArrayList।

public static void main(String[] args) {
        ArrayList<String> someDummyList = getDummyList();
        System.out.println(someDummyList);
        int size = someDummyList.size() - 1;
        ArrayList<String> someDummyListRev = IntStream.rangeClosed(0,size).mapToObj(i->someDummyList.get(size-i)).collect(Collectors.toCollection(ArrayList::new));
        System.out.println(someDummyListRev);
    }

    private static ArrayList<String> getDummyList() {
        ArrayList dummyList = new ArrayList();
        //Add elements to ArrayList object
        dummyList.add("A");
        dummyList.add("B");
        dummyList.add("C");
        dummyList.add("D");
        return dummyList;
    }

उपरोक्त दृष्टिकोण लिंक्डलिस्ट के लिए उपयुक्त नहीं है क्योंकि यह रैंडम-एक्सेस नहीं है। हम instanceofजाँच के लिए भी उपयोग कर सकते हैं ।

Answer 8

हम java 8 का उपयोग करके भी ऐसा कर सकते हैं।

public static<T> List<T> reverseList(List<T> list) {
        List<T> reverse = new ArrayList<>(list.size());

        list.stream()
                .collect(Collectors.toCollection(LinkedList::new))
                .descendingIterator()
                .forEachRemaining(reverse::add);

        return reverse;
    }

Answer 9

थोड़ा और पठनीय :)

public static <T> ArrayList<T> reverse(ArrayList<T> list) {
    int length = list.size();
    ArrayList<T> result = new ArrayList<T>(length);

    for (int i = length - 1; i >= 0; i--) {
        result.add(list.get(i));
    }

    return result;
}

Answer 10

एक और पुनरावर्ती समाधान

 public static String reverse(ArrayList<Float> list) {
   if (list.size() == 1) {
       return " " +list.get(0);
   }
   else {
       return " "+ list.remove(list.size() - 1) + reverse(list);
   } 
 }