基于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表达式更好

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。