Bagaimana saya bisa mengurutkan Daftar berdasarkan abjad?

Saya memiliki List<String>objek yang berisi nama negara. Bagaimana saya bisa mengurutkan daftar ini berdasarkan abjad?

Dengan asumsi bahwa itu adalah Strings, gunakan metode statis yang mudah digunakan sort...

 java.util.Collections.sort(listOfCountryNames)

Solusi dengan Collections.sort

Jika Anda dipaksa untuk menggunakan Daftar itu, atau jika program Anda memiliki struktur suka

• Buat Daftar
• Tambahkan beberapa nama negara
• sortir sekali
• jangan pernah mengubah daftar itu lagi

maka jawaban Thilos akan menjadi cara terbaik untuk melakukannya. Jika Anda menggabungkannya dengan saran dari Tom Hawtin - tackline , Anda mendapatkan:

java.util.Collections.sort(listOfCountryNames, Collator.getInstance());

Solusi dengan TreeSet

Jika Anda bebas untuk memutuskan, dan jika aplikasi Anda mungkin menjadi lebih kompleks, maka Anda dapat mengubah kode Anda untuk menggunakan TreeSet sebagai gantinya. Koleksi semacam ini mengurutkan entri Anda hanya ketika mereka dimasukkan. Tidak perlu memanggil sort ().

Collection<String> countryNames = 
    new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.

Catatan tentang mengapa saya lebih suka TreeSet

Ini memiliki beberapa keuntungan yang halus, tetapi penting:

• Itu lebih pendek. Namun, hanya satu baris yang lebih pendek.
• Jangan khawatir tentang apakah daftar ini benar-benar diurutkan sekarang karena TreeSet selalu disortir, apa pun yang Anda lakukan.
• Anda tidak dapat memiliki entri duplikat. Tergantung pada situasi Anda, ini mungkin pro atau kontra. Jika Anda membutuhkan duplikat, tetap pada Daftar Anda.
• Seorang programmer berpengalaman melihat TreeSet<String> countyNamesdan langsung tahu: ini adalah kumpulan String yang diurutkan tanpa duplikat, dan saya dapat yakin bahwa ini benar setiap saat . Begitu banyak informasi dalam deklarasi pendek.
• Kinerja nyata menang dalam beberapa kasus. Jika Anda menggunakan Daftar, dan memasukkan nilai sangat sering, dan daftar tersebut dapat dibaca di antara sisipan itu, maka Anda harus mengurutkan daftar setelah setiap penyisipan. Set melakukan hal yang sama, tetapi melakukannya lebih cepat.

Menggunakan koleksi yang tepat untuk tugas yang tepat adalah kunci untuk menulis kode pendek dan bebas bug. Ini tidak terlalu demonstratif dalam kasus ini, karena Anda hanya menyimpan satu baris. Tapi saya sudah berhenti menghitung seberapa sering saya melihat seseorang menggunakan Daftar ketika mereka ingin memastikan tidak ada duplikat, dan kemudian membangun fungsi itu sendiri. Atau lebih buruk lagi, menggunakan dua Daftar saat Anda benar-benar membutuhkan Peta.

Jangan salah paham: Menggunakan Collections.sort bukan kesalahan atau cacat. Tetapi ada banyak kasus ketika TreeSet jauh lebih bersih.

Anda dapat membuat salinan diurutkan baru menggunakan Java 8 Stream atau Jambu:

// Java 8 version
List<String> sortedNames = names.stream().sorted().collect(Collectors.toList());
// Guava version
List<String> sortedNames = Ordering.natural().sortedCopy(names); 

Opsi lain adalah mengurutkan di tempat melalui API Koleksi:

Collections.sort(names);

Lebih baik terlambat daripada tidak sama sekali! Inilah cara kami dapat melakukannya (hanya untuk tujuan pembelajaran) -

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

class SoftDrink {
    String name;
    String color;
    int volume; 

    SoftDrink (String name, String color, int volume) {
        this.name = name;
        this.color = color;
        this.volume = volume;
    }
}

public class ListItemComparision {
    public static void main (String...arg) {
        List<SoftDrink> softDrinkList = new ArrayList<SoftDrink>() ;
        softDrinkList .add(new SoftDrink("Faygo", "ColorOne", 4));
        softDrinkList .add(new SoftDrink("Fanta",  "ColorTwo", 3));
        softDrinkList .add(new SoftDrink("Frooti", "ColorThree", 2));       
        softDrinkList .add(new SoftDrink("Freshie", "ColorFour", 1));

        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //use instanceof to verify the references are indeed of the type in question
                return ((SoftDrink)softDrinkOne).name
                        .compareTo(((SoftDrink)softDrinkTwo).name);
            }
        }); 
        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.name + " - " + sd.color + " - " + sd.volume);
        }
        Collections.sort(softDrinkList, new Comparator() {
            @Override
            public int compare(Object softDrinkOne, Object softDrinkTwo) {
                //comparision for primitive int uses compareTo of the wrapper Integer
                return(new Integer(((SoftDrink)softDrinkOne).volume))
                        .compareTo(((SoftDrink)softDrinkTwo).volume);
            }
        });

        for (SoftDrink sd : softDrinkList) {
            System.out.println(sd.volume + " - " + sd.color + " - " + sd.name);
        }   
    }
}

Dalam satu baris, menggunakan Java 8:

list.sort(Comparator.naturalOrder());

Gunakan dua argumen untuk dari Collections.sort. Anda akan menginginkan yang cocok Comparatormemperlakukan kasus yang sesuai (yaitu tidak leksikal, bukan memesan UTF16), seperti yang diperoleh melalui java.text.Collator.getInstance.

Kecuali jika Anda mengurutkan string dalam bahasa Inggris bebas aksen saja, Anda mungkin ingin menggunakan a Collator. Ini akan mengurutkan dengan benar tanda diakritik, dapat mengabaikan huruf besar-kecil dan hal-hal khusus bahasa lainnya:

Collections.sort(countries, Collator.getInstance(new Locale(languageCode)));

Anda dapat mengatur kekuatan kolator , lihat javadoc.

Berikut ini adalah contoh untuk Slovak di mana Šharus pergi setelah S, tetapi di UTF Šadalah suatu tempat setelah Z:

List<String> countries = Arrays.asList("Slovensko", "Švédsko", "Turecko");

Collections.sort(countries);
System.out.println(countries); // outputs [Slovensko, Turecko, Švédsko]

Collections.sort(countries, Collator.getInstance(new Locale("sk")));
System.out.println(countries); // outputs [Slovensko, Švédsko, Turecko]

Inilah yang Anda cari

listOfCountryNames.sort(String::compareToIgnoreCase)

Dengan menggunakan Collections.sort(), kita dapat mengurutkan daftar.

public class EmployeeList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<String> empNames= new ArrayList<String>();

        empNames.add("sudheer");
        empNames.add("kumar");
        empNames.add("surendra");
        empNames.add("kb");

        if(!empNames.isEmpty()){

            for(String emp:empNames){

                System.out.println(emp);
            }

            Collections.sort(empNames);

            System.out.println(empNames);
        }
    }
}

keluaran:

sudheer
kumar
surendra
kb
[kb, kumar, sudheer, surendra]

menurun alfabet:

List<String> list;
...
Collections.sort(list);
Collections.reverse(list);

Sama di JAWA 8: -

//Assecnding order
        listOfCountryNames.stream().sorted().forEach((x) -> System.out.println(x));

//Decending order
        listOfCountryNames.stream().sorted((o1, o2) -> o2.compareTo(o1)).forEach((x) -> System.out.println(x));

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

}
}

Anda dapat mencoba menggunakan metode yang saya buat.

String key- akan menjadi urutan yang Anda inginkan dan dalam hal ini secara alfabet. Cukup cantumkan "abc ...".

String list[] - daftar yang ingin Anda masukkan menggunakan kunci.

int index - set sebagai 0, akan mengatur offset untuk kunci.

    public static String[] order(String key, String list[], int index) {
    ArrayList<String> order_List = new ArrayList<String>();
    ArrayList<String> temp_Order_List = null;
    char[] key_char = key.toCharArray();
    for (int offset = 0; offset < key_char.length; offset++) {
        if (key_char.length >= offset + index) {
            String str = (index > 1 ? list[0].substring(0, index - 1) : "")
                    + new String(key_char, offset, 1);
            for (int i = 0; i < list.length; i++) {
                temp_Order_List = new ArrayList<String>();
                for (int k = 0; k < list.length; k++) {
                    if (!order_List.contains(list[k])
                            && !temp_Order_List.contains(list[k])) {
                        if (list[k].equalsIgnoreCase(str))
                            order_List.add(list[k]);
                        else if (list[k].toLowerCase().startsWith(str.toLowerCase())) {
                            temp_Order_List.add(list[k]);

                        }
                    }
                }
                if (temp_Order_List.size() > 0) {
                    if (temp_Order_List.size() > 1) {
                        String[] add = order(key,
                                temp_Order_List.toArray(new String[temp_Order_List
                                        .size()]), index + 1);
                        for (String s : add) {
                            order_List.add(s);
                        }
                    } else {
                        order_List.add(temp_Order_List.get(0));
                    }
                }
            }
        }
    }
    return order_List.toArray(new String[order_List.size()]);
}