精华内容
下载资源
问答
  • Java 的Comparator比较器用法

    千次阅读 2019-09-03 21:20:45
    1.定义:Comparator是外部比较器,用于比较来对象与对象之间的,两个对象进行比较,多用于集合排序,而Comparable可以认为是一个内比较器,根据对象某一属性进行排序的 2.使用方法 1)定义节点信息 class Node{ ...
    1.定义:Comparator是外部比较器,用于比较来对象与对象之间的,两个对象进行比较,多用于集合排序,而Comparable可以认为是一个内比较器,根据对象某一属性进行排序的

    2.使用方法

    1)定义节点信息

    class Node{
        int x;
        int y;
        Node(int x,int y){
            this.x=x;
            this.y=y;
        }
        @Override
        public String toString() {
            return "Node{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    2)比较器方法

    Collections.sort(list, new Comparator<Node>() {
        /**o1-o2为升序序排列,o2-o1为降序排列,若具体到某一字段,则根据该字段进行排列*/
        @Override
        public int compare(Node o1, Node o2) {
            if (o1.x==o2.x) //若x属性相等,根据y来升序
                return o1.y-o2.y;
            return o1.x-o2.x;//x属性不相等,根据x来升序排列
        }
    });

    3)完整代码

    
    import java.util.*;
    
    class Node{
        int x;
        int y;
        Node(int x,int y){
            this.x=x;
            this.y=y;
        }
        @Override
        public String toString() {
            return "Node{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }
    public class Main {
    
        public static void way(int num[],int n){
    
        }
        public static void main(String[] args) {
            Node node4=new Node(2,2);
            Node node3=new Node(2,1);
            Node node1=new Node(1,2);
            Node node2=new Node(1,1);
            Node node5=new Node(3,1);
            Node node6=new Node(3,2);
            ArrayList<Node> list=new ArrayList<>();
            list.add(node1);
            list.add(node2);
            list.add(node3);
            list.add(node4);
            list.add(node5);
            list.add(node6);
            Collections.sort(list, new Comparator<Node>() {
                /**o1-o2为升序序排列,o2-o1为降序排列,若具体到某一字段,则根据该字段进行排列*/
                @Override
                public int compare(Node o1, Node o2) {
                    if (o1.x==o2.x) //若x属性相等,根据y来升序
                        return o1.y-o2.y;
                    return o1.x-o2.x;//x属性不相等,根据x来升序排列
                }
            });
            for (Node node:list
                 ) {
                System.out.println(node.toString());
            }
        }
    }

    3.结果如下

    展开全文
  • java中Comparable和Comparator的用法和区别 Comparable自然排序 Comparator比较器排序 一、概述 Comparable和Comparator在java中都是用于来比较数据大小。实现Comparable接口需要重写compareTo方法,实现...

    java中Comparable和Comparator的用法和区别 Comparable自然排序 Comparator比较器排序

     

    一、概述

    Comparable和Comparator在java中都是用于来比较数据大小。实现Comparable接口需要重写compareTo方法,实现Comparator方法需要重写compare方法。 这两个方法返回值都是int类型,根据返回值来判断比较对象的大小,从而实现排序

     

    二、Comparable 接口比较

    1、Comparable接口位于java.lang.Comparable<T>,下面用代码来演示Comparable接口排序。

    2、定义一个 Student 学生类,如下:

    /**
     * description: 定义Student 学生类
     * @version v1.0
     * @author w
     * @date 2019年10月31日下午10:10:34
     **/
    public class Student {
    	private String name ; // 姓名
    	private int age ; // 年龄
    	private double score ; // 分数
    // ignore getter , setter 
    	public Student(String name, int age, double score) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.score = score;
    	}
    	public Student() {
    		super();
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    	}
    }

     

    3、定义 StudentCompareable类,继承Student , 实现 Comparable接口,重写CompareTo方法。

    /**
     * description: StudentCompareable类,继承Student , 实现 Comparable接口,重写CompareTo方
     * @version v1.0
     * @author w
     * @date 2019年11月3日下午2:16:31
     **/
    public class StudentComparable extends Student implements Comparable<StudentComparable> {
    	@Override
    	public int compareTo(StudentComparable o) {
    		/**
    		 * 需求: age 年龄从 小到大 排列, score 分数从 大 到 小 排列
    		 */
    		if(this.getAge()-o.getAge() ==0) {
    			// 年龄相同,判断分数 . 
    			//注意分数是大到小排列, 所以是 o.getScore() - this.getScore()。
    			return (int) (o.getScore() - this.getScore());
    		}else {
    			return this.getAge()-o.getAge();
    		}
    	}
    	public StudentComparable() {
    		super();
    	}
    
    	public StudentComparable(String name, int age, double score) {
    		super(name, age, score);
    	}
    }

     

    4、定义 StudentComparableTest 类,测试排序功能

    /**
     * description: 测试 Compareable 排序
     * @version v1.0
     * @author w
     * @date 2019年11月3日下午2:16:31
     **/
    public class StudentComparableTest {
    	@Test
    	public  void test() {
    		StudentComparable s1 = new StudentComparable("小明", 18, 60D);
    		StudentComparable s2 = new StudentComparable("小红", 15, 90D);
    		StudentComparable s3 = new StudentComparable("小刚", 22, 80D);
    		StudentComparable s4 = new StudentComparable("小刚", 22, 85D);
    		List<StudentComparable> list = new ArrayList<StudentComparable>();
    		list.add(s1);
    		list.add(s2);
    		list.add(s3);
    		list.add(s4);
    		// 排序前
    		System.out.println(list);
    		Collections.sort(list);
    		// 排序后
    		System.out.println(list);
    	}
    }

     

    5、结果如下:

    [Student [name=小明, age=18, score=60.0], Student [name=小红, age=15, score=90.0], Student [name=小刚, age=22, score=80.0], Student [name=小刚, age=22, score=85.0]]

    [Student [name=小红, age=15, score=90.0], Student [name=小明, age=18, score=60.0], Student [name=小刚, age=22, score=85.0], Student [name=小刚, age=22, score=80.0]]

     

    6、根据排序前后的结果,可以看到 年龄是从小到大正序排序的,分数是从大到小倒序排序,达到预期结果。

     

    三、Comparator 接口排序

    1、Comparator接口位于java.util.Comparator<T>,下面用代码来演示Comparator接口排序。

    2、定义StudentComparator类 继承Student类,实现 Comparator接口,重写compare方法。

    /**
     * description: 定义StudentComparator类 继承Student类,实现 Comparator接口,重写compare方法
     * @version v1.0
     * @author w
     * @date 2019年11月3日下午5:12:42
     **/
    public class StudentComparator extends Student implements Comparator<StudentComparator> {
    	@Override
    	public int compare(StudentComparator o1, StudentComparator o2) {
    		/**
    		 * age 年龄,正序 小到大 , score 分数倒序 大到小。
    		 */
    		if(o1.getAge()==o2.getAge()) {
    			// 注意:分数是 倒序 大到小,所以是 o2-o1.
    			return (int) (o2.getScore() - o1.getScore()) ;
    		}else {
    			return o1.getAge() - o2.getAge();
    		}
    	}
    
    	public StudentComparator() {
    		super();
    	}
    
    	public StudentComparator(String name, int age, double score) {
    		super(name, age, score);
    	}
    }

    3、定义 StudentComparatorTest 类,测试排序功能

    /**
     * description: 测试Comparator 
     * @version v1.0
     * @author w
     * @date 2019年11月3日下午9:29:43
     **/
    public class StudentComparatorTest {
    	@Test
    	public  void test() {
    		StudentComparator s1 = new StudentComparator("小明", 18, 60D);
    		StudentComparator s2 = new StudentComparator("小红", 15, 90D);
    		StudentComparator s3 = new StudentComparator("小刚", 22, 80D);
    		StudentComparator s4 = new StudentComparator("小刚", 22, 85D);
    		List<StudentComparator> list = new ArrayList<StudentComparator>();
    		list.add(s1);
    		list.add(s2);
    		list.add(s3);
    		list.add(s4);
    		// 排序前
    		System.out.println(list);
    		Collections.sort(list,new StudentComparator());
    		// 排序后
    		System.out.println(list);
    	}
    }

     

    4、结果如下:

    [Student [name=小明, age=18, score=60.0], Student [name=小红, age=15, score=90.0], Student [name=小刚, age=22, score=80.0], Student [name=小刚, age=22, score=85.0]]

    [Student [name=小红, age=15, score=90.0], Student [name=小明, age=18, score=60.0], Student [name=小刚, age=22, score=85.0], Student [name=小刚, age=22, score=80.0]]

     

    5、根据排序前后的结果,可以看到 年龄是从小到大正序排序的,分数是从大到小倒序排序,达到预期结果。

     

    6、增加一个测试:按照分数大到小的排序 (结果略)

    /**
    	 * description: 按照分数大到小的排序
    	 * @return void
    	 * @version v1.0
    	 * @author w
    	 * @date 2019年11月3日 下午9:34:03
    	 */
    	@Test
    	public  void testScore() {
    		StudentComparator s1 = new StudentComparator("小明", 18, 60D);
    		StudentComparator s2 = new StudentComparator("小红", 15, 90D);
    		StudentComparator s3 = new StudentComparator("小刚", 22, 80D);
    		StudentComparator s4 = new StudentComparator("小刚", 22, 85D);
    		List<StudentComparator> list = new ArrayList<StudentComparator>();
    		list.add(s1);
    		list.add(s2);
    		list.add(s3);
    		list.add(s4);
    		// 排序前
    		System.out.println(list);
    		Collections.sort(list, new Comparator<StudentComparator>() {
    			@Override
    			public int compare(StudentComparator o1, StudentComparator o2) {
    				return (int) (o2.getScore() - o1.getScore());
    			}
    		});		
    		// 排序后
    		System.out.println(list);
    	}

     

    四、总结

    1、Comparable 位于 java.lang 包, Comparator 位于 java.util 包。

    2、实现Comparable接口需要重写compareTo方法,实现Comparator方法需要重写compare方法, 这两个方法返回值都是int类型。

    3、 int result = s1.compareTo(s2); result = 0 , 则 s1=s2 ; result < 0, 则 s1<s2 ; result > 0 , 则 s1 > s2

    4、int result = compare(T o1, T o2); 结果同上。 (若是 o2-o1,则反之。)

    5、Comparable 接口,java中大部分类已经实现了Comparable(String,BigDecimal,java.util.Date等),用于比较两个对象大小,十分方便。 称之为 自然排序

    6、Comparator 接口,主要用集合中排序(TreeSet ,TreeMap , Collections.sort()),不同需求的排序方式,直接接口实现,易于功能扩展,不影响原代码。 称之为 比较器排序

     

    BigDecimal 比较大小

     

    展开全文
  • 如果需要为列表进行排序,可以考虑使用java.util.Comparator类来完成。使用方法如下: // 列表元素的定义类 class TestObject { private String name; private int age; public TestObject(String name, int ...

    如果需要为列表进行排序,可以考虑使用java.util.Comparator类来完成。使用方法如下:

    
    // 列表元素的定义类
    class TestObject {
      private String name;
      private int age;
      public TestObject(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 this.name;
      }
      public int getAge() {
        return this.age;
      }
    }
    
    // 比较器定义类
    class SortComparator implements Comparator<Object> {
      public int compare(Object o1, Object o2) {
        TestObject obj1 = (TestObject) o1;
        TestObject obj2 = (TestObject) o2;
        return obj1.getName().compareTo(obj2.getName());
      }
    }
    
    // 列表排序
    ArrayList<TestObject> list = new ArrayList<TestObject>();
    list.add(new TestObject("张三", 22));
    list.add(new TestObject("李四", 21));
    list.add(new TestObject("王五", 26));
    list.add(new TestObject("赵六", 20));
    SortComparator sortComparator = new SortComparator();
    Collections.sort(list, sortComparator); // 调用此方法后,list中的元素已按照比较器的定义排序完成
    

     

    展开全文
  • Collections.sort(people, new Comparator() { public int compare(People o1, People o2) { return o1.getAge().compareTo(o2.getAge()); } }); System.out.println(people); } } 输出:[People{age=21, name=‘彭...

    代码

    public class ComparatorDemo {
        public static void main(String[] args) {
            People pi = new People(23,"皮xx");
            People zhang = new People(22,"张xx");
            People peng = new People(21,"彭xx");
            List<People> people = new ArrayList<People>();
            people.add(pi);
            people.add(zhang);
            people.add(peng);
            Collections.sort(people, new Comparator<People>() {
                public int compare(People o1, People o2) {
                    return o1.getAge().compareTo(o2.getAge());
                }
            });
            System.out.println(people);
        }
    }
    
    

    输出:[People{age=21, name=‘彭xx’}, People{age=22, name=‘张xx’}, People{age=23, name=‘皮xx’}]

    记忆

    记录下自己的记法:

    其实咱们也不需要清楚返回+1 or -1 是正序 or 倒序,可以换种角度,两个元素之间是否需要调整顺序,顺序是否需要调整,取决于返回的是否是负数,如果是负数,就不调整顺序,如果是正数就调整顺序

    就像上面代码所展示的:

    return o1.getAge().compareTo(o2.getAge());
    o1的年龄比o2的年龄小

    这种情况,我想升序,那么o1比o2小就是我想要的,正好返回负数,类比false;表示我不想调整顺序

    相反,我想降序,那么o1比o2小就不是我想要的了,那么就返回正数,类比true;表示我想调整顺序,这样的话就应该运用这行代码:return -(o1.getAge().compareTo(o2.getAge()));

    展开全文
  • 简单的用commons的jar包,运用其中Comparator的方法,希望对你有所帮助。
  • Comparator接口是java中很方便的一个接口。我们只需要重写compare方法即可实现排序。int compare(Object o1, Object o2) 返回一个基本类型的整型如果要按照升序排序,则o1 小于o2,返回-1(负数),相等返回0,01...
  • comparable可以认为是一个内部比较器,实现comparable的对象数组需要 重写一下comparable中的compareTo方法。 public class GeRenInfo implements Comparable<GeRenInfo>{ private Integer sxny;//所属.
  • Java有两种比较器:Comparable和Comparator。Comparable称之为内部比较器,实体类实现该接口,重写compareTo方法; Comparator称之为外部比较器,可以自定义比较器类,实现该接口,重写compare方法。Comparator使用...
  • Comparable和Comparator接口都可用作普通意义上对象间的比大小,但两个接口在实例化方面的用法不尽相同,接下来我们就来详细对比Java中的Comparable排序接口和Comparator比较器接口
  • 类型参数:T - 可以与此对象进行比较的那些对象的类型 public interface Comparable&lt;T&gt; 此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序,类的 compareTo 方法被称为它...
  • Comparable(自然排序)和Comparator(比较器)的用法(Java)
  • 需要将所需排序的类实现Comparable接口,并实现内部的comparaTo方法,比较数值可用对应包装类的compare(也可以用做差形式),比较字符用String的compareTo自然情况都是从小到大排序,可在前面加个-号 2.Comparator...
  • Comparable和Comparator都是用来实现集合中的排序的,Comparator位于包java.util下,而Comparable位于包java.lang下,Comparable是一个对象本身就已经支持自比较所需要实现的接口(如 String、Integer 自己就可以...
  • Collections.sort 用法 比较器comparator

    千次阅读 2014-07-18 16:55:03
    import java.util.Comparator;...public class SortList implements Comparator{//比较器 public int compare(Object o1,Object o2){ NewsValueContainer nvc1 = (NewsValueContainer)o1; NewsValueContain
  • 跟上篇文章一样,今天讨论的对象也是Arrays.sort()方法与Comparator接口的相互用法。 当你想对一个普通的对象数组排序,怎么办? 这时候你应该想到的是,使用Comparator接口... Comparator也叫作比较器用法在...
  •  System.err.println("未找到合适的比较器");  return 1;  }  }  public int compare(String o1, String o2) {  String s1 = (String) o1;  String s2 = (String) o2;  int len1 = s1....
  • java的比较器有两类,分别是Comparable接口和Comparator接口。 在为对象数组进行排序时,比较器的作用非常明显,首先来讲解Comparable接口。 让需要进行排序的对象实现Comparable接口,重写其中的compareTo(T o)...
  • //这里简单介绍一下Java的Comparable内部比较器Comparator外部比较器用法实现 //那么我们来做一个关于对象间的排序,首先建一个Model或者叫JavaBen。如下: //1.Java的Comparable内部比较器用法实现: //...

空空如也

空空如也

1 2 3 4 5 6
收藏数 116
精华内容 46
关键字:

comparator比较器用法