一.利用lambda對list集合排序
先定義一個集合
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(5);
list.add(4);
list.add(3);
list.add(7);
1.升序排序
list.sort((a,b)->a.compareTo(b));
或
list.sort(Comparator.comparing(a->a));
或
list.sort((a,b)->a-b);
或
// 2、匿名內(nèi)部類
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
2.降序排序
list.sort((a,b)->b-a);
匿名內(nèi)部類方法
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
對對象集合操作，其實與基本類型集合操作類似
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));
對 JSONArray 排序
定義一個json數(shù)組 resultArray
JSONArray resultArray = new JSONArray();
JSONObject result = new JSONObject();
result.put("name","張三");
result.put("age","15");
result.put("data","201812130451");
resultArray.add(result);
//根據(jù)姓名的倒序排序
resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getString("name")).reversed());
//根據(jù)時間倒序排序
resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getData("data")).reversed());
//根據(jù)年齡升序排序
resultArray.sort(Comparator.comparing(obj -> ((JSONObject) obj).getInteger("age")));
注意：reversed()函數(shù)的意思是將數(shù)組顛倒。其用法常見于字符串處理中，將字符串顛倒
如：
String str = "abcd";
StringBuffer sb = new StringBuffer(str);
sb.reverse();
System.out.println(str);
System.out.println(sb.toString());
---------------------------------------
輸出
abcd
dcba
二.java8-Lambda中比較器Comparator的使用
典型的比較器示例
Comparator<Developer> byName = new Comparator<Developer>() {
@Override
public int compare(Developer o1, Developer o2) {
return o1.getName().compareTo(o2.getName());
}
};
等價的Lambda的方式
Comparator<Developer> byName = (Developer o1, Developer o2)->o1.getName().compareTo(o2.getName());
不使用Lambda的排序
假如我們要通過Developer 對象的年齡進行排序，通常情況下我們使用Collections.sort，new個匿名Comparator 類，類似下面這種：
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;
}
}
-----------------------------------------------------------------------------------------------------
輸出結(jié)果：
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]
當(dāng)比較規(guī)則發(fā)生變化時，你需要再次new個匿名Comparator 類：
//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());
}
});
這樣也可以，不過你會不會覺得這樣有點怪，因為其實不同的只有一行代碼而已，但是卻需要重復(fù)寫很多代碼？
通過Lambda進行排序
在java8中，List接口直接提供了排序方法， 所以你不需要使用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();
}
});
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;
}
}
------------------------------------------------------------------------
輸出結(jié)果:
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]
更多的Lambda例子
根據(jù)年齡
//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());
根據(jù)名字
//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()));
根據(jù)薪水
//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()))
倒序
正常排序
Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
listDevs.sort(salaryComparator);
倒序文章來源：http://www.zghlxwxcb.cn/news/detail-727702.html
Comparator<Developer> salaryComparator = (o1, o2)->o1.getSalary().compareTo(o2.getSalary());
listDevs.sort(salaryComparator.reversed());
參考文章侵刪:
java 使用Lambda對集合排序
java8-Lambda中比較器Comparator的使用文章來源地址http://www.zghlxwxcb.cn/news/detail-727702.html
到了這里，關(guān)于Java中使用Lambda表達式對集合排序的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
