Treeset的自然排序vs定制排序

在Java编程中,有些知识
并不能仅通过语言规范或者标准API文档就能学到的。在本文中,我会尽量收集一些最常用的习惯用法,特别是很难猜到的用法。(Joshua
Bloch的《Effective
Java》对这个话题给出了更详尽的论述,可以从这本书里学习更多的用法。)

在微博中看到的一个不错的帖子,总结的很详细,拷贝过来,一是为了方便自己查阅,也能和大家一起共享,后面有原文的链接地址:

public class TestSet {

我把本文的所有代码都放在公共场所里。你可以根据自己的喜好去复制和修改任意的代码片段,不需要任何的凭证。

在Java编程中,有些知识
并不能仅通过语言规范或者标准API文档就能学到的。在本文中,我会尽量收集一些最常用的习惯用法,特别是很难猜到的用法。(Joshua
Bloch的《Effective
Java》对这个话题给出了更详尽的论述,可以从这本书里学习更多的用法。)

/*

目录

本文把所有代码都放在公共场所里。你可以根据自己的喜好去复制和修改任意的代码片段,不需要任何的凭证。
目录

* TreeSet的定制排序。

实现:

  • 实现:
    • equals()
    • hashCode()
    • compareTo()
    • clone()
  • 应用:
    • StringBuilder/StringBuffer
    • Random.nextInt(int)
    • Iterator.remove()
    • StringBuilder.reverse()
    • Thread/Runnable
    • try-finally
  • 输入/输出:
    • 从输入流里读取字节数据
    • 从输入流里读取块数据
    • 从文件里读取文本
    • 向文件里写文本
  • 预防性检测:
    • 数值
    • 对象
    • 数组索引
    • 数组区间
  • 数组:
    • 填充元素
    • 复制一个范围内的数组元素
    • 调整数组大小
  • 包装
    • 个字节包装成一个int
    • 分解成4个字节

* compare()与hashCode()以及equals()三者保持一致!

equals()


* */

hashCode()

**实现equals()
class Person {
  String name;
  int birthYear;
  byte[] raw;

@Test

compareTo()

  public boolean equals(Object obj)
{
    if (!obj instanceof Person)
      return false;

public void testTreeSet2(){

clone()

    Person other = (Person)obj;
    return
name.equals(other.name)
        && birthYear ==
other.birthYear
        && Arrays.equals(raw,
other.raw);
  }
  public int hashCode() { … }
}
**

//1.创建一个实现了Comparator接口的类对象

应用:

  • 参数必须是Object类型,不能是外围类。
  • foo.equals(null)
    必须返回false,不能抛NullPointerException。(注意,null instanceof
    任意类 总是返回false,因此上面的代码可以运行。)
  • 基本类型域(比如,int)的比较使用 ==
    ,基本类型数组域的比较使用Arrays.equals()。
  • 覆盖equals()时,记得要相应地覆盖 hashCode(),与 equals()
    保持一致。
  • 参考:java.lang.Object.equals(Object)。

Comparator com = new Comparator(){

StringBuilder/StringBuffer

**实现hashCode()
class Person {
  String a;
  Object b;
  byte c;
  int[] d;

//向TreeSet中添加Customer类的对象,在此compare()方法中,指明是按照Customer

Random.nextInt(int)

  public int hashCode() {
    return a.hashCode() + b.hashCode() + c + Arrays.hashCode(d);
  }

//的哪个属性排序的。

Iterator.remove()

  public boolean equals(Object o) { … }
}
**

@Override

StringBuilder.reverse()

  • 当x和y两个对象具有x.equals(y) == true ,你必须要确保x.hashCode()
    == y.hashCode()。
  • 根据逆反命题,如果x.hashCode() != y.hashCode(),那么x.equals(y) ==
    false 必定成立。
  • 你不需要保证,当x.equals(y) == false时,x.hashCode() !=
    y.hashCode()。但是,如果你可以尽可能地使它成立的话,这会提高哈希表的性能。
  • hashCode()最简单的合法实现就是简单地return
    0;虽然这个实现是正确的,但是这会导致HashMap这些数据结构运行得很慢。
  • 参考:java.lang.Object.hashCode()。

public int compare(Object o1,Object o2){

Thread/Runnable

**实现compareTo()

if(o1 instanceof Customer && o2 instanceof Customer){

try-finally

class Person implements
Comparable<图片 1erson>
{
  String firstName;
  String lastName;
  int birthdate;

Customer c1 = (Customer)o1;

输入/输出:

  // Compare by firstName, break ties by
lastName, finally break ties by birthdate
  public int compareTo(Person other)
{
    if
(firstName.compareTo(other.firstName) != 0)
      return
firstName.compareTo(other.firstName);
    else if
(lastName.compareTo(other.lastName) != 0)
      return
lastName.compareTo(other.lastName);
    else if (birthdate <
other.birthdate)
      return -1;
    else if (birthdate >
other.birthdate)
      return 1;
    else
      return 0;
  }
}
**

Customer c2 = (Customer)o2;

从输入流里读取字节数据

  • 总是实现泛型版本 Comparable 而不是实现原始类型 Comparable
    。因为这样可以节省代码量和减少不必要的麻烦。
  • 只关心返回结果的正负号(负/零/正),它们的大小不重要。
  • Comparator.compare()的实现与这个类似。
  • 参考:java.lang.Comparable。

int i =  c1.getId().compareTo(c2.getId());

从输入流里读取块数据

**实现clone()

if(i == 0){

从文件里读取文本

class Values implements Cloneable
{
  String abc;
  double foo;
  int[] bars;
  Date hired;

return c1.getName().compareTo(c2.getName());

向文件里写文本

  public Values clone() {
    try {
      Values result =
(Values)super.clone();
      result.bars =
result.bars.clone();
      result.hired =
result.hired.clone();
      return result;
    } catch (CloneNotSupportedException e)
{  // Impossible
      throw new
AssertionError(e);
    }
  }
}
**

}

预防性检测:

  • 使用 super.clone() 让Object类负责创建新的对象。
  • 基本类型域都已经被正确地复制了。同样,我们不需要去克隆String和BigInteger等不可变类型。
  • 手动对所有的非基本类型域(对象和数组)进行深度复制(deep
    copy)。
  • 实现了Cloneable的类,clone()方法永远不要抛CloneNotSupportedException。因此,需要捕获这个异常并忽略它,或者使用不受检异常(unchecked
    exception)包装它。
  • 不使用Object.clone()方法而是手动地实现clone()方法是可以的也是合法的。
  • 参考:java.lang.Object.clone()、java.lang.Cloneable()。

return i;

数值


}

对象

**
使用StringBuilder或StringBuffer

return 0;

数组索引

// join([“a”, “b”, “c”]) -> “a and b and c”
String join(List<String> strs) {
  StringBuilder sb = new StringBuilder();
  boolean first = true;
  for (String s : strs) {
    if (first) first = false;
    else sb.append(” and “);
    sb.append(s);
  }
  return sb.toString();
}
**

}

数组区间

  • 不要像这样使用重复的字符串连接:s += item
    ,因为它的时间效率是O(n^2)。
  • 使用StringBuilder或者StringBuffer时,可以使用append()方法添加文本和使用toString()方法去获取连接起来的整个文本。
  • 优先使用StringBuilder,因为它更快。StringBuffer的所有方法都是同步的,而你通常不需要同步的方法。
  • 参考java.lang.StringBuilder、java.lang.StringBuffer。

};

数组:

**生成一个范围内的随机整数

//2.将此对象作为形参传递给TreeSet的构造器中

填充元素

Random rand = new Random();

TreeSet set = new TreeSet(com);

复制一个范围内的数组元素

// Between 1 and 6, inclusive
int diceRoll() {
  return rand.nextInt(6) + 1;
}
**

//3.向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象。

调整数组大小

  • 总是使用Java API方法去生成一个整数范围内的随机数。
  • 不要试图去使用 Math.abs(rand.nextInt()) % n
    这些不确定的用法,因为它的结果是有偏差的。此外,它的结果值有可能是负数,比如当rand.nextInt()
    == Integer.MIN_VALUE时就会如此。
  • 参考:java.util.Random.nextInt(int)。

set.add(new Customer(“AA”,1003));

包装

**使用Iterator.remove()

set.add(new Customer(“BB”,1002));

个字节包装成一个int

void filter(List<String> list) {
  for (Iterator<String> iter = list.iterator(); iter.hasNext(); )
{
    String item = iter.next();
    if (…)
      iter.remove();
  }
}
**

set.add(new Customer(“GG”,1004));

分解成4个字节

  • remove()方法作用在next()方法最近返回的条目上。每个条目只能使用一次remove()方法。
  • 参考:java.util.Iterator.remove()。

set.add(new Customer(“CC”,1001));

实现equals()

**返转字符串

set.add(new Customer(“DD”,1001));

class Person {

String reverse(String s) {
  return new
StringBuilder(s).reverse().toString();
}
**

for(Object str : set){

String name;

  • 这个方法可能应该加入Java标准库。
  • 参考:java.lang.StringBuilder.reverse()。

System.out.println(str);

int birthYear;

**启动一条线程
**

}

byte[] raw;

下面的三个例子使用了不同的方式完成了同样的事情。

}

public boolean equals(Object obj) {

实现Runnnable的方式:

/*

if (!obj instanceof Person)

void startAThread0() {

* TreeSet:

return false;

  new Thread(new MyRunnable()).start();

* 1.向TreeSet中添加的元素必须是同一个类的。

Person other = (Person)obj;

}

*
2.可以按照添加进集合中的元素的指定的顺序遍历。像String、包装类等默认按照从小到大的顺序遍历。

return name.equals(other.name)

class MyRunnable implements Runnable {

*
3.自然排序:当向TreeSet中添加自定义类的对象时,有两种排序方法:①自然排序
②定制排序

birthYear == other.birthYear

  public void run() {

*
4.自然排序:要求自定义类实现java.lang.Comparable接口并重写其compareTo(Object
obj)

Arrays.equals(raw, other.raw);

    …

* 在此方法中,指明按照自定义类的哪个属性来排序。

}

  }

*

public int hashCode() { … }

}

*
5.向TreeSet中添加元素时,首先按照compareTo()进行比较,一旦返回0,虽然仅是两个对象的

}

继承Thread的方式:

*
此属性值相同,但是程序会认为这两个对象是相同的,进而后一个对象就不能添加进来。

参数必须是Object类型,不能是外围类。

void startAThread1() {

*

foo.equals(null) 必须返回false,不能抛NullPointerException。(注意,null
instanceof 任意类 总是返回false,因此上面的代码可以运行。)

  new MyThread().start();

* >compareTo()与hashCode()以及equals()三者保持一致!

基本类型域(比如,int)的比较使用 ==
,基本类型数组域的比较使用Arrays.equals()。

}

*

覆盖equals()时,记得要相应地覆盖 hashCode(),与 equals() 保持一致。

class MyThread extends Thread {

* */

参考: java.lang.Object.equals(Object)。

  public void run() {

public void testTreeSet(){

实现hashCode()

    …

Set set = new TreeSet();

class Person {

  }

// set.add(new String(“AA”));

String a;

}

// set.add(new String(“BB”));

Object b;

匿名继承Thread的方式:

// set.add(“JJ”);

byte c;

void startAThread2() {

// set.add(“GG”);

int[] d;

  new Thread() {

// set.add(“MM”);

public int hashCode() {

    public void run() {

//当Person类没有实现Comparable接口时,当向TreeSet中添加Person对象时,报ClassCastException异常

return a.hashCode() + b.hashCode() + c + Arrays.hashCode(d);

      …

set.add(new Person(“CC”,21));

}

    }

set.add(new Person(“MM”,23));

public boolean equals(Object o) { … }

  }.start();

set.add(new Person(“GG”,22));

}

}

set.add(new Person(“JJ”,27));

当x和y两个对象具有x.equals(y) == true ,你必须要确保x.hashCode() ==
y.hashCode()。

  • 不要直接调用run()方法。总是调用Thread.start()方法,这个方法会创建一条新的线程并使新建的线程调用run()。
  • 参考:java.lang.Thread,
    java.lang.Runnable。

set.add(new Person(“DD”,22));

根据逆反命题,如果x.hashCode() != y.hashCode(),那么x.equals(y) == false
必定成立。

使用try-finally

for(Object str : set){

你不需要保证,当x.equals(y) == false时,x.hashCode() !=
y.hashCode()。但是,如果你可以尽可能地使它成立的话,这会提高哈希表的性能。

I/O流例子:

System.out.println(str);

hashCode()最简单的合法实现就是简单地return
0;虽然这个实现是正确的,但是这会导致HashMap这些数据结构运行得很慢。

void writeStuff() throws IOException {

}

参考:java.lang.Object.hashCode()。

  OutputStream out = new FileOutputStream(…);

}

实现compareTo()

  try {

/*

class Person implements Comparable{

    out.write(…);

* Set:存储的元素是无序的,不可重复的! 1.无序性:无序性 !=
随机性。真正的无序性,指的是元素在底层存储的位置是无序的。
2.不可重复性:

String firstName;

  } finally {

*

String lastName;

    out.close();

* 说明:要求添加进Set中的元素所在的类,一定要重写equals()和hashCode()。
进而保证Set中元素不可重复性。

int birthdate;

  }

*

// Compare by firstName, break ties by lastName, finally break ties by
birthdate

}

* Set中的元素是如何存储的呢?使用哈希算法。
当向Set中添加对象时,首先调用此对象所在类的hashCode()方法。计算此对象的哈希值,此哈希值

public int compareTo(Person other) {

锁例子:

*
决定了此对象在Set中存储位置。若此位置之前没有对象存储,则这个对象直接存储到此位置。若此位置

if (firstName.compareTo(other.firstName) != 0)

void doWithLock(Lock lock) {

*
已有对象存储,再通过equals()比较这两个对象是否相同。如果相同,后一个对象就不能再添加进来。
万一返回false呢,都存储。(不建议如此)

return firstName.compareTo(other.firstName);

  lock.acquire();

* >要求:hashCode()方法要与equals()方法一致。

else if (lastName.compareTo(other.lastName) != 0)

  try {

*/

return lastName.compareTo(other.lastName);

    …

/*

else if (birthdate other.birthdate)

  } finally {

*
LinkHashSet:使用链表维护了一个添加进集合中的顺序。导致当遍历LinkedHashSet集合

return -1;

    lock.release();

* 元素时,是按照添加进去的顺序遍历的!

else if (birthdate other.birthdate)

  }

* */

return 1;

}

@Test

else

  • 如果try之前的语句运行失败并且抛出异常,那么finally语句块就不会执行。但无论怎样,在这个例子里不用担心资源的释放。
  • 如果try语句块里面的语句抛出异常,那么程序的运行就会跳到finally语句块里执行尽可能多的语句,然后跳出这个方法(除非这个方法还有另一个外围的finally语句块)。

public void testLinkedHashSet() {

return 0;


Set set = new LinkedHashSet();

}

**
从输入流里读取字节数据

set.add(123);

}

InputStream in = (…);
try {
  while (true) {
    int b = in.read();
    if (b == -1)
      break;
    (… process b …)
  }
} finally {
  in.close();
}
**

set.add(456);

总是实现泛型版本 Comparable 而不是实现原始类型 Comparable
。因为这样可以节省代码量和减少不必要的麻烦。

  • read()方法要么返回下一次从流里读取的字节数(0到255,包括0和255),要么在达到流的末端时返回-1。
  • 参考:java.io.InputStream.read()。

set.add(“AA”);

只关心返回结果的正负号(负/零/正),它们的大小不重要。

**从输入流里读取块数据

set.add(“AA”);

Comparator.compare()的实现与这个类似。

InputStream in = (…);
try {
  byte[] buf = new byte[100];
  while (true) {
    int n = in.read(buf);
    if (n == -1)
      break;
    (… process buf with offset=0 and length=n …)
  }
} finally {
  in.close();
}
**

set.add(“BB”);

参考:java.lang.Comparable。

  • 要记住的是,read()方法不一定会填满整个buf,所以你必须在处理逻辑中考虑返回的长度。
  • 参考:[url=],
    int, int]java.io.InputStream.read(byte[], int,
    int)[/url]。

set.add(null);

实现clone()

**从文件里读取文本

Iterator iterator = set.iterator();

class Values implements Cloneable {

BufferedReader in = new BufferedReader(
    new InputStreamReader(new FileInputStream(…), “UTF-8”));
try {
  while (true) {
    String line = in.readLine();
    if (line == null)
      break;
    (… process line …)
  }
} finally {
  in.close();
}
**

while(iterator.hasNext()){

String abc;

  • BufferedReader对象的创建显得很冗长。这是因为Java把字节和字符当成两个不同的概念来看待(这与C语言不同)。
  • 你可以使用任何类型的InputStream来代替FileInputStream,比如socket。
  • 当达到流的末端时,BufferedReader.readLine()会返回null。
  • 要一次读取一个字符,使用Reader.read()方法。
  • 你可以使用其他的字符编码而不使用UTF-8,但最好不要这样做。
  • 参考:java.io.BufferedReader、java.io.InputStreamReader。

System.out.println(iterator.next());

double foo;

**向文件里写文本

}

int[] bars;

PrintWriter out = new PrintWriter(
    new OutputStreamWriter(new FileOutputStream(…), “UTF-8”));
try {
  out.print(“Hello “);
  out.print(42);
  out.println(” world!”);
} finally {
  out.close();
}
**

}

Date hired;

  • Printwriter对象的创建显得很冗长。这是因为Java把字节和字符当成两个不同的概念来看待(这与C语言不同)。
  • 就像System.out,你可以使用print()和println()打印多种类型的值。
  • 你可以使用其他的字符编码而不使用UTF-8,但最好不要这样做。
  • 参考:java.io.PrintWriter、java.io.OutputStreamWriter。

@Test

public Values clone() {


public void testHashSet() {

try {

**
预防性检测(Defensive
checking)数值

Set set = new HashSet();

Values result = (Values)super.clone();

int factorial(int n) {
  if (n < 0)
    throw new IllegalArgumentException(“Undefined”);
  else if (n >= 13)
    throw new ArithmeticException(“Result overflow”);
  else if (n == 0)
    return 1;
  else
    return n * factorial(n – 1);
}
**

set.add(123);

result.bars = result.bars.clone();

  • 不要认为输入的数值都是正数、足够小的数等等。要显式地检测这些条件。
  • 一个设计良好的函数应该对所有可能性的输入值都能够正确地执行。要确保所有的情况都考虑到了并且不会产生错误的输出(比如溢出)。

set.add(456);

result.hired = result.hired.clone();

**预防性检测对象

set.add(“AA”);

int findIndex(List<String> list, String target) {
  if (list == null || target == null)
    throw new NullPointerException();
  …
}

set.add(“AA”);

**

set.add(“BB”);

  • 不要认为对象参数不会为空(null)。要显式地检测这个条件。

set.add(null);

**预防性检测数组索引

Person p1 = new Person(“GG”, 23);

void frob(byte[] b, int index) {
  if (b == null)
    throw new NullPointerException();
  if (index < 0 || index >= b.length)
    throw new IndexOutOfBoundsException();
  …
}
**

Person p2 = new Person(“GG”, 23);

  • 不要认为所以给的数组索引不会越界。要显式地检测它。

System.out.println(p1.hashCode());

**预防性检测数组区间

System.out.println(p2.hashCode());

void frob(byte[] b, int off, int len) {
  if (b == null)
    throw new NullPointerException();
  if (off < 0 || off > b.length
    || len < 0 || b.length – off < len)
    throw new IndexOutOfBoundsException();
  …
}
**

set.add(p1);

  • 不要认为所给的数组区间(比如,从off开始,读取len个元素)是不会越界。要显式地检测它。

set.add(p2);


System.out.println(set.size());


填充数组元素

System.out.println(set);

使用循环:

System.out.println();

// Fill each element of array ‘a’ with 123

Iterator iterator = set.iterator();

byte[] a = (…);

while(iterator.hasNext()){

for (int i = 0; i < a.length; i++)

System.out.println(iterator.next());

  a = 123;

}

(优先)使用标准库的方法:
Arrays.fill(a, (byte)123);

}

  • 参考:[url=],
    byte]java.util.Arrays.fill(T[], T)[/url]。
  • 参考:[url=],
    int, int, byte]java.util.Arrays.fill(T[], int, int,
    T)[/url]。

}

复制一个范围内的数组元素

public class Customer {

使用循环:

private String name;

// Copy 8 elements from array ‘a’ starting at offset 3

private Integer id;

// to array ‘b’ starting at offset 6,

public Customer() {

// assuming ‘a’ and ‘b’ are distinct arrays

super();

byte[] a = (…);

}

byte[] b = (…);

public Customer(String name, Integer age) {

for (int i = 0; i < 8; i++)

super();

  b[6 + i] = a[3 + i];

this.name = name;

(优先)使用标准库的方法:
System.arraycopy(a, 3, b, 6, 8);

this.id = age;

  • 参考:java.lang.System.arraycopy(Object, int,
    Object, int,
    int)。

}

调整数组大小

public String getName() {

使用循环(扩大规模):

return name;

// Make array ‘a’ larger to newLen

}

byte[] a = (…);

public void setName(String name) {

byte[] b = new byte[newLen];

this.name = name;

for (int i = 0; i < a.length; i++)  // Goes up to length of A

}

  b = a;

public Integer getId() {

a = b;

return id;

使用循环(减小规模):
// Make array ‘a’ smaller to newLen
byte[] a = (…);
byte[] b = new byte[newLen];
for (int i = 0; i < b.length; i++)  // Goes up to length of B
  b = a;
a = b;

(优先)使用标准库的方法:

}

a = Arrays.copyOf(a, newLen);

public void setId(Integer age) {

  • 参考:[url=],
    int]java.util.Arrays.copyOf(T[], int)[/url]。
  • 参考:[url=],
    int, int]java.util.Arrays.copyOfRange(T[], int,
    int)[/url]

this.id = age;


}

**
把4个字节包装(packing)成一个int

@Override

int packBigEndian(byte[] b) {
  return (b[0] & 0xFF) << 24
       | (b[1] & 0xFF) << 16
       | (b[2] & 0xFF) <<  8
       | (b[3] & 0xFF) <<  0;
}

public String toString() {

int packLittleEndian(byte[] b) {
  return (b[0] & 0xFF) <<  0
       | (b[1] & 0xFF) <<  8
       | (b[2] & 0xFF) << 16
       | (b[3] & 0xFF) << 24;
}
把int分解(Unpacking)成4个字节

return “Customer [name=” + name + “, id=” + id + “]”;

byte[] unpackBigEndian(int x) {
  return new byte[] {
    (byte)(x >>> 24),
    (byte)(x >>> 16),
    (byte)(x >>>  8),
    (byte)(x >>>  0)
  };
}

}

byte[] unpackLittleEndian(int x) {
  return new byte[] {
    (byte)(x >>>  0),
    (byte)(x >>>  8),
    (byte)(x >>> 16),
    (byte)(x >>> 24)
  };
}
**

@Override

  • 总是使用无符号右移操作符(>>>)对位进行包装(packing),不要使用算术右移操作符(>>)。

public int hashCode() {

原文链接: nayuki 翻译: ImportNew.com- 进林
译文链接:
原文地址:

final int prime = 31;

int result = 1;

result = prime * result + ((id == null) ? 0 : id.hashCode());

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Customer other = (Customer) obj;

if (id == null) {

if (other.id != null)

return false;

} else if (!id.equals(other.id))

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

}

public class Person implements Comparable{

private String name;

private Integer age;

public Person() {

super();

}

public Person(String name, Integer age) {

super();

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@Override

public String toString() {

return “Person [name=” + name + “, age=” + age + “]”;

}

// @Override

public int hashCode() {

final int prime = 31;

int result = 1;

result = prime * result + ((age == null) ? 0 : age.hashCode());

result = prime * result + ((name == null) ? 0 : name.hashCode());

return result;

}

@Override

public boolean equals(Object obj) {

if (this == obj)

return true;

if (obj == null)

return false;

if (getClass() != obj.getClass())

return false;

Person other = (Person) obj;

if (age == null) {

if (other.age != null)

return false;

} else if (!age.equals(other.age))

return false;

if (name == null) {

if (other.name != null)

return false;

} else if (!name.equals(other.name))

return false;

return true;

}

//当向TreeSet中添加Person类的对象时,依据此方法,确定按照哪个属性排列。

@Override

public int compareTo(Object o) {

if(o instanceof Person){

Person p = (Person)o;

//return this.name.compareTo(p.name);

int i = this.age.compareTo(p.age);

if(i == 0){

return this.name.compareTo(p.name);

}else{

return i;

}

}

return 0;

}

}

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图