[Change] the preparation of efficient Android code

分类:Mobile 2010-04-02 来源:CodeWeblog.com 人气:426

Android write efficient code

There is no doubt that devices based on Android platform must be embedded devices. Modern handheld devices is not just a simple phone, it is a small handheld computer, but even the fastest of the most high-end handheld devices far smaller than a medium-performance desktop machine.

This is why the procedure in the preparation of Android moment when consider implementing Di efficiency, these systems Bushixiangxiang in the so fast, Bingju you consider Ta Hai Yao Neng Li battery's life. This means that there is little space left for you to go to waste, so, in the process when you write Android to make your code as possible while optimizing efficiency.

This page describes several Android allows developers to run a more efficient way. Some jump through the following link, you can learn how to make your program run more efficiently


  • Introduction
  • To avoid creating an object
  • Use their own methods
  • Better than the use of virtual interfaces
  • Better than using a static virtual
  • Avoid internal use Setter and Getter
  • Buffer attribute called
  • Final statement of constant
  • Prudent use of enhanced For loop
  • Avoid Enums to avoid the type listed
  • Package through the use of space within the joint class
  • Avoid floating-point type
  • Comparison of some of the standard operation of the time
  • Conclusion


How to determine a system for the irrational, there are two basic principles:

  • Do not do unnecessary things to do.
  • As much as possible to save memory usage.

All of the following methods are based on these two.

Some may think that this page has spent a lot of space to say how "preliminary optimization" (premature optimization). Although sometimes micro-optimization of the development of efficient data structures and algorithms is very difficult, but in the embedded handheld devices, you have no choice above. For example, if the desktop virtual machine migration to your Android system, you will find that you write your program will run out of memory. This will cause the program up and running extremely slow, even without considering the rest of its system of running the program.

This is why the above two principles are so important. Android's success is the development of procedures available to the user experience, user experience, good or bad, however, decided whether the code in your timely response and thus will not make people slow collapse. Because we all procedures to run in the same equipment, so we consider them as a whole. This test driver's license as you need to learn the rules of the road is the same: If the owner to comply with, things will be very smooth; but when you do not comply, you will crash.

Before we discuss substantive issues, there is a brief explanation: Regardless of whether the virtual machine is a Java compiler features all the views presented below are correct. If we have two ways to accomplish the same thing, but foo () to explain the implementation of faster than bar (), then foo () will not build speed than the bar () slow, only by compiling the code allows you to run speed boost is unwise.

As far as possible to create objects (Object)

Object creation is not without cost. Distribution with a thread pool of generational memory management mechanism will reduce the cost of creating temporary objects are not allocated memory does not allocate memory is not as good.

If you are in a cycle of the user interface assigned an object, you have to force the recall of memory, it would appear to make the user experience a little "hiccup" phenomenon.

Therefore, if there is no need you should not create the object instance. Here is a helpful example:

  • When the input data from the original extract the string, try to return a child from the original string, string, rather than creating a copy. You will create a new string object, but it and your original data shared data space.
  • If you have a return string to method, you should be aware of any case that the result is StringBuffer, change your the function of Definition and enforced so that function directly to return rather than Tongguo create a temporary object.

A more radical approach is to partition a multidimensional array into several parallel one-dimensional array:

  • An array of type Int than an array of Integer type is better, but the same could be summarized in such a principle, two types of arrays Int than a (int, int) the efficiency of an array of objects to be much higher. For other primitive data types, this principle applies.
  •  If you need to create an object that contains a series of Foo and Bar containers (container), remember: two parallel Foo [] and Bar [] than a (Foo, Bar) array of objects much more efficient. (This example also has an exception, when you design the interface API when other code; in this case, the speed of a point on the loss would not have considered. But, in your code inside, you should try to write efficient code. )

In general, as much as possible to avoid creating short-term temporary objects. Less object creation means less garbage collection, which will improve the quality of your program's user experience.

Use their own methods (Use Native Methods)

When dealing with strings, do not hesitate to use as much as possible, such as String.indexOf (), String.lastIndexOf () method with this object itself. Because these methods use C / C + + to achieve, than in a java loop do the same thing 10-100 times faster.

Another point to add clear is that these methods use the cost of Zi Shen Jie Shi Guo's methods than those Gao Henduo, Yin Er, Duiyu minor operations, as Buyongzhelei method.

Better than the use of virtual interfaces

Suppose you have a HashMap object, you can declare it is a HashMap or is just a Map:

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

Which is better?

Generally wise to use the Map, because it can allow you to change the Map interface to implement any of these things, but this "sensible" approach is only applicable to regular programming, not suitable for embedded systems. Reference to the call through the interface will take more than 2 times the time, as opposed to through a specific reference to the virtual function call.

If you choose to use a HashMap, because it is more suited to your program, then use the Map will be worthless. Suppose you have a can restructure your code integrated coding environment, then call the Map of no use, even if you're not sure where at the beginning of your program. (Similarly, public of the API is an exception, the value of a good API is often greater than the efficiency at which point loss)

Better than using a static virtual

If you do not need to access the external object, then make your way to a static method. It will be faster call, because it does not need a virtual function-oriented form. It is also a good practice, because it tells you how to distinguish the nature of the method (signature), calling this method does not change the object state.

As far as possible avoid the use of inherent Get, Set Methods

Like C + + iyangde programming language, often using Get methods (for example i = getCount()) to replace the direct access to the property (i=mCount). This is in C + + programming which is a good habit, because the compiler will access method is set to Inline, and if you want to bind or debug attribute access, you only need to add some code at any time.

In the Android programming, this is not a very good idea. Virtual method call will generate a lot of costs, the cost of queries than the instance of the property even more. We should use the external call functions Get and Set, but internal calls, we should be called directly.

Buffer attribute called Cache Field Lookups

Access object property is much slower than access to local variables. You should not write your code:

for (int i = 0; i < this.mCount; i++)

It should read:

  int count = this.mCount;
  Item[] items = this.mItems;

  for (int i = 0; i < count; i++)

(We direct use "this" that these are its member variables)

A similar principle: that no statement in a For the second time in calling a class method. For example, the following code will be implemented again and again getCount () method, which is a great way to waste than you hide it directly to a Int variable.

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

This is a good way, when you call more than once a instances, the direct localization of this example, this example of some of the value assigned to a local variable. For example:

    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);
                    computeHorizontalScrollExtent(), false);

There are four attributes mScrollBar call to mScrollBar buffer to a stack variable among the four members of the property will become four times the call stack access, this will improve efficiency.

Incidentally, the method also can be the same as local variables with the same characteristics.

Final statement of constant

We can look at a class at the top of the following statements:

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

When a class of first use, the compiler will call a class initialization method - <clinit>, this method will be 42 deposited into variable intVal, and for strVal string constant in the class file to extract a reference scale, when these values later reference, they will call the property directly.

We can use the keyword "final" to improve the code:

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

This class will not call es a <clinit> method, because these constants are directly written into the class static attribute initialization file, this initialization directly from the virtual machine to handle. Code will be used to access intVal 42 Integer types, access strVal will use the relative savings in "constant string" to replace a property called.

A class or method declared as "final" and will not bring any benefits of implementation, it can carry out some of the most optimized. For example, if the compiler knows that a quilt class can not be overloaded Get method, it put the function set to Inline.

At the same time, you can also declare local variables final variable. However, this is meaningless. As a local variable, use the final only to make the code more clear (or you have to use inline anonymous access class).

Prudent use of Enhanced For loop

Enhanced For loop (which is often said the "For-each loop") is often used to collect Interface Iterable interface inheritance above. In these objects inside a iterator is assigned to an object to call its hasNext () and next () method. In an array list which you can access the perfunctory own it, in other collector inside, enhanced for loop is equivalent to the use of iterator.

Nevertheless, the following source code shows an acceptable enhanced for loop example:

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 () function in each cycle of re-obtain the static properties of the two, get the array length of time.

one () function to everything into local variables, to avoid the class to find attribute called

two () function uses the Java language for the 1.5 version of the loop, the editor generated source code into account the reference copy of the array and the length of the array to a local variable is an array of cases over the better method, which in the main loop does have an additional loading and storage process (apparently saved the "a"), compared to the function one (), it's slowed down a little bit and 4 bytes of growth.

Conclusion, we can get: enhanced for loop in the array which performed well, but when and Iterable object when used with caution, because this creates more of an object.

Avoid Enums to avoid the type listed

Enumerated type is very easy to use, when taking into account the size and speed, they would seem costly, for example:

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

This will be transformed into a 900 bytes of class file (Foo $ Shrubbery.class). First use, type De initialization Yaozai exclusive method of Qu Miaoshu listed above, call each item returned to load each one has its own Jingtaikongjian, the Pi stored in an array inside (1 Called "$ VALUE "static array). It was a lot of code and data, just to the three integer values.

Shrubbery shrub = Shrubbery.GROUND;

This will cause a static property of the call, if the Final GROUND is a static variable, the compiler will it as a constant in the code nested inside.

Another point to say, through the list, you can get a better API and some compile time checks. Therefore, a more balanced approach is: you should make every method in your public API to use list variables, when dealing with issues on the avoided as much as possible.

In some environments the following by ordinal () method to get a list of integer variables is useful, for example: the following code

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

Replace with:

   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

In some conditions, it will run faster, though not guaranteed.

Package through the use of space within the joint class

We look at the following class declaration

public class Foo {
    private int mValue;

    public void run() {
        Inner in = new Inner();
        mValue = 27;

    private void doStuff(int value) {
        System.out.println("Value is " + value);

    private class Inner {
        void stuff() {

Here we should note that we define an inline type, it calls the external class of private methods and private property. This is a legitimate call, the code should show "Value is 27".

The problem is, in theory Foo $ Inner (background on) should be a completely separate class, it calls irregularities in the private members of the Foo. To compensate for this shortcoming, the compiler produces a synthetic method:

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

When the in-class access from the outside "mValue" and called "doStuff" when the inline type will call these static methods, which means you do not directly access the class members, but by way of public access. We talked about the previous indirect access slower than direct access, so this is a language used by the invisible implementation example.

To have a package within the joint space of the direct statement of need to access class properties and methods, we can avoid this problem, philosophical poetry is package space, rather than private space. It runs faster and go in front of things in addition to generating functions. (Unfortunately, it also means that the property also can be the same package the other classes the following direct access to the Wei Fan a standard object-oriented of the principle of private property Shisuo You. Similarly, Ru Guo is a public API you design should carefully consider the use of this optimization)

Avoid the use of floating-point type

Before the release of the Pentium CPU, the game as much as possible the use of type Integer mathematical function is normal. Inside the Pentium processor, floating point processing into it a prominent feature, and the interactive use of floating point and integer integer comparison alone, the former will make your game run faster, the average desktop computer We can use the above free float.

Unfortunately, the embedded processors usually do not support floating-point processing, vaginal teeth all the "float" and "double" is done via software, and some basic floating point operation takes milliseconds to time.

Colleagues, even integer, a number of chips not only multiplication division. In these cases, the integer division and modulus operations are implemented by software. When you create a Hash Table, or a lot of math, this is what you need to consider.

Comparison of some of the standard operation of the time

In order to explain our point of view from, here is a table, including some of the basic operation of the approximate time used. Note that the time is not absolute time, absolute time, taking into account the CPU and clock frequency. Systems, the time will be different in size. Of course, this is a meaningful comparison, we can call different operation than the relative time spent. For example, add a member variable of time is to add a local variable of the four times.

Action Time
Add a local variable 1
Add a member variable 4
Call String.length () 5
Call empty static native method 5
Call empty static method 12
Call empty virtual method 12.5
Call empty interface method 15
Call Iterator: next () on a HashMap 165
Call put () on a HashMap 600
Inflate 1 View from XML 22,000
Inflate 1 LinearLayout containing 1 TextView 25,000
Inflate 1 LinearLayout containing 6 View objects 100,000
Inflate 1 LinearLayout containing 6 TextView objects 135,000
Launch an empty activity 3,000,000


Efficient embedded process writing the best way is to figure out what happened to your writing process. If you really want to assign an iterator class, all the way into a List in the use of enhanced for loop, make it a practice of knowingly, rather than an inadvertent omission, but a negative impact.

Prepared and find out what you are doing! You can if you own some of the code of conduct, but must pay attention to what your code is doing, and then start looking for ways to optimize it.

blog comments powered by Disqus


  • [Reserved] Redis memory usage and storage optimization 2011-08-28

    [Original] http://www.infoq.com/cn/articles/tq-redis-memory-usage-optimization-storage address Redis common data types Redis the most commonly used data types are the following five: String Hash List Set Sorted set In the specific description of thes

  • Massive data query optimization (fine) 2010-04-25

    Database query plan optimization method Database system is the core of management information systems, database-based online transaction processing (OLTP) and online analytical processing (OLAP) is the banks, enterprises, government departments one of the

  • Massive data query optimization 2010-07-15

    First, because the situation's conditions, the establishment of "appropriate" index The establishment of "appropriate" to achieve query optimization index is the most important prerequisite. Index (index) is another important addit

  • Java data structures to achieve lock has nothing to do 2010-07-28

    [From https: / / www.ibm.com/developerworks/cn/java/j-lo-lockfree/] Introduction Usually a multi-threaded environment, we need to share some data, but to avoid competitive data conversion arising inconsistencies, some Daima section needs to become atomic

  • Data Query Optimization 2010-11-04

    Millions thirty data query optimization techniques 1. Optimize the query, should try to avoid full table scans, we should first consider where and order by column index involved. 2. Should be avoided in the where clause null value judgments on the fi

  • Learning STL map, STL set of basic data structures 2010-12-23

    Learning STL map, STL set of basic data structures Abstract: This article lists a few basic STL map and the STL set of questions, answers these questions by explaining the STL containers associated with the internal data structures, and finally prese

  • Linux TCP / IP protocol stack of the key data structures Socket Buffer (sk_buff) 2011-04-08

    sk_buff structure may be the most important linux networking code data structure that represents the receive or transmit data packet's header information. It <include/linux/skbuff.h> defined and contains a lot of member variables for each sub-ne

  • Computational Geometry in GIS and related data structures and algorithms 2011-07-28

    Two of GIS and computational geometry-related data structures and algorithms Delaunay triangulation algorithm Delaunay triangulation and Veronoi map each dual graph. Commonly known as triangulation maximizes the smallest angle. 2d only concerned with

  • Massive data query optimization methods 2010-10-14

    Switch to an online article, address: http://zhengyanming2006.blog.163.com/blog/static/27411528200911944725751/ L First, because of the situation the system should establish an "appropriate" index The establishment of "appropriate

  • Immutable Data Structures in Concurrent Java Applications!!! 2010-03-29

    Concurrent applications have multiple threads running simultaneously. Access to data shared by multiple threads requires synchronization which is often a source of fragile and hard to maintain code, hard to find bugs, and performance issues. You can minim

iOS 开发

Android 开发

Python 开发



PHP 开发

Ruby 开发






Javascript 开发

.NET 开发



Copyright (C) codeweblog.com, All Rights Reserved.

CodeWeblog.com 版权所有 黔ICP备15002463号-1

processed in 0.381 (s). 14 q(s)