Arrays.sort()的使用（2）

最近看Arrays.sort()的源码才发现Arrays.sort()可以对自定义对象数组进行排序，楼主以前做题都打算自己写排序来着，现在想来蠢哭。在自己定义的类中实现Comparable接口，并重写compareTo方法，在该方法中定义比较规则即可。示例代码如下：

import java.util.Arrays;
import java.util.Random;

//使用Arrays.Sort 对自定义对象的排序Demo

class Salary implements Comparable<Salary>{
    int salary;
    String personName;
    public Salary(){
        // TODO Auto-generated constructor stub
    }
    public Salary(int salary,String personName) {
        // TODO Auto-generated constructor stub
        this.salary = salary;
        this.personName = personName;
    }

    @Override
    public int compareTo(Salary s) {
        // TODO Auto-generated method stub
        if(this.salary > s.salary){
            return 1;
        }
        if(this.salary < s.salary){
            return -1;
        }        
        return this.personName.compareTo(s.personName);
    }   
}
public class SortSalary {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Salary[] salaries = new Salary[5];
        int salary;
        String personName;  
        Random rdm = new Random(System.currentTimeMillis());
        for(int i = 0;i<5;i++){         
            salary = rdm.nextInt(10)*1000;
            personName = "Person"+i;
            salaries[i] = new Salary(salary,personName);
        }
        System.out.println("排序前");
        print(salaries);
        System.out.println("排序后");
        Arrays.sort(salaries);
        print(salaries);
    }
    private static void print(Salary[] salaries) {
        for (Salary salary : salaries) {
            System.out.println(salary.salary+" "+salary.personName);
        }
    }

}

实验结果如下：‘

排序前
9000 Person0
2000 Person1
2000 Person2
6000 Person3
6000 Person4
排序后
2000 Person1
2000 Person2
6000 Person3
6000 Person4
9000 Person0

另附上楼主过去为解决问题自己实现排序的示例：
题目描述：
现有n根木棒，已知它们的长度和重量。要用一部木工机一根一根地加工这些木棒。该机器在加工过程中需要一定的准备时间，是用于清洗机器，调整工具和模板的。木工机需要的准备时间如下：
（1）第一根木棒需要1min的准备时间；
（2）在加工了一根长为l，重为w的木棒之后，接着加工一根长为ll（l<=ll），重为ww（w<=ww）的木棒是不需要任何准备时间的。否则需要一分钟的准备时间。
给定n根木棒，你要找到最少的准备时间。例如现在有长和重分别为（4,9），（5,2），（2,1），（3,5）和（1,4）的五根木棒，那么所需准备时间最少为2min，顺序为（1,4），（3,5），（4,9），（2,1），（5,2）。
输入：
输入包含多组测试数据。输入的第一行是一个整数T，表示测试数据的个数。
每个测试例两行：
第一行是一个整数n（1<=n<=5000），表示有多少根木棒；
第二行包括n*2个整数，表示了l1，w1，l2，w2，l3，w3，…，ln，wn，这些数均不大于10000，其中li和wi表示第i根木棒的长度和重量。
输出：
输出以分钟为单位的最少准备时间。
实验代码：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        while(scan.hasNext()){
            int t=scan.nextInt(); 
            for(int i=0;i<t;i++){
                int n=scan.nextInt();
                MB[] A = new MB[n];
                for(int j=0;j<n;j++){                    
                    A[j]=new MB();
                    A[j].setLength(scan.nextInt());
                    A[j].setWeigth(scan.nextInt());
                }
                System.out.println(start(A));
            }
        }
    }

    private static int start(MB[] A){
        if(A.length ==1)    
            return 1;
        Quick_sort1(A,0,A.length-1);
        int count = 0;
        for(int i=0;i<A.length;i++){
            if(A[i].weigth!=-1){
                count++;
                int temp = A[i].weigth ;
                for(int j=i+1;j<A.length;j++){
                    if(A[j].weigth >= temp){
                        temp=A[j].weigth;
                        A[j].weigth=-1;
                    }
                }
            }
        }
        return count;
    }

    private static boolean cmpMB(MB ma,MB mb){
        if(ma.length != mb.length){
            return ma.length <= mb.length;
        }else{
            return ma.weigth <= mb.weigth;
        }               
    }

    //sort
    private static void Quick_sort1(MB[] A, int p, int r) {
        // TODO Auto-generated method stub
        if(p<r){
            int q=Partition(A,p,r);
            Quick_sort1(A,p,q-1);
            Quick_sort1(A,q+1,r);           
        }
    }

    private static int Partition(MB[] A, int p, int r) {
        // TODO Auto-generated method stub
        MB x=A[r];
        int i=p-1;
        for(int j=p;j<r;j++){
            if(cmpMB(A[j],x)){
                i=i+1;
                Exchange(A,i,j);
            }
        }
        Exchange(A,i+1,r);
        return i+1;
    }


    private static void Exchange(MB[] A, int i, int j) {
        // TODO Auto-generated method stub
        MB temp=new MB();
        temp.length=A[i].length;
        temp.weigth = A[i].weigth;

        A[i].length=A[j].length;
        A[i].weigth = A[j].weigth;

        A[j].length=temp.length;
        A[j].weigth = temp.weigth;
    }


    static class MB{
        private int length;
        private int weigth;
        public int getLength() {
            return length;
        }
        public void setLength(int length) {
            this.length = length;
        }
        public int getWeigth() {
            return weigth;
        }
        public void setWeigth(int weigth) {
            this.weigth = weigth;
        }

    }
}

这是很久之前写的代码，刚找出来，但是没有题目描述，去网上找到了这道题的题目描述，我解题思路就是按照木棒的长度和重量进行排序，然后遍历已排序的数组，按照要求累加时间。
当时在排序的时候有多个条件，那会只使用过Arrays.sort(int[]),不知道该可以使用Arrays.sort（Object[] o），并自定义比较规则，于是自己火急火燎的写了个快排。做这种题的时候时间很重要，所以使用Java的工具会方便很多。前几天还听同学提到过使用TreeMap解决笔试中的编程问题，算是Get到了，感觉很多东西有学过，但是做编程题还是用的常用的东西，想不起来用TreeMap等集合。
实验结果（AC）：

3 
5
4 9 5 2 2 1 3 5 1 4
3
2 2 1 1 2 2
3 
1 3 2 2 3 1

输出：

2
1
3