Hoe kan ik een lijst alfabetisch sorteren?

Ik heb een List<String>-object dat landnamen bevat. Hoe kan ik deze lijst alfabetisch sorteren?

Antwoord 1, autoriteit 100%

Ervan uitgaande dat dit strings zijn, gebruik dan de handige statische methode sort…

java.util.Collections.sort(listOfCountryNames)

Antwoord 2, autoriteit 64%

Oplossing met Collections.sort

Als je gedwongen bent om die lijst te gebruiken, of als je programma een structuur heeft zoals

• Lijst maken
• Voeg wat landnamen toe
• sorteer ze één keer
• wijzig die lijst nooit meer

dan is het antwoord van Thilos de beste manier om dit te doen. Als je het combineert met het advies van Tom Hawtin – tackline, krijg je:

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

Oplossing met een TreeSet

Als u vrij bent om te beslissen, en als uw toepassing misschien complexer wordt, kunt u uw code wijzigen om in plaats daarvan een TreeSet te gebruiken. Dit soort verzameling sorteert uw invoer precies wanneer ze worden ingevoegd. U hoeft sort() niet aan te roepen.

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

Kanttekening waarom ik de TreeSet verkies

Dit heeft enkele subtiele, maar belangrijke voordelen:

• Het is gewoon korter. Maar één regel korter.
• Maak je nooit zorgen over Is deze lijst echt gesorteerd op dit moment want een bomen is altijd gesorteerd, ongeacht wat je doet.
• U kunt geen dubbele vermeldingen hebben. Afhankelijk van uw situatie kan dit een pro of een con zijn. Als u duplicaten nodig heeft, blijf dan aan uw lijst.
• Een ervaren programmeur kijkt naar TreeSet<String> countyNamesEn meteen kent: Dit is een gesorteerde verzameling van strings zonder duplicaten, en ik kan er zeker van zijn dat dit op elk moment waar is . Zoveel informatie in een korte verklaring.
• echte prestaties overwinnen in sommige gevallen. Als u een lijst gebruikt en waarden heel vaak invoegt, en de lijst kan worden gelezen tussen deze inserties, dan moet u de lijst na elke insertie sorteren. De set doet hetzelfde, maar doet het veel sneller.

De juiste collectie gebruiken voor de juiste taak is een sleutel om een ​​korte en bug gratis code te schrijven. Het is in dit geval niet zo demonstratief, omdat u gewoon één regel bespaart. Maar ik ben gestopt met tellen hoe vaak ik iemand zie die een lijst met behulp van wanneer ze ervoor willen zorgen dat er geen duplicten zijn en vervolgens die functionaliteit zelf bouwen. Of nog erger, met behulp van twee lijsten wanneer je echt een kaart nodig hebt.

Breng me niet verkeerd: met behulp van collecties.Sort is geen fout of een fout. Maar er zijn veel gevallen wanneer de bomen veel schoner is.

Antwoord 3, Autoriteit 14%

U kunt een nieuw gesorteerde kopie maken met Java 8 Stream of Guava:

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

Een andere optie is om in-place via Collections API te sorteren:

Collections.sort(names);

Antwoord 4, Autoriteit 12%

Beter laat dan nooit! Hier is hoe we dit kunnen doen (voor het leren purpose only) –

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

Antwoord 5, Autoriteit 7%

In één regel, met behulp van Java 8:

list.sort(Comparator.naturalOrder());

Antwoord 6, Autoriteit 6%

Tenzij u alleen snaren in een accent-gratis Engels sorteert, wilt u waarschijnlijk een Collatorgebruiken. Het zal corrigeren van diakritische merken, kan de zaak en andere taal-specifieke dingen negeren:

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

U kunt de Collator sterkte , zie de Javadoc.

Hier is een voorbeeld voor Slowaaks waar Šmoet gaan na S, maar in UTF Šis ergens na 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]

Antwoord 7, Autoriteit 5%

Gebruik het twee argument voor Collections.sort. U wilt een geschikte Comparatordie het juiste geval behandelt (dwz doet lexicaal, niet UTF16 bestellen), zoals die verkrijgbaar via java.text.Collator.getInstance.

Antwoord 8, autoriteit 4%

Dit is wat u zoekt

listOfCountryNames.sort(String::compareToIgnoreCase)

Antwoord 9, autoriteit 2%

Door Collections.sort()te gebruiken, kunnen we een lijst sorteren.

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

uitvoer:

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

Antwoord 10, autoriteit 2%

aflopend alfabet:

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

Antwoord 11

U kunt de volgende regel gebruiken

Collections.sort(listOfCountryNames, String.CASE_INSENSITIVE_ORDER)

Het lijkt op de suggestie van Thilo, maar maakt geen verschil tussen hoofdletters en kleine letters.

Antwoord 12

Hetzelfde in JAVA 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));

Antwoord 13

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