精华内容
下载资源
问答
  • java自定义排序
    2022-03-02 13:05:42

    两种最简单的方法:

    1. 自定义Comparator接口的子类(实现compare方法),添加进sort方法的第二个参数中;
    2. 让待比较对象实现Comparable接口,并实现compareTo方法;

    1、通过实现Comparator接口来对集合中的自定义对象排序

    如果排序对象是一个student类

    class Student {
        //姓名,成绩,年龄三个变量
        private String name;
        private int score;
        private int age;
    }
    

    我们想让其根据年龄进行排序,所以我们设计按照年龄排序的比较器

    // sortAge实现Comparator接口
    class sortAge implements Comparator<Student>{
        @Override
        //实现Comparator的compare方法
        public int compare(Student stu1, Student stu2) {
            // TODO Auto-generated method stub
            return stu1.getAge()-stu2.getAge();
        }
    }
    

    测试自定义的排序规则是否生效

    public class SortList {
        public static void main(String [] args){
            //集合的定义
            List<Student> list = new ArrayList<Student>();
            //学生对象的加入
            list.add(new Student("A",89,20));
            list.add(new Student("C",60,21));
            list.add(new Student("B",99,15));
            //按照年龄排序
            //第一个参数是待排序数组,第二个参数是自定义的比较器;
            Collections.sort(list,new sortAge());
        }
    }
    

    2、通过实现Comparable接口

    直接让待排序的对象实现Comparable接口,我们这次按成绩来排名

    //student类,并实现Comparable接口
    class Student implements Comparable<Student>{
        //姓名,成绩,年龄三个变量
        private String name;
        private int score;
        private int age;
    
        @Override
        //实现Comparable的compareTo方法
        public int compareTo(Student stu) {
            // TODO Auto-generated method stub
            return this.getScore()-stu.getScore();
        }
    }
    

    测试

    public class SortList {
        public static void main(String [] args){
            //集合的定义
            List<Student> list = new ArrayList<Student>();
            //学生对象的加入
            list.add(new Student("张三",89,20));
            list.add(new Student("李四",60,21));
            list.add(new Student("路人",99,15));
            //排序
            Collections.sort(list);
        }
    }
    
    更多相关内容
  • Java 自定义排序

    千次阅读 2021-12-12 18:25:20
    java sort Comparable Comparable 可以认为是一个内比较器,实现了 Comparable 接口的类有一个特点,就是这些类是可以和自己比较的,至于具体和另一个实现了 Comparable 接口的类如何比较,则依赖 compareTo 方法的...

    数组排序

    升序排序:Arrays.Sort 方法

    int[] arr = {10, 3, 6, 1, 4, 5, 9};
    Arrays.sort(arr); 
    

    降序排序:升序排序,逆序访问赋值。

    Arrays.sort(arr);
    int[] descArray = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
            descArray[i] = array[arr.length - i - 1];
    }
    

    包装类排序

    jdk 类库中的包装类已经重写了 Compare 方法,即有默认排序规则,例如对于 Integer 类型会比较其包装的值类型大小,对于 String 类型会以长度最小字符串为基准,逐一比较相同位置字符的 ASCII 码大小,如果都相同则比较字符串的长度。

    以 Integer 为例子,升序排序:

    // Integer 集合,升序排序
    List<Integer> list = new ArrayList<Integer>(Arrays.asList(10, 3, 6, 1, 4, 5, 9));
    Collections.sort(list);
    

    降序排序:

    Comparator<Integer> reverseComparator = Collections.reverseOrder();
    Collections.sort(list, reverseComparator);
    // Collections.sort(list, Collections.reverseOrder());
    

    Java 自定义排序

    Arrays.sort() 方法可以对原始类型(基本数据类型)和对象类型进行排序;而 Collections.sort() 只能对 List 进行排序,也是通过 Arrays.sort() 方法实现的。

    java.util.Collections 中的静态方法的 Collections.sort() 主要是针对集合框架中的动态数组,链表,树,哈希表等( ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap )进行排序。

    JDK 中大部分的类都实现了 Comparable 接口,拥有 compareTo 方法。如 Integer,String 等。

    1、实现 Comparable 接口并重写 compareTo() 方法

    int java.lang.Integer.compare(int x, int y) 
    

    Compares two int values numerically. The value returned is identical to what would be returned by:
    Integer.valueOf(x).compareTo(Integer.valueOf(y))

    Parameters:
    x the first int to compare
    y the second int to compare

    Returns:
    the value 0 if x == y; a value less than 0 if x < y; and a value greater than 0 if x > y

    Since:
    The method compare(int, int) in the type Integer is not applicable for the arguments

    2、实现 Comparator 接口,重写 compare() 方法。

    将实现好的接口作为参数传入 Arrays.sort() 或 Collections.sort()。

    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.Collections;
    
    String[] str = {"abc","aa","abcd","abcde","bb","abcedf"};
    // 自定义排序
    Arrays.sort(str, new CompLen());
    // Arrays.sort(str, (a, b) -> a.length() - b.length());
    System.out.println(Arrays.toString(str));
    // 降序 Collections.reverseOrder()
    Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
    Arrays.sort(a, Collections.reverseOrder());
    
    class CompLen implements Comparator<String>{
        @Override
        public int compare(String o1, String o2) {
    		return o1.length() - o2.length(); // 也可以实现降序排列 o2.length() - o1.length();
    	}
    }
    

    compareTo(Object o) 方法是 java.lang.Comparable 接口中的方法,当需要对某个类的对象进行排序时,该类需要实现 Comparable 接口的,必须重写 public int compareTo(T o) 方法。

    它强行将实现它的每一个类的对象进行整体排序-----称为该类的自然排序,实现此接口的对象列表和数组可以用 Collections.sort() 和Arrays.sort() 进行自动排序;也就是说,只要实现了这个接口的对象(数组)就相当于有了排序的能力,所以叫做 comparable —可排序的,是一种 内部排序的方式,通过实现它唯一的方法 compareTo()

    compare(Object o1,Object o2) 方法是 java.util.Comparator 接口的方法,它实际上用的是待比较对象的 compareTo(Object o) 方法。
    对于它,则是针对一些本身没有比较能力的对象(数组)为它们实现比较的功能,所以它叫做 比较器,是一个外部的东西,通过它定义比较的方式,再传到 Collection.sort() 和 Arrays.sort() 中对目标排序,而且通过自身的方法 compare() 定义比较的内容和结果的升降序。

    java 中同类对象之间的 compareTo() 和 compare() 方法对比分析

    java 中同类对象之间的比较又分为两种,基本类型之间的比较和引用类型之间的比较。

    “==” 是一个比较运算符,基本数据类型比较的是值,引用数据类型比较的是地址值。(比较地址值即是指是否为同一个对象的引用)
    equals() 是一个方法,只能比较引用数据类型。重写前比较的是地址值,重写后比一般是比较对象的性。

    以上两种所述的方式都是只能比较对象与对象相不相等,我们往往需要的是它们之间的大小比较,当然对于基本类型值大小之间的比较,常用的是 “>”,但关于对象与对象之间的大小比较,主要有类实现 Comparable 接口(重写 compareTo() 方法),或提供 Comparator 接口(重写 compare()方 法)。

    compareTo() 方法

    重写 compareTo() 方法是实现 Comparable 接口的使用(自然排序)规则:如果当前对象 this 大于形参对象 obj,则返回正整数,如果当前对象 this 小于形参对象 obj, 则返回负整数。如果当前对象 this 等于形参对象 obj, 则返回零。

    public class Test {
    	public static void main(String[] args) {	
    		Student stu1 = new Student("hubert",20);		
    		Student stu2 = new Student("jake",18);		
    		System.out.println(stu1.compareTo(stu2));//结果为1	
    	}
    }
    
    class Student implements Comparable{
    	private String name;
    	private int age;
    	
    	public Student(String name, int age) {
    		this.name = name;
    		this.age = age;
    	}
    	
    	@Override
    	public int compareTo(Student o) {
    		return this.age
    	}
    }
    

    compare()方法

    重写 compare() 方法是提供 Comparator 接口的使用 (定制排序)。重写 compare(Object o1, Object o2) 方法,比较 o1 和 o2 的大小,如果方法返回正整数,则表示 o1 大于 o2, 如果返回 0,表示二者相等,如果返回负整数,表示 o1 小于 o2.

    引入原因:当元素的类型没有实现 java.lang.Comparable 接口而又不方便修改代码,或者实现了 java.lang.Comparable 接口的排序规则不适合当前的操作可以考虑使用 Comparator 的对象来实现排序。

    import java.util.Comparator;
    
    public class Test {
    	public static void main(String[] args) {	
    		Student stu1 = new Student("hubert",20);		
    		Student stu2 = new Student("jake",18);		
    		int compare = new Comparator() {	
    			@Override			
    			public int compare(Student o1, Student o2) {			
    				return o1.getAge() < o2.getAge() ? -1 : o1.getAge() == o2.getAge() ? 0 : 1;
    			}
    		}.compare(stu1, stu2);
    		System.out.println(compare);
    	}
    }
    
    class Student{
    	private String name;
    	private int age;
    	public Student(String name, int age) {	
    		this.name = name;		
    		this.age = age;
    	}	
    	public int getAge() {	
    		return age;	
    	}
    }
    

    Comparator 接口有两个抽象方法,一个是 compare,另一个是 equals 方法,而写这个匿名内部类时,可以不重写 equals 方法,但所有的类都继承 Object, 所以可以不实现 equals 方法。

    Module java.base Package java.lang

    Interface Comparable < T >

    public interface Comparable < T > This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class’s natural ordering, and the class’s compareTo method is referred to as its natural comparison method. Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort). Objects that implement this interface can be used as keys in a sorted map or as elements in a sorted set, without the need to specify a comparator.

    The natural ordering for a class C is said to be consistent with equals if and only if e1.compareTo(e2) == 0 has the same boolean value as e1.equals(e2) for every e1 and e2 of class C. Note that null is not an instance of any class, and e.compareTo(null) should throw a NullPointerException even though e.equals(null) returns false.

    int compareTo(T o)
    Compares this object with the specified object for order.

    Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

    Parameters: o - the object to be compared.
    Returns: a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.
    Throws:
    NullPointerException - if the specified object is null
    ClassCastException - if the specified object’s type prevents it from being compared to this object.

    两个字符串比较返回 ASCII 的差。

    String a = "a";
    String b = "c";        
    System.out.println(a.compareTo(b));
    

    字符串和子串比较返回长度差。

    String a = "a1";
    String b = "a12345678";        
    System.out.println(a.compareTo(b));
    

    返回为正数表示 a > b, 返回为负数表示 a < b, 返回为 0 表示 a == b;

    Error:Cannot invoke compareTo(int) on the primitive type int
    只能比较引用数据类型,原生类型比较需要包装类。

    模块 java.base 包 java.util

    Interface Comparator

    Type Parameters: T - the type of objects that may be compared by this comparator

    public interface Comparator
    A comparison function, which imposes a total ordering on some collection of objects. Comparators can be passed to a sort method (such as Collections.sort or Arrays.sort) to allow precise control over the sort order. Comparators can also be used to control the order of certain data structures (such as sorted sets or sorted maps), or to provide an ordering for collections of objects that don’t have a natural ordering.

    method

    int compare(T o1, T o2) Compares its two arguments for order.
    default Comparator reversed() Returns a comparator that imposes the reverse ordering of this comparator.

    static <T,U extends Comparable<? super U>> Comparator
    comparing(Function<? super T,? extends U> keyExtractor)
    Accepts a function that extracts a Comparable sort key from a type T, and returns a Comparator that compares by that sort key.
    static <T,U> Comparator comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)
    Accepts a function that extracts a sort key from a type T, and returns a Comparator that compares by that sort key using the specified Comparator.
    static Comparator comparingDouble(ToDoubleFunction<? super T> keyExtractor)
    Accepts a function that extracts a double sort key from a type T, and returns a Comparator that compares by that sort key.
    static Comparator comparingInt(ToIntFunction<? super T> keyExtractor)
    Accepts a function that extracts an int sort key from a type T, and returns a Comparator that compares by that sort key.
    static Comparator comparingLong(ToLongFunction<? super T> keyExtractor)
    Accepts a function that extracts a long sort key from a type T, and returns a Comparator that compares by that sort key.
    boolean equals(Object obj) Indicates whether some other object is “equal to” this comparator.
    static <T extends Comparable<? super T>> Comparator naturalOrder()
    Returns a comparator that compares Comparable objects in natural order.
    static Comparator nullsFirst(Comparator<? super T> comparator)
    Returns a null-friendly comparator that considers null to be less than non-null.
    static Comparator nullsLast(Comparator<? super T> comparator)
    Returns a null-friendly comparator that considers null to be greater than non-null.

    static <T extends Comparable<? super T>> Comparator reverseOrder()
    Returns a comparator that imposes the reverse of the natural ordering.
    default Comparator thenComparing(Comparator<? super T> other)
    Returns a lexicographic-order comparator with another comparator.
    default <U extends Comparable<? super U>> Comparator
    thenComparing(Function<? super T,? extends U> keyExtractor)
    Returns a lexicographic-order comparator with a function that extracts a Comparable sort key.
    default Comparator thenComparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)
    Returns a lexicographic-order comparator with a function that extracts a key to be compared with the given Comparator.
    default Comparator thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)
    Returns a lexicographic-order comparator with a function that extracts a double sort key.
    default Comparator thenComparingInt(ToIntFunction<? super T> keyExtractor)
    Returns a lexicographic-order comparator with a function that extracts an int sort key.
    default Comparator thenComparingLong(ToLongFunction<? super T> keyExtractor)
    Returns a lexicographic-order comparator with a function that extracts a long sort key.

    展开全文
  • java自定义排序

    2022-04-22 17:08:30
    java中sort的自定义排序一、Arrays.sort(nums)的一般用法二、最大数(力扣179)三、合并区间(力扣59) 一、Arrays.sort(nums)的一般用法 整个数组按照升序排序 若需要降序排序,将数组转置即可 int[] testNums =...


    一、Arrays.sort(nums)的一般用法

    1. 整个数组按照升序排序
      若需要降序排序,将数组转置即可
    int[] testNums = {1,3,6,5,4,1,2,8};
    Arrays.sort(testNums);
    System.out.println(Arrays.toString(testNums));
    
    //输出:[1, 1, 2, 3, 4, 5, 6, 8]
    
    1. 对指定范围内的数组元素进行排序
    int[] testNums2 = {1,3,6,5,4,1,2,8};
    Arrays.sort(testNums2,1,6);
    System.out.println(Arrays.toString(testNums2));
    
    //输出:[1, 1, 3, 4, 5, 6, 2, 8]
    
    1. 自定义排序
      二维数组排序为例,比如,将:[[1,2],[3,4],[1,3],[2,4]] 按照每个一维数组的和的升序进行排序
    int[][] testNums3 = {{1,2},{3,4},{1,3},{2,4}};
    Arrays.sort(testNums3, new Comparator<int[]>() {
        @Override
        public int compare(int[] o1, int[] o2) {
            return (o1[0]+o1[1])-(o2[0]+o2[1]);
        }
    });
    for (int[] nums:testNums3){
        System.out.println(Arrays.toString(nums));
    }
    
    /*
        输出:
            [1, 2]
            [1, 3]
            [2, 4]
            [3, 4]
     */
    
    • 若要实现自定义排序,要给sort()函数传入一个继承Comparator接口的对象,在compare方法中定义自己的排序规则。
    • compare函数返回一个int类型:
      • o1,o2可以看成原数组中相邻的前后两个元素。返回值可以看成o1-o2的值。
      • 若返回负数,则说明o1-o2<0,sort方法将数组按升序(o1,o2)排列。
      • 反之若返回正数,说明o1-o2>0,按降序(o2,o1)排列。
      • 注意这里o1和o2并不一定能直接相加减,以上只是提供初学者一种记忆的方法,还是需要在实战中理解,接下来以两道算法题具体说明sort函数的一些应用。

    4.使用lambda表达式自定义排序规则(重要!)

    在3中,对应的接口函数可以用lambda表达式简写如下:

    Arrays.sort(testNums3,(o1, o2) -> {
            return (o1[0]+o1[1])-(o2[0]+o2[1]);
        }
    });
    

    注意,要想改变默认的排列顺序,不能使用基本类型(int,double, char) ,而要使用它们对应的包装类。

    二、最大数(力扣179)

    原题连接
    在这里插入图片描述

    分析:先考虑两个数的情况,假设有两个数num1,num2,则答案要么是num1+num2,要么是num2+num1(注意这里的+表示拼接操作:1+2 = 12
    定义num1>num2:num1+num2>num2+num1,举例说明:因为"3"+“31”=“331”>“31”+“3”=“313”,所以"3">“31”。
    不难看出,当整个数组都按照我们定义的大小关系降序排序,最后依次拼接即为结果。比如:“31”>“30”>“2”,"31302"为所求最大数。代码如下:

    public class Solution179 {
        /*
            给定一组非负整数 nums,重新排列每个数的顺序(每个数不可拆分)使之组成一个最大的整数。
            注意:输出结果可能非常大,所以你需要返回一个字符串而不是整数。
    
            输入:nums = [3,30,34,5,9]
            输出:"9534330"
            链接:https://leetcode-cn.com/problems/largest-number/
         */
        public static void main(String[] args) {
            int[] nums = {0,20,2190,5,38,21,1};
            System.out.println(Solution.largestNumber(nums));
        }
        static class Solution {
    	    public static String largestNumber(int[] nums) {
    	        String ans = "";
    	        String[] temp = new String[nums.length];
    	        for (int i = 0; i < nums.length; i++) {
    	            temp[i] = Integer.toString(nums[i]);
    	        }
    	
    	        Arrays.sort(temp, new Comparator<String>() {
    	            @Override
    	            public int compare(String o1, String o2) {
    	                String o12 = o1+o2,o21 = o2+o1;
    	                for (int i = 0; i < o12.length(); i++) {//逐个比较对应字符的大小
    	                    //返回负数,顺序为(o1,o2)
    	                    if(o12.charAt(i)>o21.charAt(i)) return -1;
    	                    //返回正数,顺序为(o2,o1)
    	                    else if(o12.charAt(i)<o21.charAt(i)) return 1;
    	                    //无论是那种顺序,字符大的都在前面,因此是按降序排列
    	                }
    	                //若直到最后一个字符都相等,按照最后一个字符的大小来决定
    	                return o12.charAt(o12.length()-1)<o21.charAt(o21.length()-1)?1:-1;
    	            }
    	        });
    	        for (String s :
    	                temp) {
    	            ans += s;
    	        }
    	        return ans;
    	    }
    	}
    }
    

    三、合并区间(力扣59)

    原题连接
    在这里插入图片描述

    分析:首先对intervals进行排序,排序规则为第一列按升序,第一列相等时第二列按降序,例如:[1,2]>[0,3],[2,2]>[2,3](思考为什么要这样排序)。
    然后再遍历intervals进行合并。

    • 合并的过程中维护两个数值,左端点L,右端点R。
    • 一开始先给L和R赋初值为第一个区间的端点值,遍历intervals。
    • 若左端点和L相同,直接跳过(和一开始的排序有关)。
    • 若左端点大于L且大于R,说明L,R之间没有重叠区域了,记录L,R,并更新为当前区间的左右端点。
    • 若左端点大于L但是小于等于R,可能有重叠区域,将R更新为R与右端点之间的最大值。
    • 遍历结束后判断L,R是否记录。代码如下:
    /*
        以数组 intervals 表示若干个区间的集合,其中单个区间为 intervals[i] = [starti, endi] 。
        请你合并所有重叠的区间,并返回一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间。
    
        [[1,3],[1,2],[2,6],[8,10],[15,18]]
    
        输入:intervals = [[1,3],[2,6],[8,10],[15,18]]
        输出:[[1,6],[8,10],[15,18]]
        解释:区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
    
        链接:https://leetcode-cn.com/problems/merge-intervals
     */
    public class Solution56 {
        public static void main(String[] args) {
            int[][] intervals =  {{1,3},{1,2},{2,6},{8,10},{15,18},{19,20}};
    //        int[][] intervals =  {{1,4},{0,4}};
            System.out.println(Arrays.deepToString(Solution.merge(intervals)));
    
        }
    
        private static class Solution {
            public static int[][] merge(int[][] intervals) {
                //1.第一维升序,第二维降序进行排序
                //2.遍历数组,记录当前区间的端点;
                // 若下一个区间的左端点相同,直接跳过;若大于前一个的右端点,记录前一个区间,更新区间的左右端点;若小于前一个的右端点,则存在重合区域,更新区间端点
                int[][] ans = new int[10005][2];
                Arrays.sort(intervals, new Comparator<int[]>() {
                    @Override
                    public int compare(int[] o1, int[] o2) {
                        if(o1[0]!=o2[0]) return o1[0]-o2[0];
                        else return o2[1]-o1[1];
                    }
                });
    
                int L = 0,R = 0;//左右端点
                int nums = 0;//合并后的区间个数
                for (int i = 0; i < intervals.length; i++) {
                    if(i==0){
                        L = intervals[0][0];R = intervals[0][1];continue;
                    }
                    if(intervals[i][0]==L) continue;//左区间端点相等直接跳过
                    else if (intervals[i][0]>L){ //左区间端点大于前一个的左区间端点
                        if(intervals[i][0]>R){  //仍然大于右区间端点,记录
                            ans[nums][0] = L;ans[nums][1] = R;L = intervals[i][0];R = intervals[i][1];nums++;
                        }
                        else {//若小于等于右区间端点,比较它的右端点和原右端点的值,更新R
                            R = Math.max(intervals[i][1],R);
                        }
                    }
    
    
                }
    
                //存在结束循环但是最后一个区间还没有加入ans的情况
                //最后一个区间也是首个区间
                if(nums==0) {ans[nums][0]=L;ans[nums][1]=R;}
                //最后一个区间不是首个区间的话只需要判断左端点是否相等,不相等说明还没有记录
                if(nums!=0 && ans[nums][0]!=L) {ans[nums][0]=L;ans[nums][1]=R;}
    
                return Arrays.copyOfRange(ans,0,nums+1);
            }
        }
    }
    

    四、总结

    在理解各类排序算法的情况下,熟练使用Arrays.sort()方法解决问题,尤其掌握Comparator接口或lambda表达式的写法!

    展开全文
  • Java自定义排序简单总结

    千次阅读 2022-03-27 04:46:31
    Java自定义排序简单总结 默认情况下:Java实现Comparator排序是升序,即自然排序 根据参数,返回值来判断是否交换 对于a,b两个参数(a在前,b在后) jdk官方的升序基于: < return -1 > return 1 = return 0 ...

    简单总结

    默认情况下:Java实现Comparator排序是升序,即自然排序

    根据参数,返回值来判断是否交换

    对于a,b两个参数(a在前,b在后)

    jdk官方的升序基于:

    < return -1
    > return 1
    = return 0
    

    降序就是反过来

    < return 1
    > return -1
    = return 0
    

    底层源码的实现可参考:java comparator 升序、降序、倒序从源码角度理解

    如果要升序:那么a<b就是想要的顺序,所以return -1 ,false,不交换。

    如果要降序:那么a<b就是不想要的顺序,所以return 1,true,要交换。

    为了方便记忆,总结了如下的规律:

    1. 当不管大于、小于、等于时,我们都返回 -1,那么就是倒序。
    2. 当不管大于、小于、等于时,我们都返回0或者1时,效果是一样的,就是不排序。但是0表示的是,相同元素不排序,要是我们把等于返回为-1,那么两个相同的元素会交互顺序;
    3. 当需要返回-1、1、0时,返回1的时候进行位置交换。

    升序

    ArrayList< Integer > list = new ArrayList<>();
    list.add(2);
    list.add(1);
    list.add(3);
    list.add(4);
    list.add(8);
    list.add(8);
    list.sort(new Comparator< Integer >() {
        @Override
        public int compare(Integer o1, Integer o2) {
            // 升序 返回1的时候进行位置交换
            if (o1 < o2) {
                return -1;
            } else if (o1 > o2) {
                return 1;
            } else {
                return 0;
            }
        }
    });
    System.out.print("排序后 = ");
    for (int i = 0; i < list.size(); i++) {
        Integer integer = list.get(i);
        System.out.print(integer);
        if (i != list.size() - 1) {
            System.out.print("、");
        }
    }
    // 结果
    // 排序后 = 1、2、3、4、8、8
    

    降序

    ArrayList< Integer > list = new ArrayList<>();
    list.add(2);
    list.add(1);
    list.add(3);
    list.add(4);
    list.add(8);
    list.add(8);
    list.sort(new Comparator< Integer >() {
        @Override
        public int compare(Integer o1, Integer o2) {
            // 降序 返回1的时候进行位置交换
            if (o1 > o2) {
                return -1;
            } else if (o1 < o2) {
                return 1;
            } else {
                return 0;
            }
        }
    });
    System.out.print("排序后 = ");
    for (int i = 0; i < list.size(); i++) {
        Integer integer = list.get(i);
        System.out.print(integer);
        if (i != list.size() - 1) {
            System.out.print("、");
        }
    }
    // 结果
    // 排序后 = 8、8、4、3、1、2
    

    倒序

    ArrayList< Integer > list = new ArrayList<>();
    list.add(2);
    list.add(1);
    list.add(3);
    list.add(4);
    list.add(8);
    list.add(8);
    list.sort(new Comparator< Integer >() {
        @Override
        public int compare(Integer o1, Integer o2) {
            //不管大于、小于和等于 都返回 -1
            return -1;
        }
    });
    System.out.print("排序后 = ");
    for (int i = 0; i < list.size(); i++) {
        Integer integer = list.get(i);
        System.out.print(integer);
        if (i != list.size() - 1) {
            System.out.print("、");
        }
    }
    // 结果
    // 排序后 = 8、8、4、3、1、2
    

    不变

    假设不管大于、小于、等于,我们都返回0 ,会发现顺序没有变;而且你会发现,要是都返回1的话,顺序也是没有变的!

    当不管大于、小于、等于时,我们都返回一个值时,01效果是一样的,就是不排序;-1就是倒序。

    ArrayList< Integer > list = new ArrayList<>();
    list.add(2);
    list.add(1);
    list.add(3);
    list.add(4);
    list.add(8);
    list.add(8);
    list.sort(new Comparator< Integer >() {
        @Override
        public int compare(Integer o1, Integer o2) {
            // 返回0或者1的时候不排序
            return 1;
        }
    });
    System.out.print("排序后 = ");
    for (int i = 0; i < list.size(); i++) {
        Integer integer = list.get(i);
        System.out.print(integer);
        if (i != list.size() - 1) {
            System.out.print("、");
        }
    }
    // 结果
    // 排序后 = 2、1、3、4、8、8
    

    其实0表示的是,相同元素不排序,要是我们把等于返回为-1,那么两个相同的元素会交互顺序;

    对数字而言交换顺序没有关系,但是里面要是是Map对象的话,那就有关系,因为有时我们是希望相同元素不进行顺序调整的。

    代码链接:ComparatorDemo

    展开全文
  • java数组自定义排序

    2017-10-31 15:35:59
    java中数组的自定义排序,种类繁多,简单实现,可自由操控。
  • 主要介绍了Java自定义比较器实现中文排序,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java自定义排序

    千次阅读 2019-07-20 19:56:29
    Java自定义排序可以通过实现Comparator接口或Comparable接口来完成。 关键:实现Comparator接口的关键在于重写compare()方法,Comparable接口的关键在于重写compareTo()方法。JDK中大部分的类都实现了Comparable...
  • java自定义排序】.md

    2021-11-14 18:40:51
    Java自定义排序详解
  • JAVA自定义排序

    2019-09-27 14:42:47
    import java.util.Arrays; //实现Comparable接口可以进行比较大小 public class People implements Comparable<People>{ private String name; private Integer age; public People(String name, ...
  • 主要介绍了JAVA使用Comparator接口实现自定义排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JAVA实现自定义排序

    2021-12-16 11:22:28
    JAVA collections.sort中文自定义排序
  • Java自定义数组排序

    2022-06-07 17:02:39
    Java自定义数组排序
  • 主要介绍了Java针对ArrayList自定义排序的2种实现方法,结合实例形式总结分析了Java操作ArrayList自定义排序的原理与相关实现技巧,需要的朋友可以参考下
  • Java自定义排序的几种方式

    千次阅读 2021-08-20 09:50:52
    对于普通数据类型数组,Java的Arrays类中提供了几种方法: Arrays.sort(int[] a):按照数字顺序排列指定的数组 sort(int[] a, int fromIndex, int toIndex):按升序排列数组的指定范围 Arrays.parallelSort(int[] a...
  • Java自定义排序多种方式

    千次阅读 2020-08-28 14:48:16
    Java自定义排序多种方式三种方式在创建时写Comparator 定制排序compare接口重写 compareTo 方法 三种方式 在创建时写 第一次见,记录一下,之后两种是正常写法,改变排序也方便改,这个适合leetcode TreeMap<...
  • java 自定义排序规则 重写Arrays.sort排序规则(二维数组)
  • 我想按自定义对象的属性之一对ArrayList进行排序:Date对象(getStartDay())。通常,我将它们进行比较,item1.getStartDate().before(item2.getStartDate())因此我想知道是否可以编写如下内容:public class ...
  • age=20] 排序后:User [id=2, name=spark, age=19] 以上就是Java如何实现List自定义排序的详细内容,更多关于Java List自定义排序的资料请关注云海天教程其它相关文章! 原文链接:...
  • 在用PriorityQueue,Arrays.sort需要自定义排序时,可以自定义Comparable或Comparator来实现自定义排序。 Comparable是一个接口,实现它需要定义int compareTo(T o) Comparator也是接口,需要实现int compare(T o1, ...
  • 在写leetcode题目的时候,经常会想按照自己想的方式对数组或者说是字符串进行排序,就学习了这个方法,这篇文章主要是用来记录 java自定义对象数组排序Arrays.sort()方法以及Collections.sort()中的Comparator接口...
  • 使用Java实现List自定义排序的方法发布时间:2020-11-04 15:39:29来源:亿速云阅读:98作者:Leah使用Java实现List自定义排序的方法?针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决...
  • Java中如何实现List的自定义排序

    千次阅读 2020-08-20 11:55:38
    最近项目中遇到一个问题,需要对List进行自定义顺序排序,打个比方,现在我有一个SortStudent类,需要对它的年龄降序排序,再对他的省份进行自定义排序,要求按照:"安徽", "北京", "上海", "深圳", "广州"的顺序...
  • Java自定义类型如何进行排序? 方式一:实现Comparable接口 String类型是可以进行排序的,是因为他实现了Comparable接口,重写了compareTo()方法 先来看一下String类是怎么重写compareTo(obj)方法的 public int ...
  • Lucene中的自定义排序功能和Java集合中的自定义排序的实现方法差不多,都要实现一下比较接口. 在Java中只要实现Comparable接口就可以了.但是在Lucene中要实现SortComparatorSource接口和ScoreDocComparator接口.在...
  • * java中Comparator自定义排序: * Comparator接口可以实现自定义排序,实现Comparator接口时,要重写compare方法: * int compare(Object o1, Object o2) 返回一个基本类型的整型 * 如果要按照升序排序,则o1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 175,018
精华内容 70,007
关键字:

java自定义排序

友情链接: nURHelper_v1.1.10171.rar