GVKun编程网logo

在Java中将Comparable用于VO的多个动态字段（java设置多个动态变量）

29

本文将带您了解关于在Java中将Comparable用于VO的多个动态字段的新内容，同时我们还将为您解释java设置多个动态变量的相关知识，另外，我们还将为您提供关于JavaComparable和Co

本文将带您了解关于在Java中将Comparable用于VO的多个动态字段的新内容，同时我们还将为您解释java设置多个动态变量的相关知识，另外，我们还将为您提供关于Java Comparable 和 Comparator 的详解及区别、Java Comparable与Comparator 比较、Java Comparable和Comparator对比详解、Java Comparator与Comparable辨析的实用信息。

本文目录一览：

在Java中将Comparable用于VO的多个动态字段（java设置多个动态变量）

在Java中将Comparable用于VO的多个动态字段（java设置多个动态变量）

我有一堂课

public class StudentVO {   int age;   String name;  }

我在两个不同的领域使用了同一堂课。在一个地方，我需要根据年龄分类。在另一个地方，我需要根据名称进行排序，而在另一个地方，我可能需要根据年龄和名称进行排序。我怎样才能做到这一点？如果一个字段我可以覆盖compareTo()。

是否有可能做到这一点？

答案1

小编典典

1）您应该编写两个用于分别对年龄和名称进行排序的比较器，然后使用Collections.sort（List，Comparator）。像这样：

class StudentVO {  private String name;  private int age;  public String getName() {      return name;  }  public void setName(String name) {      this.name = name;  }  public int getAge() {      return age;  }  public void setAge(int age) {      this.age = age;  }}class AgeComparator implements Comparator<StudentVO> {@Overridepublic int compare(StudentVO o1, StudentVO o2) {    Integer age1 = o1.getAge();    Integer age2 = o2.getAge();    return age1.compareTo(age2);  }}class NameComparator implements Comparator<StudentVO> {  @Override  public int compare(StudentVO o1, StudentVO o2) {      return o1.getName().compareTo(o2.getName());  }}

然后使用它们，基于进行排序age：

Collections.sort(list,new AgeComparator());

排序依据name：

Collections.sort(list,new NameComparator());

2）如果您认为Listof
StudentVO具有某种自然的排序顺序，请说假设按by排序age。然后，将Comparable用于age和Comparator用于name。

 class StudentVO implements Comparable<StudentVO>{    private String name;    private int age;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public int compareTo(StudentVO o) {        return ((Integer)getAge()).compareTo(o.getAge());    }}class NameComparator implements Comparator<StudentVO> {    @Override    public int compare(StudentVO o1, StudentVO o2) {        return o1.getName().compareTo(o2.getName());    } }

然后使用它们，基于进行排序age：

Collections.sort(list);

排序依据name：

Collections.sort(list,new NameComparator());

Java Comparable 和 Comparator 的详解及区别

Java Comparable 和 Comparator 的详解及区别

这篇文章主要介绍了Java Comparable 和 Comparator 的详解及区别的相关资料,Comparable 自然排序和Comparator 定制排序的实例，需要的朋友可以参考下

Java Comparable 和 Comparator 的详解及区别

Java 中为我们提供了两种比较机制：Comparable 和 Comparator，他们之间有什么区别呢？今天来了解一下。

Comparable 自然排序

Comparable 在 java.lang 包下，是一个接口，内部只有一个方法 compareto()：

public interface Comparable { public int compareto(T o); }

Comparable 可以让实现它的类的对象进行比较，具体的比较规则是按照 compareto 方法中的规则进行。这种顺序称为 自然顺序。

compareto 方法的返回值有三种情况：

e1.compareto(e2) > 0 即 e1 > e2

e1.compareto(e2) = 0 即 e1 = e2

e1.compareto(e2)

注意：

1.由于 null 不是一个类，也不是一个对象，因此在重写 compareto 方法时应该注意 e.compareto(null) 的情况，即使 e.equals(null) 返回 false，compareto 方法也应该主动抛出一个空指针异常 NullPointerException。

2.Comparable 实现类重写 compareto 方法时一般要求 e1.compareto(e2) == 0 的结果要和 e1.equals(e2) 一致。这样将来使用 SortedSet 等根据类的自然排序进行排序的集合容器时可以保证保存的数据的顺序和想象中一致。

有人可能好奇上面的第二点如果违反了会怎样呢？

举个例子，如果你往一个 SortedSet 中先后添加两个对象 a 和 b，a b 满足 (!a.equals(b) && a.compareto(b) == 0)，同时也没有另外指定个 Comparator，那当你添加完 a 再添加 b 时会添加失败返回 false, SortedSet 的 size 也不会增加，因为在 SortedSet 看来它们是相同的，而 SortedSet 中是不允许重复的。

实际上所有实现了 Comparable 接口的 Java 核心类的结果都和 equlas 方法保持一致。

实现了 Comparable 接口的 List 或则数组可以使用 Collections.sort() 或者 Arrays.sort() 方法进行排序。

实现了 Comparable 接口的对象才能够直接被用作 SortedMap (SortedSet) 的 key，要不然得在外边指定 Comparator 排序规则。

因此自己定义的类如果想要使用有序的集合类，需要实现 Comparable 接口，比如：

** * description: 测试用的实体类 书, 实现了 Comparable 接口，自然排序 *

* author: shixinzhang *

* data: 10/5/2016 */ public class BookBean implements Serializable, Comparable { private String name; private int count; public BookBean(String name, int count) { this.name = name; this.count = count; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getCount() { return count; } public void setCount(int count) { this.count = count; } /** * 重写 equals * @param o * @return */ @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof BookBean)) return false; BookBean bean = (BookBean) o; if (getCount() != bean.getCount()) return false; return getName().equals(bean.getName()); } /** * 重写 hashCode 的计算方法 * 根据所有属性进行 迭代计算，避免重复 * 计算 hashCode 时 计算因子 31 见得很多，是一个质数，不能再被除 * @return */ @Override public int hashCode() { //调用 String 的 hashCode(), 唯一表示一个字符串内容 int result = getName().hashCode(); //乘以 31, 再加上 count result = 31 * result + getCount(); return result; } @Override public String toString() { return "BookBean{" + "name='" + name + ''' + ", count=" + count + '}'; } /** * 当向 TreeSet 中添加 BookBean 时，会调用这个方法进行排序 * @param another * @return */ @Override public int compareto(Object another) { if (another instanceof BookBean){ BookBean anotherBook = (BookBean) another; int result; //比如这里按照书价排序 result = getCount() - anotherBook.getCount(); //或者按照 String 的比较顺序 //result = getName().compareto(anotherBook.getName()); if (result == 0){ //当书价一致时，再对比书名。 保证所有属性比较一遍 result = getName().compareto(anotherBook.getName()); } return result; } // 一样就返回 0 return 0; }

上述代码还重写了 equlas(), hashCode() 方法，自定义的类想要进行比较时都要重写这些方法。

后面重写 compareto 时，要判断某个相同时对比下一个属性，把所有属性都比较一次。

Comparable 接口属于 Java 集合框架的一部分。

Comparator 定制排序

Comparator 在 java.util 包下，也是一个接口，JDK 1.8 以前只有两个方法：

public interface Comparator { public int compare(T lhs, T rhs); public boolean equals(Object object); }

JDK 1.8 以后又新增了很多方法：

基本上都是跟 Function 相关的，这里暂不介绍 1.8 新增的。

从上面内容可知使用自然排序需要类实现 Comparable，并且在内部重写 comparaTo 方法。

而 Comparator 则是在外部制定排序规则，然后作为排序策略参数传递给某些类，比如 Collections.sort(), Arrays.sort(), 或者一些内部有序的集合（比如 SortedSet，SortedMap 等）。

使用方式主要分三步：

1.创建一个 Comparator 接口的实现类，并赋值给一个对象

在 compare 方法中针对自定义类写排序规则

2.将 Comparator 对象作为参数传递给 排序类的某个方法

3.向排序类中添加 compare 方法中使用的自定义类

举个例子：

// 1.创建一个实现 Comparator 接口的对象 Comparator comparator = new Comparator() { @Override public int compare(Object object1, Object object2) { if (object1 instanceof NewBookBean && object2 instanceof NewBookBean){ NewBookBean newBookBean = (NewBookBean) object1; NewBookBean newBookBean1 = (NewBookBean) object2; //具体比较方法参照 自然排序的 compareto 方法，这里只举个栗子 return newBookBean.getCount() - newBookBean1.getCount(); } return 0; } }; //2.将此对象作为形参传递给 TreeSet 的构造器中 TreeSet treeSet = new TreeSet(comparator); //3.向 TreeSet 中添加 步骤 1 中 compare 方法中设计的类的对象 treeSet.add(new NewBookBean("A",34)); treeSet.add(new NewBookBean("S",1)); treeSet.add( new NewBookBean("V",46)); treeSet.add( new NewBookBean("Q",26));

其实可以看到，Comparator 的使用是一种策略模式，不熟悉策略模式的同学可以点这里查看： 策略模式：网络小说的固定套路 了解。

排序类中持有一个 Comparator 接口的引用：

Comparator super K> comparator;

而我们可以传入各种自定义排序规则的 Comparator 实现类，对同样的类制定不同的排序策略。

总结

Java 中的两种排序方式：

Comparable 自然排序。（实体类实现）

Comparator 是定制排序。（无法修改实体类时，直接在调用方创建）

同时存在时采用 Comparator（定制排序）的规则进行比较。

对于一些普通的数据类型（比如 String, Integer, Double…），它们默认实现了Comparable 接口，实现了 compareto 方法，我们可以直接使用。

而对于一些自定义类，它们可能在不同情况下需要实现不同的比较策略，我们可以新创建 Comparator 接口，然后使用特定的 Comparator 实现进行比较。

这就是 Comparable 和 Comparator 的区别。

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

Java Comparable与Comparator 比较

Java Comparable与Comparator 比较

    在有些时候，我们需要对自定义的类的集合进行比较、排序。Java为实现此功能提供了两个接口：Comparable与Comparator。

    1、Comparable与Comparator区别：

    Comparable与Comparator接口都是为了实现集合排序，它们的区别在于Comparable在类的内部定义的方法实现排序，Comparator是在类的外部实现排序。

    Comparable是一个对象自身已经支持自比较锁需要实现的接口。String、Integer等类自己就可以完成比较大小的操作。

    Comparator是一个专用的比较器，如果一个对象不支持自比较或者自比较函数不能满足应用的需求，可以写一个比较器来实现自定义规则的比较排序。

    2、Comparable与Comparator实例：

    Comparable：实现Comparable接口要覆盖compareTo方法，在compareTo方法中实现比较： 

public class Person implements Comparable{
  String name;
  int age;
  public int compareTo(Person another){
    int i = 0;
    i = name.compareTo(another.name); //使用字符串比较
    if(i == 0){ // 如果名字相同，比较年龄，返回比较年龄结果。
      return age - another.age;
    } else {
      return i; //名字不相同，返回比较名字的结果。
    }
  }
}

    实现了Comparable接口后，Collection.sort()方法就可以对Person类的集合进行排序了。

    Comparator：实现Comparator要覆盖compare方法。 

public class Person{
  String name;
  int age;
}

class PersonComparator implements Comparator{
  public int compare(Person one,Person another){
    int i = 0;
    i = one.name.compareTo(another.name);//使用字符串的比较
    if(i == 0){ // 名字相同，比较年龄，返回比较年龄的结果。
      return one.age - another.age;
    } else {
      return i; // 名字不同，返回名字比较结果。
    }
  }
}

    Collection.sort(PersonList,PersonComparator()) 就可以对其排序。

Java Comparable和Comparator对比详解

Java Comparable和Comparator对比详解

这篇文章主要介绍了Java Comparable和Comparator对比详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

在实际项目开发过程中，我们经常需要对某个对象或者某个集合中的元素进行排序，常用的两种方式是实现某个接口。常见的可以实现比较功能的接口有Comparable接口和 Comparator接口，那么这两个又有什么区别呢？

关于Comparable接口

关于Comparable接口，其位于 java.lang.Comparable 中，实现这个接口，可以通过重写其 compareto 方法进行自定义排序，一般用于实体类中，比如针对学生对象，根据其姓名、身高、年龄、地址等进行排序，商品根据名称、库存、价格排序等。下面一段代码中主要是对 学生的姓名、年龄、地址进行排序，当我们重写其 compareto 方法后，对于一个学生对象的集合，我们可以通过调用 Collections.sort(studentList) 对其进行排序，即可达到想要的效果。

public class Students implements Comparable { private String name; private int age; private String address; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("姓名：").append(this.name); sb.append("年龄：").append(this.age); sb.append("地址：").append(this.address); return sb.toString(); } // 重写排序方法，先根据年龄升序，再根据姓名降序，最后根据地址升序 @Override public int compareto(Students o) { int result= 0; result = this.age - o.getAge(); if (0 == result){ result = o.getName().compareto(this.getName()); if (0 == result){ result = this.getAddress().compareto(o.getAddress()); } } return result; } }

关于Comparator接口

关于Comparator接口，其位于 java.util.Comparator 中，实现这个接口，可以通过重写其 compare 方法进行自定义的排序，比如针对 字符串的 list，根据其长度递减排序；根据Integer 的集合，根据其大小升序（Collections.sort()方法中默认实现的就是升序）。此外，针对数组的排序，还可以调用 Arrays.sort() 进行排序，其默认是根据字典顺序进行排序。import java.util.*; public class CompareController1 implements Comparator { @Override public int compare(Integer o1, Integer o2) { // int length1 = o1.length(); // int length2 = o2.length(); return o2 - o1; //按照降序排列 } public static void main(String[] args) { List list = new ArrayList(); list.add(1); list.add(23); list.add(400); list.add(222); list.add(34); Collections.sort(list,new CompareController1()); System.out.println(list.toString()); Object[] objects = list.toArray(); // 针对String类型，默认是按照字典表进行排序 // 针对 int 类型，默认是 按照 升序 进行排序 Arrays.sort(objects); //不能直接打印数组，那样打印出来的是地址，可以使用 foreach System.out.println(Arrays.toString(objects)); } }扩展补充：

关于Collections.sort(）和 Arrays.sort()

1) Collections.sort(）方法底层实际就是Arrays.sort()，

2) Arrays.sort()的底层分为两种，满足某种条件就调用这个排序 legacyMergeSort，其底层就是归并排序；如果不满足，就是 Timsort

3) Timsort 的底层根据数组的长度进行区分，如果数组的长度小于32，直接使用简单的合并算法，即二分插入排序（binary merge sort）；如果长度大于32，就是 合并算法。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持小编。

Java Comparator与Comparable辨析

Java Comparator与Comparable辨析

Comparator与Comparable辨析

声明

文章均为本人技术笔记，转载请注明出处：
[1] https://segmentfault.com/u/yzwall
[2] blog.csdn.net/j_dark/

比较三种状态

根据需求定义“序”（升序 or 降序）；

  • LESS_THAN： 返回负数，表示比较两元素满足序，无须调整，；

  • EQUAL：返回0，表示比较两元素“相等”，无须调整位置，；

  • GREATER_THAN：返回正数，表示比较两元素不满足序，按序调整位置；

对象内部排序：Comparable<T>

Comparable<T>源码

// full name: java.lang.Comparable<T>
public interface Comparable<T> {
    public int compareTo(T o);
}

继承Comparable<T>接口的对象必须重写compareTo方法，实现对象内部排序；
目前所有的包装类和String类都实现了Comparable<T>接口；

Comparable实现示例

class Student implements Comparable<Student>{
    private static final int LESS_THAN =  -1;
    private static final int EQUAL =  0;
    private static final int GREATER_THAN =  1;
    int age;
    int id;
    
    ...
    @Override
    // 按照age升序排练，age相等按照id降序排练
    public int compareTo(Student o) {
        if (this.age < o.age) {
            return LESS_THAN;
        } 
        if (this.age ==  o.age) {
            return this.id > o.id ? LESS_THAN : (this.id == o.id) ? EQUAL : GREATER_THAN;
        } else {
            return GREATER_THAN;
        }
    }
    ...
}

根据Comparable排序

集合或数组元素实现Comparable<T>接口，通过以下两种方式实现排序：
集合排序：Collections.sort(List<T> list)，底层调用Arrays.sort()实现；
数组排序：Arrays.sort(T[] arr)；

对象外部排序：Comparator<T>

Comparator<T>源码

public interface Comparator<T> {
    ...
    // 重写compare比较规则，通过外部传入实现自定义排序
    int compare(T o1, T o2);
}

Comparator实现示例

/**
 * 集合排序：Colletions.sort(list, new MyComparator());
 * 数组排序：Arrays.sort(arr, new MyComparator());
 */
class MyComparator implements Comparator<Student> {
    private static final int LESS_THAN =  -1;
    private static final int EQUAL =  0;
    private static final int GREATER_THAN =  1;
    
    @Override
    // 按照age降序排练，age相等按照id升序排练
    public int compare(Student a, Student b) {
        if (a.age > b.age) {
            return LESS_THAN;
        } 
        if (a.age ==  b.age) {
            return a.id < b.id ? LESS_THAN : (a.id == b.id) ? EQUAL : GREATER_THAN;
        } else {
            return GREATER_THAN;
        }
    }
}

根据Comparator排序

Comparator体现了策略设计模式，即不改变对象自身，而使用一个策略对象去改变它的行为。

集合或数组元素实现Comparator<T>接口，通过以下两种方式实现排序：
集合排序：Collections.sort(List<T> list， new Comparator<T>)，底层调用Arrays.sort(T[] arr, Comparator<? super T> c)实现；
数组排序：Arrays.sort(T[] arr, Comparator<? super T> c)；

Comparator<T>与Comparable<T>辨析

Comparable<T>与Comparator<T>都是用于对集合或数组元素的排序比较，

  • Comparable<T>面向对象，对象重写compareTo方法即可在内部完成比较，更改比较逻辑时只能更改对象自身（比如通过Comparable接口无法改变包装类型和String类型的比较规则）；

  • Comparator<T>面向集合/数组，在外部自定义比较器实现接口，传入集合/数组内部提供比较，更改比较逻辑时只需更改自定义比较器，无须更改对象，应用更广泛；

参考

[1] http://blog.csdn.net/mageshuai/article/details/3849143

我们今天的关于在Java中将Comparable用于VO的多个动态字段和java设置多个动态变量的分享就到这里，谢谢您的阅读，如果想了解更多关于Java Comparable 和 Comparator 的详解及区别、Java Comparable与Comparator 比较、Java Comparable和Comparator对比详解、Java Comparator与Comparable辨析的相关信息，可以在本站进行搜索。

本文标签：

上一篇Python-UnicodeDecodeError，无效的继续字节（无效的pythonsdk）

下一篇任务管理器新图将在下一次Windows 10更新中发布（任务管理器新任务）

相关文章