Arrays.sort()的使用（2）

今天药忘吃喽~ 2021-09-26 14:26 288阅读 0赞

最近看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