一、安卓上的类型安全枚举

public class Machine {
    public static final int STOPPED = 10;
    public static final int INITIALIZING = 20;
    public static final int STARTING = 30;
    public static final int RUNNING = 40;
    public static final int STOPPING = 50;
    public static final int CRASHED = 60;
    private int mState;
    public Machine() {
        mState = STOPPED;
    }
    public int getState() {
        return mState;
    }
    public void setState(int state) {
        mState = state;
    }
}

问题：虽然这些常量是期望的，但是没有方法保证setState()方法接收其他的值。如果
要在设置方法中添加检查，那么一旦得到的是非预期值，开发者就需要处理错误。开发者所需要的是在编译时检查非法赋值。类型安全的枚举解决了这个问题，如下所示：

public class Machine {
    public enum State {
        STOPPED, INITIALIZING, STARTING, RUNNING, STOPPING, CRASHED
    }
    private State mState;
    public Machine() {
        mState = State.STOPPED;
    }
    public State getState() {
        return mState;
    }
    public void setState(State state) {
        mState = state;
    }
}

注意在声明不同类型安全值的地方新加的内部枚举类。这在编译时就会解决非法赋值的问题，所以代码更不容易出错。
Android早期的版本中不建议使用枚举类型，因为和使用整型常量相比，这种设计带来的内存和性能损失更大。如今有了更强的JIT编译器以及一个不断改进的Dalvik虚拟机，开发者不必再担心这个问题，放心大胆地使用类型安全枚举即可。

二、增强for循环

void loopOne(String[] names){
    int size = names.length;
    for(int i=0;i<size;i++){
         printName(names[i]); 
    }
}

void loopTwo(String[] names){
    for(String name:names){
        printName(name);
    }
}

void loopThree(Collection<String> names){
    for(String name:names){
        printName(name);
    }  
}

void loopFour(Collection<String> names){
    Iterator<String> iterator = names.iterator();
    while(iterator.hasNext()){
        printName(iterator.next());
    }
}

// 不要在ArrayList上使用增强版的for循环
void loopFive(ArrayList<String> names){
    int size = names.size();
    for(int i=0;i<size;i++){
        printName(names[i]);
    }
}

如果只是读取元素的话，可以放心地对数组使用增强版 for 循环。对 Collection 对象来说，增强版 for 循环和使用迭代器遍历元素有着相同的性能。 ArrayList 对象应避免使用增强版 for 循环。
如果不仅需要遍历元素，而且需要元素的位置，就一定要使用数组或者 ArrayList ，因为所有其他 Collection 类在这些情况下会更慢。
一般情况下，如果在读取元素几乎不变的数据集时对性能要求很高，建议使用常规数组。

三、队列、同步和锁

1. 更智能的队列

LinkedBlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>();

上面的一行代码能提供阻塞队列，甚至能提供额外的线程安全操作。java.util.concurrent包含许多可选的队列以及并发映射类，所以，一般情况下，建议使用它们。

2.更智能的锁

Java提供的 synchronized 关键字允许开发者创建线程安全的方法和代码块。synchronized关键字易于使用，也很容易滥用，对性能造成负面影响。当需要区分读数据和写数据时，synchronized 关键字并不是最有效的。幸好，java.util.concurrent.locks包中的工具类对这种情况提供了很好的支持。

public class ReadWriteLockDemo(){
    private final ReentrantReadWriteLock mLock;
    private String mName;
    private int mAge;
    private String mAddress;

    public ReadWriteLockDemo(){
        mLock = new ReentrantReadWriteLock();
    }

    public void setPersonData(String name, int age, String address){
        ReentrantReadWriteLock.WriteLock writeLock = mLock.writeLock();
        try{
            writeLock.lock();
            mName = name;
            mAge = age;
            mAddress = address;
        }finally{
            writeLock.unlock();
        }
    }

    public String getName() {
        ReentrantReadWriteLock.ReadLock readLock = mLock.readLock();
        try {
            readLock.lock();
            return mName;
        } finally {
            readLock.unlock();
        }
    }
// 重复代码不再赘述
}

上面的代码展示了在什么地方使用 ReentrantReadWriteLock ，它允许多个并发线程对数据进行只读访问，并确保同一时间只有一个线程写入相同的数据。
在代码中使用 synchronized 关键字仍然是处理锁问题的有效方法，但无论何种情况下，都要考虑 ReentrantReadWriteLock 是否是更有效的解决方案。

四、管理和分配内存

1. 应尽可能避免在循环中分配对象

2. 有时候无法避免在循环中创建对象，所以还需要采用某种方法处理这种情况。本书的解决方案是使用一个静态工厂方法按需分配对象，Joshua Bloch在《Effective Java中文版》一书的第一条中详细地描述了该方法。

public final class Pair{
    public int firstValue;
    public int secondValue;

    //引用对象池中的另一个对象
    private Pair next;

    //同步锁
    private static final Object sPoolSync = new Object();
    //对象池中第一个可用对象
    private static Pair sPool;

    private static int sPoolSize = 0;
    private static final int MAX_POOL_SIZE = 50;

    /**
    * 只能用obtain()方法获取对象
    */
    private Pair() { }

    /**
    * 返回回收的对象或者当对象池为空时创建一个新对象
    */
    public static Pair obtain(){
        synchronized(sPoolSync){
            if(sPool != null){
                Pair m = sPool;
                sPool.next = m.next;
                m.next = null;
                sPoolSize --;
                return m;
            }
        }
        return new Pair();
    }

    /**
    * 回收该对象。调用该方法后需要释放所有对该实例的引用
    */
    public void recycle(){
        synchronized(sPoolSync){
            if(sPoolSize < MAX_POOL_SIZE){
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
}

注意，本例增加了多个字段，有静态的也有非静态的。可使用这些字段实现传统的 Pair 对象链表。通过使用私有构造函数来防止在类外面创建对象，只能通过 obtain 方法创建该类的对象。 obtain 方法首先会检查对象池中是否包含任何存在的对象，并删除列表中的第一个元素然后返回它。如果对象池为空， obtain 方法会创建一个新的对象。要把对象重新放回池中，需要在使用完该对象时，对它调用 recycle 方法。这时，不能再有对该对象的引用。
另外，由于 obtain 和 recycle 是线程安全的，可以在多个并发线程中安全地使用这两个方法。唯一的缺点是，必须记住要手动调用 recycle 方法，不过这是一个很小的代价。