-1

我了解对数组进行冒泡排序的概念，Int但是是否可以将冒泡排序应用于对象数组？具体来说，我想按int对象中包含的变量进行排序。

Int 数组只有 1 个 Int 或数组的一个元素的数据成员，但 Objects 有多个数据成员，这才是真正让我感到困惑的部分。

我还研究了比较器，例如 java 的 CompareTo 方法。从我对它的研究中了解到，比较器基本上返回两个对象之间的价值差异。如何将其应用于对数组进行排序？

4

4 回答 4

1

AComparator<T>不返回两个对象之间的差异。它而是返回T.

正如文件所述：

返回负整数、零或正整数，因为第一个参数小于、等于或大于第二个。

OOP 的好处是您能够封装数据和行为，这种情况就是一个明显的例子。让我们看看这个样板代码：

class HugeClass implements Comparable<HugeClass> {
  // lots of variables

  public int compareTo(HugeClass o) {
    // lots of code to decide if this instance is lesser, equal or greater than o
    // then we return -1, 0 or 1 accordingly
  }

现在您可以轻松实现冒泡排序。取而代之的是直接做if (x < y)，就像你对ints 做的那样if (x.compareTo(y) < 0)，但这是同一个故事，你不关心实际如何计算排序，你只依赖于compareTo方法。

实际上，您可以编写一个冒泡排序方法，该方法能够对每个可能的可比较类执行排序。例如：

public sort(Comparable<?>[] data) {
  .. code
}
于 2013-02-05T03:30:06.903 回答
0

也许这可以帮助您解决困惑：

public class Test {

 public static A a1 = new A("001", "a", "wa~", 7);
 public static A a2 = new A("001", "c", "wa~", 9);
 public static A a3 = new A("001", "b", "wa~", 3);
 public static A a4 = new A("000", "d", "wa~", 6);

 public static void main(String[] args) {
  A[] voA = new A[] { a1, a2, a3, a4 };

  java.util.Arrays.sort(voA, new Mycomparator());

  A[] newA = new A[voA.length];

  for (int i = 0; i < voA.length; i++)
   System.out.println("[" + i + "]:" + voA[i].A1 + " " + voA[i].A2 + " " + voA[i].A3 + " " + voA[i].A4);
 }
}

class A {
 String A1;
 String A2;
 String A3;
 int A4;

 public A(String oA1, String oA2, String oA3, int oA4) {
  this.A1 = oA1;
  this.A2 = oA2;
  this.A3 = oA3;
  this.A4 = oA4;
 }

}

class Mycomparator implements java.util.Comparator {
 public int compare(Object o1, Object o2) {
  A a1 = (A) o1;
  A a2 = (A) o2;
  if(a1.A1.compareTo(a2.A1)!=0) {
   return a1.A1.compareTo(a2.A1);
  } else if(a1.A2.compareTo(a2.A2)!=0) {
   return a1.A2.compareTo(a2.A2);
  } else if(a1.A3.compareTo(a2.A3)!=0) {
   return a1.A3.compareTo(a2.A3);
  } else {
   return a1.A4 >a2.A4?1:a1.A4==a2.A4?0:-1;
  }
 }
}
于 2013-02-05T03:32:32.997 回答
0

实现 Comparator 的对象不会返回任何类型的差异。当它大于另一个对象时它只返回一个正数，当它小于另一个对象时返回一个负数。这就是 sort 函数所关心的。您可以对对象数组进行排序（实现 Comparable 如下）

class MyObject implements Comparable<MyObject>{
  int myInt;
  public int compareTo(MyObject other){
    if(myInt>other.myInt)
      return 1;
    else if(myInt<other.myInt)
      return -1;
    else if(myInt==other.myInt)
      return 0;
    else
      throw new Error("This should never happen");
  }
}

那么如果你有一个数组

MyObject[] arr;

你可以用它排序

Arrays.sort(arr);

人们接受差异的唯一原因是因为它写起来更快

myInt - other.myInt

比编写所有那些 if-else 子句（而且在硬件上也可能更快）

于 2013-02-05T03:34:00.217 回答
0

这是一种思考您的困惑的方法：

想象一下，我有一组带有数字的盒子。盒子里有很多物体：大的、小的、红色的、绿色的……如果我让你按照盒子上的数字对盒子（“物体”）进行排序，你就没有问题了。如果我让你查看盒子内部，并按照绿球的大小对它们进行分类，你可能会这样做。无论哪种情况，您都在对对象进行排序...

于 2013-02-05T03:29:57.607 回答