por - sort arraylist object java
Ordenar ArrayList de objetos personalizados por propiedad (24)
JAVA 8 lambda expresión
Collections.sort(studList, (Student s1, Student s2) ->{
return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});
O
Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)
Leí sobre la clasificación de ArrayLists usando un Comparator pero en todos los ejemplos las personas usaron compareTo que según algunas investigaciones es un método para Strings.
Quería ordenar una ArrayList de objetos personalizados por una de sus propiedades: un objeto Date ( getStartDay() ). Normalmente los comparo por item1.getStartDate().before(item2.getStartDate()) así que me preguntaba si podría escribir algo como:
public class CustomComparator {
public boolean compare(Object object1, Object object2) {
return object1.getStartDate().before(object2.getStartDate());
}
}
public class RandomName {
...
Collections.sort(Database.arrayList, new CustomComparator);
...
}
Con Java 8 puedes usar una referencia de método para tu comparador:
import static java.util.Comparator.comparing;
Collections.sort(list, comparing(MyObject::getStartDate));
Con esta biblioteca here puede ordenar la lista de objetos personalizados en varias columnas. La biblioteca utiliza las características de la versión 8.0. La muestra también está disponible allí. Aquí hay una muestra para hacer.
SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
.addField("age", true); // This (true) will sort the age descending
// Other ways to specify a property to the sorter are
// .addField("lastName", String.class);
// .addField("dob", Date.class, true);
// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();
// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);
Dado que Date implementa Comparable , tiene un método compareTo tal como lo hace String .
Entonces tu Comparator personalizado podría verse así:
public class CustomComparator implements Comparator<MyObject> {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
}
El método compare() debe devolver un int , por lo que no podría devolver directamente un boolean como lo estaba planeando.
Su código de clasificación sería casi como usted escribió:
Collections.sort(Database.arrayList, new CustomComparator());
Una forma un poco más corta de escribir todo esto, si no necesita reutilizar su comparador, es escribirlo como una clase anónima en línea:
Collections.sort(Database.arrayList, new Comparator<MyObject>() {
@Override
public int compare(MyObject o1, MyObject o2) {
return o1.getStartDate().compareTo(o2.getStartDate());
}
});
Desde java-8
Ahora puede escribir el último ejemplo en una forma más corta utilizando una expresión lambda para el Comparator :
Collections.sort(Database.arrayList,
(o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
Y la List tiene un método de sort(Comparator) , por lo que puede reducir esto aún más:
Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));
Este es un lenguaje tan común que hay un método incorporado para generar un Comparator para una clase con una clave Comparable :
Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));
Todas estas son formas equivalentes.
Dado que las tecnologías aparecen todos los días, la respuesta cambiará con el tiempo. Le eché un vistazo a LambdaJ y me parece muy interesante.
Puedes intentar resolver estas tareas con LambdaJ . Lo puedes encontrar aquí: http://code.google.com/p/lambdaj/
Aquí tienes un ejemplo:
Ordenar Iterativa
List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
public int compare(Person p1, Person p2) {
return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
}
});
Ordenar con lambda
List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge());
Por supuesto, tener este tipo de belleza impacta en el rendimiento (un promedio de 2 veces), pero ¿puedes encontrar un código más legible?
Desde Java 8 y en adelante no tenemos que usar Collections.sort() directamente. List interfaz de la List tiene un método de sort() predeterminado:
List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> {
return u1.getFirstName.compareTo(u2.getFirstName());});
Consulte http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html .
El uso de Java 8 puede definir el Comparator en una línea usando Comparator.comparing()
Utilice cualquiera de las siguientes formas:
Opción 1:
listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));
Opcion 2:
Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));
Encontré que la mayoría, si no todas, de estas respuestas se basan en la clase subyacente (Objeto) para implementar una interfaz comparable o auxiliar.
¡No con mi solución! El siguiente código le permite comparar el campo del objeto al conocer el nombre de su cadena. Puede modificarlo fácilmente para no usar el nombre, pero luego debe exponerlo o construir uno de los Objetos con los que desea comparar.
Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));
public class ReflectiveComparator {
public class FieldComparator implements Comparator<Object> {
private String fieldName;
public FieldComparator(String fieldName){
this.fieldName = fieldName;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public int compare(Object object1, Object object2) {
try {
Field field = object1.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Comparable object1FieldValue = (Comparable) field.get(object1);
Comparable object2FieldValue = (Comparable) field.get(object2);
return object1FieldValue.compareTo(object2FieldValue);
}catch (Exception e){}
return 0;
}
}
public class ListComparator implements Comparator<Object> {
private String fieldName;
public ListComparator(String fieldName) {
this.fieldName = fieldName;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public int compare(Object object1, Object object2) {
try {
Field field = object1.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Comparable o1FieldValue = (Comparable) field.get(object1);
Comparable o2FieldValue = (Comparable) field.get(object2);
if (o1FieldValue == null){ return -1;}
if (o2FieldValue == null){ return 1;}
return o1FieldValue.compareTo(o2FieldValue);
} catch (NoSuchFieldException e) {
throw new IllegalStateException("Field doesn''t exist", e);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Field inaccessible", e);
}
}
}
}
Este código de fragmentos podría ser útil. Si quiere ordenar un Objeto en mi caso, quiero ordenar por VolumeName:
public List<Volume> getSortedVolumes() throws SystemException {
List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
Collections.sort(volumes, new Comparator<Volume>() {
public int compare(Volume o1, Volume o2) {
Volume p1 = (Volume) o1;
Volume p2 = (Volume) o2;
return p1.getVolumeName().compareToIgnoreCase(
p2.getVolumeName());
}
});
return volumes;
}
Esto funciona. Lo uso en mi jsp.
Java 8 Lambda acorta el ordenamiento.
Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));
La mejor manera fácil con JAVA 8 es para el orden alfabético inglés
Implementacion de clase
public class NewspaperClass implements Comparable<NewspaperClass>{
public String name;
@Override
public int compareTo(NewspaperClass another) {
return name.compareTo(another.name);
}
}
Ordenar
Collections.sort(Your List);
Si desea ordenar el alfabeto que contiene caracteres que no están en inglés, puede usar la configuración regional ... El código que se encuentra debajo del código turco utiliza la clasificación de caracteres ...
Implementacion de clase
public class NewspaperClass implements Comparator<NewspaperClass> {
public String name;
public Boolean isUserNewspaper=false;
private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));
@Override
public int compare(NewspaperClass lhs, NewspaperClass rhs) {
trCollator.setStrength(Collator.PRIMARY);
return trCollator.compare(lhs.name,rhs.name);
}
}
Ordenar
Collections.sort(your array list,new NewspaperClass());
Las clases que tienen un orden de clasificación natural (un Número de clase, como un ejemplo) deben implementar la interfaz Comparable, mientras que las clases que no tienen un orden de clasificación natural (una Clase Chair, como ejemplo) deben contar con un Comparador (o un Comparador anónimo) clase).
Dos ejemplos:
public class Number implements Comparable<Number> {
private int value;
public Number(int value) { this.value = value; }
public int compareTo(Number anotherInstance) {
return this.value - anotherInstance.value;
}
}
public class Chair {
private int weight;
private int height;
public Chair(int weight, int height) {
this.weight = weight;
this.height = height;
}
/* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
public int compare(Chair chair1, Chair chair2) {
return chair1.getWeight() - chair2.getWeight();
}
}
class ChairHeightComparator implements Comparator<Chair> {
public int compare(Chair chair1, Chair chair2) {
return chair1.getHeight() - chair2.getHeight();
}
}
Uso:
List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);
List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());
// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
public int compare(Chair chair1, Chair chair2) {
...
}
});
Nuevo, ya que 1.8 es un método List.sort () en lugar de usar Collection.sort (), por lo que llama directamente a mylistcontainer.sort ()
Aquí hay un fragmento de código que muestra la función List.sort ():
List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));
// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]
// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]
La clase de frutas es:
public class Fruit implements Comparable<Fruit>
{
private String name;
private String color;
private int quantity;
public Fruit(String name,String color,int quantity)
{ this.name = name; this.color = color; this.quantity = quantity;}
public String getFruitName() { return name; }
public String getColor() { return color; }
public int getQuantity() { return quantity; }
@Override public final int compareTo(Fruit f) // sorting the color
{
return this.color.compareTo(f.color);
}
@Override public String toString()
{ return (name + " is: " + color);
}
} // fin de la clase de frutas
Para Java 8:
Collections.sort(list, comparing(ClassName::getName));
o
Collections.sort(list, comparing(ClassName::getName).reversed());
Otra forma es
Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));
Para ordenar un ArrayList puede usar el siguiente fragmento de código:
Collections.sort(studList, new Comparator<Student>(){
public int compare(Student s1, Student s2) {
return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
}
});
Prefiero este proceso:
public class SortUtil
{
public static <T> List<T> sort(List<T> list, String sortByProperty)
{
Collections.sort(list, new BeanComparator(sortByProperty));
return list;
}
}
List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");
Si la lista de objetos tiene una propiedad llamada startDate , debe usar esto una y otra vez. Incluso puedes encadenarlos startDate.time .
Esto requiere que su objeto sea Comparable que significa que necesita una implementación compareTo , equals y hashCode .
Sí, podría ser más rápido ... Pero ahora no tiene que hacer un nuevo Comparador para cada tipo de clase. Si puede ahorrar en el tiempo de desarrollo y abandonar el tiempo de ejecución, puede ir con este.
Puede usar el Comparador de Bean para ordenar en cualquier propiedad en su clase personalizada.
Puede ver esta presentation en el foro de Java en Stuttgart, Alemania, en 2016.
Solo unas pocas diapositivas utilizan el idioma alemán, el 99% del contenido es código fuente Java "basado en inglés"; me gusta
someCollection.sort(
OurCustomComparator
.comparing(Person::getName)
.thenComparing(Person::getId)
);
donde OurCustomComparator utiliza métodos predeterminados (y otras ideas interesantes). Como se muestra, lo que lleva a un código muy conciso para elegir un método getter para la clasificación; y super simple encadenamiento (o reversión) de criterios de clasificación.
Si estás en java8, encontrarás mucho material para comenzar.
Puedes probar el Ordering guayaba:
Function<Item, Date> getStartDate = new Function<Item, Date>() {
public Date apply(Item item) {
return item.getStartDate();
}
};
List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
sortedCopy(items);
Sí tu puedes. Hay dos opciones para comparar elementos, la interfaz Comparable y la interfaz Comparator .
Ambas interfaces permiten un comportamiento diferente. Comparable le permite hacer que el objeto actúe como usted describió Strings (de hecho, String implementa Comparable). El segundo, Comparator, le permite hacer lo que está pidiendo. Lo harías así:
Collections.sort(myArrayList, new MyComparator());
Eso hará que el método Collections.sort use su comparador para su mecanismo de clasificación. Si los objetos en el ArrayList se implementan de manera similar, puede hacer algo como esto:
Collections.sort(myArrayList);
La clase Collections contiene varias de estas herramientas útiles y comunes.
Sí, eso es posible, por ejemplo, en esta respuesta que IndexValue por la propiedad v de la clase IndexValue
// Sorting by property v using a custom comparator.
Arrays.sort( array, new Comparator<IndexValue>(){
public int compare( IndexValue a, IndexValue b ){
return a.v - b.v;
}
});
Si nota que aquí estoy creando una clase interna anónima (que es el Java para cierres) y la paso directamente al método de sort de la clase Arrays
Su objeto también puede implementar Comparable (eso es lo que hacen String y la mayoría de las bibliotecas centrales en Java), pero eso definiría el "orden natural" de la clase en sí, y no le permite conectar otras nuevas.
su clase customComparator debe implementar java.util.Comparator para poder ser utilizada. también debe anular comparar () Y es igual a ()
compare () debe responder a la pregunta: ¿es el objeto 1 menor que, igual o mayor que el objeto 2?
documentos completos: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html
Puedes ordenar usando java 8
yourList.sort(Comparator.comparing(Classname::getName));
or
yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
public class test {
public static class Person {
public String name;
public int id;
public Date hireDate;
public Person(String iname, int iid, Date ihireDate) {
name = iname;
id = iid;
hireDate = ihireDate;
}
public String toString() {
return name + " " + id + " " + hireDate.toString();
}
// Comparator
public static class CompId implements Comparator<Person> {
@Override
public int compare(Person arg0, Person arg1) {
return arg0.id - arg1.id;
}
}
public static class CompDate implements Comparator<Person> {
private int mod = 1;
public CompDate(boolean desc) {
if (desc) mod =-1;
}
@Override
public int compare(Person arg0, Person arg1) {
return mod*arg0.hireDate.compareTo(arg1.hireDate);
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
ArrayList<Person> people;
people = new ArrayList<Person>();
try {
people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Collections.sort(people, new Person.CompId());
System.out.println("BY ID");
for (Person p : people) {
System.out.println(p.toString());
}
Collections.sort(people, new Person.CompDate(false));
System.out.println("BY Date asc");
for (Person p : people) {
System.out.println(p.toString());
}
Collections.sort(people, new Person.CompDate(true));
System.out.println("BY Date desc");
for (Person p : people) {
System.out.println(p.toString());
}
}
}