Java经典用法总结
程序员文章站
2024-03-08 16:42:17
在java编程中,有些知识并不能仅通过语言规范或者标准api文档就能学到的,本文为大家罗列。
一、实现
1、现equals()
class p...
在java编程中,有些知识并不能仅通过语言规范或者标准api文档就能学到的,本文为大家罗列。
一、实现
1、现equals()
class person { string name; int birthyear; byte[] raw; public boolean equals(object obj) { if (!obj instanceof person) return false; person other = (person)obj; return name.equals(other.name) && birthyear == other.birthyear && arrays.equals(raw, other.raw); } public int hashcode() { ... } }
- 参数必须是object类型,不能是外围类。
- foo.equals(null) 必须返回false,不能抛nullpointerexception。(注意,null instanceof 任意类 总是返回false,因此上面的代码可以运行。)
- 基本类型域(比如,int)的比较使用 == ,基本类型数组域的比较使用arrays.equals()。
- 覆盖equals()时,记得要相应地覆盖 hashcode(),与 equals() 保持一致。
2、现hashcode()
class person { string a; object b; byte c; int[] d; public int hashcode() { return a.hashcode() + b.hashcode() + c + arrays.hashcode(d); } public boolean equals(object o) { ... } }
- 当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这些数据结构运行得很慢。
3、实现compareto()
class person implements comparable<person> { string firstname; string lastname; int birthdate; // 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; } }
总是实现泛型版本 comparable 而不是实现原始类型 comparable 。因为这样可以节省代码量和减少不必要的麻烦。
只关心返回结果的正负号(负/零/正),它们的大小不重要。
comparator.compare()的实现与这个类似。
4、实现clone()
class values implements cloneable { string abc; double foo; int[] bars; date hired; 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()方法是可以的也是合法的。
二、预防性检测
1、预防性检测(defensive checking)数值
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); }
- 不要认为输入的数值都是正数、足够小的数等等。要显式地检测这些条件。
- 一个设计良好的函数应该对所有可能性的输入值都能够正确地执行。要确保所有的情况都考虑到了并且不会产生错误的输出(比如溢出)。
2、预防性检测对象
int findindex(list<string> list, string target) { if (list == null || target == null) throw new nullpointerexception(); ... }
- 不要认为对象参数不会为空(null)。要显式地检测这个条件。
3、预防性检测数组索引
void frob(byte[] b, int index) { if (b == null) throw new nullpointerexception(); if (index < 0 || index >= b.length) throw new indexoutofboundsexception(); ... }
不要认为所以给的数组索引不会越界。要显式地检测它。
4、预防性检测数组区间
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(); ... }
不要认为所给的数组区间(比如,从off开始,读取len个元素)是不会越界。要显式地检测它。
三、数组
1、填充数组元素
使用循环:
// fill each element of array 'a' with 123 byte[] a = (...); for (int i = 0; i < a.length; i++) a[i] = 123; (优先)使用标准库的方法: arrays.fill(a, (byte)123);
2、复制一个范围内的数组元素
使用循环:
// copy 8 elements from array 'a' starting at offset 3 // to array 'b' starting at offset 6, // assuming 'a' and 'b' are distinct arrays byte[] a = (...); byte[] b = (...); for (int i = 0; i < 8; i++) b[6 + i] = a[3 + i]; (优先)使用标准库的方法: system.arraycopy(a, 3, b, 6, 8);
3、调整数组大小
使用循环(扩大规模):
// make array 'a' larger to newlen byte[] a = (...); byte[] b = new byte[newlen]; for (int i = 0; i < a.length; i++) // goes up to length of a b[i] = a[i]; a = b;
使用循环(减小规模):
// 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[i] = a[i]; a = b;
(优先)使用标准库的方法:
1a = arrays.copyof(a, newlen);
4、把4个字节包装(packing)成一个int
int packbigendian(byte[] b) { return (b[0] & 0xff) << 24 | (b[1] & 0xff) << 16 | (b[2] & 0xff) << 8 | (b[3] & 0xff) << 0; } int packlittleendian(byte[] b) { return (b[0] & 0xff) << 0 | (b[1] & 0xff) << 8 | (b[2] & 0xff) << 16 | (b[3] & 0xff) << 24; }
5、把int分解(unpacking)成4个字节
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) }; }
总是使用无符号右移操作符(>>>)对位进行包装(packing),不要使用算术右移操作符(>>)。
以上就是本文的全部内容,希望对大家的学习有所帮助。