如何编写高效的Android代码

现代的手持设备，与其说是电话，更像一台拿在手中的电脑。可是，即便是“最快”的手持设备，其性能也赶不上一台普通的台式电脑。

这就是为何咱们在书写Android应用程序的时候要格外关注效率。这些设备并无那么快，而且受电池电量的制约。这意味着，设备没有更多的能力，咱们必须把程序写的尽可能有效。

本文讨论了不少能让开发者使他们的程序运行更有效的方法，遵守这些方法，你可使你的程序发挥最大的效力。

简介

对于占用资源的系统，有两条基本原则：

不要作没必要要的事
不要分配没必要要的内存

全部下面的内容都遵守这两个原则。

有些人可能立刻会跳出来，把本节的大部份内容归于“草率的优化”（xing:参见[The Root of All Evil]），不能否认微优化（micro-optimization。xing:代码优化，相对于结构优化）的确会带来不少问题，诸如没法使用更有效的数据结构和算法。可是在手持设备上，你别无选择。假如你认为Android虚拟机的性能与台式机至关，你的程序颇有可能一开始就占用了系统的所有内存（xing:内存很小），这会让你的程序慢得像蜗牛同样，更遑论作其余的操做了。

Android的成功依赖于你的程序提供的用户体验。而这种用户体验，部分依赖于你的程序是响应快速而灵活的，仍是响应缓慢而僵化的。由于全部的程序都运行在同一个设备之上，都在一块儿，这就若是在同一条路上行驶的汽车。而这篇文档就至关于你在取得驾照以前必需要学习的交通规则。若是你们都按照这些规则去作，驾驶就会很顺畅，可是若是你不这样作，你可能会车毁人亡。这就是为何这些原则十分重要。

当咱们开门见山、直击主题以前，还必需要提醒你们一点：无论VM是否支持实时（JIT）编译器（xing:它容许实时地将Java解释型程序自动编译成本机机器语言，以使程序执行的速度更快。有些JVM包含JIT编译器。），下面提到的这些原则都是成立的。假如咱们有目标彻底相同的两个方法，在解释执行时foo()比bar()快，那么编译以后，foo()依然会比bar()快。因此不要寄但愿于编译器能够拯救你的程序。

 

避免创建对象

世界上没有免费的对象。虽然GC为每一个线程都创建了临时对象池，可使建立对象的代价变得小一些，可是分配内存永远都比不分配内存的代价大。

若是你在用户界面循环中分配对象内存，就会引起周期性的垃圾回收，用户就会以为界面像打嗝同样一顿一顿的。

因此，除非必要，应尽可能避免尽力对象的实例。下面的例子将帮助你理解这条原则：

当你从用户输入的数据中截取一段字符串时，尽可能使用substring函数取得原始数据的一个子串，而不是为子串另外创建一份拷贝。这样你就有一个新的String对象，它与原始数据共享一个char数组。
若是你有一个函数返回一个String对象，而你确切的知道这个字符串会被附加到一个StringBuffer，那么，请改变这个函数的参数和实现方式，直接把结果附加到StringBuffer中，而不要再创建一个短命的临时对象。
一个更极端的例子是，把多维数组分红多个一维数组。

int数组比Integer数组好，这也归纳了一个基本事实，两个平行的int数组比(int,int)对象数组性能要好不少。同理，这试用于全部基本类型的组合。
若是你想用一种容器存储(Foo,Bar)元组，尝试使用两个单独的Foo[]数组和Bar[]数组，必定比(Foo,Bar)数组效率更高。（也有例外的状况，就是当你创建一个API，让别人调用它的时候。这时候你要注重对API借口的设计而牺牲一点儿速度。固然在API的内部，你仍要尽量的提升代码的效率）

整体来讲，就是避免建立短命的临时对象。减小对象的建立就能减小垃圾收集，进而减小对用户体验的影响。

使用本地方法

当你在处理字串的时候，不要吝惜使用String.indexOf(), String.lastIndexOf()等特殊实现的方法（specialty methods）。这些方法都是使用C/C++实现的，比起Java循环快10到100倍。

使用实类比接口好

假设你有一个HashMap对象，你能够将它声明为HashMap或者Map:

Map myMap1 = new HashMap();
HashMap myMap2 = new HashMap();

　　哪一个更好呢？

按照传统的观点Map会更好些，由于这样你能够改变他的具体实现类，只要这个类继承自Map接口。传统的观点对于传统的程序是正确的，可是它并不适合嵌入式系统。调用一个接口的引用会比调用实体类的引用多花费一倍的时间。

若是HashMap彻底适合你的程序，那么使用Map就没有什么价值。若是有些地方你不能肯定，先避免使用Map，剩下的交给IDE提供的重构功能好了。(固然公共API是一个例外：一个好的API经常会牺牲一些性能）

用静态方法比虚方法好

若是你不须要访问一个对象的成员变量，那么请把方法声明成static。虚方法执行的更快，由于它能够被直接调用而不须要一个虚函数表。另外你也能够经过声明体现出这个函数的调用不会改变对象的状态。

不用getter和setter

在不少本地语言如C++中，都会使用getter（好比：i = getCount()）来避免直接访问成员变量（i = mCount）。在C++中这是一个很是好的习惯，由于编译器可以内联访问，若是你须要约束或调试变量，你能够在任什么时候候添加代码。

在Android上，这就不是个好主意了。虚方法的开销比直接访问成员变量大得多。在通用的接口定义中，能够依照OO的方式定义getters和setters，可是在通常的类中，你应该直接访问变量。

将成员变量缓存到本地

访问成员变量比访问本地变量慢得多，下面一段代码：

for (int i = 0; i < this.mCount; i++)dumpItem(this.mItems[i]);　

最好改为这样：

int count = this.mCount;

Item[] items = this.mItems;
for (int i = 0; i < count; i++)dumpItems(items[i]);

　　（使用"this"是为了代表这些是成员变量）

另外一个类似的原则是：永远不要在for的第二个条件中调用任何方法protected void drawHorizontalScrollBar(Canvas canvas, int width, int height) {

if (isHorizontalScrollBarEnabled()) {
        int size = mScrollBar.getSize(false);
        if (size <= 0) {
         size = mScrollBarSize;
        }
        mScrollBar.setBounds(0, height - size, width, height);
        mScrollBar.setParams(computeHorizontalScrollRange(),computeHorizontalScrollOffset(),computeHorizontalScrollExtent(), false);
        mScrollBar.draw(canvas);
    }
}

　　这里有4次访问成员变量mScrollBar，若是将它缓存到本地，4次成员变量访问就会变成4次效率更高的栈变量访问。

另外就是方法的参数与本地变量的效率相同。

使用常量

让咱们来看看这两段在类前面的声明：

 

static int intVal = 42;
static String strVal = "Hello, world!";

　

必以其会生成一个叫作的初始化类的方法，当类第一次被使用的时候这个方法会被执行。方法会将42赋给intVal，而后把一个指向类中常量表的引用赋给strVal。当之后要用到这些值的时候，会在成员变量表中查找到他们。

下面咱们作些改进，使用“final"关键字：

 static final int intVal = 42;

static final String strVal = "Hello, world!";

　　如今，类再也不须要<clinit>方法，由于在成员变量初始化的时候，会将常量直接保存到类文件中。用到intVal的代码被直接替换成42，而使用strVal的会指向一个字符串常量，而不是使用成员变量。

将一个方法或类声明为"final"不会带来性能的提高，可是会帮助编译器优化代码。举例说，若是编译器知道一个"getter"方法不会被重载，那么编译器会对其采用内联调用。

你也能够将本地变量声明为"final"，一样，这也不会带来性能的提高。使用"final"只能使本地变量看起来更清晰些（可是也有些时候这是必须的，好比在使用匿名内部类的时候）（xing:原文是 or you have to, e.g. for use in an anonymous inner class）

谨慎使用foreach

foreach能够用在实现了Iterable接口的集合类型上。foreach会给这些对象分配一个iterator，而后调用 hasNext()和next()方法。你最好使用foreach处理ArrayList对象，可是对其余集合对象，foreach至关于使用 iterator。

下面展现了foreach一种可接受的用法：

 

public class Foo {
    int mSplat;
    static Foo mArray[] = new Foo[27];
    public static void zero() {
        int sum = 0;
        for (int i = 0; i < mArray.length; i++) {
            sum += mArray[i].mSplat;
        }
    }
    public static void one() {
        int sum = 0;
        Foo[] localArray = mArray;
        int len = localArray.length;
        for (int i = 0; i < len; i++) {
            sum += localArray[i].mSplat;
        }
    }
    public static void two() {
        int sum = 0;
        for (Foo a: mArray) {sum += a.mSplat;}
    }
}

在zero()中，每次循环都会访问两次静态成员变量，取得一次数组的长度。

retrieves the static field twice and gets the array length once for every iteration through the loop.

在one()中，将全部成员变量存储到本地变量。 pulls everything out into local variables, avoiding the lookups.

two()使用了在java1.5中引入的foreach语法。编译器会将对数组的引用和数组的长度保存到本地变量中，这对访问数组元素很是好。可是编译器还会在每次循环中产生一个额外的对本地变量的存储操做（对变量a的存取）这样会比one()多出4个字节，速度要稍微慢一些。

综上所述：foreach语法在运用于array时性能很好，可是运用于其余集合对象时要当心，由于它会产生额外的对象。

避免使用枚举

枚举变量很是方便，但不幸的是它会牺牲执行的速度和并大幅增长文件体积。例如：

public class Foo {public enum Shrubbery { GROUND, CRAWLING, HANGING }}

会产生一个900字节的.class文件(Foo$Shubbery.class)。在它被首次调用时，这个类会调用初始化方法来准备每一个枚举变量。每一个枚举项都会被声明成一个静态变量，并被赋值。而后将这些静态变量放在一个名为"$VALUES"的静态数组变量中。而这么一大堆代码，仅仅是为了使用三个整数。

这样:

Shrubbery shrub = Shrubbery.GROUND;会引发一个对静态变量的引用，若是这个静态变量是final int，那么编译器会直接内联这个常数。

一方面说，使用枚举变量可让你的API更出色，并能提供编译时的检查。因此在一般的时候你毫无疑问应该为公共API选择枚举变量。可是当性能方面有所限制的时候，你就应该避免这种作法了。

有些状况下，使用ordinal()方法获取枚举变量的整数值会更好一些，举例来讲，将：

 

for (int n = 0; n < list.size(); n++) {
    if (list.items[n].e == MyEnum.VAL_X) {
        // do stuff 1
    }
    else if (list.items[n].e == MyEnum.VAL_Y) {
        // do stuff 2
    }
}

替换为:

 

int valX = MyEnum.VAL_X.ordinal();
int valY = MyEnum.VAL_Y.ordinal();
int count = list.size();
MyItem items = list.items();
for (int n = 0; n < count; n++) {
    int valItem = items[n].e.ordinal();
    if (valItem == valX) {
     // do stuff 1
    }
    else if (valItem == valY) {
     // do stuff 2
    }
}

　会使性能获得一些改善，但这并非最终的解决之道。

将与内部类一同使用的变量声明在包范围内

请看下面的类定义：

 

public class Foo {
    private int mValue;
    public void run() {
        Inner in = new Inner();
        mValue = 27;
        in.stuff();
    }
    private void doStuff(int value) {
     System.out.println("Value is " + value);
    }
    private class Inner {void stuff() {
     Foo.this.doStuff(Foo.this.mValue);
    }
}

　　这其中的关键是，咱们定义了一个内部类(Foo$Inner)，它须要访问外部类的私有域变量和函数。这是合法的，而且会打印出咱们但愿的结果"Value is 27"。

问题是在技术上来说（在幕后）Foo$Inner是一个彻底独立的类，它要直接访问Foo的私有成员是非法的。要跨越这个鸿沟，编译器须要生成一组方法：

 

static int Foo.access$100(Foo foo) {
 return foo.mValue;
}
static void Foo.access$200(Foo foo, int value) {
 foo.doStuff(value);
}

　　内部类在每次访问"mValue"和"doStuff"方法时，都会调用这些静态方法。就是说，上面的代码说明了一个问题，你是在经过接口方法访问这些成员变量和函数而不是直接调用它们。在前面咱们已经说过，使用接口方法（getter、setter）比直接访问速度要慢。因此这个例子就是在特定语法下面产生的一个“隐性的”性能障碍。

经过将内部类访问的变量和函数声明由私有范围改成包范围，咱们能够避免这个问题。这样作可让代码运行更快，而且避免产生额外的静态方法。（遗憾的是，这些域和方法能够被同一个包内的其余类直接访问，这与经典的OO原则相违背。所以当你设计公共API的时候应该谨慎使用这条优化原则）

避免使用浮点数

在奔腾CPU出现以前，游戏设计者作得最多的就是整数运算。随着奔腾的到来，浮点运算处理器成为了CPU内置的特性，浮点和整数配合使用，可以让你的游戏运行得更顺畅。一般在桌面电脑上，你能够随意的使用浮点运算。

可是很是遗憾，嵌入式处理器一般没有支持浮点运算的硬件，全部对"float"和"double"的运算都是经过软件实现的。一些基本的浮点运算，甚至须要毫秒级的时间才能完成。

甚至是整数，一些芯片有对乘法的硬件支持而缺乏对除法的支持。这种状况下，整数的除法和取模运算也是有软件来完成的。因此当你在使用哈希表或者作大量数学运算时必定要当心谨慎。