[Java] जावा में एक सूची को कैसे उलट करें?



Answers

अपनी सूची में .clone () विधि का प्रयोग करें। यह एक उथली प्रतिलिपि वापस करेगा, जिसका अर्थ है कि इसमें एक ही ऑब्जेक्ट्स के पॉइंटर्स होंगे, इसलिए आपको सूची कॉपी करने की आवश्यकता नहीं होगी। फिर बस संग्रह का उपयोग करें।

Ergo,

Collections.reverse(list.clone());

यदि आप किसी List का उपयोग कर रहे हैं और clone() तक पहुंच नहीं है तो आप subList() उपयोग कर सकते हैं:

List<?> shallowCopy = list.subList(0, list.size());
Collections.reverse(shallowCopy);
Question

मैं एक सूची में एक उलटा सूची दृश्य देखना चाहता हूं ( List#sublist सूची में एक सूची में एक शानदार दृश्य प्रदान करता है)। क्या कोई ऐसा कार्य है जो इस कार्यक्षमता को प्रदान करता है?

मैं सूची की किसी भी प्रकार की प्रतिलिपि बनाना नहीं चाहता हूं और न ही सूची को संशोधित करना चाहता हूं।

हालांकि, अगर मैं इस मामले में कम से कम एक रिवर्स इटेटरेटर प्राप्त कर सकता हूं तो यह पर्याप्त होगा।

साथ ही, मुझे पता है कि इसे स्वयं कैसे कार्यान्वित किया जाए। मैं सिर्फ यह पूछ रहा हूं कि जावा पहले से ही ऐसा कुछ प्रदान करता है या नहीं।

डेमो कार्यान्वयन:

static <T> Iterable<T> iterableReverseList(final List<T> l) {
    return new Iterable<T>() {
        public Iterator<T> iterator() {
            return new Iterator<T>() {
                ListIterator<T> listIter = l.listIterator(l.size());                    
                public boolean hasNext() { return listIter.hasPrevious(); }
                public T next() { return listIter.previous(); }
                public void remove() { listIter.remove(); }                 
            };
        }
    };
}

मैंने अभी पाया है कि कुछ List कार्यान्वयन descendingIterator() है जो मुझे चाहिए। हालांकि List लिए कोई सामान्य कार्यान्वयन नहीं है। जो कि अजीब तरह का है क्योंकि मैंने LinkedList में जो कार्यान्वयन देखा है वह किसी भी List साथ काम करने के लिए सामान्य है।




जब आप ऑब्जेक्ट का अनुरोध करते हैं तो आप स्थिति को भी उलटा कर सकते हैं:

Object obj = list.get(list.size() - 1 - position);



मैं इसका उपयोग करता हूं:

public class ReversedView<E> extends AbstractList<E>{

    public static <E> List<E> of(List<E> list) {
        return new ReversedView<>(list);
    }

    private final List<E> backingList;

    private ReversedView(List<E> backingList){
        this.backingList = backingList;
    }

    @Override
    public E get(int i) {
        return backingList.get(backingList.size()-i-1);
    }

    @Override
    public int size() {
        return backingList.size();
    }

}

इस तरह:

ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list



यह बिल्कुल सुरुचिपूर्ण नहीं है, लेकिन यदि आप List.listIterator (int अनुक्रमणिका) का उपयोग करते हैं तो आप सूची के अंत में एक द्वि-दिशात्मक सूचीकरण प्राप्त कर सकते हैं:

//Assume List<String> foo;
ListIterator li = foo.listIterator(foo.size());

while (li.hasPrevious()) {
   String curr = li.previous()
}



java.util.Deque descendingIterator() है descendingIterator() - यदि आपकी List एक Deque , तो आप इसका उपयोग कर सकते हैं।






Links