Antworten:
Angenommen, dies sind Strings, verwenden Sie die bequeme statische Methode sort…
java.util.Collections.sort(listOfCountryNames)Wenn Sie gezwungen sind, diese Liste zu verwenden, oder wenn Ihr Programm eine Struktur wie hat
dann ist Thilos Antwort der beste Weg, dies zu tun. Wenn Sie es mit dem Rat von Tom Hawtin - Tackline kombinieren , erhalten Sie:
java.util.Collections.sort(listOfCountryNames, Collator.getInstance());Wenn Sie frei entscheiden können und Ihre Anwendung komplexer wird, können Sie Ihren Code ändern, um stattdessen ein TreeSet zu verwenden. Diese Art der Sammlung sortiert Ihre Einträge nur dann, wenn sie eingefügt werden. Sort () muss nicht aufgerufen werden.
Collection<String> countryNames =
new TreeSet<String>(Collator.getInstance());
countryNames.add("UK");
countryNames.add("Germany");
countryNames.add("Australia");
// Tada... sorted.Dies hat einige subtile, aber wichtige Vorteile:
TreeSet<String> countyNamesund weiß sofort: Dies ist eine sortierte Sammlung von Strings ohne Duplikate, und ich kann sicher sein, dass dies in jedem Moment zutrifft . So viele Informationen in einer kurzen Erklärung.Die Verwendung der richtigen Sammlung für die richtige Aufgabe ist ein Schlüssel zum Schreiben von kurzem und fehlerfreiem Code. Dies ist in diesem Fall nicht so demonstrativ, da Sie nur eine Zeile speichern. Aber ich habe aufgehört zu zählen, wie oft ich jemanden sehe, der eine Liste verwendet, wenn er sicherstellen möchte, dass keine Duplikate vorhanden sind, und diese Funktionalität dann selbst erstellt. Oder noch schlimmer: Verwenden Sie zwei Listen, wenn Sie wirklich eine Karte benötigen.
Versteh mich nicht falsch: Die Verwendung von Collections.sort ist kein Fehler oder Fehler. Es gibt jedoch viele Fälle, in denen das TreeSet viel sauberer ist.
Sie können mit Java 8 Stream oder Guava eine neue sortierte Kopie erstellen:
// Java 8 version
List<String> sortedNames = names.stream().sorted().collect(Collectors.toList());
// Guava version
List<String> sortedNames = Ordering.natural().sortedCopy(names); Eine weitere Option ist das Sortieren vor Ort über die Sammlungs-API:
Collections.sort(names);Besser spät als nie! Hier ist, wie wir es tun können (nur zu Lernzwecken) -
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);
}
}
}In einer Zeile mit Java 8:
list.sort(Comparator.naturalOrder());Verwenden Sie die beiden Argumente für von Collections.sort. Sie möchten eine geeignete Comparator, die Groß- und Kleinschreibung behandelt (dh lexikalische, nicht UTF16-Reihenfolge), wie die, die über erhältlich ist java.text.Collator.getInstance.
Wenn Sie Zeichenfolgen nicht nur in akzentfreiem Englisch sortieren, möchten Sie wahrscheinlich a verwenden Collator. Es sortiert diakritische Zeichen korrekt, kann Groß- und Kleinschreibung und andere sprachspezifische Dinge ignorieren:
Collections.sort(countries, Collator.getInstance(new Locale(languageCode)));Sie können die Stärke des Kollators einstellen , siehe Javadoc.
Hier ist ein Beispiel für Slowakisch, wohin Šes gehen soll S, aber in UTF Šist es irgendwo danach 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]Hier ist was Sie suchen
listOfCountryNames.sort(String::compareToIgnoreCase)Mit Collections.sort()können wir eine Liste sortieren.
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);
}
}
}Ausgabe:
sudheer
kumar
surendra
kb
[kb, kumar, sudheer, surendra]absteigendes Alphabet:
List<String> list;
...
Collections.sort(list);
Collections.reverse(list);Gleiches gilt für 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));//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;
}
}Sie können versuchen, eine Methode zu verwenden, die ich gemacht habe.
String key- wird die gewünschte Reihenfolge sein und in diesem Fall in alphabetischer Reihenfolge. Setzen Sie einfach "abc ...".
String list[] - die Liste, die Sie mit dem Schlüssel ordnen möchten.
int index - als 0 gesetzt, setzt den Offset für die Taste.
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()]);
}