Android高效编程的一些知识

总结自以下文章：
http://flysnow.iteye.com/blog/914259
http://blog.csdn.net/biaobiaoqi/article/details/6732401
http://blog.csdn.net/biaobiaoqi/article/details/6741417
http://www.thinksaas.cn/group/topic/204795/
http://www.docin.com/p-331786692.html
http://www.csdn.net/article/2009-08-03/265358

对于Android平台这类嵌入式设备来说编写代码时要时刻考虑执行的效率。这些系统不是想象中的那么快，并且你还要考虑它的续航能力。这就意味着没有多少剩余空间给你去浪费了，因此，在你写Android程序的时候，要尽可能的使你的代码优化而提高效率。
如何编写高效的Android程序，网上已经有很多资料，在学习中做了一些汇总如下：
对于如何判断一个系统的不合理，这里有两个基本的原则：

1. 不要做不必要的事情
2. 尽可能的节省内存的使用

尽可能避免创建对象

对象的创建并不是没有代价的。如果你在一个用户界面的循环中分配一个对象，你不得不强制的进行内存回收，这么就会可能使系统出现卡顿的现象。
因此，如果没有必要你就不应该创建对象实例。
比如：当从原始的输入数据中提取字符串时，试着从原始字符串返回一个子字符串，而不是创建一份拷贝。你将会创建一个新的字符串对象，但是它和你的原始数据共享数据空间。
尽量使用StringBuffer来处理字符串：
如果你有一个返回字符串的方法，你应该知道无论如何返回的结果是StringBuffer，改变你的函数的定义和执行，让函数直接返回而不是通过创建一个临时的对象。
尽量
一个比较激进的方法就是把一个多维数组分割成几个平行的一维数组：
一个int类型的数组要比一个Integer类型的数组要好，但同样也可以归纳这样一个原则，两个int类型的数组要比一个（int，int）对象数组的效率要高的多，。对于其他原始数据类型，这个原则同样适用。对象也是这样。
一般来说，尽可能的避免创建短期的临时对象。越少的对象创建意味着越少的垃圾回收，这会提高你程序的用户体验。

使用本地方法

当你在处理字串的时候，不要吝惜使用String.indexOf(), String.lastIndexOf()等特殊实现的方法（specialty methods）。这些方法都是使用C/C++实现的，比起Java循环快10到100倍。
这些自身方法使用的代价要比那些解释过的方法高很多，因而，对于细微的运算，尽量不用这类方法。

使用实类比接口好

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

        Map map1 = new HashMap<>();        HashMap map2 = new HashMap<>();

哪个更好呢？
按照传统的观点Map会更好些，因为这样你可以改变他的具体实现类，只要这个类继承自Map接口。但调用一个接口的引用会比调用实体类的引用多花费一倍的时间。如果HashMap完全适合你的程序，那么使用Map就没有什么价值。如果有些地方你不能确定，先避免使用Map，剩下的交给IDE提供的重构功能好了。(当然公共API是一个例外：一个好的API常常会牺牲一些性能）

用静态方法比虚方法好

如果你不需要访问一个对象的成员变量，那么请把方法声明成static。静态方法执行的更快，因为它可以被直接调用而不需要一个虚函数表。另外你也可以通过声明体现出这个函数的调用不会改变对象的状态。

不用getter和setter

在很多本地语言如C++中，都会使用getter（比如：i = getCount()）来避免直接访问成员变量（i = mCount）。在C++中这是一个非常好的习惯，因为编译器能够内联访问，如果你需要约束或调试变量，你可以在任何时候添加代码。在Android上，这就不是个好主意了。虚方法的开销比直接访问成员变量大得多，比实例属性查询的代价还要多。在通用的接口定义中，可以依照OO的方式定义getters和setters，但是在一般的类中，你应该直接访问变量。我们可以在外部调用时使用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的第二个条件中调用任何方法。如下面方法所示，在每次循环的时候都会调用getCount()方法，这样做比你在一个int先把结果保存起来开销大很多。

for (int i = 0; i < this.getCount(); i++)dumpItems(this.getItem(i));

同样如果你要多次访问一个变量，也最好先为它建立一个本地变量。另外就是方法的参数与本地变量的效率相同。

使用常量

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

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

必以其会生成一个叫做的初始化类的方法，当类第一次被使用的时候这个方法会被执行。方法会将42赋给intVal，然后把一个指向类中常量表的引用赋给strVal。当以后要用到这些值的时候，会在成员变量表中查找到他们。下面我们做些改进，使用“final”关键字：

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

现在，类不再需要方法，因为在成员变量初始化的时候，会将常量直接保存到类文件中。用到intVal的代码被直接替换成42，而使用strVal的会指向一个字符串常量，而不是使用成员变量。将一个方法或类声明为”final”不会带来性能的提升，但是会帮助编译器优化代码。举例说，如果编译器知道一个”getter”方法不会被重载，那么编译器会对其采用内联调用。你也可以将本地变量声明为”final”，同样，这也不会带来性能的提升。使用”final”只能使本地变量看起来更清晰些（但是也有些时候这是必须的，比如在使用匿名内部类的时候）

谨慎使用foreach

foreach可以用在实现了Iterable接口的集合类型上。foreach会给这些对象分配一个iterator，然后调用 hasNext()和next()方法。你最好使用foreach处理ArrayList对象，但是对其他集合对象，foreach相当于使用 iterator。
foreach语法在运用于array时性能很好，但是运用于其他集合对象时要小心，因为它会产生额外的对象。

避免使用枚举

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

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

会产生一个900字节的.class文件(FooShubbery.class)。在它被首次调用时，这个类会调用初始化方法来准备每个枚举变量。每个枚举项都会被声明成一个静态变量，并被赋值。然后将这些静态变量放在一个名为"VALUES”的静态数组变量中。而这么一大堆代码，仅仅是为了使用三个整数。
这样:Shrubbery shrub = Shrubbery.GROUND;会引起一个对静态变量的引用，如果这个静态变量是final int，那么编译器会直接内联这个常数。
一方面说，使用枚举变量可以让你的API更出色，并能提供编译时的检查。所以在通常的时候你毫无疑问应该为公共API选择枚举变量。但是当性能方面有所限制的时候，你就应该避免这种做法了。
下面是一种在Android编程中使用int来实现enum的效果：

    private final static int TEST_TYPE_0 = 0;    private final static int TEST_TYPE_1 = 1;    @IntDef({TEST_TYPE_0,TEST_TYPE_1})    @Retention(RetentionPolicy.SOURCE)    public @interface TestType{}    private @TestType int type;    ……    type = TEST_TYPE_0;

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

请看下面的类定义：

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);}}

这其中的关键是，我们定义了一个内部类(FooInner)，它需要访问外部类的私有域变量和函数。这是合法的，并且会打印出我们希望的结果”Valueis27”。问题是在技术上来讲（在幕后）FooInner是一个完全独立的类，它要直接访问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”的运算都是通过软件实现的。一些基本的浮点运算，甚至需要毫秒级的时间才能完成。
甚至是整数，一些芯片有对乘法的硬件支持而缺少对除法的支持。这种情况下，整数的除法和取模运算也是有软件来完成的。所以当你在使用哈希表或者做大量数学运算时一定要小心谨慎。