Java经典用法总结
在Java编程中,有些知识并不能仅通过语言规范或者标准API文档就能学到的,本文为大家罗列。
一、实现
1、现equals()
classPerson{ Stringname; intbirthYear; byte[]raw; publicbooleanequals(Objectobj){ if(!objinstanceofPerson) returnfalse; Personother=(Person)obj; returnname.equals(other.name) &&birthYear==other.birthYear &&Arrays.equals(raw,other.raw); } publicinthashCode(){...} }
- 参数必须是Object类型,不能是外围类。
- foo.equals(null)必须返回false,不能抛NullPointerException。(注意,nullinstanceof任意类总是返回false,因此上面的代码可以运行。)
- 基本类型域(比如,int)的比较使用==,基本类型数组域的比较使用Arrays.equals()。
- 覆盖equals()时,记得要相应地覆盖hashCode(),与equals()保持一致。
2、现hashCode()
classPerson{ Stringa; Objectb; bytec; int[]d; publicinthashCode(){ returna.hashCode()+b.hashCode()+c+Arrays.hashCode(d); } publicbooleanequals(Objecto){...} }
- 当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()最简单的合法实现就是简单地return0;虽然这个实现是正确的,但是这会导致HashMap这些数据结构运行得很慢。
3、实现compareTo()
classPersonimplementsComparable<Person>{ StringfirstName; StringlastName; intbirthdate; //ComparebyfirstName,breaktiesbylastName,finallybreaktiesbybirthdate publicintcompareTo(Personother){ if(firstName.compareTo(other.firstName)!=0) returnfirstName.compareTo(other.firstName); elseif(lastName.compareTo(other.lastName)!=0) returnlastName.compareTo(other.lastName); elseif(birthdate<other.birthdate) return-1; elseif(birthdate>other.birthdate) return1; else return0; } }
总是实现泛型版本Comparable而不是实现原始类型Comparable。因为这样可以节省代码量和减少不必要的麻烦。
只关心返回结果的正负号(负/零/正),它们的大小不重要。
Comparator.compare()的实现与这个类似。
4、实现clone()
classValuesimplementsCloneable{ Stringabc; doublefoo; int[]bars; Datehired; publicValuesclone(){ try{ Valuesresult=(Values)super.clone(); result.bars=result.bars.clone(); result.hired=result.hired.clone(); returnresult; }catch(CloneNotSupportedExceptione){//Impossible thrownewAssertionError(e); } } }
- 使用super.clone()让Object类负责创建新的对象。
- 基本类型域都已经被正确地复制了。同样,我们不需要去克隆String和BigInteger等不可变类型。
- 手动对所有的非基本类型域(对象和数组)进行深度复制(deepcopy)。
- 实现了Cloneable的类,clone()方法永远不要抛CloneNotSupportedException。因此,需要捕获这个异常并忽略它,或者使用不受检异常(uncheckedexception)包装它。
- 不使用Object.clone()方法而是手动地实现clone()方法是可以的也是合法的。
二、预防性检测
1、预防性检测(Defensivechecking)数值
intfactorial(intn){ if(n<0) thrownewIllegalArgumentException("Undefined"); elseif(n>=13) thrownewArithmeticException("Resultoverflow"); elseif(n==0) return1; else returnn*factorial(n-1); }
- 不要认为输入的数值都是正数、足够小的数等等。要显式地检测这些条件。
- 一个设计良好的函数应该对所有可能性的输入值都能够正确地执行。要确保所有的情况都考虑到了并且不会产生错误的输出(比如溢出)。
2、预防性检测对象
intfindIndex(List<String>list,Stringtarget){ if(list==null||target==null) thrownewNullPointerException(); ... }
- 不要认为对象参数不会为空(null)。要显式地检测这个条件。
3、预防性检测数组索引
voidfrob(byte[]b,intindex){ if(b==null) thrownewNullPointerException(); if(index<0||index>=b.length) thrownewIndexOutOfBoundsException(); ... }
不要认为所以给的数组索引不会越界。要显式地检测它。
4、预防性检测数组区间
voidfrob(byte[]b,intoff,intlen){ if(b==null) thrownewNullPointerException(); if(off<0||off>b.length ||len<0||b.length-off<len) thrownewIndexOutOfBoundsException(); ... }
不要认为所给的数组区间(比如,从off开始,读取len个元素)是不会越界。要显式地检测它。
三、数组
1、填充数组元素
使用循环:
//Filleachelementofarray'a'with123 byte[]a=(...); for(inti=0;i<a.length;i++) a[i]=123; (优先)使用标准库的方法: Arrays.fill(a,(byte)123);
2、复制一个范围内的数组元素
使用循环:
//Copy8elementsfromarray'a'startingatoffset3 //toarray'b'startingatoffset6, //assuming'a'and'b'aredistinctarrays byte[]a=(...); byte[]b=(...); for(inti=0;i<8;i++) b[6+i]=a[3+i]; (优先)使用标准库的方法: System.arraycopy(a,3,b,6,8);
3、调整数组大小
使用循环(扩大规模):
//Makearray'a'largertonewLen byte[]a=(...); byte[]b=newbyte[newLen]; for(inti=0;i<a.length;i++)//GoesuptolengthofA b[i]=a[i]; a=b;
使用循环(减小规模):
//Makearray'a'smallertonewLen byte[]a=(...); byte[]b=newbyte[newLen]; for(inti=0;i<b.length;i++)//GoesuptolengthofB b[i]=a[i]; a=b;
(优先)使用标准库的方法:
1a=Arrays.copyOf(a,newLen);
4、把4个字节包装(packing)成一个int
intpackBigEndian(byte[]b){ return(b[0]&0xFF)<<24 |(b[1]&0xFF)<<16 |(b[2]&0xFF)<<8 |(b[3]&0xFF)<<0; } intpackLittleEndian(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(intx){ returnnewbyte[]{ (byte)(x>>>24), (byte)(x>>>16), (byte)(x>>>8), (byte)(x>>>0) }; } byte[]unpackLittleEndian(intx){ returnnewbyte[]{ (byte)(x>>>0), (byte)(x>>>8), (byte)(x>>>16), (byte)(x>>>24) }; }
总是使用无符号右移操作符(>>>)对位进行包装(packing),不要使用算术右移操作符(>>)。
以上就是本文的全部内容,希望对大家的学习有所帮助。