Java习惯用法总结分享

在Java编制程序中,有个别知识
并无法仅经过言语专门的学问只怕职业API文档就会学到的。在本文中,作者会尽量采摘一些最常用的习贯用法,极其是很难猜到的用法。(Joshua
Bloch的《Effective
Java》对这几个话题给出了更详细的阐释,能够从那本书里读书越多的用法。卡塔尔(قطر‎

在天涯论坛中看见的叁个不利的帖子,总括的很详细,拷贝过来,一是为了有协理自身查阅,也能和我们协作分享,后边有原作的链接地址:

public class TestSet {

自己把本文的装有代码都献身公共场地里。你能够依赖本人的喜好去复制和纠正放肆的代码片段,无需其它的凭证。

在Java编制程序中,有些知识
并无法仅经过言语专门的学业照旧专门的学业API文档就能够学到的。在本文中,我会尽量搜聚一些最常用的习于旧贯用法,极度是很难猜到的用法。(乔希ua
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(yState of Qatar == true ,你必须要要保险x.hashCode(卡塔尔国== y.hashCode(卡塔尔国。
  • 依据逆反命题,假如x.hashCode(卡塔尔国 != y.hashCode(State of Qatar,那么x.equals(yState of Qatar ==
    false 必定创造。
  • 您没有必要保险,当x.equals(yState of Qatar == false时,x.hashCode(卡塔尔 !=
    y.hashCode(卡塔尔(قطر‎。不过,假诺您能够尽量地使它创制的话,那会拉长哈希表的性质。
  • hashCode(State of Qatar最简便易行的官方达成正是回顾地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<澳门新浦京8455com 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(State of Qatar方法永恒不要抛CloneNotSupportedException。由此,须求捕获那个非常并忽略它,恐怕利用不受检特别(unchecked
    exception)包装它。
  • 不使用Object.clone(State of Qatar方法而是手动地促成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(卡塔尔(قطر‎方法添Gavin本和利用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(State of Qatar方法。
  • 参考:澳门新浦京8455com,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(State of Qatar以致equals(卡塔尔(قطر‎三者保持一致!

基本类型域(比如,int卡塔尔的相比较使用 ==
,基本项目数组域的可比使用Arrays.equals(卡塔尔国。

}

*

覆盖equals(State of Qatar时,记得要对应地覆盖 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(yState of Qatar == true ,你必须求保管x.hashCode(卡塔尔国 ==
y.hashCode(State of Qatar。

  • 永不从来调用run(卡塔尔国方法。总是调用Thread.start(State of Qatar方法,这几个方法会创制一条新的线程并使新建的线程调用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(State of Qatar。
进而保障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(State of Qatar方法一致。

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(State of Qatar和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地图