List<bean>排序
前言:
对List中的所有bean进行排序 ,排序主要是利用JDK自带的 Collections.sort;
代码如下:
这是一个运用Demo:
public class MyCompareSort {
public static void peopleSort(List<People> beanList) {
Collections.sort(beanList, new Comparator<People>() {
@Override
public int compare(People o1, People o2) {
//我们这里选择bean结构的id作为排序规则
return o1.getId() - o2.getId();
}
});
}
/**
* 造假数据验证
* @param args
*/
public static void main(String[] args) {
List<People> list = new ArrayList<>();
list.add(new People(1, "b"));
list.add(new People(-2, "a"));
list.add(new People(4, "c"));
list.add(new People(15, "f"));
list.add(new People(12, "e"));
list.add(new People(7, "d"));
System.out.println("list : " + list);
peopleSort(list);
System.out.println("sortlist : " + list);
}
}
/**
* bean结构
*/
@Data
class People {
private Integer id;
private String name;
public People(Integer id, String name) {
this.id = id;
this.name = name;
}
}
结果:
解析:
应用场景:
当需要排序的是集合或数组, 不是单纯的数字型时,我们可以使用Comparator或Comparable,对bean结构进行排序;
参考:JDK8源码:
/**
* Compares its two arguments for order. Returns a negative integer,
* zero, or a positive integer as the first argument is less than, equal
* to, or greater than the second.<p>
*
* In the foregoing description, the notation
* <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
* <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
* <tt>0</tt>, or <tt>1</tt> according to whether the value of
* <i>expression</i> is negative, zero or positive.<p>
*
* The implementor must ensure that <tt>sgn(compare(x, y)) ==
* -sgn(compare(y, x))</tt> for all <tt>x</tt> and <tt>y</tt>. (This
* implies that <tt>compare(x, y)</tt> must throw an exception if and only
* if <tt>compare(y, x)</tt> throws an exception.)<p>
*
* The implementor must also ensure that the relation is transitive:
* <tt>((compare(x, y)>0) && (compare(y, z)>0))</tt> implies
* <tt>compare(x, z)>0</tt>.<p>
*
* Finally, the implementor must ensure that <tt>compare(x, y)==0</tt>
* implies that <tt>sgn(compare(x, z))==sgn(compare(y, z))</tt> for all
* <tt>z</tt>.<p>
*
* It is generally the case, but <i>not</i> strictly required that
* <tt>(compare(x, y)==0) == (x.equals(y))</tt>. Generally speaking,
* any comparator that violates this condition should clearly indicate
* this fact. The recommended language is "Note: this comparator
* imposes orderings that are inconsistent with equals."
*
* @param o1 the first object to be compared.
* @param o2 the second object to be compared.
* @return a negative integer, zero, or a positive integer as the
* first argument is less than, equal to, or greater than the
* second.
* @throws NullPointerException if an argument is null and this
* comparator does not permit null arguments
* @throws ClassCastException if the arguments' types prevent them from
* being compared by this comparator.
*/
int compare(T o1, T o2);
上述表明我们重写compare这个方法时:
第一个参数小于第二个参数时返回为 负整数 , 即上述Demo中的 o1.getId() - o2.getId()
第一个参数等于第二个参数时返回为 零
第一个参数大于第二个参数时返回为 正整数;