Ordenar colecciones usando expresiones Lambda en Java

1. Use lambda para ordenar la colección de listas

Primero define una colección

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(5);
list.add(4);
list.add(3);
list.add(7);

1. Ordenar en orden ascendente

list.sort((a,b)->a.compareTo(b));

o

list.sort(Comparator.comparing(a->a));

o

list.sort((a,b)->a-b);

o

// 2、匿名内部类
list.sort(new Comparator<Integer>() {
    
    
	@Override
	public int compare(Integer o1, Integer o2) {
    
    
		return o1-o2;
	}
});

2. Orden descendente

list.sort((a,b)->b-a);

método de clase interna anónimo

 list.sort(new Comparator<Integer>() {
    
    
      @Override
       public int compare(Integer o1, Integer o2) {
    
    
              return o2-o1;
       }
 });

Las operaciones en colecciones de objetos son en realidad similares a las operaciones en colecciones de tipos básicos

List<User> list1 = new ArrayList<User>();
User user = new User("张三", "15", "男");
User user1 = new User("李四", "10", "男");
list1.add(user);
list1.add(user1);
//1、年龄升序
list1.sort((a,b) -> a.getAge().compareTo(b.getAge()));
//2、姓名降序排列
list1.sort(Comparator.comparing(User::getName).reversed());
//等价于 2
list1.sort(Comparator.comparing(a->((User)a).getAge()).reversed());
//3、先按性别排，如果年龄相同，再按年龄排序
list1.sort(Comparator.comparing(User::getSex).reversed().thenComparing(User::getAge));

Ordenar JSONArray

Definir una matriz json resultArray

JSONArray resultArray = new JSONArray();
JSONObject result = new JSONObject();
result.put("name","张三");
result.put("age","15");
result.put("data","201812130451");
resultArray.add(result);
//根据姓名的倒序排序
resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getString("name")).reversed());
//根据时间倒序排序
resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getData("data")).reversed());
//根据年龄升序排序
resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getInteger("age")));

Nota: La función invertida() significa invertir la matriz. Su uso es común en el procesamiento de cadenas, para invertir la cadena
como:

String str = "abcd";
StringBuffer sb = new StringBuffer(str);
sb.reverse();
System.out.println(str);
System.out.println(sb.toString());

---------------------------------------
输出
abcd
dcba

2. El uso del comparador Comparator en java8-Lambda

Ejemplo típico de comparador

Comparator<Developer> byName = new Comparator<Developer>() {
    
    
    @Override
    public int compare(Developer o1, Developer o2) {
    
    
        return o1.getName().compareTo(o2.getName());
    }
};

Vía lambda equivalente

Comparator<Developer> byName = (Developer o1, Developer o2)->o1.getName().compareTo(o2.getName());

Clasificación sin Lambda

Si queremos ordenar por la antigüedad del objeto Desarrollador, generalmente usamos Collections.sort, una nueva clase Comparator anónima, como la siguiente:

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

public class TestSorting {
    
    

    public static void main(String[] args) {
    
    

        List<Developer> listDevs = getDevelopers();

        System.out.println("Before Sort");
        for (Developer developer : listDevs) {
    
    
            System.out.println(developer);
        }

        //sort by age
        Collections.sort(listDevs, new Comparator<Developer>() {
    
    
            @Override
            public int compare(Developer o1, Developer o2) {
    
    
                return o1.getAge() - o2.getAge();
            }
        });

        System.out.println("After Sort");
        for (Developer developer : listDevs) {
    
    
            System.out.println(developer);
        }

    }

    private static List<Developer> getDevelopers() {
    
    

        List<Developer> result = new ArrayList<Developer>();

        result.add(new Developer("ricky", new BigDecimal("70000"), 33));
        result.add(new Developer("alvin", new BigDecimal("80000"), 20));
        result.add(new Developer("jason", new BigDecimal("100000"), 10));
        result.add(new Developer("iris", new BigDecimal("170000"), 55));

        return result;

    }

}

-----------------------------------------------------------------------------------------------------
输出结果：
Before Sort
Developer [name=ricky, salary=70000, age=33]
Developer [name=alvin, salary=80000, age=20]
Developer [name=jason, salary=100000, age=10]
Developer [name=iris, salary=170000, age=55]

After Sort
Developer [name=jason, salary=100000, age=10]
Developer [name=alvin, salary=80000, age=20]
Developer [name=ricky, salary=70000, age=33]
Developer [name=iris, salary=170000, age=55]

Cuando cambian las reglas de comparación, debe volver a crear una nueva clase Comparator anónima:

    //sort by age
    Collections.sort(listDevs, new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o1.getAge() - o2.getAge();
        }
    });

    //sort by name
    Collections.sort(listDevs, new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o1.getName().compareTo(o2.getName());
        }
    });

    //sort by salary
    Collections.sort(listDevs, new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o1.getSalary().compareTo(o2.getSalary());
        }
    });

Esto también es posible, pero ¿crees que esto es un poco extraño, porque de hecho, la diferencia es solo una línea de código, pero necesita repetir mucho código?

Clasificación por lambda

En java8, la interfaz List proporciona directamente métodos de clasificación, por lo que no necesita usar Collections.sort

    //List.sort() since Java 8
    listDevs.sort(new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o2.getAge() - o1.getAge();
        }
    });

ejemplo lambda

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class TestSorting {
    
    

    public static void main(String[] args) {
    
    

        List<Developer> listDevs = getDevelopers();

        System.out.println("Before Sort");
        for (Developer developer : listDevs) {
    
    
            System.out.println(developer);
        }

        System.out.println("After Sort");

        //lambda here!
        listDevs.sort((Developer o1, Developer o2)->o1.getAge()-o2.getAge());

        //java 8 only, lambda also, to print the List
        listDevs.forEach((developer)->System.out.println(developer));
    }

    private static List<Developer> getDevelopers() {
    
    

        List<Developer> result = new ArrayList<Developer>();

        result.add(new Developer("ricky", new BigDecimal("70000"), 33));
        result.add(new Developer("alvin", new BigDecimal("80000"), 20));
        result.add(new Developer("jason", new BigDecimal("100000"), 10));
        result.add(new Developer("iris", new BigDecimal("170000"), 55));

        return result;

    }

}
------------------------------------------------------------------------
输出结果:
Before Sort
Developer [name=ricky, salary=70000, age=33]
Developer [name=alvin, salary=80000, age=20]
Developer [name=jason, salary=100000, age=10]
Developer [name=iris, salary=170000, age=55]

After Sort
Developer [name=jason, salary=100000, age=10]
Developer [name=alvin, salary=80000, age=20]
Developer [name=ricky, salary=70000, age=33]
Developer [name=iris, salary=170000, age=55]

Más ejemplos de Lambda

según la edad

    //sort by age
    Collections.sort(listDevs, new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o1.getAge() - o2.getAge();
        }
    });

    //lambda
    listDevs.sort((Developer o1, Developer o2)->o1.getAge()-o2.getAge());

    //lambda, valid, parameter type is optional
    listDevs.sort((o1, o2)->o1.getAge()-o2.getAge());

por nombre

    //sort by name
    Collections.sort(listDevs, new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o1.getName().compareTo(o2.getName());
        }
    });

    //lambda
    listDevs.sort((Developer o1, Developer o2)->o1.getName().compareTo(o2.getName()));

    //lambda
    listDevs.sort((o1, o2)->o1.getName().compareTo(o2.getName()));

según salario

    //sort by salary
    Collections.sort(listDevs, new Comparator<Developer>() {
    
    
        @Override
        public int compare(Developer o1, Developer o2) {
    
    
            return o1.getSalary().compareTo(o2.getSalary());
        }
    });

    //lambda
    listDevs.sort((Developer o1, Developer o2)->o1.getSalary().compareTo(o2.getSalary()));

    //lambda
    listDevs.sort((o1, o2)->o1.getSalary().compareTo(o2.getSalary()))

Orden inverso
Orden normal

Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
listDevs.sort(salaryComparator);

orden inverso

Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
listDevs.sort(salaryComparator.reversed());

Intrusión y eliminación de artículos de referencia:
Java usa Lambda para ordenar colecciones
usando Comparator en java8-Lambda