কিভাবে একটি অ্যারেলিস্ট বাছাই?

Question

আমার জাভাতে ডাবলসের একটি তালিকা রয়েছে এবং আমি অ্যারেলিস্টকে অবতরণ অনুসারে বাছাই করতে চাই।

ইনপুট অ্যারেলিস্টটি নীচে হিসাবে রয়েছে:

List<Double> testList = new ArrayList();

testList.add(0.5);
testList.add(0.2);
testList.add(0.9);
testList.add(0.1);
testList.add(0.1);
testList.add(0.1);
testList.add(0.54);
testList.add(0.71);
testList.add(0.71);
testList.add(0.71);
testList.add(0.92);
testList.add(0.12);
testList.add(0.65);
testList.add(0.34);
testList.add(0.62);

আউটপুটটি এমন হওয়া উচিত

0.92
0.9
0.71
0.71
0.71
0.65
0.62
0.54
0.5
0.34
0.2
0.12
0.1
0.1
0.1

Answer 1

Collections.sort(testList);
Collections.reverse(testList);

যা আপনি চান তা করবে। আমদানি মনে রাখবেন Collections!

এখানে জন্য ডকুমেন্টেশনCollections ।

Comments

হতে পারে এটি উল্লেখ করার মতো যে আপনি নিজের নিজস্ব সংজ্ঞা দিতে পারেন Comparator:)

— Polygnome

@ পলিজোনোম ওপি কেবলমাত্র বাছাই করছে Double।

— tckmn

হ্যাঁ, তবে আপনি ব্যবহারের ক্ষেত্রে নির্ভর করে এগুলি বিভিন্ন উপায়ে বাছাই করতে পারেন। কখনও কখনও আপনি তাদের 0. দূরত্ব এটি অনুসারে বাছাইয়ের জন্য আমি এমনকি এর রানটাইম বৈশিষ্ট্য সম্পর্কে জানি না চাইতে পারেন reverse, কিন্তু বাছাই সাজানো আসলে দ্রুত তারপর হতে পারে আরোহী বাছাই এবং তারপর reversing। তদুপরি, একটি তালিকা বাস্তবায়ন যা Comparatorকনস্ট্রাক্টর আর্গুমেন্ট হিসাবে সমর্থন করে (সুতরাং এটি অবিস্মরণীয় রাখা) তালিকাটি সর্বদা বাছাই করা নিশ্চিত করবে।

— বহুগ্রাহ্য

আয়েশা হ্যাঁ, পর্দার আড়ালে Collections.sortব্যবহার compareToকরুন।

— tckmn

একটি ব্যবহার করা উচিত Collections.sort(list, Collections.reverseOrder());। আরও বুদ্ধিমান (এবং সম্ভবত আরও দক্ষ) হওয়া ছাড়াও, বিপরীত ক্রমের তুলনামূলক ব্যবহারটি নিশ্চিত করে তোলে যে সাজানো স্থিতিশীল রয়েছে (অর্থাত্ তুলনাকারী অনুসারে উপাদানগুলির সমান হলে উপাদানগুলির ক্রম পরিবর্তন হবে না, যখন বিপরীত ক্রমটি পরিবর্তিত হবে) )।

— মার্কো 13

Answer 2

নিম্নক্রম:

Collections.sort(mArrayList, new Comparator<CustomData>() {
    @Override
    public int compare(CustomData lhs, CustomData rhs) {
        // -1 - less than, 1 - greater than, 0 - equal, all inversed for descending
        return lhs.customInt > rhs.customInt ? -1 : (lhs.customInt < rhs.customInt) ? 1 : 0;
    }
});

Comments

আমি যা CustomData করব List<AnotherModel>যা যদি AnotherModelআছে idএবং আমি অনুসারে বাছাই করতে চাই id? এবং আমি কেবল CustomData আমার ক্লাসে মডেল অ্যাক্সেস করি।

— ডাঃ জ্যাকি

আপনি কেবলমাত্র কাস্টমডাটা ক্লাসটিকে অন্যমোডেলের সাথে প্রতিস্থাপন করতে এবং এর মতো একটি লাইন পাবেন: lhs.id> rhs.id ফিরবেন? -1: .. ইত্যাদি

— ব্যবহারকারী 2808054

তুলনা রিটার্ন স্টেটমেন্টটি আরও ভাল হিসাবে লেখা যেতে পারেInteger.compare(rhs.customInt, lhs.customInt);

— লর্ডকিজ

Answer 3

Java.util. সংগ্রহ সংগ্রহ শ্রেণীর ব্যবহারের পদ্ধতিটি ব্যবহার করুন

Collections.sort(list)

আসলে, আপনি যদি কাস্টম অবজেক্টটি বাছাই করতে চান তবে আপনি ব্যবহার করতে পারেন

Collections.sort(List<T> list, Comparator<? super T> c) 

সংগ্রহ দেখুন এপিআই

Answer 4

আপনার উদাহরণস্বরূপ, এটি জাভা 8-এ যাদু করবে

List<Double> testList = new ArrayList();
testList.sort(Comparator.naturalOrder());

আপনি যদি সাজানোর জিনিসটির কিছু ক্ষেত্র বাছাই করতে চান তবে আপনি সহজেই এটি করতে পারেন:

testList.sort(Comparator.comparing(ClassName::getFieldName));

অথবা

 testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());

অথবা

 testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());

সূত্র: https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

Comments

'তুলনা' পদ্ধতিটি কোথায় অবস্থিত?

— lippo

আপনাকে আমদানি করতে হবে: স্ট্যাটিক java.util.Comparator.compering আমদানি করুন;

— krmanish007

এটি জাভা 1.7 এর সাথে পাওয়া যায়?

— লিপ্পো

না, এটি স্ট্রিম এবং ক্রিয়ামূলক ইন্টারফেসের একটি অংশ, যা জাভা 8 এর সমস্ত অংশ

— krmanish007

আপনি ঠিক @ অজানচর্লেস ঠিক আছেন। তারা শূন্য-আরগ মুছে ফেলেছে, তাই আমি এখনই আমার উত্তর আপডেট করেছি।

— krmanish007

Answer 5

ল্যাম্বডাস (জাভা 8) ব্যবহার করে এবং এটি সিন্ট্যাক্সের বেস্টে নামিয়ে দেওয়া (জেভিএম এই ক্ষেত্রে প্রচুর পরিমাণে অনুমান করবে ), আপনি পাবেন:

Collections.sort(testList, (a, b) -> b.compareTo(a));

আরও ভার্বোজ সংস্করণ:

// Implement a reverse-order Comparator by lambda function
Comparator<Double> comp = (Double a, Double b) -> {
    return b.compareTo(a);
};

Collections.sort(testList, comp);

ল্যাম্বডা ব্যবহার করা সম্ভব কারণ তুলনাকারী ইন্টারফেসটির প্রয়োগের জন্য কেবল একটি একক পদ্ধতি রয়েছে, তাই ভিএম কোন পদ্ধতিটি প্রয়োগ করছে তা অনুমান করতে পারে। যেহেতু প্যারাম ধরনের অনুমান করা যায়, তারা বিবৃত করা (অর্থাত প্রয়োজন হবে না (a, b)পরিবর্তে (Double a, Double b)। যেহেতু ল্যামডা শরীরের শুধুমাত্র একটি একক লাইন আছে, এবং পদ্ধতি কোন মান ফিরিয়ে বলে আশা করা হচ্ছে, returnঅনুমিত এবং ধনুর্বন্ধনী হয় প্রয়োজন হয় না।

Comments

এটি দুর্দান্ত, ধন্যবাদ! এটি একটি আরও কিছুটা কমপ্যাক্ট: কালেকশন.সোর্ট (টেস্টলিস্ট, তুলনামূলক। রিভার্সআর্ডার ());

— কাভিক্স

আরও কমপ্যাক্ট: টেস্টলিস্ট.সোর্ট (তুলনামূলক.রেভারআর্ডার ());

— জুনসপেলিতা

Answer 6

জাভা 8 এর সাথে তালিকার ইন্টারফেসে একটি ডিফল্ট বাছাই পদ্ধতি রয়েছে যা আপনি যদি কোনও তুলনামূলক সরবরাহ করেন তবে আপনাকে সংগ্রহটি বাছাই করার অনুমতি দেবে। আপনি প্রশ্নে উদাহরণটি সহজেই নিম্নরূপে বাছাই করতে পারেন:

testList.sort((a, b) -> Double.compare(b, a));

দ্রষ্টব্য: ল্যাম্বডায় আর্গগুলি অদলবদল হয় তা নিশ্চিত করার জন্য ডাবল ডটকমকে পাস করার সময় অদলবদল করা হয়

Comments

আমার কাছে এটি সর্বোত্তম উত্তর কারণ এটি অবজেক্টগুলি ব্যবহার করে বাছাইয়ের জন্যও কাজ করে ... উদাহরণস্বরূপ locationDetails.sort((locationDetailAsc,locationDetailsDsc) -> Long.compare(locationDetailsDsc.getSnapshot().getQuantity(), locationDetailAsc.getSnapshot().getQuantity()));

— আনাস

Answer 7

যদি আপনার উপাদান থাকে তবে Collections.sort(list)আপনি বাছাই করতে ব্যবহার করতে পারেন । অন্যথায় আমি আপনাকে এখানে অনুরূপ ইন্টারফেস প্রয়োগ করার পরামর্শ দিচ্ছি:listlistComparable

public class Circle implements Comparable<Circle> {}

এবং অবশ্যই compareToএখানে আপনার নিজস্ব পদ্ধতি উপলব্ধি প্রদান :

@Override
    public int compareTo(Circle another) {
        if (this.getD()<another.getD()){
            return -1;
        }else{
            return 1;
        }
    }

এবং তারপরে আপনি Colection.sort(list)এখন হিসাবে ব্যবহার করতে পারেন তালিকায় তুলনামূলক ধরণের অবজেক্ট রয়েছে এবং বাছাই করা যায়। অর্ডার compareToপদ্ধতির উপর নির্ভর করে । আরও বিস্তারিত তথ্যের জন্য এই https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html দেখুন।

Answer 8

Collections.sortআপনাকে Comparatorবাছাইয়ের যুক্তি সংজ্ঞায়িত করে এমন একটি উদাহরণ পাস করতে দেয় । সুতরাং তালিকাটিকে প্রাকৃতিক ক্রমে বাছাই করা এবং তারপরে এটির বিপরীতে পরিবর্তনের পরিবর্তে, তালিকাটি বিপরীত ক্রমে সাজানোর Collections.reverseOrder()জন্য কেবল পাস করতে পারেন sort:

// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());

@ মার্কো 13 দ্বারা উল্লিখিত হিসাবে, আরও মুশকিল (এবং সম্ভবত আরও দক্ষ) হওয়া বাদ দিয়ে বিপরীত ক্রমের তুলনামূলক ব্যবহারটি নিশ্চিত করে তোলে যে সাজানটি স্থিতিশীল রয়েছে (অর্থাত্ যখন তারা তুলনাকারীর সাথে সামঞ্জস্য হয় তখন উপাদানগুলির ক্রম পরিবর্তন হবে না, যদিও বিপরীত ক্রম পরিবর্তন করবে)

Answer 9

//Here is sorted List alphabetically with syncronized

package com.mnas.technology.automation.utility;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

/**
 * @author manoj.kumar
 */
public class SynchronizedArrayList {
    static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName());

    @SuppressWarnings("unchecked")
    public static void main(String[] args) {

        List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>());
        synchronizedList.add(new Employee("Aditya"));
        synchronizedList.add(new Employee("Siddharth"));
        synchronizedList.add(new Employee("Manoj"));
        Collections.sort(synchronizedList, new Comparator() {
            public int compare(Object synchronizedListOne, Object synchronizedListTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((Employee) synchronizedListOne).name
                        .compareTo(((Employee) synchronizedListTwo).name);
            }
        }); 
    /*for( Employee sd : synchronizedList) {
    log.info("Sorted Synchronized Array List..."+sd.name);
    }*/

        // when iterating over a synchronized list, we need to synchronize access to the synchronized list
        synchronized (synchronizedList) {
            Iterator<Employee> iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                log.info("Sorted Synchronized Array List Items: " + iterator.next().name);
            }
        }

    }
}

class Employee {
    String name;

    Employee(String name) {
        this.name = name;

    }
}

Comments

— থাস

Answer 10

এখানে একটি সংক্ষিপ্ত চিটশিট রয়েছে যা সাধারণ ক্ষেত্রেগুলি জুড়ে:

// sort
list.sort(naturalOrder())

// sort (reversed)
list.sort(reverseOrder())

// sort by field
list.sort(comparing(Type::getField))

// sort by field (reversed)
list.sort(comparing(Type::getField).reversed())

// sort by int field
list.sort(comparingInt(Type::getIntField))

// sort by double field (reversed)
list.sort(comparingDouble(Type::getDoubleField).reversed())

// sort by nullable field (nulls last)
list.sort(comparing(Type::getNullableField, nullsLast(naturalOrder())))

// two-level sort
list.sort(comparing(Type::getField1).thenComparing(Type::getField2))

Answer 11

আপনি যদি জাভা এসই 8 ব্যবহার করছেন, তবে এটি সাহায্য হতে পারে।

//create a comparator object using a Lambda expression
Comparator<Double> compareDouble = (d1, d2) -> d1.compareTo(d2);

//Sort the Collection in this case 'testList' in reverse order
Collections.sort(testList, Collections.reverseOrder(compareDouble));

//print the sorted list using method reference only applicable in SE 8
testList.forEach(System.out::println);

Comments

রয়েছে Collections.reverseOrder()যা আপনার বাস্তবায়ন করে তোলে, কোনো আর্গুমেন্ট ছাড়া compareDoubleঅতিরিক্ত (এটা স্বাভাবিক ক্রম সমতুল্য Doubleগুলি)। এখানে উত্তরটি হওয়া উচিতCollections.sort(testList, Collections.reverseOrder());

— ম্যাট

Answer 12

| * | একটি তালিকা বাছাই করা:

import java.util.Collections;

| => এসসি অর্ডার বাছাই করুন:

Collections.sort(NamAryVar);

| => ডিএসসি অর্ডার বাছাই করুন:

Collections.sort(NamAryVar, Collections.reverseOrder());

---

| * | তালিকার ক্রমটিকে বিপরীত করুন:

Collections.reverse(NamAryVar);

Answer 13

আপনি এটির মতো করতে পারেন:

List<String> yourList = new ArrayList<String>();
Collections.sort(yourList, Collections.reverseOrder());

সংগ্রহের একটি ডিফল্ট তুলনামূলক রয়েছে যা আপনাকে এটিতে সহায়তা করতে পারে।

এছাড়াও, আপনি যদি কিছু জাভা 8 টি নতুন বৈশিষ্ট্য ব্যবহার করতে চান তবে আপনি এটি করতে পারেন:

List<String> yourList = new ArrayList<String>();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());

Answer 14

উদাহরণস্বরূপ আমার কাছে একটি শ্রেণি ব্যক্তি রয়েছে: স্ট্রিং নাম, অন্ত বয়স ==> কনস্ট্রাক্টর নতুন ব্যক্তি (নাম, বয়স)

import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;


public void main(String[] args){
    Person ibrahima=new Person("Timera",40);
    Person toto=new Person("Toto",35);
    Person alex=new Person("Alex",50);
    ArrayList<Person> myList=new ArrayList<Person>
    Collections.sort(myList, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            // return p1.age+"".compareTo(p2.age+""); //sort by age
            return p1.name.compareTo(p2.name); // if you want to short by name
        }
    });
    System.out.println(myList.toString());
    //[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]]
    Collections.reverse(myList);
    System.out.println(myList.toString());
    //[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]]

}

Comments

if you want to short by name->if you want to sort by name

— লিন্রংবিন

Answer 15

জাভা 8 এ এখন এটি অনেক সহজ।

List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four");
List<String> alphaNumbersUpperCase = alphaNumbers.stream()
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]

- বিপরীতে এটি ব্যবহার করুন

.sorted(Comparator.reverseOrder())

Answer 16

আপনি এটি ব্যবহার করতে পারেন

ArrayList<Group> groupList = new ArrayList<>();
Collections.sort(groupList, Collections.reverseOrder());
Collections.reverse(groupList);

Answer 17

সঙ্গে অন্ধকার সংগ্রহগুলি আপনি একটি আদিম ডবল তালিকা তৈরি তা বাছাই এবং তারপর বিপরীত ক্রম সাজানো এটা করা যেতে পারে। এই পদ্ধতির বক্সিং দ্বিগুণ এড়ানো হবে।

MutableDoubleList doubleList =
    DoubleLists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis().reverseThis();
doubleList.each(System.out::println);

আপনি যদি একটি চান List<Double>, তবে নিম্নলিখিতগুলি কাজ করবে।

List<Double> objectList =
    Lists.mutable.with(
        0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71,
        0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62)
        .sortThis(Collections.reverseOrder());
objectList.forEach(System.out::println);

আপনি যদি প্রকারটি ধরে রাখতে চান তবে আপনি ইউটিলিটি ক্লাসটি ArrayList<Double>ব্যবহার করে তালিকাটি সূচনা করে বাছাই করতে পারেন ArrayListIterate:

ArrayList<Double> arrayList =
    ArrayListIterate.sortThis(
            new ArrayList<>(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);

দ্রষ্টব্য: আমি গ্রহগ্রাহ সংগ্রহের প্রতিশ্রুতিবদ্ধ ।

Answer 18

নিম্নলিখিত লাইনটি পুরু করা উচিত

testList.sort(Collections.reverseOrder());