Listeyi alfabetik olarak nasıl sıralayabilirim?

List<String>Ülke adlarını içeren bir nesnem var. Bu listeyi alfabetik olarak nasıl sıralayabilirim?

Bunların Dizeler olduğunu varsayarsak, uygun statik yöntemi kullanın sort…

 java.util.Collections.sort(listOfCountryNames)

Collections.sort ile çözüm

Bu Listeyi kullanmak zorunda kalırsanız veya programınız aşağıdaki gibi bir yapıya sahipse

• Liste Oluştur
• Bazı ülke adları ekleyin
• onları bir kez sırala
• listeyi bir daha asla değiştirme

Thilos cevabı bunu yapmanın en iyi yolu olacaktır. Tom Hawtin - tackline'ın tavsiyesi ile birleştirirseniz , şunları elde edersiniz:

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

TreeSet ile çözüm

Karar vermekte özgürseniz ve uygulamanız daha karmaşık hale gelebilirse, bunun yerine bir TreeSet kullanmak için kodunuzu değiştirebilirsiniz. Bu tür bir koleksiyon girişlerinizi sadece eklendiklerinde sıralar. Sort () öğesini çağırmanıza gerek yoktur.

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

TreeSet'i neden tercih ettiğime dair yan not

Bunun bazı ince ama önemli avantajları vardır:

• Sadece daha kısa. Yine de sadece bir satır daha kısadır.
• Endişelenmeyin , bu liste gerçekten şu anda sıralanıyor, çünkü ne yaparsanız yapın, bir TreeSet her zaman sıralanır.
• Yinelenen girişleriniz olamaz. Durumunuza bağlı olarak bu bir profesyonel ya da aleyhte olabilir. Kopyalara ihtiyacınız varsa Listenize sadık kalın.
• Deneyimli bir programcı bakar TreeSet<String> countyNamesve anında bilir: Bu yinelenen dizeleri sıralı bir koleksiyon ve bunun her an doğru olduğundan emin olabilirim . Kısa bir açıklamada çok fazla bilgi var.
• Bazı durumlarda gerçek performans kazanır. Bir Liste kullanır ve değerleri çok sık eklerseniz ve liste bu eklemeler arasında okunabiliyorsa, listeyi her eklemeden sonra sıralamanız gerekir. Set aynı şeyi yapar, ancak çok daha hızlı yapar.

Doğru görev için doğru koleksiyonu kullanmak kısa ve hatasız kod yazmak için bir anahtardır. Bu durumda bu kadar açıklayıcı değil, çünkü sadece bir satır kaydedersiniz. Ancak yinelenen bir şey olmadığından emin olmak istediklerinde bir Listeyi kullanan birinin ne sıklıkta gördüğümü saymayı bıraktım ve sonra bu işlevselliği kendileri oluşturduk. Ya da daha kötüsü, gerçekten bir Haritaya ihtiyacınız olduğunda iki Liste kullanmak.

Beni yanlış anlamayın: Collections.sort kullanmak bir hata ya da kusur değildir. Ancak TreeSet'in çok daha temiz olduğu birçok durum var.

Java 8 Stream veya Guava kullanarak yeni bir sıralanmış kopya oluşturabilirsiniz:

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

Başka bir seçenek de Koleksiyonlar API'sı aracılığıyla yerinde sıralamaktır:

Collections.sort(names);

Geç olsun güç olmasın! İşte bunu nasıl yapabiliriz (sadece öğrenme amaçlı) -

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

Bir satırda Java 8 kullanarak:

list.sort(Comparator.naturalOrder());

İçin iki bağımsız değişkenini kullanın Collections.sort. Bu şekilde Comparatorelde edilebilecek gibi davayı uygun şekilde ele alan (UTF16 sıralamasında değil sözcüksel olan) bir uygunluk isteyeceksiniz java.text.Collator.getInstance.

Dizeleri yalnızca aksan içermeyen İngilizce olarak sıralamıyorsanız, muhtemelen bir Collator. Aksan işaretlerini doğru bir şekilde sıralar, büyük / küçük harf ve diğer dile özgü şeyleri yoksayabilir:

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

Kollektör gücünü ayarlayabilirsiniz , bkz. Javadoc.

İşte Slovakya'ya nereye Šgitmesi gerektiğini gösteren bir örnek S, ancak UTF'de bir Šyer 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]

İşte aradığınız şey

listOfCountryNames.sort(String::compareToIgnoreCase)

Kullanarak Collections.sort()bir listeyi sıralayabiliriz.

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

çıktı:

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

azalan alfabe:

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

JAVA 8 ile aynı: -

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

}
}

Yaptığım bir yöntemi kullanmayı deneyebilirsiniz.

String key- İstediğiniz sıra ve bu durumda alfabetik olarak olacaktır. Sadece "abc ..." koy.

String list[] - tuşunu kullanarak sıraya koymak istediğiniz liste.

int index - 0 olarak ayarlandığında, tuşun ofsetini ayarlar.

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