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

Question

इस ऐरेलिस्ट को रिवर्स करने का सबसे आसान तरीका क्या है?

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

उदाहरण (Reference):

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

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

Answer 3

एक छोटी सी अधिक पठनीय :) अतिरिक्त ArrayList या ऐड के संयोजन का उपयोग किए बिना

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 4

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

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

Answer 5

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

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

Answer 6

बस मामले में हम जावा 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; 
    } 

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

Answer 7

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

सबसे आसान तरीका है, सहज बोल, 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() परिणाम सूची के बारे में बहुत कम गारंटी देता है। यदि आप यह सुनिश्चित करना चाहते हैं कि परिणाम एक ऐरेलिस्ट के रूप में वापस आता है, तो इसके बजाय Collectors.toCollection(ArrayList::new) का उपयोग करें।

---

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

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

Answer 8

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 9

एक पुनरावर्ती तरह से और जोड़ने तत्वों के लिए एक नई सूची बनाने के बिना एक 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; 
    } 

}