[[169562]]

在編程開發中，內存的占用是我們經常要面對的現實，通常的內存調優的方向就是盡量減少內存的占用。這其中避免創建不必要的對象是一項重要的方面。

Android設備不像PC那樣有著足夠大的內存，而且單個App占用的內存實際上是比較小的。所以避免創建不必要的對象對于Android開發尤為重要。

本文會介紹一些常見的避免創建對象的場景和方法，其中有些屬于微優化，有的屬于編碼技巧，當然也有確實能夠起到顯著效果的方法。

使用單例

單例是我們常用的設計模式，使用這種模式，我們可以只提供一個對象供全局調用。因此單例是避免創建不必要的對象的一種方式。

單例模式上手容易，但是需要注意很多問題，最重要的就是多線程并發的情況下保證單例的唯一性。當然方式很多，比如餓漢式，懶漢式double-check等。這里介紹一個很極客的書寫單例的方式。

 

public static class SingleInstance { 
    private SingleInstance() { 
    } 
 
   public static SingleInstance getInstance() { 
            return SingleInstanceHolder.sInstance; 
   } 
 
  private static class SingleInstanceHolder { 
            private static SingleInstance sInstance = new SingleInstance(); 
  } 
} 

 

在Java中，類的靜態初始化會在類被加載時觸發，我們利用這個原理，可以實現利用這一特性，結合內部類，可以實現上面的代碼，進行懶漢式創建實例。

避免進行隱式裝箱

自動裝箱是Java 5 引入的一個特性，即自動將原始類型的數據轉換成對應的引用類型，比如將int轉為Integer等。

這種特性，極大的減少了編碼時的瑣碎工作，但是稍有不注意就可能創建了不必要的對象了。比如下面的代碼

 

Integer sum = 0; 
  for (int i = 1000; i < 5000; i++) { 
        sum += i; 
} 

 

上面的代碼sum+=i可以看成sum = sum + i，但是+這個操作符不適用于Integer對象，首先sum進行自動拆箱操作，進行數值相加操作，***發生自動裝箱操作轉換成Integer對象。其內部變化如下

 

int result = sum.intValue() + i; 
Integer sum = new Integer(result); 

 

由于我們這里聲明的sum為Integer類型，在上面的循環中會創建將近4000個無用的Integer對象，在這樣龐大的循環中，會降低程序的性能并且加重了垃圾回收的工作量。因此在我們編程時，需要注意到這一點，正確地聲明變量類型，避免因為自動裝箱引起的性能問題。

另外，當將原始數據類型的值加入集合中時，也會發生自動裝箱，所以這個過程中也是有對象創建的。如有需要避免這種情況，可以選擇SparseArray,SparseBooleanArray,SparseLongArray等容器。

謹慎選用容器

Java和Android提供了很多編輯的容器集合來組織對象。比如ArrayList,ContentValues,HashMap等。

然而，這樣容器雖然使用起來方便，但也存在一些問題，就是他們會自動擴容，這其中不是創建新的對象，而是創建一個更大的容器對象。這就意味這將占用更大的內存空間。

以HashMap為例，當我們put key和value時，會檢測是否需要擴容，如需要則雙倍擴容

 

@Override 
public V put(K key, V value) { 
    if (key == null) { 
        return putValueForNullKey(value); 
    } 
    //some code here 
 
    // No entry for (non-null) key is present; create one 
    modCount++; 
    if (size++ > threshold) { 
        tab = doubleCapacity(); 
        index = hash & (tab.length - 1); 
    } 
    addNewEntry(key, value, hash, index); 
    return null; 
} 

 

關于擴容的問題，通常有如下幾種方法

• 預估一個較大的容量值，避免多次擴容
• 尋找替代的數據結構，確保做到時間和空間的平衡

用好LaunchMode

提到LaunchMode必然和Activity有關系。正常情況下我們在manifest中聲明Activity，如果不設置LaunchMode就使用默認的standard模式。

一旦設置成standard，每當有一次Intent請求，就會創建一個新的Activity實例。舉個例子，如果有10個撰寫郵件的Intent，那么就會創建10個ComposeMailActivity的實例來處理這些Intent。結果很明顯，這種模式會創建某個Activity的多個實例。

如果對于一個搜索功能的Activity，實際上保持一個Activity示例就可以了，使用standard模式會造成Activity實例的過多創建，因而不好。

確保符合常理的情況下，合理的使用LaunchMode，減少Activity的創建。

Activity處理onConfigurationChanged

這又是一個關于Activity對象創建相關的，因為Activity創建的成本相對其他對象要高很多。

默認情況下，當我們進行屏幕旋轉時，原Activity會銷毀，一個新的Activity被創建，之所以這樣做是為了處理布局適應。當然這是系統默認的做法，在我們開發可控的情況下，我們可以避免重新創建Activity。

以屏幕切換為例，在Activity聲明時，加上

 

<activity 
  android:name=".MainActivity" 
  android:configChanges="orientation" 
  android:label="@string/app_name" 
  android:theme="@style/AppTheme.NoActionBar"/> 

 

然后重寫Activity的onConfigurationChanged方法

 

@Override 
public void onConfigurationChanged(Configuration newConfig) { 
   super.onConfigurationChanged(newConfig); 
   if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) { 
        setContentView(R.layout.portrait_layout); 
     } else if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) { 
        setContentView(R.layout.landscape_layout); 
    } 
} 

 

注意字符串拼接

字符串這個或許是最不起眼的一項了。這里主要講的是字符串的拼接

 

Log.i(LOGTAG, "onCreate bundle=" + savedInstanceState); 

這應該是我們最常見的打log的方式了，然而字符串的拼接內部實際是生成StringBuilder對象，然后挨個進行append，直至***調用toString方法的過程。

下面是一段代碼循環的代碼，這明顯是很不好的，因為這其中創建了很多的StringBuilder對象。

 

public void implicitUseStringBuilder(String[] values) { 
        String result = ""; 
        for (int i = 0; i < values.length; i++) { 
            result += values[i]; 
        } 
        System.out.println(result); 
    } 

 

降低字符串拼接的方法有

• 使用String.format替換
• 如果是循環拼接，建議顯式在循環外部創建StringBuilder使用

減少布局層級

布局層級過多，不僅導致inflate過程耗時，還多創建了多余的輔助布局。所以減少輔助布局還是很有必要的。可以嘗試其他布局方式或者自定義視圖來解決這類的問題。

提前檢查，減少不必要的異常

異常對于程序來說，在平常不過了，然后其實異常的代碼很高的，因為它需要收集現場數據stacktrace。但是還是有一些避免異常拋出的措施的，那就是做一些提前檢查。

比如，我們想要打印一個文件的每一行字符串，沒做檢查的代碼如下，是存在FileNotFoundException拋出可能的。

 

private void printFileByLine(String filePath) { 
   try { 
      FileInputStream inputStream = new FileInputStream("textfile.txt"); 
      BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)); 
      String strLine; 
      //Read File Line By Line 
      while ((strLine = br.readLine()) != null) { 
          // Print the content on the console 
          System.out.println(strLine); 
      } 
        br.close(); 
    } catch (FileNotFoundException e) { 
       e.printStackTrace(); 
    } catch (IOException e) { 
        e.printStackTrace(); 
   } 
} 

 

如果我們進行文件是否存在的檢查，拋出FileNotFoundException的概率會減少很多，

 

private void printFileByLine(String filePath) { 
   if (!new File(filePath).exists()) { 
            return; 
   } 
    try { 
       FileInputStream inputStream = new FileInputStream("anonymous.txt"); 
       BufferedReader br = new BufferedReader(new InputStreamReader(inputStream)); 
       String strLine; 
      //Read File Line By Line 
       while ((strLine = br.readLine()) != null) { 
            // Print the content on the console 
           System.out.println(strLine); 
       } 
         br.close(); 
    } catch (FileNotFoundException e) { 
        e.printStackTrace(); 
    } catch (IOException e) { 
        e.printStackTrace(); 
   } 
} 

 

上述的檢查是一個不錯的編碼技巧，建議采納。

不要過多創建線程

在android中，我們應該盡量避免在主線程中執行耗時的操作，因而需要使用其他線程。

 

private void testThread() { 
    new Thread() { 
       @Override 
       public void run() { 
          super.run(); 
          //do some io work 
      } 
   }.start(); 
} 

 

雖然這些能工作，但是創建線程的代價遠比普通對象要高的多，建議使用HandlerThread或者ThreadPool做替換。

使用注解替代枚舉

枚舉是我們經常使用的一種用作值限定的手段，使用枚舉比單純的常量約定要靠譜。然后枚舉的實質還是創建對象。好在Android提供了相關的注解，使得值限定在編譯時進行，進而減少了運行時的壓力。相關的注解為IntDef和StringDef。

如下以IntDef為例，介紹如何使用

在一個文件中如下聲明

 

public class AppConstants { 
   public static final int STATE_OPEN = 0; 
   public static final int STATE_CLOSE = 1; 
   public static final int STATE_BROKEN = 2; 
 
   @IntDef({STATE_OPEN, STATE_CLOSE, STATE_BROKEN}) 
   public @interface DoorState { 
   } 
} 

 

然后設置書寫這樣的方法

 

private void setDoorState(@AppConstants.DoorState int state) { 
   //some code 
} 

 

當調用方法時只能使用STATE_OPEN，STATE_CLOSE和STATE_BROKEN。使用其他值會導致編譯提醒和警告。

選用對象池

在Android中有很多池的概念，如線程池，連接池。包括我們很長用的Handler.Message就是使用了池的技術。

比如，我們想要使用Handler發送消息，可以使用Message msg = new Message()，也可以使用Message msg = handler.obtainMessage()。使用池并不會每一次都創建新的對象，而是優先從池中取對象。

使用對象池需要需要注意幾點

• 將對象放回池中，注意初始化對象的數據，防止存在臟數據
• 合理控制池的增長，避免過大，導致很多對象處于閑置狀態

謹慎初始化Application

Android應用可以支持開啟多個進程。 通常的做法是這樣

 

<service 
   android:name=".NetworkService" 
   android:process=":network"/> 

 

通常我們在Application的onCreate方法中會做很多初始化操作,但是每個進程啟動都需要執行到這個onCreate方法,為了避免不必要的初始化,建議按照進程(通過判斷當前進程名)對應初始化.

 

public class MyApplication extends Application { 
   private static final String LOGTAG = "MyApplication"; 
 
     @Override 
     public void onCreate() { 
        String currentProcessName = getCurrentProcessName(); 
        Log.i(LOGTAG, "onCreate currentProcessName=" + currentProcessName); 
           super.onCreate(); 
           if (getPackageName().equals(currentProcessName)) { 
                //init for default process 
           } else if (currentProcessName.endsWith(":network")) { 
                //init for netowrk process 
           } 
     } 
 
    private String getCurrentProcessName() { 
        String currentProcessName = ""; 
        int pid = android.os.Process.myPid(); 
        ActivityManager manager = (ActivityManager) this.getSystemService(Context.ACTIVITY_SERVICE); 
        for (ActivityManager.RunningAppProcessInfo processInfo : manager.getRunningAppProcesses()) { 
            if (processInfo.pid == pid) { 
                    currentProcessName = processInfo.processName; 
                    break; 
            } 
       } 
      return currentProcessName; 
    } 
} 

 

上面的一些知識就是關于Android中如何避免創建多余對象的總結.歡迎提出意見和觀點,共同進步.