高效率Android代码

• Introduction
• Avoid Creating Objects
• Use Native Methods
• Prefer Virtual Over Interface
• Prefer Static Over Virtual
• Avoid Internal Getters/Setters
• Cache Field Lookups
• Declare Constants Final
• Use Enhanced For Loop Syntax With Caution
• Avoid Enums
• Use Package Scope with Inner Classes
• Avoid Float
• Some Sample Performance Numbers
• Closing Notes

Introduction

• Don't do work that you don't need to do.
• Don't allocate memory if you can avoid it.

Avoid Creating Objects

• When extracting strings from a set of input data, try to return a substring of the original data, instead of creating a copy. You will create a new String object, but it will share the char[] with the data.
• If you have a method returning a string, and you know that its result will always be appended to a StringBuffer anyway, change your signature and implementation so that the function does the append directly, instead of creating a short-lived temporary object.

• An array of ints is a much better than an array of Integers, but this also generalizes to the fact that two parallel arrays of ints are also a?lot?more efficient than an array of (int,int) objects. The same goes for any combination of primitive types.
• If you need to implement a container that stores tuples of (Foo,Bar) objects, try to remember that two parallel Foo[] and Bar[] arrays are generally much better than a single array of custom (Foo,Bar) objects. (The exception to this, of course, is when you're designing an API for other code to access; in those cases, it's usually better to trade correct API design for a small hit in speed. But in your own internal code, you should try and be as efficient as possible.)

Use Native Methods

Prefer Virtual Over Interface

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

Prefer Static Over Virtual

Avoid Internal Getters/Setters

Cache Field Lookups

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

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

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

Declare Constants Final

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

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

Use Enhanced For Loop Syntax With Caution

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

Avoid Enums

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

Shrubbery shrub = Shrubbery.GROUND;

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
   }

Use Package Scope with Inner Classes

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

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

Avoid Float

Some Sample Performance Numbers

Closing Notes