Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱
MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina.com

集合 排序 判断对象相等 Comparable Comparator


目录

集合判断是否是同一元素的策略

List:equals

对于List集合(ArrayList、LinkedList等):仅仅是通过判断两个对象的【equals】方法是否为true。

以下为 ArrayList 的部分源码:

  1. public boolean contains(Object o) {
  2. return indexOf(o) >= 0;
  3. }
  4. public int indexOf(Object o) {
  5. if (o == null) {
  6. for (int i = 0; i < size; i++)
  7. if (elementData[i] == null)
  8. return i;
  9. } else {
  10. for (int i = 0; i < size; i++)
  11. if (o.equals(elementData[i])) //核心代码:contains 时完全是根据 equals 方法来判断是否是同一元素
  12. return i;
  13. }
  14. return -1;
  15. }

Tree:compare 或 compareTo

对于Tree集合(TreeSet、TreeMap):

  • 如果构造时指定了 Comparator,则根据 Comparator 接口中的 compare 方法返回值是否为 0 来判断。
  • 如果构造时没有指定 Comparator,则其中的元素必须实现 Comparable 接口,此时根据 compareTo 方法返回值是否为 0 来判断。

注意上面的 compare 方法的目的并不是判断对象相同的,而是给对象排序的。

TreeSet、TreeMap部分源码:

  1. public TreeSet() {
  2. this(new TreeMap<E,Object>());
  3. }
  4. public TreeSet(Comparator<? super E> comparator) {
  5. this(new TreeMap<>(comparator));
  6. }
  7. public boolean contains(Object o) {
  8. return m.containsKey(o);
  9. }
  1. public boolean containsKey(Object key) {
  2. return getEntry(key) != null;
  3. }
  4. final Entry<K,V> getEntry(Object key) {
  5. if (comparator != null) return getEntryUsingComparator(key); //核心代码:如果指定了比较器......
  6. if (key == null) throw new NullPointerException();
  7. @SuppressWarnings("unchecked") //核心代码:如果没有指定比较器,则将元素强转为 Comparable
  8. Comparable<? super K> k = (Comparable<? super K>) key;
  9. Entry<K,V> p = root;
  10. while (p != null) {
  11. int cmp = k.compareTo(p.key);
  12. if (cmp < 0) p = p.left;
  13. else if (cmp > 0) p = p.right;
  14. else return p; //核心代码:如果 compareTo 的值为0 ,则返回此值,否则继续遍历
  15. }
  16. return null;
  17. }
  18. final Entry<K,V> getEntryUsingComparator(Object key) {
  19. @SuppressWarnings("unchecked")
  20. K k = (K) key;
  21. Comparator<? super K> cpr = comparator;
  22. if (cpr != null) {
  23. Entry<K,V> p = root;
  24. while (p != null) {
  25. int cmp = cpr.compare(k, p.key);
  26. if (cmp < 0) p = p.left;
  27. else if (cmp > 0) p = p.right;
  28. else return p; //核心代码:如果 compare 的值为0 ,则返回此值,否则继续遍历
  29. }
  30. }
  31. return null;
  32. }

Hash:hashCode + equals

对于Hash系列的集合(HashSet、HashMap):

  • 先判断元素的 hashCode 的值是否相同,如果不同则认为是不同的元素。
  • 如果两个元素的 hashCode 的值相同,则再判断元素的 equals 返回值是否为 true,如果为 true 则是不同的元素,否则为相同的元素。

HashSet、HashMap部分源码:

  1. public HashSet() {
  2. map = new HashMap<>();
  3. }
  4. public boolean add(E e) {
  5. return map.put(e, PRESENT)==null;
  6. }
  7. public boolean contains(Object o) {
  8. return map.containsKey(o);
  9. }
  1. public boolean containsKey(Object key) {
  2. return getNode(hash(key), key) != null;
  3. }
  4. static final int hash(Object key) {
  5. int h;
  6. return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
  7. }
  8. final Node<K,V> getNode(int hash, Object key) {
  9. Node<K,V>[] tab;
  10. Node<K,V> first, e;
  11. int n; K k;
  12. if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
  13. if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k)))) // always check first node
  14. return first;
  15. if ((e = first.next) != null) {
  16. if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key);
  17. do {
  18. if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e;
  19. } while ((e = e.next) != null);
  20. }
  21. }
  22. return null;
  23. }

特殊对象 String:字符序列

String 类重写了 hashCode 和 equals 方法,如果两个 String 的内容相同则 hashCode 和 equals 方法也相同或为 true。

  1. private final char value[]; // The value is used for character storage.
  2. private int hash; // Default to 0
  3. public int hashCode() {
  4. int h = hash;
  5. if (h == 0 && value.length > 0) { //如果长度为 0 ,则其 hash 也为 0
  6. char val[] = value;
  7. for (int i = 0; i < value.length; i++) {
  8. h = 31 * h + val[i]; //哈希值完全就是对字符串中所有字符通过某种算法计算后的结果,而且算法是稳定的
  9. }
  10. hash = h;
  11. }
  12. return h;
  13. }
  1. public boolean equals(Object anObject) {
  2. if (this == anObject) {
  3. return true;
  4. }
  5. if (anObject instanceof String) { //必须是 String
  6. String anotherString = (String) anObject;
  7. int n = value.length;
  8. if (n == anotherString.value.length) {
  9. char v1[] = value;
  10. char v2[] = anotherString.value;
  11. int i = 0;
  12. while (n-- != 0) {
  13. if (v1[i] != v2[i]) return false; //逐个比较字符,一旦发现对应位置有不相同的,则为不同的字符串
  14. i++;
  15. }
  16. return true;
  17. }
  18. }
  19. return false;
  20. }

测试代码

List

测试代码

  1. class Person {
  2. public String name;
  3. public int age;
  4. public Person(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. @Override
  9. public boolean equals(Object o) {
  10. Person p = (Person) o;
  11. System.out.println("调用了equals方法,当前对象【" + toString() + "】被比较对象【" + p.toString() + "】");
  12. return this.age == p.age || this.name.equals(p.name);
  13. }
  14. @Override
  15. public String toString() {
  16. return "{" + name + "," + age + "}";
  17. }
  18. }
  1. List<Person> list = Arrays.asList(new Person("a", 20), new Person("a", 21), new Person("b", 20), new Person("b", 21));
  2. System.out.println(list);
  3. System.out.println(list.contains(new Person("c", 20)) + " " + list.contains(new Person("b", 10086)));

日志

  1. [{a,20}, {a,21}, {b,20}, {b,21}]
  2. 调用了equals方法,当前对象【{c,20}】被比较对象【{a,20}】
  3. 调用了equals方法,当前对象【{b,10086}】被比较对象【{a,20}】
  4. 调用了equals方法,当前对象【{b,10086}】被比较对象【{a,21}】
  5. 调用了equals方法,当前对象【{b,10086}】被比较对象【{b,20}】
  6. true true

Tree

Person

  1. class Person implements Comparable<Person> {
  2. public String name;
  3. public int age;
  4. public Person(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. @Override
  9. public boolean equals(Object p) {
  10. System.out.println("调用了equals方法,当前对象【" + toString() + "】被比较对象【" + p.toString() + "】");
  11. return this.name.equals(((Person) p).name);
  12. }
  13. @Override
  14. public String toString() {
  15. return "{" + name + "," + age + "}";
  16. }
  17. @Override
  18. public int compareTo(Person o) {
  19. System.out.println("调用了compareTo方法,当前对象【" + toString() + "】被比较对象【" + o.toString() + "】");
  20. return this.age - o.age;
  21. }
  22. }

不指定 Comparator

  1. TreeSet<Person> set = new TreeSet<>();
  2. System.out.println("添加第1个元素");
  3. set.add(new Person("a", 20));
  4. System.out.println("添加第2个元素"); // compareTo 方法返回值不为 0,判断为不同元素,所以添加进去
  5. set.add(new Person("a", 21));
  6. System.out.println("添加第3个元素"); // compareTo 方法返回值为 0,判断为相同元素,所以不添加进去
  7. set.add(new Person("b", 20));
  8. System.out.println("添加第4个元素"); // 相同元素,所以不添加进去
  9. set.add(new Person("b", 21));
  10. System.out.println(set);

日志:

  1. 添加第1个元素
  2. 调用了compareTo方法,当前对象【{a,20}】被比较对象【{a,20}】
  3. 添加第2个元素
  4. 调用了compareTo方法,当前对象【{a,21}】被比较对象【{a,20}】
  5. 添加第3个元素
  6. 调用了compareTo方法,当前对象【{b,20}】被比较对象【{a,20}】//先和第一个元素比较,因为相同,所以直接结束
  7. 添加第4个元素
  8. 调用了compareTo方法,当前对象【{b,21}】被比较对象【{a,20}】//先和第一个元素比较,不相同,继续和下一个元素比较
  9. 调用了compareTo方法,当前对象【{b,21}】被比较对象【{a,21}】//再和第二个元素比较,因为相同,所以结束
  10. [{a,20}, {a,21}]

指定 Comparator

  1. TreeSet<Person> set = new TreeSet<>((p1, p2) -> {
  2. System.out.println("调用了compare方法,对象1【" + p1.toString() + "】对象2【" + p2.toString() + "】");
  3. return p1.name.compareTo(p2.name);
  4. });

日志:

  1. 添加第1个元素
  2. 调用了compare方法,对象1【{a,20}】对象2【{a,20}】
  3. 添加第2个元素
  4. 调用了compare方法,对象1【{a,21}】对象2【{a,20}】
  5. 添加第3个元素
  6. 调用了compare方法,对象1【{b,20}】对象2【{a,20}】
  7. 添加第4个元素
  8. 调用了compare方法,对象1【{b,21}】对象2【{a,20}】
  9. 调用了compare方法,对象1【{b,21}】对象2【{b,20}】
  10. [{a,20}, {b,20}]

Hash 集合

Person

  1. class Person {
  2. public String name;
  3. public int age;
  4. public Person(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. @Override
  9. public int hashCode() {
  10. System.out.println("调用了hashCode方法,当前对象【" + toString() + "】");
  11. return age;
  12. }
  13. @Override
  14. public boolean equals(Object p) {
  15. System.out.println("调用了equals方法,当前对象【" + toString() + "】被比较对象【" + p.toString() + "】");
  16. return this.name.equals(((Person) p).name);
  17. }
  18. @Override
  19. public String toString() {
  20. return "{" + name + "," + age + "}";
  21. }
  22. }

HashSet

  1. HashSet<Person> set = new HashSet<>();
  2. System.out.println("添加第1个元素");
  3. set.add(new Person("a", 20));
  4. System.out.println("添加第2个元素");
  5. set.add(new Person("a", 21));// hashCode 不相同,直接判断为不同元素,所以直接添加进去
  6. System.out.println("添加第3个元素");
  7. set.add(new Person("b", 21)); // hashCode 相同,进一步判断 equals 方法是否相同;因为不相同,所以添加进去
  8. System.out.println("添加第4个元素");
  9. set.add(new Person("c", 21)); // hashCode 相同,进一步判断 equals 方法是否相同;因为不相同,所以添加进去
  10. System.out.println("添加第5个元素");
  11. set.add(new Person("b", 21)); // hashCode 相同,进一步判断 equals 方法是否相同;因为相同,所以不添加进去
  12. System.out.println(set); //[{a,20}, {a,21}, {b,21}, {c,21}]

HashMap

  1. HashMap<Person, Integer> map = new HashMap<>();
  2. System.out.println("添加第1个元素");
  3. map.put(new Person("a", 20), 1);
  4. System.out.println("添加第2个元素");
  5. map.put(new Person("a", 21), 1);// hashCode 不相同,直接判断为不同元素,所以直接添加进去
  6. System.out.println("添加第3个元素");
  7. map.put(new Person("b", 21), 1); // hashCode 相同,进一步判断 equals 方法是否相同;因为不相同,所以添加进去
  8. System.out.println("添加第4个元素");
  9. map.put(new Person("c", 21), 1); // hashCode 相同,进一步判断 equals 方法是否相同;因为不相同,所以添加进去
  10. System.out.println("添加第5个元素");
  11. map.put(new Person("b", 21), 1); // hashCode 相同,进一步判断 equals 方法是否相同;因为相同,所以不添加进去
  12. System.out.println(map.keySet()); //[{a,20}, {a,21}, {b,21}, {c,21}]

日志

以上两种方式具有完全相同的日志:

  1. 添加第1个元素
  2. 调用了hashCode方法,当前对象【{a,20}】
  3. 添加第2个元素
  4. 调用了hashCode方法,当前对象【{a,21}】
  5. 添加第3个元素
  6. 调用了hashCode方法,当前对象【{b,21}】
  7. 调用了equals方法,当前对象【{b,21}】被比较对象【{a,21}】
  8. 添加第4个元素
  9. 调用了hashCode方法,当前对象【{c,21}】
  10. 调用了equals方法,当前对象【{c,21}】被比较对象【{a,21}】//首先是和第一个具有相同 hashCode 的元素比较
  11. 调用了equals方法,当前对象【{c,21}】被比较对象【{b,21}】//不一致时再和下一个具有相同 hashCode 的元素比较
  12. 添加第5个元素
  13. 调用了hashCode方法,当前对象【{b,21}】
  14. 调用了equals方法,当前对象【{b,21}】被比较对象【{a,21}】//首先是和第一个具有相同 hashCode 的元素比较
  15. 调用了equals方法,当前对象【{b,21}】被比较对象【{b,21}】//一旦发现具有相同 hashCode 的元素也相互 equals,就会立即结束
  16. [{a,20}, {a,21}, {b,21}, {c,21}]

Comparable 和 Comparator

接口 Comparable:类的自然排序

官方文档

public interface java.lang.Comparable<T> 
类型参数:T - 可以与此对象进行比较的那些对象的类型

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序,类的 compareTo 方法被称为它的自然比较方法

实现此接口的对象列表和数组可以通过 Collections.sort 和 Arrays.sort 进行自动排序。实现此接口的对象可以用作有序映射 SortedMap<K,V> 中的键或有序集合 SortedSet<E> 中的元素,无需指定比较器。

划重点,Comparable 的最重要的适用场景为:

  1. Collections.sort
  2. Arrays.sort
  3. SortedMap<K,V>
  4. SortedSet<E>

对于类 C 的每一个 e1 和 e2 来说,当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时,类 C 的自然排序才叫做与 equals 一致。

注意,null 不是任何类的实例,即使 e.equals(null) 返回 false,e.compareTo(null) 也将抛出 NullPointerException

建议最好使自然排序与 equals 一致。这是因为在使用自然排序与 equals 不一致的元素(或键)时,没有显式比较器的有序集合(和有序映射表)行为表现“怪异”。尤其是,这样的有序集合(或有序映射表)违背了根据 equals 方法定义的集合(或映射表)的常规协定。

例如,如果将两个键 a 和 b 添加到没有使用显式比较器的有序集合中,使 (!a.equals(b) && a.compareTo(b) == 0),那么第二个 add 操作将返回 false(有序集合的大小没有增加),因为从有序集合的角度来看,a 和 b 是相等的。

实际上,所有实现 Comparable 的 Java 核心类都具有与 equals 一致的自然排序。java.math.BigDecimal 是个例外,它的自然排序将值相等但精确度不同的 BigDecimal 对象(比如 4.0 和 4.00)视为相等。

compareTo 方法

int compareTo(T o) //比较此对象与指定对象的顺序 
为防止记乱,可以这么记: a.compareTo(b) 代表的是 a-b 的值,正值代表 a>b ,所以被比较的是小对象,那么被比较的对象应该放前面,这时就需要做一次调换位置的操作了。

  • 参数:o - 要比较的对象。
  • 返回:如果该对象小于、等于或大于指定对象,则分别返回负整数、零或正整数。
  • 抛出:ClassCastException - 如果指定对象的类型不允许它与此对象进行比较。

使用须知

sgn(expression) //表示 signum 数学函数,该函数根据 expression 的值是负数、零还是正数,分别返回 -1、0 或 1 中的一个值

  • 实现类必须确保对于所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的关系。这意味着如果 y.compareTo(x) 抛出一个异常,则 x.compareTo(y) 也要抛出一个异常。
  • 实现类还必须确保关系是可传递的:(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0 。
  • 实现者必须确保 x.compareTo(y)==0 意味着对于所有的 z,都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))
  • 强烈推荐 (x.compareTo(y)==0) == (x.equals(y)) 这种做法,但并不是 严格要求这样做。一般来说,任何实现 Comparable 接口和违背此条件的类都应该清楚地指出这一事实。推荐如此阐述:“注意:此类具有与 equals 不一致的自然排序。”

接口 Comparator:集合的比较器

官方文档

public interface java.util.Comparator<T> 
类型参数:T - 此 Comparator 可以比较的对象类型

强行对某个对象 Collection 进行整体排序的比较函数。可以将 Comparator 传递给 sort 方法(如 Collections.sort 或 Arrays.sort),从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构(如有序集合 SortedSet<E> 或有序映射 SortedMap<K,V> )的顺序,或者为那些没有自然顺序的对象 Collection 提供排序。

当且仅当对于一组元素 S 中的每个 e1 和 e2 而言,c.compare(e1, e2)==0 与 e1.equals(e2) 具有相等的布尔值时,Comparator c 强行对 S 进行的排序才叫做与 equals 一致的排序。

当使用具有与 equals 不一致的强行排序能力的 Comparator 对有序 set(或有序映射)进行排序时,应该小心谨慎。假定一个带显式 Comparator c 的有序 set(或有序映射)与从 set S 中抽取出来的元素(或键)一起使用。如果 c 强行对 S 进行的排序是与 equals 不一致的,那么有序 set(或有序映射)将是行为“怪异的”。尤其是有序 set(或有序映射)将违背根据 equals 所定义的 set(或映射)的常规协定。

例如,假定使用 Comparator c 将满足 (a.equals(b) && c.compare(a, b) != 0) 的两个元素 a 和 b 添加到一个空 TreeSet 中,则第二个 add 操作将返回 true(树 set 的大小将会增加),因为从树 set 的角度来看,a 和 b 是不相等的,即使这与 Set.add 方法的规范相反。

注:通常来说,让 Comparator 也实现 java.io.Serializable 是一个好主意,因为它们在可序列化的数据结构(像 TreeSet、TreeMap)中可用作排序方法。为了成功地序列化数据结构,Comparator(如果已提供)必须实现 Serializable。

compare方法

int compare(T o1, T o2) //比较用来排序的两个参数。 
为防止记乱,可以这么记: compare(b, a) 代表的是 a-b 的值,正值代表 a>b ,所以 b 是小对象,那么 b 应该放前面,这时就需要做一次调换位置的操作了。

  • 参数:o1 - 要比较的第一个对象。o2 - 要比较的第二个对象。
  • 返回:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。
  • 抛出:ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

equals 方法

boolean equals(Object obj) // 指示某个其他对象是否“等于”此 Comparator 
注意,这里的 equals 指的是比较器 Comparator 的 equals,也即比较器之间是否 equals,而不是比较器要比较的对象之间是否 equals。

  • 覆盖:类 Object 中的 equals
  • 参数:obj - 要进行比较的引用对象。
  • 返回:仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。
  • 另请参见:Object.equals(Object), Object.hashCode()

此方法必须遵守 Object.equals(Object) 的常规协定。此外, 仅当 指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时,此方法才返回 true。因此,comp1.equals(comp2) 意味着对于每个对象引用 o1 和 o2 而言,都存在 sgn(comp1.compare(o1, o2)) ==sgn (comp2.compare(o1, o2))

注意,不 重写 Object.equals(Object) 方法总是 安全的。然而,在某些情况下,重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序,从而提高性能。

使用须知

sgn(expression) //表示 signum 数学函数,该函数根据 expression 的值是负数、零还是正数,分别返回 -1、0 或 1 中的一个值

  • 实现程序必须确保对于所有的 x 和 y 而言,都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。这意味着如果 compare(y, x) 抛出一个异常,则 compare(x, y) 也要抛出一个异常。
  • 实现程序还必须确保关系是可传递的:((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0
  • 实现程序必须确保 compare(x, y)==0 意味着对于所有的 z 而言,都存在 sgn(compare(x, z)) == sgn(compare(y, z))
  • 强烈推荐 (compare(x, y)==0) == (x.equals(y)) 这种做法,但并不是 严格要求这样做。一般说来,任何违背这个条件的 Comparator 都应该清楚地指出这一事实。推荐的语言是“注意:此 Comparator 强行进行与 equals 不一致的排序。”

案例

Comparable 接口是让类自身具有排序功能。 
Comparator 接口是对 Collection 进行整体排序的功能。

探究两个接口方法的返回值

定义一个对象

  1. class MyBean implements Comparable<MyBean> {
  2. public Integer age;
  3. public MyBean(int age) {
  4. super();
  5. this.age = age;
  6. }
  7. @Override
  8. public int compareTo(MyBean o) {
  9. return -1; //下面案例中更改的都是这个值
  10. }
  11. @Override
  12. public String toString() {
  13. return age + "";
  14. }
  15. }

Comparable:

  1. List<MyBean> list = Arrays.asList(new MyBean(2), new MyBean(3), new MyBean(1), new MyBean(2));
  2. Collections.sort(list);
  3. System.out.println(list);
  1. 原始排序为 [2, 3, 1, 2]
  2. 【-1// [2, 1, 3, 2],一定要注意,返回 -1 的意义不是 this.age - o.age 的值一直为 -1 ,这两种情况的排序结果是完全不一样的
  3. 1// [2, 3, 1, 2]
  4. 0// [2, 3, 1, 2]
  5. this.age.compareTo(o.age)】//[1, 2, 2, 3]
  6. this.age - o.age// [1, 2, 2, 3]
  7. o.age.compareTo(this.age)】//[3, 2, 2, 1]

Comparator:

  1. Integer[] array = { 2, 3, 1, 2 };
  2. //MyBean[] array = { new MyBean(2), new MyBean(3), new MyBean(1), new MyBean(2) }; //这种方式和上面的结果也是完全一样的
  3. Arrays.sort(array, (o1, o2) -> -1); //下面案例中更改的都是这个值
  4. System.out.println(Arrays.toString(array));
  1. 原始排序为 [2, 3, 1, 2]
  2. 【-1// [2, 1, 3, 2],一定要注意,返回 -1 的意义不是 o1 - o2 的值一直为 -1 ,这两种情况的排序结果是完全不一样的
  3. 1// [2, 3, 1, 2]
  4. 0// [2, 3, 1, 2]
  5. o1.compareTo(o2)】//[1, 2, 2, 3]
  6. o1 - o2// [1, 2, 2, 3]
  7. o2.compareTo(o1)】//[3, 2, 2, 1]

Tips:

  • 可以发现,(一般情况下) Comparator 比较的结果和 Comparable 是完全一致的。
  • 以上两种情况,经测试,使用集合与使用数组排序后的结果是完全一致的。
  • 当指定比较器 Comparator 时,仅会通过指定比较器对元素排序,实现 Comparable 的元素的自然排序将不再有任何意义。

元素为空的情况

Comparable:如果需要用到 compareTo 方法去比较元素,则不允许除了首个元素外其余任何元素为空。

  1. class A implements Comparable<A> {
  2. @Override
  3. public int compareTo(A o) {
  4. return 1;
  5. }
  6. }
  7. class B implements Comparable<B> {
  8. @Override
  9. public int compareTo(B o) {
  10. return -1;
  11. }
  12. }
  1. // 首个元素为空的情况
  2. A[] array1 = { null, new A() };
  3. B[] array2 = { null, new B() };
  4. Arrays.sort(array1);
  5. Arrays.sort(array2);
  6. System.out.println(Arrays.toString(array1)); //[null, A@15db9742]
  7. System.out.println(Arrays.toString(array2)); //[B@7852e922, null]
  1. //非首个元素为空的情况
  2. A[] array1 = { new A(), null };
  3. B[] array2 = { new B(), null };
  4. Arrays.sort(array1); //NullPointerException
  5. Arrays.sort(array2); //NullPointerException

Comparator:完全由你控制是否可以有元素为空,所以这个功能更强大、兼容性更强。

  1. class C { }
  2. C[] array = { null, new C(), null, null };
  3. Arrays.sort(array, (o1, o2) -> 1); //对象的比较完全由你在 compare 方法中控制

Comparator 的使用案例

Person

  1. class Person {
  2. public String name;
  3. public int age;
  4. public Person(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. @Override
  9. public String toString() {
  10. return "{age=" + age + " ,name=" + name + "}";
  11. }
  12. }

Comparator

  1. class MyComparator implements Comparator<Person> {
  2. @Override
  3. public int compare(Person o1, Person o2) {
  4. if (o2 == null) { //如果后面的一个元素为空,则保持其位置
  5. return -1; //这一行代码的意义并不是将 (后面的)空元素 放在最后一个位置,而仅仅是保持元素的位置,不进行任何换位操作
  6. } else if (o1 == null) {
  7. return 1; //如果前面的一个元素为空,则和后一个元素更换其位置
  8. } else { //如果两者都不为空,则先比较年龄,再比较姓名
  9. if (o1.age != o2.age) { //如果年龄不相等,则先按年龄由小到大排序
  10. return o1.age - o2.age; //其实这种表达式就是最标准的自然排序方式
  11. } else {
  12. if (o2.name == null) { //判断姓名时也同样先判断姓名是否为空
  13. return -1; //如果后面的一个元素的姓名为空,则保持其位置
  14. } else if (o1.name == null) {
  15. return 1; //如果前面的一个元素的姓名为空,则和后一个元素更换其位置
  16. } else {
  17. return o1.name.compareTo(o2.name); //如果都不为空,则直接用String的自然排序方式排序
  18. }
  19. }
  20. }
  21. }
  22. }

测试代码

  1. Person[] array = { null, new Person(null, 1), new Person(null, 2), new Person("ab", 1), //
  2. new Person("ab", 2), null, new Person("ac", 2), new Person("a", 2) };
  3. Arrays.sort(array, new MyComparator());
  4. System.out.println(Arrays.toString(array));
  5. //[{age=1 ,name=ab}, {age=1 ,name=null},
  6. //{age=2 ,name=a}, {age=2 ,name=ab}, {age=2 ,name=ac},
  7. //{age=2 ,name=null}, null, null]

2018-7-12

Vitamio 多媒体框架 介绍的更多相关文章

  1. iOS多媒体框架介绍

    媒体层 媒体层包含图形技术.音频技术和视频技术,这些技术相互结合就可为移动设备带来最好的多媒体体验,更重要的是,它们让创建外观音效俱佳的应用程序变得更加容易.您可以使用iOS的高级框架更快速地创建高级 ...

  2. Android的多媒体框架OpenCore介绍

    网上资料很少, 不过还是找到一个比较详细的说明: 特地在此整理了下: 地址:http://blog.csdn.net/djy1992/article/details/9339787 分为几个阶段: 1 ...

  3. Android多媒体框架对音乐播放器的支持

    下面介绍一下Andriod多媒体框架对开发者提供的支持有哪些.               1. MediaScannerReceiver                   这个广播接收者在接收到A ...

  4. [连载]《C#通讯(串口和网络)框架的设计与实现》-1.通讯框架介绍

    [连载]<C#通讯(串口和网络)框架的设计与实现>- 0.前言 目       录 第一章           通讯框架介绍... 2 1.1           通讯的本质... 2 1 ...

  5. YARN基本框架介绍

    YARN基本框架介绍 转载请注明出处:http://www.cnblogs.com/BYRans/ 在之前的博客<YARN与MRv1的对比>中介绍了YARN对Hadoop 1.0的完善.本 ...

  6. Selenium自动化测试框架介绍

    Selenium自动化测试框架介绍 1.测试架构作用 a.可维护性 b.提高编写脚本效率 c.提高脚本的可读性 2.框架的几大要素: Driver管理,脚本,数据,元素对象,LOG,报告,运行机制,失 ...

  7. UiAutomator自动化测试框架介绍

    UiAutomator自动化测试框架介绍 环境搭建 1         必要条件 1.1       JDK 1.2       SDK(API高于15) 1.3       Eclipse 2    ...

  8. [翻译]Spring框架参考文档(V4.3.3)-第二章Spring框架介绍 2.1 2.2 翻译--2.3待继续

    英文链接:http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/overview.ht ...

  9. MJExtension框架介绍

    MJExtension框架介绍 标签: MJExtension 2015-05-01 08:22 1120人阅读 评论(0) 收藏 举报  分类: Foundation(14)  版权声明:本文为博主 ...

随机推荐

  1. 【USACO 3.2.3】纺车的轮子

    [描述] 一架纺车有五个纺轮,这五个不透明的轮子边缘上都有一些缺口.这些缺口必须被迅速而准确地排列好.每个轮子都有一个起始标记(在0度),这样所有的轮子都可以在统一的已知位置开始转动.轮子按照角度变大 ...

  2. IE layout详解

    引言: Internet Explorer 中有很多奇怪的渲染问题可以给他一个”layout”得到解决,John Gallant 和 Holly Bergevin把他归类为“dimensional b ...

  3. 10 款强大的JavaScript图表图形插件推荐

    转自:http://www.iteye.com/news/24535 网上有很多用于绘制图表图形的免费JavaScript插件和图表库,这类插件大量出现的原因,一是人们不再依赖于Flash,二是浏览器 ...

  4. HTML5 canvas生成图片马赛克特效插件

    HTML5 canvas生成图片马赛克特效插件 简要教程 这是一款使用html5 canvas来将图片制作成马赛克效果的js插件.该插件的灵感来自于美国肖像画家Chuck Close.已经有人使用这个 ...

  5. MLlib-聚类

    聚类 例子 流聚类 例子 聚类 MLlib支持k-means聚类,一种最常用的聚类方法,将数据点聚成指定数据的簇.MLlib实现了一种k-means++的并行变种,叫做kmeansII.MLlib的实 ...

  6. KEIL C编译器常见警告与错误信息的解决办法

    对于函数的自变量.局部变量和全局变量声明如果没有指定内存类型,则内存模式将成为内定的内存类型.如果指定了内存类型的变量,则不理会内存模式,完全有所指定的内存类型为主.    SMALL模式:小模式   ...

  7. 转:Yii实战中8个必备常用的扩展,模块和widget

    转载自:http://www.yiiframework.com/wiki/180/yii8/ 在经过畅K网的实战后,总结一下在Yii的项目中会经常用到的组件和一些基本的使用方法,分享给大家,同时也给自 ...

  8. 【HDOJ】1438 钥匙计数之一

    状态压缩.分最后一个槽的值以及当前的配置方案是否可以进行DP. /* 1438 */ #include <cstdio> #include <cstring> #include ...

  9. Excel进行项目规划的好处

    1.表格的方式 2.多个工作表 3.插入图片 4.清晰的规划 5.大众都能看得懂 6.辅助一些数据表设计,其他的流程设计 7.对项目该做什么,进度等等有一个明确的认识 8.项目管理,吃透需求,对进度把 ...

  10. POJSorting It All Out (拓扑)

    题目链接. 题目大意: 给定一定的数量的小于关系: 1.如果发现环,输出从前几次就可以确定出现环 2.如果能够确定唯一序列,输出. 3.如果通过全部关系,还不能确定序列,则输出不能确定. 分析: 个人 ...