Java中不可或缺的50個小技巧，好用！

《Effective JavaJava》名著，必讀。若是能嚴格聽從本文的原則，以編寫API的質量來苛求本身的代碼，會大大提高編碼素質。

如下內容只記錄了我本身整理的東西，仍是建議讀原文。爲了聚焦知識點，一些說明故意忽略掉了。至關因而一篇摘要。

一、考慮用靜態工廠方法替代構造函數

例子：

Integer.valueOf(「1」)、Boolean.valueOf(「true」)等。

優點：

• 可讀性高（方法名）

• 性能（不必定建立對象）

• 靈活性高

下面針對三個優點進行一些解讀。

可讀性高

new Point(x,y)和Point.at(x,y)、Point.origin()。構造函數只能看出兩個參數，不知其意，後者更易理解。

性能

在某些狀況下，能夠事先進行實例化一些對象，調用時直接調用便可，不須要進行改變。好比，Boolean。

public final class Boolean implements Serializable, Comparable<Boolean> {
    // 預先設置兩個對象
    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);

    public Boolean(boolean var1) {
        this.value = var1;
    }

    public Boolean(String var1) {
        this(parseBoolean(var1));
    }

    // 工廠方法
    public static Boolean valueOf(boolean var0) {
        return var0?TRUE:FALSE;    // 返回預先設置的對象，而不是建立對象
    }
    // 工廠方法
    public static Boolean valueOf(String var0) {
        return parseBoolean(var0)?TRUE:FALSE;
    }
    // ... other code
}

靈活性高

可根據具體狀況，返回子類。至關於更強大的工廠。直接從父類獲取到子類。尤爲適用於工具類（提供各類API）。例子：Collections。

public class Collections {
    // 私有，典型工廠
    private Collections() {
    }

    public static final List EMPTY_LIST = new EmptyList<>();
    // 工廠方法
    public static final <T> List<T> emptyList() {
        return (List<T>) EMPTY_LIST;
    }
    private static class EmptyList<E> extends AbstractList<E> implements RandomAccess, Serializable {
    // code
    }

    // 工廠方法
    public static <E> List<E> checkedList(List<E> list, Class<E> type) {
    // 根據具體狀況，獲取相應子類
        return (list instanceof RandomAccess ?
                new CheckedRandomAccessList<>(list, type) :
                new CheckedList<>(list, type));
    }

    // 子類1
    static class CheckedRandomAccessList<E> extends CheckedList<E> implements RandomAccess {
        CheckedRandomAccessList(List<E> list, Class<E> type) {
            super(list, type);
        }

        public List<E> subList(int fromIndex, int toIndex) {
            return new CheckedRandomAccessList<>(
                    list.subList(fromIndex, toIndex), type);
        }
    }

    // 子類2
    static class CheckedList<E> extends CheckedCollection<E> implements List<E> {
    // code
    }
}

二、多個構造函數時，考慮使用構造器

尤爲在進行Android開發時，會碰到這種狀況。一般是一個對象，具備多個成員變量可能須要初始化，常規方法，須要提供大量構造函數。例如：

// 非Android中的AlertDialog，便於說明問題，舉個例子
public class AlertDialog {
    private int width;
    private int height;
    private String title;
    private String confirmText;
    private String denyText;

    private AlertDialog(){}
    public AlertDialog(int width, int height){    // 空白的警告框
         AlertDialog(width,height,null);
    }

    // 帶標題的警告框
    public AlertDialog(int width, int height, String title){    // 帶標題的警告框
        AlertDialog(width, height, title, "肯定");
    }

    // 帶標題的警告框，有肯定按鈕
    public AlertDialog(int width, int height, String title, String confirm){   
        AlertDialog(width, height, title, confirm, null);
    }

    // 帶標題的警告框，有肯定按鈕，取消按鈕
    public AlertDialog(int width, int height, String title, String confirm, String denyText){
        // set every thing.
    }
}

有多種樣式的警告框，爲了調用方便，必須提供多個構造函數。不然用戶在調用時，只能使用完整構造函數，容易犯錯且沒法進行閱讀。極不靈活。若是採用另一種方式，則能夠解決，但會花費不少經歷處理併發的狀況:

// 非Android中的AlertDialog，便於說明問題，舉個例子
public class AlertDialog {
    private int width;
    private int height;
    private String title;
    private String confirmText;
    private String denyText;

    public AlertDialog(){}// 空白的構造函數
   
    public void setWidth(int width){
        this.width = width;
    }
    // 其餘set方法
}

調用時，經過調用各個參數的set方法進行設置。問題來了：

1. 併發

2. 沒法進行參數校驗。例如，只建立了對象，設置了標題，卻沒有尺寸，至關於建立了一個沒有尺寸的警告框。

在Android中，大量的控件都使用了構造器Builder。

// 非Android中的AlertDialog，便於說明問題，舉個例子
public class AlertDialog {
    private int width;
    private int height;
    private String title;
    private String confirmText;
    private String denyText;

    // private
    private AlertDialog(){}

    // Builder中使用
    protected AlertDialog(Builder b){
        width = b.width;
        height = b.height;
        // .....
        if(width==0||height==0) throws new Exception("size must be set");
    }

    // 構造器
    public static class Builder {
        private int width;
        private int height;
        private String title;
        private String confirmText;
        private String denyText;

        // 注意：返回的Builder。
        public Builder setTitle(String title) {
            this.title = title;
            return this;
        }
        // 其餘set...
        
        public AlertDialog build(){
            return AlertDialog(this);
        }
    }
}

因而，能夠根據相應需求，進行相應設置，並在AlertDialog真正構造時，進行參數校驗。就像這樣：

new AlertDialog.Builder().setTitle("提示").build();

上述例子，會成功拋出異常。

三、用私有化構造器或者枚舉型強化Singleton。

Singleton指最多會被實例化一次的類。一般狀況下，之前的作法是沒有問題的。可是在某些高級狀況，經過使用反射的相關知識訪問private的構造函數，破壞Singleton。

public class Elvis{
    // 注意，公有final對象
    public static final Elvis INSTANCE = new Elvis();
    private Elvis(){}
}

另外一種狀況，在序列化的過程當中，反序列化獲得的對象已經再也不是之前的對象（破壞了Singleton），這種狀況下，能夠經過單元素枚舉型處理。

public enum Elvis{
    INSTANCE;
    // some methods
}

四、經過私有化構造器強化不可實例化的能力

有一些工具類，僅僅是提供一些能力，本身自己不具有任何屬性，因此，不適合提供構造函數。然而，缺失構造函數編譯器會自動添加上一個無參的構造器。因此，須要提供一個私有化的構造函數。爲了防止在類內部誤用，再加上一個保護措施和註釋。

public class Util{
    private Util(){
        // 拋出異常，防止內部誤調用
        throw new AssertionError();
    }
}

弊端是沒法對該類進行繼承（子類會調用super()）。

五、避免建立沒必要要的對象

• 對象的重用

• 昂貴的對象，使用對象池

• 廉價的對象，慎用對象池。現代JVM對廉價對象的建立和銷燬很是快，此時不適於使用對象池。

六、消除過時的對象引用

如下三種狀況可能會形成內存泄露：

• 本身管理的內存（數組長度減少後，pop出的對象容易致使內存泄漏）

• 緩存

• 監聽和回調

本身管理的內存

對於本身管理的內存要當心，好比：

public class Stack{
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
    public Stack(){
         elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e){
        ensureCapacity();
        elements[size++]=e;    // allocate新的堆內存和棧內存
    }

    public Object pop(){
        if(size==0) throw new EmptyStackException();
        return element[--size];    // pop出element[size]，該對象再也不有效。內存泄漏緣由。
    }
    
    private void ensureCapacity(){
        if(elements.length==size)
            elements = Arrays.copyOf(elements, 2*size+1);
    }
}

彈出的對象再也不有效，但JVM不知道，因此會一直保持該對象，形成內存泄露。

解決：

public Object pop(){
    if(size==0) throw new EmptyStackException();
    elements[size] = null;        // 等待回收
    return element[--size];
}

緩存

緩存的對象容易被程序員遺忘，須要設置機制來維護緩存，例如不按期回收再也不使用的緩存（使用定時器）。某些狀況下，使用WeakHashMap能夠達到緩存回收的功效。注，只有緩存依賴於外部環境，而不是依賴於值時，WeakHashMap纔有效。

監聽或回調

使用監聽和回調要記住取消註冊。確保回收的最好的實現是使用弱引用（weak reference），例如，只將他們保存成WeakHashMap的鍵。

七、避免顯示調用GC

Java的GC有強大的回收機制，能夠簡單的記住：不要顯示調用finalizer。能夠這樣理解：

jvm是針對具體的硬件設計的，然而程序卻不是針對具體硬件設計的，因此，java代碼沒法很好的解決gc問題（由於他具備平臺差別化）。另外，finalizer的性能開銷也很是大，從這個角度上考慮也不該該使用它。

八、覆蓋equals方法請遵照通用約定

• 自反性。x.equals(x) == true

• 對稱性。當前僅當y.equals(x)==true時，x.equals(y)==true

• 傳遞性。if(x.equals(y)&&y.equals(z))，y.equals(z)==true

• 一致性。

• 非空性。x.equals(null)==false

九、覆蓋equals方法時總要覆蓋hashCode

爲了保證基於散列的集合使用該類（HashMap、HashSet、HashTable），同時，也是Object.hashCode的通用約定，覆蓋equals方法時，必須覆蓋hashCode。

十、始終覆蓋toString

Object的toString方法的通用約定是該對象的描述。注意覆蓋時，若是有格式，請備註或者嚴格按照格式返回。

十一、謹慎覆蓋clone

十二、考慮實現Comparable接口

1三、使類和成員的可訪問性最小化

目的是解耦。簡單來說，使用修飾符的優先級從大到小，private>protected>default(缺省)>public。若是在設計之初，設計爲private修飾符後，在以後的編碼過程若是不得不擴大其做用於，應該先檢查是否設計的確如此。

子類覆蓋超類，不容許訪問級別低於超類的訪問級別。（超類的protected，子類覆蓋後不能改成default）。

成員變量決不容許是公有的。一旦設置爲公有，則放棄了對他處理的能力。這種類並非線程安全的。即便是final的，也不容許。除非但願經過public static final來暴露常量。成員變量老是須要使用setter和getter來維護。有一個例外：長度非零的數組。這是安全漏洞的一個根源。

// 安全漏洞！此處的數組，並非不可變的
public static final Thing[] VALUES = {...}

改進：

private static final Thing[] PRIVATE_VALUES = {...}
// 此時獲取到的纔是「常量」
public static final List<Thing> VALUS = 
    Collections.unmodifiableList(Arrays.asList(PRIVATE_VALUES))

另外一種：

private static final Thing[] PRIVATE_VALUES = {...}
// 此時獲取到的纔是「常量」
public static final Thing[] values(){
    return PRIVATE_VALUES.clone();
}

1四、在公有類中使用訪問方法而非公有成員變量（相似13）

1五、使可變性最小化

1六、複合優先於繼承

繼承有利於代碼複用，可是儘量不要進行跨包的繼承。包內的繼承是優秀的設計方式，一個包裏的文件處在同一個程序員的控制之下。可是繼承有其侷限性：子類依賴於超類。超類一旦發生更改，將可能破壞子類。而且，若是超類是有缺陷的，子類也會得「遺傳病」。

複合，即不擴展已有的類，而是在的類中新增一個現有類的。至關於現有類做爲一個組建存在於新類中。如此，將只會用到須要用到的東西，而不表現現有類全部的方法和成員變量。新類也能夠稱爲「包裝類」，也就是設計模式中的Decorate模式。

1七、要麼就爲繼承而設計，並提供文檔說明，要麼就禁止繼承

1八、接口優於抽象類

1九、接口只用於定義類型

20、類層次優先於標籤類

2一、用函數對象表示策略

函數參數能夠傳入相似listener的對象，目的是使用listener中的方法。若是使用匿名的參數，每一次調用會建立新的對象。能夠將listener聲明爲成員變量，每次都複用同一個對象，而且可使用靜態域（static變量）。好比String類的CASE_INSENSITIVE_ORDER域。

關注公衆號【程序員白楠楠】獲取2020年底總結面試資料一套！

2二、優先考慮靜態類成員

嵌套類的目的應該只是爲了他的外圍類提供服務，若是之後還可能用於其餘環境中，則應該設計爲頂層類。靜態類至關於一個普通的外部類，只是剛好聲明在了一個類內部。一般的用戶是：Calculator.Operation.PLUS等。和普通類的區別只是，在PLUS前，有了2個前綴，來代表其含義。而非靜態類必須存在於外部類對象中。不要手動在外部建立一個內部非靜態類對象，建立的過程是：instance.New MemberClass()。這很是奇怪。

若是成員類不須要訪問外圍類，則須要添加static，是他成爲靜態成員類，不然每一個實例都將包含一個額外指向外圍對象的引用。將會影響垃圾回收機制。

2三、應指定泛型的具體類型，而不是直接使用原生類型。

例如，應該指定List，而不建議直接使用List。

2四、消除非首檢警告

在使用IDE進行編碼時，強大的IDE都會在你編碼過程當中提示warning，須要儘量的消除warning，至少，應該當心這些warning。慎用SuppresWarning，若是IDE提示你能夠經過添加該註解解決掉warning，請不要那麼作。若是實在要使用，請添加註釋說明緣由。

2五、列表優先於數組

類比泛型，數組是有必定缺陷的。List和List是沒有關係的，而Sub[]是Super[]的子類。

// Fails at runtime
Object[] objectArray = new Long[1];
objectArray[0] = "I don't fit in";       // throw exception

// won't compile
List<Object> ol = new ArrayList<Long>();   // Incompatible types
ol.add("I don't fit in");

從代碼中能夠看到，使用泛型，會提早發現錯誤。

2六、優先考慮泛型

2七、優先考慮泛型方法

2八、利用有限制通配符來提高API的靈活性

PECS，producer-extends，consumer-super。

//public class Stack<E>{
//    public Stack();
//    public void push(E e);
//    public E pop();
//    public boolean isEmpty();
//}

public void pushAll(Iterator<? extends E> src){
    for(E e : src)
        push(e);
}

public void popAll(Collection<? super E> dst){
    while(!isEmpty()){
        dst.add(pop());
    }
}

// Get and Put Principle

全部comparable和comparator都是消費者（Consumer）。

2九、優先考慮類型安全的異構容器

30、用enum代替int常量

public enum Apple { FUJI, PIPPIN, GRANNY_SMITH }
public enum Orange { NAVEL, TEMPLE, BLOOD }

枚舉型在java中很是強大，當須要一組固定常量時，使用enum比int好不少。好比代碼可讀性，安全性等。

3一、enum用實例域代替序數

// bad solution
public enum Ensemble {
    SOLO, DUET, TRIO, QUARTET, QUINTET, 
    SEXTET, SEPTET, OCTET, NONET, DECTET;

    public int numberOfMusicians() { return ordinal() + 1; }
}
// 

// improvement
public enum Ensemble {
    SOLO(1), DUET(2), TRIO(3), QUARTET(4), QUINTET(5), 
    SEXTET(6), SEPTET(7), OCTET(8), NONET(9), DECTET(10), TRIPLE_QUARTET(12);

    private final int numberOfMusicians;
    Ensemble(int size) { this.numberOfMusicians = size; }
    public int numberOfMusicians() { return numberOfMusicians; }
}

永遠不要像第一種的方式，利用序數訪問enum，須要在構造函數中使用參數來初始化。

3二、用EnumSet代替位域

public class Text{
    public static final int STYLE_BOLD                     = 1 << 0;    // 1
    public static final int STYLE_ITALIC                    = 1 << 1;    // 2
    public static final int STYLE_UNDERLINE          = 1 << 2;    // 4
    public static final int STYLE_STRIKETHROUGH = 1 << 3;    // 8

    public void applyStyles(int styles){  
        // ...
    }
}



// 
text.applyStyles(STYLE_BOLD | STYLE_ITALIC);

以上叫作位圖法，可是有更好的方案來傳遞多組常量——EnumSet。

public class Text{
    public enum Style { BOLD, ITALIC, UNDERLINE, STRIKETHROUGH }

    // 注意此處，使用的是Set而不是EnumSet
    public void applyStyles(Set<Style> styles){  
        // ...
    }
}



// 
text.applyStyles(EnumSet.of(Style.BOLD, Style.ITALIC));

3三、用EnumMap代替序數索引

任什麼時候候都不要使用enum的ordinal()方法。

3四、用接口模擬可伸縮的枚舉

3五、註解優先於命名模式

3六、堅持使用Override註解

3七、檢查參數的有效性

公有方法檢查參數，參數異常須要跑出Exception。私有方法利用斷言assertion檢查參數。

3八、必要時進行保護性拷貝

假設類的客戶端會盡其所能來破壞這個類的約束條件，所以你必須保護性的設計程序。如下是一個不可變類的設計。

public Period(Date start, Date end){
    this.start  = new Date(start);        // 使用了值的拷貝，沒有使用原對象（指針）
    this.end = new Date(end);
    if(this.start.compareTo(this.end)>0)
        throw new IllegalArgumentException(start + " after " + end)
}

注意：保護性拷貝是在檢查參數以前進行的，防止多線程的影響。不要使用clone方法進行保護性拷貝。

以上方法防護了傳入參數的修改，可是對於get方法獲取到的對象，仍然能夠被修改，經過如下方法能夠防止這種攻擊。

public Date start(){
    return new Date(start);
}

public Date end(){
    return new Date(end);
}

3九、謹慎設計方法簽名

40、慎用重載

4一、慎用可變參數

4二、返回0長度的數組或者集合，而不是null

null通常用於表示沒有被初始化或處理，若是方法返回了null，則須要在上層作更多的處理，以防止NPE。

4三、爲全部導出的API元素編寫文檔註釋

正確的javadoc文檔，須要每一個被導出的類、接口、構造器、方法和域以前增長文檔註釋。註釋應該是對實現透明的，只須要簡潔的描述它和客戶端之間的約定。而且，還應該附上該方法的反作用。

4四、將局部變量的做用域最小化

4五、for-each優先於for循環

for-each規避掉了for循環的index變量的引用，一般來講它是沒必要要的——會增長引入錯誤的風險，而且風險一旦發生，很難被發現。不過有三種狀況下，沒法使用for-each（注：在jdk1.8中已經很好的解決了這些問題）。

• 過濾

• 轉換

• 平行迭代

4六、若是須要精確的答案，請避免使用float和double

float和double是執行的二進制浮點運算，目的是在普遍數值範圍上使用精確的快速近似計算而設計的。然而他們並無提供徹底精確的計算（實際應用中，常常會碰到出現x.99999等結果）。尤爲是，在進行貨幣計算時，他們並不適用。好比：

System.out.println(1.03-.42);

獲得的結果將是：0.610000000001。

爲了解決這個問題，須要使用BigDecimal。然而這也有一些問題，相對於普通的運算，它顯得更加麻煩，並且也更慢。一般來講後一個缺點能夠忽略，可是前者可能會讓人很不舒服。有一種作法是將須要處理的數值*10(或更多），使用int進行計算，不過須要你本身處理四捨五入等操做。

4七、基本類型優先於裝箱基本類型

• 基本類型只有值，裝箱類具備與他們值不一樣的同一性。

• 基本類型只有功能完備的值，裝箱類還具備非功能值：null。因此你可能會碰到NPE

• 基本類型省空間省時間

4八、若是有更精確的類型，請避免使用字符串

• 字符串不適合代替其餘值的類型。例如：int，boolean等

• 不適合代替枚舉類型（第30條）

• 不適合彙集類型

4九、小心字符串鏈接的性能

操做符「+」能夠將多個字符串進行鏈接。可是在大規模使用「+」的狀況下，鏈接n個字符串的開銷是n的平房級時間。這是因爲字符串的不可變性致使的。在這種狀況下請使用StringBuilder進行鏈接。

50、經過接口引用對象

總結

最後，小編總結了2020面試題，這份面試題的包含的模塊分爲19個模塊，分別是： Java 基礎、容器、多線程、反射、對象拷貝、Java Web 、異常、網絡、設計模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM 。

關注個人公衆號：程序員白楠楠，獲取上述資料。