一、对常量使用静态 final
下面是位于类顶部的声明：
static int intVal = 42;
static String strVal = "Hello, world!";
编译器会生成一个名为 <clinit> 的类初始化器方法，当第一次使用该类时，系统会执行此方法。此方法会将值 42 存储到 intVal，并从类文件字符串常量表中提取 strVal 的引用。以后引用这些值时，可以通过查询字段访问它们。
我们可以使用“final”关键字加以改进：
static final int intVal = 42;
static final String strVal = "Hello, world!";此类不再需要 <clinit> 方法，因为常量会进入 dex 文件中的静态字段初始化器。引用 intVal 的代码将直接使用整数值 42，并且对 strVal 的访问将使用成本相对较低的“字符串常量”指令，而非字段查询。
注意：此优化仅适用于原语类型和 String 常量，不适用于任意引用类型。尽管如此，最好还是尽可能声明常量 static final。
二、增强型 for 循环使用场所
对于实现 Iterable 接口的集合以及数组，可以使用增强型 for 循环（有时也称为“for-each”循环）。对于集合，系统会分配迭代器以对 hasNext() 和 next() 进行接口调用。对于 ArrayList，手写计数循环的速度快约 3 倍（有或没有 JIT），但对于其他集合，增强型 for 循环语法与使用显式迭代器完全等效。
遍历数组有以下几种替代方案：
static class Foo {
int splat;
}
Foo[] array = ...
public void zero() {
int sum = 0;
for (int i = 0; i < array.length; ++i) {
sum += array[i].splat;
}
}
public void one() {
int sum = 0;
Foo[] localArray = array;
int len = localArray.length;
for (int i = 0; i < len; ++i) {
sum += localArray[i].splat;
}
}
public void two() {
int sum = 0;
for (Foo a : array) {
sum += a.splat;
}
}
zero() 速度最慢，因为 JIT 还无法消除每次循环迭代都要获取数组长度这项成本。
one() 速度更快。它会将所有内容都提取到局部变量中，避免查询。只有数组长度方面具有性能优势。
对于没有 JIT 的设备，two() 速度最快；对于具有 JIT 的设备，two() 与 one() 速度难以区分。two() 使用了在 1.5 版 Java 编程语言中引入的增强型 for 循环语法。
因此，应默认使用增强型 for 循环，但对于性能关键型 ArrayList 迭代，不妨考虑使用手写计数循环。
提示：另请参阅 Josh Bloch 的《Effective Java》第 46 条。
三、对于私有内部类，考虑使用包访问权限，而非私有访问权限
请查看以下类定义：
public class Foo {
private class Inner {
void stuff() {
Foo.this.doStuff(Foo.this.mValue);
}
}
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);
}
}对于上述代码，需要注意的是，我们定义了一个私有内部类 (Foo$Inner)，它会直接访问外部类中的私有方法和私有实例字段。这是合乎规则的，并且代码会按预期输出“Value is 27”。
问题在于，虚拟机认为从 Foo$Inner 直接访问 Foo 的私有成员不符合规则，因为 Foo 和 Foo$Inner 属于不同的类，虽然 Java 语言允许内部类访问外部类的私有成员。为了消除这种差异，编译器会生成一些合成方法：
/*package*/ static int Foo.access$100(Foo foo) {
return foo.mValue;
}
/*package*/ static void Foo.access$200(Foo foo, int value) {
foo.doStuff(value);
}javac Foo.java后，在执行javap -verbose Foo.class，可以看到在Foo类中确实由编译器帮助生成了辅助方法，以访问到外部类中的私有成员变量MValue，以及私有方法doStuff（）
每当需要访问外部类中的 mValue 字段或调用外部类中的 doStuff() 方法时，内部类代码就会调用这些静态方法。这意味着以上代码实际上可以归结为一种情况，那就是您通过访问器方法访问成员字段。之前我们讨论了访问器的速度比直接访问字段要慢，因此这是一个特定习惯用语会对性能产生“不可见”影响的示例。
如果您在性能关键位置 (hotspot) 使用这样的代码，则可以将内部类访问的字段和方法声明为拥有包访问权限（而非私有访问权限），从而避免产生相关开销。遗憾的是，这意味着同一软件包中的其他类可以直接访问这些字段，因此不应在公共 API 中使用此方法。
四、避免枚举，浮点数的使用。
- 使用自定义注解代替枚举
单个枚举会使应用的 classes.dex 文件增加大约 1.0 到 1.4KB 的大小。这些增加的大小会快速累积，产生复杂的系统或共享库。如果可能，请考虑使用 @IntDef 注释和代码缩减移除枚举并将它们转换为整数。此类型转换可保留枚举的各种安全优势。
日常我们使用枚举来定义一些常量的取值，使用枚举能够确保参数的安全性。但是Android开发文档上指出，使用枚举会比使用静态变量多消耗两倍的内存，应该尽量避免在Android中使用枚举，那么枚举为什么会更消耗内存呢？下面一起分析一下。
public enum Sex {
MAN, WOMAN;
}从反编译的代码来看，我们定义的枚举，编译器会将其转换成一个类，这个类继承自java.lang.Enum类，除此之外，编译器还会帮我们生成多个枚举类的实例，赋值给我们定义的枚举类型常量，并且还声明了一个枚举对象的数组，保存了所有的枚举对象。下面我们分别来计算一下采用静态变量和枚举占用内存的大小对比。
下面是反编译后的枚举类文件，可以看到明显比我们想象中的要占用更多内存空间：
public final class Sex extends Enum {
public static Sex[] values()
{
return (Sex[])$VALUES.clone();
}
public static Sex valueOf(String s)
{
return (Sex)Enum.valueOf(com/liunian/androidbasic/enumtest/Sex, s);
}
private Sex(String s, int i)
{
super(s, i);
}
public static final Sex MAN;
public static final Sex WOMAN;
private static final Sex $VALUES[];
static
{
MAN = new Sex("MAN", 0);
WOMAN = new Sex("WOMAN", 1);
$VALUES = (new Sex[] {
MAN, WOMAN
});
}
}枚举占用内存的大小比静态变量多得多，枚举类型数据的内存优化，使用注解的方案。
- 避免使用浮点数
一般来讲，在 Android 设备上，浮点数要比整数慢约 2 倍。
在速度方面，float 和 double 在更现代的硬件上没有区别。在空间方面，double 所占空间大 2 倍。对于台式机，假定空间不是问题，您应该优先使用 double，而非 float。
此外，即使对于整数，某些处理器拥有硬件乘法器，却缺少硬件除法器。在这种情况下，整数的除法和取模运算会在软件中执行；如果您要设计哈希表或要进行大量数学运算，则需要考虑这一点。