基于Arrays.sort()和lambda表达式
arrays.sort()和lambda表达式
1、对基本数据类型数组的排序
数字排序:
int[] intarray = new int[]{1,34,5,-9}; arrays.sort(intarray); system.out.println(arrays.tostring(intarray));
字符串排序(先大写后小写):
string[] strarray = new string[]{"z", "a", "d"}; arrays.sort(strarray); system.out.println(arrays.tostring(strarray));
字符串排序(忽略大小写):
arrays.sort(strarray, string.case_insensitive_order);
反向排序:
arrays.sort(strarray, collections.reverseorder());
注意:arrays.sort()使用的是双轴快排:
1.对于很小的数组(长度小于27),会使用插入排序。
2.选择两个点p1,p2作为轴心,比如我们可以使用第一个元素和最后一个元素。
3.p1必须比p2要小,否则将这两个元素交换,现在将整个数组分为四部分:
(1)第一部分:比p1小的元素。
(2)第二部分:比p1大但是比p2小的元素。
(3)第三部分:比p2大的元素。
(4)第四部分:尚未比较的部分。
在开始比较前,除了轴点,其余元素几乎都在第四部分,直到比较完之后第四部分没有元素。
4.从第四部分选出一个元素a[k],与两个轴心比较,然后放到第一二三部分中的一个。
5.移动l,k,g指向。
6.重复 4 5 步,直到第四部分没有元素。
7.将p1与第一部分的最后一个元素交换。将p2与第三部分的第一个元素交换。
8.递归的将第一二三部分排序。
对于基本类型的数组如int[], double[], char[] ,arrays类只提供了默认的升序排列,没有降序,需要传入自定义比较器,使用arrays.sort(num,c),传入一个实现了comparator接口的类的对象c。逆序排列:
arrays.sort(num,new comparator<integer>(){ public int compare(integer a, integer b){ return b-a; } });
arrays的其他方法:
-
arrays.sort(num, fromindex, toindex);
给某区间排序。 -
arrays.sort(num, fromindex, toindex,c);
给某区间按c比较器排序。
2、给对象数组排序
要先comparable接口或comparator接口。
两种比较器的对比:
内部比较器: 需要比较的对象必须实现comparable接口,并重写compareto(t o)方法,表明该对象可以用来排序,否则不能直接使用arrays.sort()方法。
public class employee implements comparable<employee> { private int id;// 员工编号 private double salary;// 员工薪资 public int getid() { return id; } public void setid(int id) { this.id = id; } public double getsalary() { return salary; } public void setsalary(double salary) { this.salary = salary; } public employee(int id, double salary) { super(); this.id = id; this.salary = salary; } // 为了输出方便,重写tostring方法 @override public string tostring() { // 简单输出信息 return "id:"+ id + ",salary=" + salary; } // 比较此对象与指定对象的顺序 @override public int compareto(employee o) { // 比较员工编号,如果此对象的编号大于、等于、小于指定对象,则返回1、0、-1 int result = this.id > o.id ? 1 : (this.id == o.id ? 0 : -1); // 如果编号相等,则比较薪资 if (result == 0) { // 比较员工薪资,如果此对象的薪资大于、等于、小于指定对象,则返回1、0、-1 result = this.salary > o.salary ? 1 : (this.salary == o.salary ? 0 : -1); } return result; } }
外部比较器: 需要自己写一个比较器实现comparator接口,并实现compare(t o1, t o2)方法,根据自己的需求定义比较规则。使用外部比较器这种方式比较灵活,例如现在需求是按照员工编号和薪资进行排序,以后可能按照姓名进行排序,这时只要再写一个按照姓名规则比较的比较器就可以了。
/** * 测试两种比较器 * @author sam * */ public class testemployeecompare { /** * @param args */ public static void main(string[] args) { list<employee> employees = new arraylist<employee>(); employees.add(new employee(2, 5000)); employees.add(new employee(1, 4500)); employees.add(new employee(4, 3500)); employees.add(new employee(5, 3000)); employees.add(new employee(4, 4000)); // 内部比较器:要排序的对象要求实现了comparable接口 ,直接传入该对象即可 arrays.sort(employees); system.out.println("通过内部比较器实现:"); system.out.println(employees); list<employee> employees2 = new arraylist<employee>(); employees2.add(new employee(2, 5000)); employees2.add(new employee(1, 4500)); employees2.add(new employee(4, 3500)); employees2.add(new employee(5, 3000)); employees2.add(new employee(4, 4000)); // 外部比较器:自定义类实现comparator接口 ,需要传入自定义比较器类 arrays.sort(employees2, new employeecomparable()); system.out.println("通过外部比较器实现:"); system.out.println(employees2); } } /** * 自定义员工比较器 * */ class employeecomparable implements comparator<employee> { @override public int compare(employee o1, employee o2) { // 比较员工编号,如果此对象的编号大于、等于、小于指定对象,则返回1、0、-1 int result = o1.getid() > o2.getid() ? 1 : (o1.getid() == o2.getid() ? 0 : -1); // 如果编号相等,则比较薪资 if (result == 0) { // 比较员工薪资,如果此对象的薪资大于、等于、小于指定对象,则返回1、0、-1 result = o1.getsalary() > o2.getsalary() ? 1 : (o1.getsalary() == o2.getsalary() ? 0 : -1); } return result; } }
最后巧用lambda表达式:(参数) -> 一个表达式或一段代码
如:
实现逆序:
arrays.sort(nums, ( integer a, integer b) -> { return b-a;});
字符串数组,按长度排序:
arrays.sort(strs, (string first, string second) -> { if(first.length() < second.length()) return -1; else if(first.length() > second.length()) return 1; else return 0; });
再谈comparator-使用lambda表达式
先写一个person类,主要有address跟name两个成员属性以及他们的getter()方法,最后补刀重写tostring()方法
public class person { private string address; private string name; public person(string firstname, string lastname) { this.address = firstname; this.name = lastname; } public string getaddress() { return address; } public string getname() { return name; } @override public string tostring() { return getclass().getsimplename()+"{" + "address='" + address + '\'' + ", name='" + name + '\'' + '}'; } }
以前
以前写比较排序的时候,总需要写一大堆代码,比如下面:
public class testch06 { public static void main(string... args) throws clonenotsupportedexception { //定义一个person类数组 person[] arr = {new person("wo", "2722"), new person("uj", "2829"), new person("dh", "272"), new person("us", "1"), new person("jaka", "881711")}; lencomparator lc = new lencomparator(); //排序 arrays.sort(arr, lc); system.out.println(arrays.tostring(arr)); } } /** * 按照名字长度来排序的比较器-->主要用于string类型的数组 */ class lencomparator implements comparator<person> { @override public int compare(person o1, person o2) { return integer.compare(o1.getname().length(), o2.getname().length()); } }
现在
如今java8se出来了很久了,如果还使用上面的代码写作确实有点缺优雅,因为comparator接口包含了很多方便的静态方法类创建比较器(这些方法可以用于lambda表达式或者方法引用)
//按照名字进行排序 arrays.sort(arr, comparator.comparing(person::getname)); //按照名字长度进行排序 arrays.sort(arr,comparator.comparing(person::getname,(s,t)->integer.compare(s.length(),t.length()))); arrays.sort(arr,comparator.comparingint(p->p.getname().length())); //先按照名字进行排序,如果名字相同,再按照地址比较 arrays.sort(arr,comparator.comparing(person::getname).thencomparing(person::getaddress));
温馨提示:其实在平常用的比较也不多,只是在需要的时候才用到,更希望大家可以掌握一些lambda表达式更好
以上为个人经验,希望能给大家一个参考,也希望大家多多支持。
上一篇: 远程连接Jedis和整合SpringBoot的详细过程
下一篇: 安卓开发学期学习总结(第一学期)