精华内容
下载资源
问答
  • 2021-05-27 19:16:52

    一、自然排序 java.lang.Comparable

    • 在Java中,如果想要对数组进行自然排序,可以调用Arrays.sort()方法进行排序,不过数组元素必须是实现了Comparable接口的类对象(不传入比较器时)
    	int[] nums = {5,3,4,1,6};
    	Arrays.sort(nums);
    
    • 因此,如果需要对自定义的类的对象实现自然排序,则需要让该类继承Comparable接口,重写CompareTo方法即可
    • String、包装类等实现了Comparable接口,重写了CompareTo()
    1. 重写规则
    1. 当前对象大于形参对象,返回1
    2. 当前对象等于形参对象,返回0
    3. 当前对象小于形参对象,返回-1
    2. 自定义类实现自然排序

    自定义Person类,按照年龄大小进行自然排序:

    // 继承Comparable接口,重写CompareTo方法
    class Person implements Comparable {
    
        private String name ;
        private int age ;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void setName(String name) {this.name = name;}
    
        public void setAge(int age) {this.age = age;}
    
        public String getName() {return name;}
    
        public int getAge() {return age;}
    
    	// 这里可以使用泛型进行替换
        @Override
        public int compareTo(Object o){
            if(o instanceof Person){
                Person person = (Person)o;
                return Integer.compare(this.age,person.getAge()); // 可以直接调用包装器的comparaTo方法
            }
            throw new RuntimeException("传入的数据类型不一致");
        }
        public String toString(){
            return "name: "+this.name+
                    " age: " + this.age;
        }
    }
    

    测试运行:

    public void test(){
            Person[] persons = new Person[5];
            Random random = new Random();
            for(int i = 0 ; i  < persons.length; i ++)
                persons[i] = new Person(i+"",random.nextInt(25));
            // 排序前:
            System.out.println("排序前");
            for (Person person : persons) {
                System.out.println(person);
            }
            Arrays.sort(persons);
            // 排序后:
            System.out.println("排序后");
            for (Person person : persons) {
                System.out.println(person);
            }
        }
    
    • 运行结果:
    排序前
    name: 0 age: 16
    name: 1 age: 17
    name: 2 age: 2
    name: 3 age: 18
    name: 4 age: 0
    排序后
    name: 4 age: 0
    name: 2 age: 2
    name: 0 age: 16
    name: 1 age: 17
    name: 3 age: 18
    

    二、自定义排序 比较器:java.util.Comparator

    • 当将一个比较器对象作为参数传递给使用Arrays.sort()数组进行排序,此时不需要考虑数组元素是否实现了Comparable接口
    • 比较器:实现了Comparator接口的类,该类只需要重写Compare()方法即可
    1. 使用背景:
    1. 某些类没有实现Comparable接口而不方便修改代码
    2. 实现了Comparable接口的排序规则不适合当前操作
    2. 重写规则
    • 当o1 大于 o2,返回 1
    • 当o1 等于 o2,返回 0
    • 当o1 小于 o2,返回 -1
    3. 对于上述Person类使用比较器的方式进行比较排序
    • 对每个人进行比较,按年龄升序排列;若年龄相同,对姓名按自然排序排列
    class PersonComparator implements Comparator{
        // 对每个人进行比较,按年龄升序排列;若年龄相同,则比较姓名
        @Override
        public int compare(Object o1, Object o2) {
            if(o1 instanceof Person && o2 instanceof Person){
                Person p1 = (Person) o1 ;
                Person p2 = (Person) o2 ;
                if(p1.getAge() == p2.getAge()){
                    return p1.getName().compareTo(p1.getName());
                }
                else{
                    return Integer.compare(p1.getAge(), p2.getAge());
    
                }
            }
            throw  new RuntimeException("传入的数据类型错误");
        }
    }
    

    测试代码:

        @Test
        public void Test2(){
            Person[] persons = new Person[5];
            Random random = new Random();
            for(int i = 0 ; i  < persons.length; i ++)
            	// 对年龄进行取余操作,便于观察到年龄相同时,按姓名进行排列
                persons[i] = new Person(i+"",random.nextInt(25)%3); 
            for (Person person : persons) {
                System.out.println(person);
            }
            System.out.println();
            Arrays.sort(persons);
            for (Person person : persons) {
                System.out.println(person);
            }
        }
    
    • 运行结果:
    name: 0 age: 0
    name: 1 age: 0
    name: 2 age: 1
    name: 3 age: 0
    name: 4 age: 2
    
    name: 0 age: 0
    name: 1 age: 0
    name: 3 age: 0
    name: 2 age: 1
    name: 4 age: 2
    
    更多相关内容
  • 给大家介绍Java中的排序并不是指插入排序、希尔排序、归并排序等具体的排序算法。而是自然排序和比较器排序,文中通过实例代码介绍的很详细,有需要的朋友们可以参考借鉴。
  • 本文实例讲述了PHP中strnatcmp()函数“自然排序算法”进行字符串比较用法。分享给大家供大家参考,具体如下: PHP中strnatcmp()函数使用”自然”算法来比较两个字符串(区分大小写),通常在自然算法中,数字 2 小于...
  • matlab自然排序

    2019-02-12 17:04:02
    适用于matlab中批量读取文件,对文件进行自然排序。。
  • 自然排序与定制排序

    2019-09-10 17:11:46
    1.自然排序 在Java中提供了一个Comparable接口,在接口中实现了一个public int compareTo(T o);方法 该方法返回一个整数值,通过obj1.compareTo(obj2),对两个对象进行比较,如果返回值是0则表明两数相等,如果...

    1.自然排序

    在Java中提供了一个Comparable接口,在接口中定义了public int compareTo(To);抽象方法
    该方法返回一个整数值,通过obj1.compareTo(obj2),对两个对象进行比较,如果返回值是0则表明两数相等,如果返回正整数则表明obj1大于obj2,否则如果返回负整数则表明obj1小于obj2

    TreeSet会自动调用compareTo(Object obj)方法进行元素之间的排序,然后以升序排列

    在Set集合中的TreeSet章中说过,Set其实就是Map集合的特殊表现形式(value为null的集合)那么跟踪源码,下面这个add方法的注释,说明排序是通过自然排序的

        /**
         * Adds the specified element to this set if it is not already present.
         * More formally, adds the specified element {@code e} to this set if
         * the set contains no element {@code e2} such that
         * <tt>(e==null&nbsp;?&nbsp;e2==null&nbsp;:&nbsp;e.equals(e2))</tt>.
         * If this set already contains the element, the call leaves the set
         * unchanged and returns {@code false}.
         *
         * @param e element to be added to this set
         * @return {@code true} if this set did not already contain the specified
         *         element
         * @throws ClassCastException if the specified object cannot be compared
         *         with the elements currently in this set
         * @throws NullPointerException if the specified element is null
         *         and this set uses natural ordering, or its comparator
         *         does not permit null elements
         */
        public boolean add(E e) {
            return m.put(e, PRESENT)==null;
        }
    

    再次跟进到put方法

    private final Comparator<? super K> comparator;
    //put方法作为添加元素和修改元素的两种功能,添加元素的时候统一返回的是null,修改元素的时候统一返回的是修改之前的元素的value。作为TreeSet方法很明显只有返回null
        public V put(K key, V value) {
            Entry<K,V> t = root;//根节点
            if (t == null) {//判断根节点是否为空
                compare(key, key); // type (and possibly null) check(检查类型可能为空)
                
                root = new Entry<>(key, value, null);//将parent赋值为null并作为根节点
                size = 1;
                modCount++;
                return null;//返回null,跳过余下代码
            }
            int cmp;
            Entry<K,V> parent;
            // split comparator and comparable paths
            Comparator<? super K> cpr = comparator;//判断comparator是定制排序还是自然排序
            //如果comparator是自然排序
            if (cpr != null) {//判断 comparator 是否为null,如果是自然顺序则为null
            	//通过循环比较key的值计算将要添加的结点的位置
                do {
                    parent = t;
                    cmp = cpr.compare(key, t.key);//如果发现有某个结点的key值和将要添加的key的值相等,说明这是修改操作,修改其value值返回旧value值
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);//如果根节点不是空
            }
            else {//如果在创建对象的时候并没有从外部传入comparator比较器
                if (key == null)//判断key的值是否为null
                    throw new NullPointerException();//如果是就抛出空指针异常
                @SuppressWarnings("unchecked")
                    Comparable<? super K> k = (Comparable<? super K>) key;
                do {
                    parent = t;
                    cmp = k.compareTo(t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else
                        return t.setValue(value);
                } while (t != null);
            }
            Entry<K,V> e = new Entry<>(key, value, parent);
            if (cmp < 0)
                parent.left = e;
            else
                parent.right = e;
            fixAfterInsertion(e);//调用方法重构红黑树
            size++;
            modCount++;
            return null;
        }
    

    通过上述源码解析我们很容易就发现,我们传入值到add方法中,会调用put方法,put方法将自然排序和定制排序进行了隔离,而源码中将接口Comparator设置为finale类型
    并在put方法中进行判断,
    如果是Comparator定制排序(默认排序),则可以通过key的compare排序后判断key值是否相等,如果不相等则生成数的左或右节点,相等则替换(在TreeSet中value值都为null,所以即使替换也看不出效果),
    如果是Comparable自然排序(外传入排序(因为包装类或String类型中都写有自然排序方法,如下代码)),那么private final Comparator<? super K> comparator;就会是null,则cpr就是null,那么程序就会执行自然排序,排序并在不相等的情况下生成树的左或右子节点,相等则替换
    最后重构红黑树

        public int compareTo(String anotherString) {
            int len1 = value.length;
            int len2 = anotherString.value.length;
            int lim = Math.min(len1, len2);
            char v1[] = value;
            char v2[] = anotherString.value;
    
            int k = 0;
            while (k < lim) {
                char c1 = v1[k];
                char c2 = v2[k];
                if (c1 != c2) {
                    return c1 - c2;
                }
                k++;
            }
            return len1 - len2;
        }
    

    看完String类中重写的Comparable接口中的compareTo方法后就会更加容易理解,为什么注释中会说是通过自然排序了
    因为这是为了使对象通过一个默认的顺序进行排序,如果是已经定义好的(如:String、Integer等)
    所有添加的数据都按照这个顺序进行排序,则称为自然排序

    但是我们发现一个问题,即我们传入的值之间必须是需要进行比较的
    那么问题来了,如果传入相同的对象确实,可以很容易的通过某种规则进行比较,但是不同的对象呢?
    

    代码如下

    package TreeSetTest;
    
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1 {
    	public static void main(String[] args) {
    		TreeSet ts=new TreeSet();
    		ts.add(new String());
    		ts.add(new Date());
    	}
    }
    

    会出现java.lang.String cannot be cast to java.util.Date的错误,无法从String转换成Date,在String类中的compareTo方法中对应的形参是该类对象,如果传入一个Date类的对象,对象之间会发生强制转换,而我们知道,这样是并不能发生转换的

    package TreeSetTest;
    
    import java.util.Date;
    import java.util.TreeSet;
    //这样又是可以的了
    public class Test1 {
    	public static void main(String[] args) {
    		TreeSet ts=new TreeSet();
    		ts.add(new String());
    		ts.add(new String());
    
    	}
    }
    
    所以在TreeSet中是必须要求对象是相同的并且自然排序需要写在对象所在的类中(因为是外传入排序)
    

    2.定制排序

    定制排序是使用的java中提供的Comparator接口,自然排序就是说排序发生在封装类中,用户无法使用,但是定制排序是可以通过用户自己实现的,在创建TreeSet对象时就可以自定义Comparator接口中的int compare(T o1,To2)方法,比较两个参数的大小,如果该方法返回正整数则表明o1大于o2,如果返回0则说明o1=o2,如果返回负整数则说明o1小于o2

    整数类型

    package TreeSetTest;
    
    import java.util.Comparator;
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1{
    	public static void main(String[] args) {
    		TreeSet<Person> ts=new TreeSet<Person>(new Comparator(){
    			@Override
    			public int compare(Object o1,Object o2) {
    				Person p1=(Person)o1;
    				Person p2=(Person)o2;
    				return -(p1.getAge()-p2.getAge());
    			}
    		});
    		ts.add(new Person(15,"小明","男"));
    		ts.add(new Person(17,"小明","女"));
    		System.out.println(ts);
    	}
    }
    
    

    输出如下

    [Person [age=17, name=小明, sex=女], Person [age=15, name=小明, sex=男]]
    

    String类型

    package TreeSetTest;
    
    import java.util.Comparator;
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1{
    	public static void main(String[] args) {
    		TreeSet<Person> ts=new TreeSet<Person>(new Comparator(){
    			@Override
    			public int compare(Object o1,Object o2) {
    				Person p1=(Person)o1;
    				Person p2=(Person)o2;
    				return p1.getName().compareTo(p2.getName());
    			}
    		});
    		ts.add(new Person(15,"小明","男"));
    		ts.add(new Person(17,"小红","女"));
    		System.out.println(ts);
    	}
    }
    

    输出结果:

    [Person [age=15, name=小明, sex=男], Person [age=17, name=小红, sex=女]]
    

    当字符串相同情况

    说明:这里在比较值相等的情况,是添加无效的,有人会说map中为什么可以覆盖,那是因为key值并没有变,而是修改了Value值,而在TreeSet中的值都是key值,value为null值,所以TreeSet中出现相同值是不会报错也不会被替换的

    如下测试:

    package TreeSetTest;
    
    import java.util.Comparator;
    import java.util.Date;
    import java.util.TreeSet;
    
    public class Test1{
    	public static void main(String[] args) {
    		TreeSet<Person> ts=new TreeSet<Person>(new Comparator<Person>(){
    			@Override
    			public int compare(Person o1, Person o2) {
    				Person p1=(Person)o1;
    				Person p2=(Person)o2;
    				return p1.getName().compareTo(p2.getName());
    			}
    		});
    		ts.add(new Person(15,"小明","男"));
    		ts.add(new Person(17,"小明","女"));
    		System.out.println(ts);
    	}
    }
    

    输出结果:

    [Person [age=15, name=小明, sex=男]]
    

    这里我们需要注意的是,数值是可以直接减的,但是字符串等类类型通过调用自然排序的方法是最简单有效的,至于是升序还是降序,前面加负号即可

    展开全文
  • Matlab自然排序,基于已有的sort排序算法简单实现了matlab的自然排序,使用方法见博文https://blog.csdn.net/G0m3e/article/details/52982737#comments_12194760
  • natsort, 在 python 中,简单但灵活的自然排序 natsort 简单而灵活的python 自然排序。源代码:https://github.com/SethMMorton/natsort下载:https://pypi.org/project/natsort
  •  * @function 二维数组自然排序   * @author www.phpernote.com   * @param array $array 需要排序的数组(二维)   * @param string key 需要根据哪个键排序   * @param string order 排序方式(SORT_ASC...
  • 比较器(Comparable和Comparator)、自然排序、定制排序

    千次阅读 多人点赞 2019-11-07 19:53:53
    比如Integer,double等基本类型数据,Java可以对他们进行比较排序,但是在 Java 中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题 。这篇博客对比较器进行了详细的说明并配有完整的代码实现。

    写在前面: 我是「扬帆向海」,这个昵称来源于我的名字以及女朋友的名字。我热爱技术、热爱开源、热爱编程。技术是开源的、知识是共享的。

    这博客是对自己学习的一点点总结及记录,如果您对 Java算法 感兴趣,可以关注我的动态,我们一起学习。

    用知识改变命运,让我们的家人过上更好的生活

    比如Integer,double等基本类型数据,Java可以对他们进行比较排序,但是在 Java 中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题 。

    一、java中的sort()方法

    在java.util.Collections类中有个sort()方法,主要是用来给数组排序

    public class CompareTest1 {
        @Test
        public void test() {
            String[] arr = new String[]{"AA", "SS", "FF", "OO", "EE", "HH"};
            System.out.println("排序之前: " + Arrays.toString(arr));
            Arrays.sort(arr);
            System.out.println("排序之后: " + Arrays.toString(arr));
        }
    }
    

    代码执行结果:

    排序之前: [AA, SS, FF, OO, EE, HH]
    排序之后: [AA, EE, FF, HH, OO, SS]
    

    需求:商场有一批水果,对水果的价格进行排序

    水果类:

    public class Fruit {
        private String name;
        private double price;
    
        public Fruit() {
        }
    
        public Fruit(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Fruit{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    }
    
    

    测试类:

    public class CompareTest2 {
        @Test
        public void test() {
            Fruit[] arr = new Fruit[5];
            arr[0] = new Fruit("apple", 18);
            arr[1] = new Fruit("pear", 6);
            arr[2] = new Fruit("banana", 14);
            arr[3] = new Fruit("watermelon", 26);
            arr[4] = new Fruit("tomato", 6);
            System.out.println("排序之前: " + Arrays.toString(arr));
            // 排序
            Arrays.sort(arr);
            System.out.println("排序之后: " + Arrays.toString(arr));
        }
    }
    

    程序将会报错:

    java.lang.ClassCastException: xxx.Fruit cannot be cast to java.lang.Comparable
    

    报错原因:类型转换错误

    为了解决这个错误,对象之间的排序将用到比较器。

    Java 实现对象排序的方式有两种:

    自然排序: java.lang.Comparable

    定制排序: java.util.Comparator

    二、自然排序:Comparable

    1.自然排序的定义

    Comparable 接口强行对实现它的每个类的对象进行整体排序

    2.实现过程

    实现 Comparable接口的类必须实现 compareTo(Object obj) 方法,两个对象通过 compareTo方法的返回值来比较大小 。
    ① 如果当前对象 this 大于形参对象 obj 则返回正整数;
    ② 如果当前对象 this 小于 形参对象 obj则返回 负整数;
    ③ 如果当前对象 this 等于 形参对象 obj 则返回零 。
    实现 Comparable接口的对象列表(和数组)可以通过 Collections.sort 或 Arrays.sort 进行自动排序。
    实现此接口的对象可以用作有序映射中的键或有序集合中的集合,无需指定比较器

    为了解决类型转换错误,在水果类里面实现Comparable接口。

    3.示例代码

    水果类:

    public class Fruit implements Comparable<Fruit> {
        private String name;
        private double price;
    
        public Fruit() {
        }
    
        public Fruit(String name, double price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Fruit{" +
                    "name='" + name + '\'' +
                    ", price=" + price +
                    '}';
        }
    
        // 水果价格从低到高进行排序,若价格相同则按水果名称从高到低排序
        @Override
        public int compareTo(Fruit fruit) {
            if (this.price > fruit.price) {
                return 1;
            } else if (this.price < fruit.price) {
                return -1;
            } else {
                // this.name.compareTo(fruit.name) 按名称从低到高,前面加负号,表示相反
                return -this.name.compareTo(fruit.name);
            }
        }
    }
    

    注:测试类代码同Test2
    代码执行结果:

    排序之前: [Fruit{name='apple', price=18.0}, Fruit{name='pear', price=6.0}, Fruit{name='banana', price=14.0}, Fruit{name='watermelon', price=26.0}, Fruit{name='tomato', price=6.0}]
    排序之后: [Fruit{name='tomato', price=6.0}, Fruit{name='pear', price=6.0}, Fruit{name='banana', price=14.0}, Fruit{name='apple', price=18.0}, Fruit{name='watermelon', price=26.0}]
    

    三、定制排序 :Comparator

    在实际开发中,遇到当元素的类型实现了Comparable 接口,但是它的排序方式不适合当前的操作;或者根本没有实现Comparable
    接口,而又不方便修改代码。那么可以考虑使用 Comparator 的对象进行排序。

    1.实现过程

    定义一个比较器对象;
    重写 compare(Object o1,Object o2) 方法,比较 o1 和 o2 的大小:
    ① 如果方法返回正整数,则表示 o1 大于 o2 ;
    ② 如果方法返回 0 ,表示相等;
    ③ 如果方法返回负整数,表示o1 小于 o2 。

    可以 将 Comparator 传递给 sort 方法,从而允许在排序顺序上实现精确控制 。

    2.示例代码

    public class CompareTest3 {
        /**
         * 按字符从大到小进行排序
         */
        @Test
        public void test() {
            String[] arr = new String[]{"AA", "CC", "KK", "MM", "GG", "FF", "DD"};
            System.out.println("原来的字符串: " + Arrays.toString(arr));
            Arrays.sort(arr, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    return -o1.compareTo(o2);
                }
            });
            System.out.println("按字符从大到小排序后的字符串: " + Arrays.toString(arr));
        }
    }
    
    

    代码执行结果:

    原来的字符串: [AA, CC, KK, MM, GG, FF, DD]
    按字符从大到小排序后的字符串: [MM, KK, GG, FF, DD, CC, AA]
    

    对水果的价格进行排序

    注:水果类同前,节省篇幅,在此不再重复。

    public class CompareTest4 {
        @Test
        public void test() {
            Fruit[] arr = new Fruit[5];
            arr[0] = new Fruit("apple", 18);
            arr[1] = new Fruit("pear", 6);
            arr[2] = new Fruit("banana", 14);
            arr[3] = new Fruit("watermelon", 26);
            arr[4] = new Fruit("watermelon", 6);
            System.out.println("排序之前: " + Arrays.toString(arr));
    
            Arrays.sort(arr, new Comparator<Fruit>() {
                // 按照水果名称从低到高排序,若名称相同则按照价格从高到低排序
                @Override
                public int compare(Fruit o1, Fruit o2) {
                    if (o1.getName().equals(o2.getName())) {
                        return -Double.compare(o1.getPrice(), o2.getPrice());
                    } else {
                        return o1.getName().compareTo(o2.getName());
                    }
                }
            });
            System.out.println("排序之后: " + Arrays.toString(arr));
        }
    }
    
    

    代码执行结果:

    排序之前: [Fruit{name='apple', price=18.0}, Fruit{name='pear', price=6.0}, Fruit{name='banana', price=14.0}, Fruit{name='watermelon', price=26.0}, Fruit{name='watermelon', price=6.0}]
    排序之后: [Fruit{name='apple', price=18.0}, Fruit{name='banana', price=14.0}, Fruit{name='pear', price=6.0}, Fruit{name='watermelon', price=26.0}, Fruit{name='watermelon', price=6.0}]
    
    

    当定制排序和自然排序同时存在时,最终的排序结果是按照定制排序进行排序的。

    上一篇 聊聊 StringBuffer 与 StringBuilder

    展开全文
  • 主要介绍了Java自然排序Comparable使用方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了简单了解java自定义和自然排序,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Python中简单而灵活的自然排序。 源代码: : 下载: : 文档: : 快速范例 常问问题 要求 可选依赖项 安装 如何进行测试 如何建立文件 弃用时间表 历史 注意:有关natsort版本7.0.0的更改,请参阅“弃用时间表”...
  • 吞咽自然排序 使用自然排序方式按路径名称对流进行排序 安装 npm install --save-dev gulp-natural-sort 用法 要以升序对流进行重新排序,请执行以下操作: return gulp . src ( path . join ( paths . tutorials ...
  • Java自然排序与定制排序

    千次阅读 2020-01-10 20:25:57
    一、自然排序 自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 如果当前对象this大于形参对象obj,则返回正整数;如果当前对象this小于形参对象obj,则返回负整数;如果当前对象this等于参数...

    一、自然排序

    自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则

    如果当前对象this大于形参对象obj,则返回正整数;如果当前对象this小于形参对象obj,则返回负整数;如果当前对象this等于参数对象obj,则返回零。

    1.Person类

    public class Person implements Comparable<Person> {
        private Integer age;
    
        public Person(Integer age) {
            this.age = age;
        }
    
        @Override
        public int compareTo(Person person) {
            return this.age - person.age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    '}';
        }
    }
    

    2.测试

    Arrays有方法public static void sort(Object[] a)

    @Test
    public void test1() {
        Person[] peoples = new Person[4];
        peoples[0] = new Person(11);
        peoples[1] = new Person(19);
        peoples[2] = new Person(18);
        peoples[3] = new Person(10);
    
        Arrays.sort(peoples);
    
        System.out.println(Arrays.toString(peoples));
    }

    3.结果

    二、定制排序

    定制排序:java.util.Comparator

    当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码时,那么可以考虑使用Comparator的对象来排序

    1.Person类

    public class Person {
        private Integer age;
    
        public Person(Integer age) {
            this.age = age;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    '}';
        }
    }
    

    2.测试

    Arrays有方法public static <T> void sort(T[] a, Comparator<? super T> c)

    @Test
    public void test2() {
        Person[] peoples = new Person[4];
        peoples[0] = new Person( 13);
        peoples[1] = new Person(19);
        peoples[2] = new Person(17);
        peoples[3] = new Person(16);
    
        Arrays.sort(peoples, new Comparator<Person>() {
            @Override
            public int compare(Person person1, Person person2) {
                return person1.getAge() - person2.getAge();
            }
        });
    
        System.out.println(Arrays.toString(peoples));
    }

    3.结果

    展开全文
  • Sort on a string that may contain a number19个我想要一些保留自然排序order1的字符串比较函数. Java中是否有这样的内容?我在String class中找不到任何东西,Comparator class只知道两个实现.我可以自己动手(这...
  • 1. 自然排序 自然排序:类实现了java.lang.Comparable接口,重写compareTo()的规则 //这里固定指:o1表示位于前面的对象,o2表示后面的对象,并且表示o1比o2小 o1.compareTo(o2) //升序 Collections.sort(persons, ...
  • 第一种称为自然排序,参与排序的对象需实现comparable接口,重写其compareTo()方法,方法体中实现对象的比较大小规则,示例如下: 实体类:(基本属性,getter/setter方法,有参无参构造方法,toString方法) package test; ...
  • 自然排序(Comparable): package Java集合; /* * TreeMap的特点是可以进行自然排序和定制排序 */ import java.util.Comparator; import java.util.Iterator; import java.util.Set; import java.util.TreeMap; ...
  • Java中的自然排序

    千次阅读 2019-08-06 10:49:12
    自然排序的方式有两种 一、实现Comparable接口,重写CompareTo()方法 package cn.itlaobing.action; import java.util.*; /** * 实现 Comparable接口 */ public class Student implements Comparable&...
  • 1.6kB),通过区分Unicode字符,数字,日期等来对数组和集合进行自然排序。 人们对包含数字的字符串进行排序的方式与大多数排序算法不同,后者通过按Unicode代码点顺序比较字符串来对值进行排序。 这会产生与人的...
  • 这里写的一个自然排序算法,可以将list进行转换,如果需要排序的是list的实体,修改方法naturalSort中的排序的两个参数就行 package cn.javabb.common; import java.util.Arrays; import java.util.Coll...
  • TreeSet的两种排序方式:自然排序和定制排序 TreeSet是SortedSet接口的实现类,TreeSet可以确保集合元素处于排序状态。TreeSet有两种排序方法:自然排序和定制排序。默认采用自然排序。 1. 自然排序 要求自定义类...
  • Matlab对文件名进行自然排序

    千次阅读 2020-10-12 00:23:40
    function [cs,index] = sort_nat(c,mode) %sort_nat: Natural order sort of cell array of strings. % usage: [S,INDEX] = sort_nat(C) % % where, % C is a cell array (vector) of strings to be sorted. ...
  • 自然排序

    千次阅读 2015-04-07 18:05:37
    自然排序  如果数组中部分元素已按自然数顺序排放,例如,数组,则初期自然排好序的子数组段显然有4段,分别为,,和。请充分利用上述特点设计并实现一个自然合并排序算法,并分析该算法的计算时间复杂度。 ...
  • matlab程序,可调用函数,直接使用将需要排序的内容按照自然规律排序
  • xquery-自然排序 ![自然先生] ( ) XQuery 中两次尝试(需要 MarkLogic 7)。
  • TreeSet集合,自然排序
  • TreeSet的自然排序和定制排序

    千次阅读 2017-07-31 07:15:49
    (该方法不能自动生成)自然排序(Comparable) TreeSet拥有的集合元素的compareTo()方法来比较元素的大小关系,然后将集合元素按照升序排列。 int compareTo(T o) 将此对象与指定的对象进行比较,以返

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 228,548
精华内容 91,419
关键字:

自然排序

友情链接: cmake-3.14.3-win64-x64.rar