একটি অ্যারেলিস্টকে রিভার্স করার সহজ উপায় কী?

Question

এই অ্যারেলিস্টটি বিপরীত করার সহজ উপায় কী?

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

@ আগরওয়ালশঙ্কর আমি একটি ত্রুটির প্রয়োজন পেয়েছি অ্যারেলিস্টটি শূন্য খুঁজে পেয়েছি। আমি কিছু অনুপস্থিত করছি.

— সাগর দেবঙ্গা

@ সাগরদেভঙ্গা তালিকাটি উল্টোদিকে পরিবর্তিত হয়েছে, ফিরে আসেনি।

— কারসিজেনিকেট

Collections.reverse (তালিকা); আমি এটি একটি অ্যান্ড্রয়েড প্রকল্পে ব্যবহার করেছি, দুর্দান্ত কাজ করে।

— দামির ভারেভাক

এটি আমার উপাদানগুলিকে বিপরীতমুখী করে না ...

Answer 2

সহজ উপায় নয় তবে আপনি যদি পুনরাবৃত্তি করার অনুরাগী হন তবে আপনি অ্যারেলিস্টটি রিভার্স করার জন্য নিম্নলিখিত পদ্ধতিতে আগ্রহী হতে পারেন:

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আপডেট হয়?

— টনি চ্যান

@ টার্বো জে প্রতিটি পুনরাবৃত্তির সাথে আপডেট করার দরকার নেই। এটি অ্যারেলিস্টের শেষ সূচকে সূচনা করা হয় এবং শেষ উপাদানটি অ্যাক্সেস করতে ব্যবহৃত হয়। লুপের ভিতরে শেষ উপাদানটি সরানো হয় এবং সূচীতে সন্নিবেশ করা হয়; অ্যারেলিস্টে এটি শেষ অবস্থানে পৌঁছানোর আগ পর্যন্ত আমার বর্ধিত হয়।

— টড

হ্যাঁ, তবে দ্বিতীয় পুনরাবৃত্তিতে আপনি IndexOutOfBoundsExceptionযেহেতু অ্যাক্সেস করার চেষ্টা করছেন j(মূল অ্যারেলিস্টের শেষ সূচক) তবে আপনি ইতিমধ্যে সেই সূচীতে থাকা অবজেক্টটি সরিয়ে ফেলেছেন?

— টনি চ্যান

দুঃখিত, কেবল কোডটি চালিয়েছে, অবশ্যই কাজ করে। আমি ভুলে গিয়েছি যে 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
}

বিশেষ দ্রষ্টব্য। যে Collectors.toList()ফলাফলের তালিকা সম্পর্কে খুব কম গ্যারান্টী করে তোলে। আপনি যদি ফলাফলটি অ্যারেলিস্ট হিসাবে ফিরে আসে তা নিশ্চিত করতে চান তবে Collectors.toCollection(ArrayList::new)পরিবর্তে ব্যবহার করুন।

---

তৃতীয় বিকল্পটি বিপরীত ক্রমে একটি ভিউ তৈরি করা । এটি একটি আরও জটিল সমাধান, এবং আরও পড়ার / তার নিজের প্রশ্নে যোগ্য। পেয়ারার তালিকাগুলি # বিপরীত পদ্ধতিটি একটি কার্যকর পর্ব।

একটি "সাধারণ" বাস্তবায়ন নির্বাচন করা পাঠকের অনুশীলন হিসাবে ছেড়ে গেছে।

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

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

Comments

এই আমি ব্যবহার করেছি, আপনাকে ধন্যবাদ!

Answer 6

পুনরাবৃত্তিমূলকভাবে একটি অ্যারেলিস্টকে বিপরীত করা এবং উপাদানগুলি যুক্ত করার জন্য একটি নতুন তালিকা তৈরি না করে:

   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।

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

জাভা 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);
   } 
 }