注：本文是根据网络上的文章受启发，自己再写代码总结而成。因为无法找到原文的原始出处，所以没法给出原文链接。文章也会引用部分网络素材内容，如果原作者看到请与我联系。
0.前言
本博主的java水平与专业java开发同学相比水平不可同日而语，所以平时有空的话会多写写java代码。正好在网上看到一篇关于java习惯用法的总结，觉得还不错，于是按照文章里的大致架构，自己重新实现了一把里面的相关代码，相当于自己做个小小的总结。
1.基本方法实现
equals()
hashcode()
compareTo()
clone()
1.1 equals()实例与hashCode()实例
import java.util.Arrays;
public class Person {
String name;
int birthday;
byte[] raw;
public boolean equals(Object obj) {
// 原文中的代码有误，需要将!符号后面的表达式扩起来
if (!(obj instanceof Person)) {
return false;
}
Person other = (Person) obj;
return name.equals(other.name)
&& birthday == other.birthday
&& Arrays.equals(raw, other.raw);
}
public int hashCode() {
return name.hashCode() + birthday + Arrays.hashCode(raw);
}
public static void main(String[] args) {
Person leilei = new Person();
leilei.name = "leilei";
leilei.birthday = 19991010;
Person lulu = new Person();
lulu.name = "leilei";
lulu.birthday = 19991010;
System.out.println(leilei.equals(lulu));
}
}equals()方法需要注意的几个点
1.参数必须是Object类型，不能是外围类。jdk源码中的equals()方法，传入的参数就是Object类型。
2.foo.equals(null) 必须返回false，不能抛NullPointerException。(注意，null instanceof 任意类 总是返回false，因此上面的代码可以运行)
3.基本类型比较使用 ==，基本类型数组域的比较使用Arrays.equals()。
4.覆盖equals()时，记得要相应地覆盖 hashCode()，与 equals() 保持一致
hashCode()方法注意的几个点
1.当x和y两个对象具有x.equals(y) == true ，你必须要确保x.hashCode() == y.hashCode()。
2.根据逆反命题，如果x.hashCode() != y.hashCode()，那么x.equals(y) == false 必定成立。
3.你不需要保证，当x.equals(y) == false时，x.hashCode() != y.hashCode()。但是，如果你可以尽可能地使它成立的话，这会提高哈希表的性能。
4.hashCode()最简单的合法实现就是简单地return 0；虽然这个实现是正确的，但是这会导致HashMap这些数据结构运行得很慢。
1.2 compareTo()方法实现
package leilei.bit.edu.common;
import java.util.TreeSet;
public class PersonA implements Comparable<PersonA>{
String firstName;
String lastName;
int birthday;
public int compareTo(PersonA 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(birthday < other.birthday) {
return -1;
} else if(birthday > other.birthday) {
return 1;
} else {
return 0;
}
}
@Override
public String toString() {
return "firstName: " + firstName + ",lastName: " + lastName;
}
public static void main(String[] args) {
PersonA p1 = new PersonA();
p1.firstName = "li";
p1.lastName = "lei";
PersonA p2 = new PersonA();
p2.firstName = "han";
p2.lastName = "meimei";
PersonA p3 = new PersonA();
p3.firstName = "xiao";
p3.lastName = "ming";
TreeSet tree = new TreeSet();
tree.add(p1);
tree.add(p2);
tree.add(p3);
for(Object obj:tree) {
System.out.println(obj);
}
}
}
输出：
firstName: han,lastName: meimei
firstName: li,lastName: lei
firstName: xiao,lastName: mingTreeSet在java内部是一种排序的数据结构。根据程序的输出可以看出，person对象在tree中是根据firstName排序的。
1.总是实现泛型版本 Comparable 而不是实现原始类型 Comparable 。因为这样可以节省代码量和减少不必要的麻烦。
2.只关心返回结果的正负号（负/零/正），它们的大小不重要。
3.Comparator.compare()的实现与这个类似。
1.3 clone()方法
实际中我很少使用clone方法，怕自己的理解有偏差，直接将原文的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);
}
}
}
1.使用 super.clone() 让Object类负责创建新的对象。
2.基本类型域都已经被正确地复制了。同样，我们不需要去克隆String和BigInteger等不可变类型。
3.手动对所有的非基本类型域（对象和数组）进行深度复制（deep copy）。
4.实现了Cloneable的类，clone()方法永远不要抛CloneNotSupportedException。因此，需要捕获这个异常并忽略它，或者使用不受检异常（unchecked exception）包装它。
5.不使用Object.clone()方法而是手动地实现clone()方法是可以的也是合法的。
2.应用类
2.1 StringBuilder 与 StringBuffer
这两个类在实际开发中用得很多，举一个很简单的小例子。
@Test
public void Str_Build() {
StringBuilder sb = new StringBuilder();
sb.append("I ");
sb.append("love");
sb.append(" coding");
System.out.println(sb.toString());
}让代码run起来
I love coding注意点：
1.不要像这样使用重复的字符串连接：s += item ，因为它的时间效率是O(n^2)。
2.使用StringBuilder或者StringBuffer时，可以使用append()方法添加文本和使用toString()方法去获取连接起来的整个文本。示例代码中就是这么做的。
3.优先使用StringBuilder，因为它更快。StringBuffer的所有方法都是同步的，而你通常不需要同步的方法。
4.StringBuilder的缺陷之一，就是开发过程中，经常用sb作为new出来的对象名称。。。
2.2 生成一个随机整数
@Test
public void int_random() {
Random rand = new Random();
int a = rand.nextInt(10) + 1;
System.out.println("random num is: " + a);
}让代码run起来
random num is: 102.3 使用Iterator.remove()
@Test
public void collections_remove() {
List<Integer> list = new ArrayList<Integer>();
for(int i=1; i<=10; i++) {
list.add(i);
}
Iterator<Integer> it = list.iterator();
while(it.hasNext()) {
int num = it.next();
if(num%2 == 0) {
System.out.println(num + "===" + num);
it.remove();
}
}
for(int each:list) {
System.out.print(each + " ");
}
}让代码run起来
2===2
4===4
6===6
8===8
10===10
1 3 5 7 9 remove()方法作用在next()方法最近返回的条目上。每个条目只能使用一次remove()方法。
2.4 反转字符串
c++的程序猿里的一道经典面试题就是反转字符串。对于java或者python等更高级的语言来说，反转字符串都是一句话搞定的事情。
@Test
public void reverse_str() {
String raw_str = "some";
String rev_str = new StringBuilder(raw_str).reverse().toString();
System.out.println("rev_str is: " + rev_str);
}让代码run起来
rev_str is: emos2.5 Thread/Runnable
//实现Runnable的方式
void startAThread0() {
new Thread(new MyRunnable()).start();
}
class MyRunnable implements Runnable {
public void run() {
...
}
}
//继承Thread的方式
void startAThread1() {
new MyThread().start();
}
class MyThread extends Thread {
public void run() {
...
}
}
匿名继承Thread的方式
void startAThread2() {
new Thread() {
public void run() {
...
}
}.start();
}不要直接调用run()方法。总是调用Thread.start()方法，这个方法会创建一条新的线程并使新建的线程调用run()。
2.6 try-finally
IO流的例子
void writeStuff() throws IOException {
OutputStream out = new FileOutputStream(...);
try {
out.write(...);
} finally {
out.close();
}
}
锁的例子
void doWithLock(Lock lock) {
lock.acquire();
try {
...
} finally {
lock.release();
}
}1.如果try之前的语句运行失败并且抛出异常，那么finally语句块就不会执行。但无论怎样，在这个例子里不用担心资源的释放。
2.如果try语句块里面的语句抛出异常，那么程序的运行就会跳到finally语句块里执行尽可能多的语句，然后跳出这个方法（除非这个方法还有另一个外围的finally语句块）。
3.输入输出
3.1 从输入流中读取字节数据
@Test
public void test1() throws Exception {
InputStream in = new FileInputStream(new File("xxx"));
try {
while(true) {
int n = in.read();
if(n == -1) {
break;
} else {
System.out.println(n);
}
}
} finally {
in.close();
}
}输出：
112
97
99
107
97
103
101
...由此可见，read()方法要么返回下一次从流里读取的字节数（0到255，包括0和255），要么在达到流的末端。
3.2 从输入流中读取块数据
@Test
public void test2() throws Exception {
InputStream in = new FileInputStream(new File("xxx"));
try {
byte[] buf = new byte[100];
while(true) {
int n = in.read(buf);
if(n == -1) {
break;
} else {
System.out.println(n);
}
}
} finally {
in.close();
}
}输出：
100
100
100
100
100
100
81要记住的是，read()方法不一定会填满整个buf，所以你必须在处理逻辑中考虑返回的长度。
3.3 读取文本文件
@Test
public void test3() throws Exception {
String filename = "xxx";
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(new File(filename)),"utf-8"));
try {
while (true) {
String line = br.readLine();
if (line == null) {
break;
} else {
System.out.println(line);
}
}
} finally {
br.close();
}
}1.BufferedReader对象的创建显得很冗长。这是因为Java把字节和字符当成两个不同的概念来看待
2.你可以使用任何类型的InputStream来代替FileInputStream，比如socket
3.当达到流的末端时，BufferedReader.readLine()会返回null。
4.要一次读取一个字符，使用Reader.read()方法。
5.你可以使用其他的字符编码而不使用UTF-8，但最好不要这样做。
3.4.向文本写文件
@Test
public void test4() throws Exception {
String filename = "xxx";
PrintWriter out = new PrintWriter(
new OutputStreamWriter(new FileOutputStream(new File(filename)),"utf-8"));
try {
out.println("hello");
out.println(42);
out.println("world");
} finally {
out.close();
}
}1.Printwriter对象的创建显得很冗长。这是因为Java把字节和字符当成两个不同的概念来看待
2.就像System.out，你可以使用print()和println()打印多种类型的值。
3.你可以使用其他的字符编码而不使用UTF-8，但最好不要这样做。
4 预防性(Defensive Checking)检测
4.1 预防性检测数值
package leilei.bit.edu.common;
public class Checking {
public static int factorial(int n) {
if (n < 0) {
throw new IllegalArgumentException("Undefined");
} else if(n > 13) {
throw new ArithmeticException("Reuslt overflow");
} else if(n == 0) {
return 1;
} else {
return factorial(n-1) * n;
}
}
public static void main(String[] args) {
int n = 5;
int ret = factorial(n);
System.out.println("ret is: " + ret);
}
}
1.不要认为输入的数值都是正数、足够小的数等等。要显式地检测这些条件。
2.一个设计良好的函数应该对所有可能性的输入值都能够正确地执行。要确保所有的情况都考虑到了并且不会产生错误的输出（比如溢出）。
4.2 预防性检测对象
public int findIndex(List<String> list, String target) {
if (list == null || target == null)
throw new NullPointerException();
...
}1.不要认为对象参数不会为空（null）。要显式地检测这个条件。
4.3预防性检测数组索引
public static void outOfBound(int[] b, int index) {
if(b==null) {
throw new NullPointerException();
}
if(index < 0 || index >= b.length) {
throw new IndexOutOfBoundsException();
}
...
}不要认为所以给的数组索引不会越界。要显式地检测它。
4.4 预防性检测数组区间
public static void errorRange(int[] 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个元素）是不会越界。要显式地检测它。
5.数组
5.1 填充数组元素
5.2 复制一个范围内的数组元素
5.3 调整数组大小
具体代码如下：
package leilei.bit.edu.bigNum;
import java.util.Arrays;
public class Array_Test {
public static void printArray(int[] a) {
for(int i=0; i<a.length; i++) {
System.out.print(a[i] + " ");
}
}
public static void fill_test() {
int[] a = new int[5];
Arrays.fill(a,0,5,1);
printArray(a);
}
public static void copy_test() {
int[] a = {1,2,3,4,5};
int[] b = new int[5];
System.arraycopy(a, 0, b, 0, a.length);
printArray(b);
}
public static void copyOf_test() {
int[] a = {1,2,3,4,5};
a = Arrays.copyOf(a,10);
printArray(a);
}
public static void main(String[] args) {
fill_test();
System.out.println();
copy_test();
System.out.println();
copyOf_test();
}
}
代码运行结果如下：
1 1 1 1 1
1 2 3 4 5
1 2 3 4 5 0 0 0 0 0 6.包装
以下代码演示了将四个字节包装成一个int，以及将一个int分解成四个字节。
package leilei.bit.edu.bigNum;
public class Pack {
public static void pack() {
byte[] a = {1,2,3,4};
int result = (a[0] & 0xFF) << 24
|(a[1] & 0xFF) << 16
|(a[2] & 0xFF) << 8
|(a[3] & 0xFF) << 0;
System.out.println("result is: " + result);
}
public static void unpack() {
int x = 16909060;
byte[] result = {
(byte)(x >>> 24),
(byte)(x >>> 16),
(byte)(x >>> 8),
(byte)(x >>> 0)
};
System.out.print("the unpack result is: ");
for(int i=0; i<result.length; i++) {
System.out.print(result[i] + " ");
}
}
public static void main(String[] args) {
pack();
unpack();
}
}
让代码run起来：
result is: 16909060
the unpack result is: 1 2 3 4