java比较器，匿名比较器，lambda比较器，优先级队列的使用

川长思鸟来 2022-09-11 01:11 201阅读 0赞

java有一个比较器接口Comparator，里面有一个compare方法。  
比较函数有两个参数a,b；返回a-b就是升序，返回b-a就是降序。不过最好用比较，不要用相减。  
**使用场景：**

1.  Arrays里面有一个sort(T\[\],Comparator)可以根据比较器对数组的数据进行排序。排序二维数组是最好用的选择。  
    例如每个人都有身高和体重\[h,w\]，有n个人，就可以弄成二维数组。然后按照身高或者体重进行排序。
2.  数组降序排序也要使用比较器，根据比较器进行排序。
3.  优先级队列里面也要使用比较器。

//points是一个n*2的数组。
     public static void findMinArrowShots(int[][] points) {
        
     		//lambda写法，比较简洁，不过存在溢出危险，最好使用比较，升序，把后面改成b[0]-a[0]就是降序
     		//这里的a,b都是一维数组，因为points是二维数组
    		Arrays.sort(points,(a,b)->(a[0]-b[0]));
    		
    		//lambda写法，该方式不会溢出，虽然写多一点，推荐该方式，升序，把判断的>,<转一下就是降序
    		Arrays.sort(points,(a,b)->{
        
                if(a[0]>b[0]){
        
                    return 1;
                }else if(a[0]<b[0]){
        
                    return -1;
                }else{
        
                    return 0;
                }
            });
            
            /**
             * 匿名内部类写法
             * 该方式会直接获取points里面的节点
             */
            Arrays.sort(points, new Comparator<int[]>() {
        
                @Override
                public int compare(int[] o1, int[] o2) {
        
                    /**
                    这个是按points[i][0]从小到大排序，如果要从大到小，只需要把判断的符合改一下
                     * 这里的每个参数就是二维数组里面的一个一维数组
                     * o1[]就是points[i]
                     */
                    if(o1[0]>o2[0]){
        
                        return 1;
                    }else if(o1[0]<o2[0]){
        
                        return -1;
                    }else{
        
                        return 0;
                    }
                }
            });
            
            /**
             * 这是先创建比较器，然后再将比较器对象作为参数放到函数中
             * 这里能使用points是因为在points的作用域里面
             */
            Comparator comparator=new Comparator<Integer>() {
        
                @Override
                public int compare(Integer o1, Integer o2) {
        
                    if(points[o1][0]>points[o2][0]){
        
                        return 1;
                    }else if(points[o1][0]<points[o2][0]){
        
                        return -1;
                    }else{
        
                        return 0;
                    }
                }
            };
            PriorityQueue queue1=new PriorityQueue(comparator);
            for(int i=0;i<points.length;i++){
        
                queue1.offer(i);
            }
            
            /**
             * lambda表达式写法
             * 个人比较喜欢这种。
             */
            PriorityQueue<Integer> queue=new PriorityQueue<>((a, b)-> {
        
                if(points[a][0]>points[b][0]){
        //
                    return 1;
                }else if(points[a][0]<points[b][0]){
        
                    return -1;
                }
                return 0;
            });
    
            for(int i=0;i<points.length;i++){
        
                queue.offer(i);
            }
        }