android开发经验笔记总计四大组件：IntentHanlderListViewAndroid的线程和线程池 动画View子线程更新ui的三种方式Bitmap的加载和CacheJNIToastHTTPAndroid性能优化综合技术Java基础：Java集合：

四大组件：

Activity

AndroidRuntime： android.util.AndroidRuntimeException: Calling startActivity from outside of 
an Activity context requires the FLAG_ACTIVITY_NEW_TASK flag .Is this really what you  want?

public class MyApp extends Application
{
    private Bitmap mBitmap;

    public Bitmap getBitmap()
    {
        return mBitmap;
    }

    public void setBitmap(Bitmap bitmap)
    {
        this.mBitmap = bitmap;
    }
    
}

<pre name="code" class="java"><application android:name=".MyApp" android:icon="@drawable/icon" android:label="@string/app_name">
</application>

    ImageView imageview = (ImageView)findViewById(R.id.ivImageView);
    MyApp myApp = (MyApp)getApplication();
    imageview.setImageBitmap(myApp.getBitmap());

package com.example.result;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity {

	public static final int REQUEST_CODE1 = 1;
	public static final int REQUEST_CODE2 = 2;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		Button button1 = (Button) findViewById(R.id.button1);
		button1.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Intent intent = new Intent(MainActivity.this,
						SecondActivity.class);
				startActivityForResult(intent, REQUEST_CODE1);
			}
		});

		Button button2 = (Button) findViewById(R.id.button2);
		button2.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Intent intent = new Intent(MainActivity.this,
						ThridActivity.class);
				startActivityForResult(intent, REQUEST_CODE2);
			}
		});

	}

	@Override
	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
		if (requestCode == REQUEST_CODE1) {
			Toast.makeText(getApplicationContext(),
					"111->" + data.getStringExtra("njj"), Toast.LENGTH_SHORT)
					.show();
		}
		if (requestCode == REQUEST_CODE2) {
			Toast.makeText(getApplicationContext(),
					"222->" + data.getStringExtra("njj"), Toast.LENGTH_SHORT)
					.show();
		}
	}
}

package com.example.result;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class SecondActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_second);

		Button button2 = (Button) findViewById(R.id.button2);
		button2.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Intent intent = new Intent();
				intent.putExtra("njj", "niejianjian - second");
				setResult(RESULT_OK, intent);
				finish();
			}
		});

	}
}

package com.example.result;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class ThridActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_thrid);

		Button button3 = (Button) findViewById(R.id.button3);
		button3.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				Intent intent = new Intent();
				intent.putExtra("njj", "niejianjian - thrid");
				setResult(RESULT_OK, intent);
				finish();
			}
		});

	}
}

BroadcastReceiver

        <receiver android:name="com.example.boradcasttest.MyReceive2" >
            <intent-filter android:priority="30" >
                <action android:name="njj.test.receive" />
            </intent-filter>
        </receiver>

                        Intent intent = new Intent();
			intent.setAction("njj.test.receive");
			sendBroadcast(intent);

		IntentFilter filter = new IntentFilter();
		filter.addAction("njj.test.receive"); // 添加actionyongyu匹配需要接受的广播
		registerReceiver(receiver, filter); // receiver是一个广播对象。

<span style="white-space:pre">	</span>BroadcastReceiver receiver = new BroadcastReceiver() {
<span style="white-space:pre">		</span>@Override
<span style="white-space:pre">		</span>public void onReceive(Context context, Intent intent) {
<span style="white-space:pre">		</span>}
<span style="white-space:pre">	</span>};

unregisterReceiver(receiver);

        <receiver android:name="com.example.boradcasttest.MyReceive1" >
            <intent-filter android:priority="20" >
                <action android:name="njj.test.receive" />
            </intent-filter>
        </receiver>
        <receiver android:name="com.example.boradcasttest.MyReceive2" >
            <intent-filter android:priority="0" >
                <action android:name="njj.test.receive" />
            </intent-filter>
        </receiver>

				Intent intent = new Intent();
				intent.setAction("njj.test.receive");
				intent.putExtra("key", "发送给receive1的广播");
				sendOrderedBroadcast(intent, null);

public class MyReceive1 extends BroadcastReceiver {

	@Override
	public void onReceive(Context context, Intent intent) {
		System.out.println("onreceive");
		if (intent.getAction().equals("njj.test.receive")) {
			Toast.makeText(context, intent.getStringExtra("key"),
					Toast.LENGTH_SHORT).show();
			Bundle bundle = new Bundle();
			bundle.putString("re1", "有序广播");
			setResultExtras(bundle);
			// abortBroadcast(); // 终止传递
		}
	}
}

public class MyReceive2 extends BroadcastReceiver {
	@Override
	public void onReceive(Context context, Intent intent) {
		Bundle bundle = getResultExtras(true);
		String msg = bundle.getString("re1");
		String msg2 = intent.getStringExtra("key");
		System.out.println("msg -> " + msg);
		System.out.println("msg2 -> " + msg2);
	}
}

Service

package com.example.boradcasttest;

import android.app.Activity;
import android.app.IntentService;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

	MyConn myConn;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		myConn = new MyConn();

		Button button1 = (Button) findViewById(R.id.button1);
		button1.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("click ----> button1");
				Intent intent = new Intent(MainActivity.this, MyService1.class);
				startService(intent);
			}
		});

		Button button2 = (Button) findViewById(R.id.button2);
		button2.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("click ----> button2");
				Intent intent = new Intent(MainActivity.this, MyService1.class);
				stopService(intent);
			}
		});

		Button button3 = (Button) findViewById(R.id.button3);
		button3.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("click ----> button3");
				Intent intent = new Intent(MainActivity.this, MyService1.class);
				bindService(intent, myConn, BIND_AUTO_CREATE);
			}
		});

		Button button4 = (Button) findViewById(R.id.button4);
		button4.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("click ----> button4");
				unbindService(myConn);
			}
		});

		Button button5 = (Button) findViewById(R.id.button5);
		button5.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("click ----> button5");
				Intent intent = new Intent();
				intent.setAction("stop.service1");
				sendBroadcast(intent);
			}
		});

	}

	private class MyConn implements ServiceConnection {

		public void onServiceConnected(ComponentName name, IBinder service) {
			// 可以通过IBinder的对象 去使用service里面的方法
		}

		public void onServiceDisconnected(ComponentName name) {
		}
	}

}

package com.example.boradcasttest;

import android.app.Service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.os.IBinder;

public class MyService1 extends Service {

	@Override
	public IBinder onBind(Intent intent) {
		System.out.println("MyService1 -> onBind");
		return null;
	}

	@Override
	public void onRebind(Intent intent) {
		System.out.println("MyService1 -> onRebind");
		super.onRebind(intent);
	}

	@Override
	public boolean onUnbind(Intent intent) {
		System.out.println("MyService1 -> onUnbind");
		return super.onUnbind(intent);
	}

	@Override
	public void onCreate() {
		System.out.println("MyService1 -> onCreate");
		super.onCreate();
	}

	@Override
	@Deprecated
	public void onStart(Intent intent, int startId) {
		System.out.println("MyService1 -> onStart");
		IntentFilter filter = new IntentFilter();
		filter.addAction("stop.service1");
		registerReceiver(receiver, filter);
		super.onStart(intent, startId);
	}

	@Override
	public boolean bindService(Intent service, ServiceConnection conn, int flags) {
		System.out.println("MyService1 -> bindService");
		return super.bindService(service, conn, flags);
	}

	@Override
	public void unbindService(ServiceConnection conn) {
		System.out.println("MyService1 -> unbindService");
		super.unbindService(conn);
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		System.out.println("MyService1 -> onStartCommand");
		return super.onStartCommand(intent, flags, startId);
	}

	@Override
	public boolean stopService(Intent name) {
		System.out.println("MyService1 -> stopService");
		stopSelf(); // 停止服务
		return super.stopService(name);
	}

	@Override
	public void onDestroy() {
		System.out.println("MyService1 -> onDestroy");
		super.onDestroy();
	}

	BroadcastReceiver receiver = new BroadcastReceiver() {

		@Override
		public void onReceive(Context context, Intent intent) {
			System.out.println("MyService1 -> receiver");
			if (intent.getAction().equals("stop.service1")) {
				context.stopService(intent);
			}
		}
	};

}

        <service android:name="MyService1" ></service>

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
	// TODO Auto-generated method stub
	Intent notificationIntent = new Intent(this, MainActivity.class);
	PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
	Notification noti = new Notification.Builder(this)
				.setContentTitle("Title")
				.setContentText("Message")
				.setSmallIcon(R.drawable.ic_launcher)
				.setContentIntent(pendingIntent)
				.build();
	startForeground(12346, noti);
	return Service.START_STICKY;
}

public class MyService extends Service {  
  
    @Override  
    public void onCreate() {  
        super.onCreate();  
    }  
      
    @Override  
    public void onStart(Intent intent, int startId) {  
        super.onStart(intent, startId);  
        //经测试，Service里面是不能进行耗时的操作的，必须要手动开启一个工作线程来处理耗时操作   
        System.out.println("onStart");  
        try {  
            Thread.sleep(20000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println("睡眠结束");  
    }  
      
    @Override  
    public IBinder onBind(Intent intent) {  
        return null;  
    }  
}  

public class MyIntentService extends IntentService {  
  
    public MyIntentService() {  
        super("yyyyyyyyyyy");  
    }  
  
    @Override  
    protected void onHandleIntent(Intent intent) {  
        // 经测试，IntentService里面是可以进行耗时的操作的   
        //IntentService使用队列的方式将请求的Intent加入队列，然后开启一个worker thread(线程)来处理队列中的Intent   
        //对于异步的startService请求，IntentService会处理完成一个之后再处理第二个   
        System.out.println("onStart");  
        try {  
            Thread.sleep(20000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println("睡眠结束");  
    }  
}  

public class ServiceDemoActivity extends Activity {  
    /** Called when the activity is first created. */  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.main);  
        startService(new Intent(this,MyService.class));//主界面阻塞，最终会出现Application not responding   
        //连续两次启动IntentService，会发现应用程序不会阻塞，而且最重的是第二次的请求会再第一个请求结束之后运行(这个证实了IntentService采用单独的线程每次只从队列中拿出一个请求进行处理)   
        startService(new Intent(this,MyIntentService.class));  
        startService(new Intent(this,MyIntentService.class));  
    }  
}  

public class HelloIntentService extends IntentService {

  /**
   * A constructor is required, and must call the super IntentService(String)
   * constructor with a name for the worker thread.
   */
  public HelloIntentService() {
      super("HelloIntentService");
  }

  /**
   * The IntentService calls this method from the default worker thread with
   * the intent that started the service. When this method returns, IntentService
   * stops the service, as appropriate.
   */
  @Override
  protected void onHandleIntent(Intent intent) {
      // Normally we would do some work here, like download a file.
      // For our sample, we just sleep for 5 seconds.
      long endTime = System.currentTimeMillis() + 5*1000;
      while (System.currentTimeMillis() < endTime) {
          synchronized (this) {
              try {
                  wait(endTime - System.currentTimeMillis());
              } catch (Exception e) {
              }
          }
      }
  }
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
    return super.onStartCommand(intent,flags,startId);
}

private void showToastByRunnable(final IntentService context, final CharSequence text, final int duration) {
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
@Override
public void run() {
Toast.makeText(context, text, duration).show();
}
});
}
Handler的msg方式实现，这个方式比较复杂。
Handler msgHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
Toast.makeText(ToastIntentService.this, msg.getData().getString("Text"), Toast.LENGTH_SHORT).show();
super.handleMessage(msg);
}
};
private void showToastByMsg(final IntentService context, final CharSequence text, final int duration) {
Bundle data = new Bundle();
data.putString("Text", text.toString());
Message msg = new Message();
msg.setData(data);
msgHandler.sendMessage(msg);
}

ContentProvider

1.Android有一个独到之处，就是数据库只能被它的创建者所使用，其他的应用是不能访问到的，所以如果你想实现不同应用之间的数据共享，就不得不用contentprovider了。在Android中，contentprovider是一个特殊的存储数据的类型，他提供了一套标准的接口用来获取以及操作数据，并且，android自身也提供了几个现成的contentprovider：Contacts，Browser，CallLog，Settings，MediaStore。

Intent

android应用的三大组件——Activitied、Services、BroadcastReceiver，通过消息触发，这个消息就称作意图(Intent)。

2.Intent可以传递的数据类型：从原码查看：

1).基本数据类型

Intent putExtra(String name, int[] value)  
Intent putExtra(String name, float value)  
Intent putExtra(String name, byte[] value)  
Intent putExtra(String name, long[] value)  
Intent putExtra(String name, float[] value)  
Intent putExtra(String name, long value)  
Intent putExtra(String name, String[] value)  
Intent putExtra(String name, boolean value)  
Intent putExtra(String name, boolean[] value)  
Intent putExtra(String name, short value)  
Intent putExtra(String name, double value)  
Intent putExtra(String name, short[] value)  
Intent putExtra(String name, String value)  
Intent putExtra(String name, byte value)  
Intent putExtra(String name, char[] value)  
Intent putExtra(String name, CharSequence[] value) 

    public Intent putExtra(String name, CharSequence value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putCharSequence(name, value);
        return this;
    }

    public Intent putExtra(String name, Bundle value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putBundle(name, value);
        return this;
    }

3).传递Parcelable对象

    public Intent putExtra(String name, Parcelable value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putParcelable(name, value);
        return this;
    }

4).传递Serializable对象

    public Intent putExtra(String name, Serializable value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putSerializable(name, value);
        return this;
    }

5).传递Intent对象

    public Intent putExtras(Intent src) {
        if (src.mExtras != null) {
            if (mExtras == null) {
                mExtras = new Bundle(src.mExtras);
            } else {
                mExtras.putAll(src.mExtras);
            }
        }
        return this;
    }

    @Deprecated
    public Intent putExtra(String name, IBinder value) {
        if (mExtras == null) {
            mExtras = new Bundle();
        }
        mExtras.putIBinder(name, value);
        return this;
    }

    public Bundle() {
        mMap = new ArrayMap<String, Object>();
        mClassLoader = getClass().getClassLoader();
    }

A description of an Intent and target action to perform with it. Instances of this class are created with getActivity(Context, int, Intent, int), getActivities(Context, int, Intent[], int), getBroadcast(Context, int, Intent, int), and getService(Context, int, Intent, int); the returned object can be handed to other applications so that they can perform the action you described on your behalf at a later time.

4.IntentFilter

顾名思义，IntentFilter对象负责过滤掉无法响应和处理的intent，只将自己关心的intent接受进来进行处理，intentFilter实行白名单管理，但IntentFilter只会过滤掉隐式的intent，显式的intent会直接传送到目标组件。android组件可以有一个或者多个intentfilter，每个之间都互相独立，只需要其中一个验证通过即可。除了用于过滤广播的intentfilter可以在代码中创建外，其他的intentfilter都必须在Androidmanifest.xml文件中进行声明。

http://blog.csdn.net/today520/article/details/7000048

Action是要求Intent中必须有一个action且必须能够和过来规则中的某个action相同，而category要求Intent可以没有category，但是如果你一旦有category，不管有几个，每个都要能够和过来规则中的任何一个category相同。

为什么不设置category也能匹配？原因是系统在调用startActivity和startActivityForResult的时候会默认为Intent加上“android.intent.category.DEFAULT”这个category。所以category就可以匹配前面的过滤规则中的第三个category。同时，为了我们的activity能够接受到隐式调用，就必须在intent-filter中指定“android.intent.category.DEFAULT”这个category。

参考博客：http://blog.csdn.net/annkie/article/details/8483253

Hanlder

主线程初始化的时候，默认创建了looper。Handler在使用之前必须有looper的存在，否则会报错。如果在非主线成使用handler，必须创建looper。

ActivityThread中的main()方法中，系统已经自动调用了Looper.prepare()；

不是的，有以下两种：
一，如果不带参数的实例化：Handler handler = new Handler();那么这个会默认用当前线程的looper。
二，一般而言如果Handler是要来刷新操作UI的，那么就需要在主线程下跑。那么在主线程 Handler handler = new Handler()。
三，如果在其他线程，也要满足这个功能的话，要Handler handler = new Handler(Looper.getMainLooper());不用刷新ui,只是处理消息。 
四，当前线程如果是主线程的话，Handler handler = new Handler();不是主线程的话，Looper.prepare(); Handler handler = new Handler();Looper.loop();或者Handler handler = new Handler(Looper.getMainLooper())。

消息循环和消息队列都是属于THread，而Handler本身并不具有Looper和MessageQueue；但是消息系统的建立和交互，是Thread将Looper和MessageQueue交给某个Handler维护建立消息模型，所以消息系统模型的核心就是Looper。消息循环和消息队列都是由Looper建立的，而建立Handler的关键就是这个Looper。

一个Thread同时可以对应多个Handler，一个Handler同时只能属于一个Thread。Handler属于那个Thread取决于Handler在哪个Thread中建立。在一个Thread中Looper也是唯一的，一个Thread对应一个Looper，建立Handler的Looper来自哪个Thread，Handler就属于哪个Thread。故建立Thread消息系统，就是将Thread的Looper交给Handler去打理，实现消息系统模型，完成消息的异步处理。

在线程中建立Handler：

1).获得Thread的Looper交给Handler的成员变量引用维护；

2).通过Looper获取MessageQueue交个Hanler的成员变量引用维护。

消息发送和派发接口：

1).post(Runnable)消息，Runnable是消息回调，经过消息循环引发消息回调函数执行；

2).sendMessage(Message)消息，经过消息循环派发消息处理函数中处理消息；

3).diapatchMessage派发消息，若是post或带有回调函数则执行回调函数，否则执行消息处理函数Handler的handleMessage（通常派生类重写）。

package com.example.handlertestdemo;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity {

	public int a = 0;

	Handler handler = new Handler() {
		public void handleMessage(android.os.Message msg) {
			switch (msg.what) {
			case 0:
				a++;
				System.out.println("a = " + a);
				sendEmptyMessageDelayed(0, 1000);
				if (a == 5) {
					if (hasMessages(0)) {
						removeMessages(0); // 终止消息的执行
					}
				}
				break;
			case 1:
				System.out.println("msg.what = 1 ---> msg0 is exits = "
						+ hasMessages(0));
				sendEmptyMessageDelayed(1, 7000);
				removeCallbacks(runnable); // 终止线程的执行
				break;
			default:
				break;
			}
		};
	};

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		Button button1 = (Button) findViewById(R.id.button1);
		button1.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				handler.sendEmptyMessageDelayed(0, 3000);
				handler.sendEmptyMessage(1);
			}
		});
	}

	Runnable runnable = new Runnable() {

		@Override
		public void run() {
			// 执行内容
		}
	};

}

为什么要使用Handler？

有时候需要在子线程中进行耗时的I/O操作，可能是读取文件或者访问网络等，当耗时操作完成以后可能需要在UI上做一些改变，由于Adnroid开发规范的限制，我们并不能在子线程中访问UI控件，否则会出发程序异常，这个时候通过Handler就可以将更新UI的操作切换到主线程中执行。因此，本质上来说，Handler并不是专门用于更新UI的，只是被常常用来更新UI。

MessageQueue虽然叫做消息队列，但是它的内部存储结构并不是真正的队列，而是采用单链表的数据结构来存储消息列表的。

MessageQueue只是一个消息的存储单元，它并不能去处理消息，Looper会以无限循环的形式去查询是否有新消息，如果有的话就处理消息，否则一直等待。

线程默认是没有Looper的，如果需要使用Handler就必须为线程创建Looper。我们经常提到的主线程，也叫做UI线程，它就是ActivityThread，ActivityThread被创建时就会初始化Looper，这也是在主线程中默认可以使用Looper的原因。

系统之所以提供Handler，主要原因就是为了解决在子线程中无法访问UI的矛盾。

系统为什么不允许在子线程中访问UI呢？

因为Andorid的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态。

为什么不对UI控件的访问加上锁机制？

缺点有两个：首先加上锁机制会让UI访问逻辑变得复杂；其次锁机制会降低UI访问的效率，因为锁机制会阻塞某些线程的执行。所以最高效的方法就是采用单线程模型来处理UI操作。

Handler创建完毕，这个时候其内部的Looper以及MessageQueue就可以和Handler一起工作了，然后通过Handler的post方法将一个Runable投递到Handler内部的Looper中去处理，也可以通过Handler的send方法来发送一个消息，这个消息同样会在Looper中去处理。其实post方法最终也是通过send方法处理的。

Send方法的工作过程：

Handler的send方法被调用是，它会调用MessageQueue的enqueueMessage方法将这个消息放入消息队列中，然后Looper发现有新的消息到来是，就会出来这个消息，最终消息中的Runnable或者Handler的handleMessage方法会被调用。

Thread是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据。

当某些数据以线程为作用域并且不同线程具有不同的数据副本的时候，就可以考虑采用ThreadLocal。

对于Handler来说，它需要获取当前线程的Looper，很显然Looper的作用域就是线程并且不同线程具有不同的Looper、

线程是一次性消费品，如果多次创建和销毁线程是很耗费资源的，所以就构建了一个循环线程Looper Thread，当有耗时任务投放到该循环线程中的时候，线程执行耗时任务，当执行完毕了，循环线程处于等待状态，等待下一个耗时任务被投放进来。

1).HandlerThread适用于构建循环线程

2).在创建Handler作为HandlerThread线程消息执行者的时候必须调用start方法之后，因为创建Handler需要的Looper参数是从HandlerThread类中获得的，而Looper对象的赋值又是在HandlerThread的run方法中创建。

1.Cancelling a Task
我们可以在任何时刻来取消我们的异步任务的执行，通过调用 cancel(boolean)方法，调用完这个方法后系统会随后调用 isCancelled() 方法并且返回true。如果调用了这个方法，那么在 doInBackgroud() 方法执行完之后，就不会调用 onPostExecute() 方法了，取而代之的是调用 onCancelled() 方法。为了确保Task已经被取消了，我们需要经常调用 isCancelled() 方法来判断，如果有必要的话。
2.在使用AsyncTask做异步任务的时候必须要遵循的原则：
AsyncTask类必须在UI Thread当中加载，在Android Jelly_Bean版本后这些都是自动完成的
AsyncTask的对象必须在UI Thread当中实例化
execute方法必须在UI Thread当中调用
不要手动的去调用AsyncTask的onPreExecute, doInBackground, publishProgress, onProgressUpdate, onPostExecute方法，这些都是由Android系统自动调用的
AsyncTask任务只能被执行一次

参考博客：

http://www.cnblogs.com/codingmyworld/archive/2011/09/14/2174255.html

http://www.androidchina.net/313.html

ListView

public View getView( int position, View convertView, ViewGroup parent) {
           View view = convertView;
           ViewHolder holder;

            if (view == null) {
                LayoutInflater inflater = (LayoutInflater) mContext
                          .getSystemService(Context. LAYOUT_INFLATER_SERVICE);
                view = inflater.inflate(R.layout. list_item, null);

                holder = new ViewH older();
                 // 每项的视图布局是一样的
                holder. image = (ImageView) view.findViewById(R.id.image );
                holder. tv_title = (TextView) view.findViewById(R.id.tv_title );
                holder. tv_info = (TextView) view.findViewById(R.id.tv_info );
                view.setTag(holder);
           } else {
                holder = (ViewHolder) view.getTag();
           }

            // 每项的数据都不一样
          holder. image.setImageDrawable( dataList.get(position). image);
          holder. tv_title.setText( dataList.get(position). title);
           holder. tv_info.setText( dataList.get(position). info);

            return view;
     }

     private static class ViewHolder {
            public ImageView image;
            public TextView tv_title;
            public TextView tv_info;
     }

package com.alexchen.listviewoptimize;
 
import java.util.ArrayList;
import java.util.List;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.ListView;
import android.widget.TextView;
 
public class MainActivity extends Activity {
 
      private ListView lv_demo;
      private List<String> list;
 
      @Override
      protected void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
             setContentView(R.layout.activity_main);
             lv_demo = (ListView) findViewById(R.id.lv_demo);
             //list为要加载的条目文本的集合，这里总共是100条
             list = new ArrayList<String>();
             for (int i = 0; i < 100; i++) {
                   list.add("条目" + i);
             }
 
             lv_demo.setAdapter(new MyAdapter());
       }
 
       private class MyAdapter extends BaseAdapter {
 
             @Override
             public int getCount() {
                   return list.size();
             }
 
             @Override
             public View getView(int position, View convertView, ViewGroup parent) {
                  //listview_item里只有一个textview
                  View view = View.inflate(MainActivity.this, R.layout.listview_item, null);
                  //使用每一次都findviewById的方法来获得listview_item内部的组件
                  TextView tv_item = (TextView) view.findViewById(R.id.tv_item);
                  tv_item.setText(list.get(position));
                  return view;
             }
 
             @Override
             public Object getItem(int position) {
                   return null;
             }
 
             @Override
             public long getItemId(int position) {
                   return 0;
             }
 
       }
}

优化一：

也是最普通的优化，就在MyAdapter类中的getView方法中，我们注意到，上面的写法每次需要一个View对象时，都是去重新inflate一个View出来返回去，没有实现View对象的复用，而实际上对于ListView而言，只需要保留能够显示的最大个数的view即可，其他新的view可以通过复用的方式使用消失的条目的view，而getView方法里也提供了一个参数：convertView，这个就代表着可以复用的view对象，当然这个对象也可能为空，当它为空的时候，表示该条目view第一次创建，所以我们需要inflate一个view出来,所以在这里，我们使用下面这种方式来重写getView方法：

@Override
    public View getView(int position, View convertView, ViewGroup parent) {
      View view;
      // 判断convertView的状态，来达到复用效果     
      if (null == convertView) {
          //如果convertView为空，则表示第一次显示该条目，需要创建一个view       
          view = View.inflate(MainActivity.this, R.layout.listview_item, null);
      } else {
          //否则表示可以复用convertView       
          view = convertView;
      }
      // listview_item里只有一个textview     
      TextView tv_item = (TextView) view.findViewById(R.id.tv_item);
      tv_item.setText(list.get(position));
      return view;
    }

优化二：

TextView tv_item = (TextView) view.findViewById(R.id.tv_item);

private static class ViewHolder {
      private TextView tvHolder;
}

@Override
public View getView(int position, View convertView, ViewGroup parent) {
      View view;
      ViewHolder holder;
      // 判断convertView的状态，来达到复用效果
      if (null == convertView) {
            // 如果convertView为空，则表示第一次显示该条目，需要创建一个view
            view = View.inflate(MainActivity.this, R.layout.listview_item, null);
            //新建一个viewholder对象
            holder = new ViewHolder();
            //将findviewbyID的结果赋值给holder对应的成员变量
            holder.tvHolder = (TextView) view.findViewById(R.id.tv_item);
            // 将holder与view进行绑定
            view.setTag(holder);
      } else {
            // 否则表示可以复用convertView
            view = convertView;
            holder = (ViewHolder) view.getTag();
      }
      // 直接操作holder中的成员变量即可，不需要每次都findViewById
      holder.tvHolder.setText(list.get(position));
      return view;
}

经过上面的做法，可能大家感觉不太到优化的效果，根据Google的文档，实际优化效果在百分之5左右。

优化三：

上面的两个例子中ListView都是显示的本地的List集合中的内容，List的长度也只有100个，我们可以毫不费力一次性加载完这100个数据；但是实际应用中，我们往往会需要使用Listview来显示网络上的内容，比如说我们拿使用ListView显示新闻为例：

其一：假如网络情况很好，我们使用的手机也许能够一下子加载完所有新闻数据，然后显示在ListView中，用户可能感觉还好，假如说在网络不太顺畅的情况下，用户加载完所有网络的数据，可能这个list是1000条新闻，那么用户可能需要面对一个空白的Activity好几分钟，这个显然是不合适的

其二：我们知道Android虚拟机给每个应用分配的运行时内存是一定的，一般性能不太好的机器只有16M，好一点的可能也就是64M的样子，假如说我们现在要浏览的新闻总数为一万条，即便是网络很好的情况下，我们可以很快的加载完毕，但是多数情况下也会出现内存溢出从而导致应用崩溃的情况。

那么为了解决上面的两个问题，我们需要进行分批加载，比如说1000条新闻的List集合，我们一次加载20条，等到用户翻页到底部的时候，我们再添加下面的20条到List中，再使用Adapter刷新ListView，这样用户一次只需要等待20条数据的传输时间，不需要一次等待好几分钟把数据都加载完再在ListView上显示。其次这样也可以缓解很多条新闻一次加载进行产生OOM应用崩溃的情况。

实际上，分批加载也不能完全解决问题，因为虽然我们在分批中一次只增加20条数据到List集合中，然后再刷新到ListView中去，假如有10万条数据，如果我们顺利读到最后这个List集合中还是会累积海量条数的数据，还是可能会造成OOM的情况，这时候我们就需要用到分页，比如说我们将这10万条数据分为1000页，每一页100条数据，每一页加载时都覆盖掉上一页中List集合中的内容，然后每一页内再使用分批加载，这样用户的体验就会相对好一些。

Android的线程和线程池

AsyncTask来说，它的底层用到了线程池，对于IntentService和HandlerThread来说，它的底层则直接就是线程。

AsyncTask封装了线程池和Handler，它主要是为了方便开发者在子线程中更新UI。

HandelrThread是一种具有消息循环的线程，在它的内部可以使用Handler。

IntentService是一个服务，系统对其进行了封装使它可以更方便的执行后台任务，IntentService内部采用了HandlerThread的来执行任务，当任务执行完毕后IntentService会自动退出。

IntentService的优点：从任务执行的角度看，IntentService的作用很像一个后台线程，但是IntentService是一种服务，他不容易被系统杀死从未可以尽量保证任务的进行，而如果一个后台线程，由于这个时候进程中没有活动的四大组件，那么这个进程的优先级就会变得很低，很容易被系统杀死。

主线程(main Thread)是指进程所拥有的线程。

主线程的作用是运行四大组件以及处理它们和用户的交互，而子线程的作用则是执行耗时任务，比如网络请求、I/O操作等。

AsyncTask

一个AsyncTask对象只能执行一次，即只能调用一次execute方法，否则会报错。

HandlerThread继承了Thread，它是一种可以使用Handler的Thread。在run方法中通过Looper.prepaer()来创建消息队列，并通过Looper.loop()来开启消息循环，这样在实际的使用中就允许在HandlerThread中创建Handler了。

普通Thread要用于在run方法中执行一个耗时任务，而HandlerThread在内部创建了消息队列，外界需要通过Handler的消息方式来通知HandlerThread执行一个具体的任务。

由于HandlerThread的run方法是一个无限循环，因此当明确不需要再使用HandlerThread时，可以通过它的quit和quitSafely方法来终止线程的执行。

IntentService是一种特殊的Service，它继承了Service并且他是一个抽象类，因此必须创建它的子类才能使用IntentService。由于IntentService是服务的原因，它的优先级别单纯的线程高很多，所以IntentService比较适合执行一些高优先级的后台任务，不易被杀死。

动画

View

自定义View

http://blog.csdn.net/u012975370/article/details/50033553#t4

DecorView为整个Window界面的最顶层View。

DecorView只有一个子元素为LinearLayout，代表整个window界面，包括通知栏、标题栏、内容显示栏三块区域。

一个视图实际上是具有两对宽高的，一对是测量宽高，一对是绘制宽高。

绘制VIew本身的内容，通过调用View.onDraw(canvas)函数实现
绘制自己的孩子通过dispatchDraw（canvas）实现
　　View组件的绘制会调用draw(Canvas canvas)方法，draw过程中主要是先画Drawable背景，对 drawable调用setBounds()然后是draw(Canvas c)方法.有点注意的是背景drawable的实际大小会影响view组件的大小，drawable的实际大小通过getIntrinsicWidth()和getIntrinsicHeight()获取，当背景比较大时view组件大小等于背景drawable的大小。画完背景后，draw过程会调用onDraw(Canvas canvas)方法，然后就是dispatchDraw(Canvas canvas)方法, dispatchDraw()主要是分发给子组件进行绘制，我们通常定制组件的时候重写的是onDraw()方法。值得注意的是ViewGroup容器组件的绘制，当它没有背景时直接调用的是dispatchDraw()方法, 而绕过了draw()方法，当它有背景的时候就调用draw()方法，而draw()方法里包含了dispatchDraw()方法的调用。因此要在ViewGroup上绘制东西的时候往往重写的是dispatchDraw()方法而不是onDraw()方法，或者自定制一个Drawable，重写它的draw(Canvas c)和 getIntrinsicWidth(),getIntrinsicHeight()方法，然后设为背景。

EXACYTLY  一般是设置了明确的值或者是MATH_PARENT

AT_MOST  表示子布局限制在一个最大值内，一般为WARP_CONTENT

UNSPECIFIED  表示子布局想要多大就多大，很少使用

• 每个Activity，都至少有一个Window，这个Window实际类型为PhoneWindow，当Activity中有子窗口，比如Dialog的时候，就会出现多个Window。Activity的Window是我们控制的，状态栏和导航栏的Window由系统控制。
• 在DecorView的里面，一定有一个id为content的FraneLayout的布局容器，咱们自己定义的xml布局都放在这里面。
• Activity的Window里面有一个DecorView，它使继承自FrameLayout的一个自定义控件，作为整个View层的容器，及View树的根节点。
• Window是虚拟的概念，DecorView才是看得见，摸得着的东西，Activity.setContentView()实际调用的是PhoneWindow.setContentView()，在这里面实现了DecorView的初始化和id为content的FraneLayout的布局容器的初始化，并且会根据主题等配置，选择不同的xml文件。而且在Activity.setContentView()之后，Window的一些特征位将被锁定。
• Activity.findViewById()实际上调用的是DecorView的findviewById()，这个方法在View中定义，但是是final的，实际起作用的是在ViewGroup中被重写的findViewTraversal()方法。
• Activity的mWindow成员变量是在attach()的时候被初始化的，attach()是Activity被通过反射手段实例化之后调用的第一个方法，在这之后生命周期方法才会依次调用
• 在onResume()刚执行之后，界面还是不可见的，只有执行完Activity.makeVisible()，DecorView才对用户可见
• ViewManager这个接口里面就三个接口，添加、移除和更新，实现这个接口的有WindowManager和ViewGroup，但是他们两个面向的对象是不一样的，WindowManager实现的是对Window的操作，而ViewGroup则是对View的增、删、更新操作。
• WindowManagerImpl是WindowManager的实现类，但是他就是一个代理类，代理的是WindowManagerGlobal，WindowManagerGlobal一个App里面就有一个，因为它是单例的，它里面管理了App中所有打开的DecorView，ContentView和PhoneWindow的布局参数WindowManager.LayoutParams，而且WindowManagerGlobal这个类是和WMS通信用的，是通过IWindowSession对象完成这个工作的，而IWindowSession一个App只有一个，但是每个ViewRootImpl都持有对IWindowSession的引用，所以ViewRootImpl可以和WMS喊话，但是WMS怎么和ViewRootImpl喊话呢？是通过ViewRootImpl::W这个内部类实现的，而且源码中很多地方采用了这种将接口隐藏为内部类的方式，这样可以实现六大设计原则之一——接口最小原则，这样ViewRootImpl和WMS就互相持有对方的代理，就可以互相交流了
• ViewRootImpl这个类每个Activity都有一个，它负责和WMS通信，同时相应WMS的指挥，还负责View界面的测量、布局和绘制工作，所以当你调用View.invalidate()和View.requestLayout()的时候，都会把事件传递到ViewRootImpl，然后ViewRootImpl计算出需要重绘的区域，告诉WMS，WMS再通知其他服务完成绘制和动画等效果，当然，这是后话，咱们以后再说。
• Window分为三种，子窗口，应用窗口和系统窗口，子窗口必须依附于一个上下文，就是Activity，因为它需要Activity的appToken，子窗口和Activity的WindowManager是一个的，都是根据appToken获取的，描述一个Window属于哪种类型，是根据LayoutParam.type决定的，不同类型有不同的取值范围，系统类的的Window需要特殊权限，当然Toast比较特殊，不需要权限
• PopupWindow使用的时候，如果想触发按键和触摸事件，需要添加一个背景，代码中会根据是否设置背景进行不同的逻辑判断
• Dialog在Activity不可见的时候，要主动dismiss掉，否则会因为appToken为空crash
• Toast属于系统窗口，由系统服务NotificationManagerService统一调度，NotificationManagerService中维持着一个集合ArrayList，最多存放50个Toast，但是NotificationManagerService只负责管理Toast，具体的显示工作由Toast::TN来实现
• View中的performClick()的出发条件：

  public boolean performClick() {
          sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
          if (mOnClickListener != null) {
              playSoundEffect(SoundEffectConstants.CLICK);
              mOnClickListener.onClick(this);
              return true;
          }
          return false;
      }

  由源码可以看出，只要是使用了view.setOnClickListener()方法设置监听器，就会自动触发view.performClick()。需要注意的是，如果同时使用了view.setOnTouchListener()方法，则有可能存在拦截view.performClick()的响应事件，因为当view.OnTouchEvent()在event.getAction() == MotionEvent.ACTION_DOWN时返回false，系统会认为view不需要处理Touch事件，则后续的Touch事件（move、up、click）就不会被传进来，所以也不会触发view.performClick()，而view.setOnTouchListener()相当于是重写了view.OnTouchEvent()，所以在写view的TouchListener处理时，需要留意view是否存在点击事件监听，如果有，则在适当的位置使用view.performClick()触发点击事件。

子线程更新ui的三种方式

1.通用的就是handler

2.通过runOnUiThread方法

    public final void runOnUiThread(Runnable action) {
        if (Thread.currentThread() != mUiThread) {
            mHandler.post(action);
        } else {
            action.run();
        }
    }

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 此处执行耗时操作，结束后，执行runOnUiThread将线程切换到主线程去更新ui
                
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // 更新ui操作
                    }
                });
            }
        }).start();

        final Activity activity = (Activity) mTextView.getContext();
        new Thread(new Runnable() {
            @Override
            public void run() {
                activity.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        
                    }
                });
            }
        }).start();

3.通过view.post(runnable)来实现

        mTextView.post(new Runnable() {
            @Override
            public void run() {

            }
        });

4.子线程直接更新ui的极端情况

android的UI访问是没有加锁的，这样会导致多个线程访问ui会不安全，那么既然这样，为什么不加锁呢，因为加上锁机制会让ui访问的逻辑变得复杂，其次锁机制会降低ui访问的效率，锁机制会阻塞某些线程的执行。所以android规定，只能在主线程更新ui。

子线程真的无法更新ui吗，答案是no，因为有些极端情况，还是可以更新ui的。

我们在onCreate中直接执行以下代码：

        Log.i("niejianjian", " -> onCreate -> " + Thread.currentThread().getId());
        new Thread(new Runnable() {
            @Override
            public void run() {
                Log.i("niejianjian", " -> Thread -> " + Thread.currentThread().getId());
                mTextView.setText("fjsdlj l");
            }
        }).start();

        Log.i("niejianjian", " -> onCreate -> " + Thread.currentThread().getId());
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Log.i("niejianjian", " -> Thread -> " + Thread.currentThread().getId());
                mTextView.setText("fjsdlj l");
            }
        }).start();

android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.
	at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:6257)
        at android.view.ViewRootImpl.requestLayout(ViewRootImpl.java:868)

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a view hierarchy can touch its views.");
    }
}

ViewRootImpl的创建在onResume方法回调之后，而我们一开篇是在onCreate方法中创建了子线程并访问UI，在那个时刻，ViewRootImpl是没有创建的，无法检测当前线程是否是UI线程，所以程序没有崩溃一样能跑起来，而之后修改了程序，让线程休眠了200毫秒后，程序就崩了。很明显200毫秒后ViewRootImpl已经创建了，可以执行checkThread方法检查当前线程。

Bitmap的加载和Cache

Android对单个应用施加了内存限制，16MB，这导致在加载Bitmap的时候很容易出现内存溢出，异常信息为：

java.lang.OutofMemoryError：bitmap size exceeds VM budget

比较常使用的缓存策略为LruCache和DiskLruCache。其中LruCache常备用做内存缓存，额DiskLruCache常被用作存储缓存。

Lru是Least Recnetly Used的缩写，也就是最近最少使用算法，其核心思想为：当缓存快满时，会淘汰掉近期最少使用的缓存目标。

如何加载一个Bitmap？

BitmapFactory提供了四类方法：decodeFile、decodeResource、decodeSream、decodeByteArray，分别支持从文件系统、资源、输入流以及字节数组中加载出一个Bitmap，其中decodeFile和decodeResource又简介调用了decodeStream方法。

如何高效的加载Bitmap？

采用BitmapFactory.Options来加载所需尺寸的图片。一般情况下ImageView都没有原始图片那么大，如果将图片整个加载，在设给imageView的话，显然没必要，因为并没有办法显示原始的图片。通过BitmapFactory.Options就可以按一定的采样率来加载缩小后的图片了，这样就可以降低内存占用从而在一定程度上避免了OOM。

通过BitmapFactory.Options来缩放图片，主要用到了参数inSampleSize参数，即采样率。

当inSampleSize为1时，采样后的图片大小为原始大小；数值必须是大于一的整数，当小于1时，相当于是1。比如insample是2，那么采样后的图片的宽高均为原图的1/2，而像素是原图的1/4，所以内存大小也为原图的1/4。inSample的取值应该总是2的指数，如果不是2的指数，系统会自动向下取整（并不完全成立）。

如何获取采样率？

1).将BitmapFactory.Options的inJustDecodeBounds参数设为true并加载图片

2).从BitmapFactory.Options中取出图片的原始宽高信息，它们对应于outWidth和outHeight参数

3).根据采样率的规则并结合目标View的所需大小，计算出采样率inSampleSize

4).将BitmapFactory.Options的inJustDecodeBounds参数设为false，然后重新加载图片。 

优化列表的卡顿现象：

1).不要在getView中执行耗时操作。必须通过异步操作来实现，比如ImageLoader

2).控制异步任务的刷新频率

3).开启硬件加速。设置android:hardwareAccelerated=”true”即可

针对控制刷新频率的详解：(为什么要在列表滑动的时候停止加载图片)

在getView方法中会通过ImageLoader的bindBitmap方法来异步加载图片，但是如果用户可以频繁的上下滑动，这个会在一瞬间产生上百个异步任务，这些异步任务会造成线程池的拥堵并随即带来大量的Ui更新操作，这是没有意义的。由于一瞬间存在了大量的UI更新操作，这些UI操作是运行在主线程，所以造成了一定程度的卡顿。

具体实现时，可以给ListView和GridView设置setScrollListener，并在OnScrollListener的onScrollStateChanged方法中判断是否滑动，如果是就停止加载图片。

JNI

Java JNI的本意是Java Native Interface，它是为了方便Java调用C、C++等本地代码所封装的一层接口。

NDK是Android所提哦功能的一个工具集合，通过NDK可以在Android中更方便地通过JNI来访问本地代码，比如C或者C++。

NDK的好处：

1).提高代码的安全性。由于so库反编译比较困难，因此NDK提高了Android程序的安全性。

2).可以很方便地使用目前已有的C/C++开源库。

3).便于平台间的移植。通过C/C++实现的动态库可以很方便的在其他平台上使用。

4).提高程序在某些特定情形下的执行效率，但是并不能明显提升Android程序的性能。

JNI的开发流程

1.在java中声明native方法

2.编译java源文件得到class文件，然后通过javah命令导出JNI的头文件

3.实现JNI方法

4.编译so库并在java中调用

Toast

HTTP

1.HTTP协议可以通过传输层的TCP协议在额客户端和服务器之间传输数据。

2.HTTP协议采用了请求/响应的工作方式。基于HTTP1.0协议的客户端每次向服务器发出请求后，服务器就会向客户端返回响应消息（包括请求是否正确以及锁请求的数据），在确认客户端已经收到响应消息后，服务器就会关闭网络连接，并不保存任何历史信息和状态信息。HTTP协议也被认为是无状态协议。

3.通讯过程：

 通过客户端Socket建立连接；向服务器发送请求；服务器回送响应；服务器关闭连接。

4.HTTP1.1协议增加了持久连接支持。也就是服务器将关闭客户端连接的主动权还给了客户端，客户端向服务器发送一个请求并接受到一个响应后，只要不调用Socket类的close方法关闭网络，就可以继续想服务器发送HTTP请求。

5.Android6.0（API23）删除了http.client的一些类，导致HttpPost类完全找不到了。

Android性能优化

1.布局优化

减少布局文件的层级，这样就减少了Android绘制工作。

如果可以使用LinearLayout也可以使用RelativeLayout时，就选择LinearLayout。这是因为RelativeLayout的功能比较复杂，它的布局过程需要花费更多的CPU时间。LinearLayout和FrameLayout一样是一种简单高校的ViewGroup。如果使用LinearLayout布局需要嵌套才能完成，此时建议使用RelativeLayout。

在不影响层级深度的情况下，使用LinearLayout而不是Relativelayout。因为Relative会让子view执行两次onMeasure，LinearLayout在有weight的时候，才会让子view执行两次onMeasure。Measure耗时越长，绘制效率越低。

布局优化另一种手段是采用<include>标签、<merge>标签和ViewStub。<include>标签只要用于布局重用，<merge>标签一般和<include>配合使用，它可以降低减少布局的层级，而ViewStub则提供了按需加载的功能，当需要时才会将ViewStub中布局加载到内存，这就提高了程序的初始化效率。

1).<include>标签只支持以android:layout_开头的属性，比如android:layout_width、android:layout_height，其他属性不支持，比如android:background。

2).android:id是特例，如果<include>和被包含的布局文件的根源素都指定了id属性，那么以<include>指定的id属性为准。

3).如果<include>标签指定了android:layout_*这种属性，那么要求android:layout_width、android:layout_height必须存在，否则其他android:layout_*形式的属性都无效。

4).<merge>标签一般和<include>标签一起使用从而减少布局的层级。如果父布局是LinearLayout，而且orientation=”vertical”，<include>标签中包含的布局中包含两个按钮，也是LinearLayout布局，方向也是orientaion=”vertical”，此时，再被包含的布局中再写LinearLayout就是多要点，通过merge标签就额可以去掉多余的那一层LinearLayout。

5).ViewStub继承了View，它非常轻量级且宽高都是0 。因此它本身不参与任何的布局和绘制过程。ViewStub的意义在于按需加载所需的布局文件，在实际开发中，有很多布局文件在正常情况下不会显示，比如网络异常时的界面，这个时候就没有必要在整个界面初始化的时候将它加载进来，在需要的时候在加载。

<ViewStub
        android:id="@+id/stub_import"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:inflatedId="@+id/panel_import"
        android:layout="@layout/activity_test" />

其中stub_import是ViewStub的id，而panel_import是layout/activity_test这个布局的根元素的id。在需要加载ViewStub中的布局的时候，可以按照如下两种方式加载：

((ViewStub) findViewById(R.id.stub_import)).setVisibility(View.VISIBLE);

或者

View importpPanel = ((ViewStub)findViewById(R.id.stub_import)).inflate();

2.绘制化

绘制优化是指View的onDraw方法要避免执行大量的操作，主要体现在两方面。

1).onDraw中不要创建新的布局对象，这是因为onDraw方法可能会被频繁调用，这样就会在一瞬间产生大量的临时对象，这不仅占用了过多的内存而且还会导致系统更加频繁的gc，降低了程序的执行效率。

2).另一方面，onDraw方法中不要做耗时的任务，也不能执行成千上万次的循环操作，尽管每次循环都很轻量级，但是大量的循环仍然十分抢占CPU的时间片，这会造成View的绘制过程不流畅。按照Google官方给出的性能优化典范中的标准，View的绘制帧率保证60fps是最佳的，这就是要求每帧的绘制时间不超过16ms(1000/16)，虽然程序很难保证这个时间，但是尽量降低onDraw方法复杂度总是切实有效的。

3.内存泄漏优化

内存泄漏的优化分为两方面，一方面是开发过程中避免写出有内存泄漏的代码，另一方面是通过一些分析工具比如MAT来找出潜在的内存泄漏进行解决。

1).静态变量导致的内存泄漏

这面的代码将导致内存泄漏，Activity不能正常销毁。

public class MainActivity1 extends Activity {
	private static final String TAG = "MainActivity1";

	private static Context mContext;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mContext = this;
	}
}

public class MainActivity1 extends Activity {
	private static final String TAG = "MainActivity1";

	private static View mView;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mView = new View(this);
	}
}

2).单例模式导致的内存泄漏

首先提供一个单例模式TestManger，TestManager可以接受外部的注册并将外部的监听器存储起来。

public class TestManager {
	private List<onDataArrivedListener> mOnDataArrivedListeners = new ArrayList<onDataArrivedListener>();

	private static class SingletonHolder {
		public static final TestManager INSTANCE = new TestManager();
	}

	private TestManager() {
	}

	public static TestManager getInstance() {
		return SingletonHolder.INSTANCE;
	}

	public synchronized void registerListener(onDataArrivedListener listener) {
		if (!mOnDataArrivedListeners.contains(listener)) {
			mOnDataArrivedListeners.add(listener);
		}
	}

	public synchronized void unregisterListener(onDataArrivedListener listener) {
		mOnDataArrivedListeners.remove(listener);
	}

	public interface onDataArrivedListener {
		public void onDataArrived(Object data);
	}
}

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		TestManager.getInstance().registerListener(this);
	}

3).属性动画导致的内存泄漏

从Android3.0开始，Google提供了属性动画，属性动画中有一类无限循环的动画，如果在Activity中播放此类动画且没有在onDestory中停止动画，那么动画会一直被播放下去，尽管已经无法在界面上看到动画效果了，并且这个时候Activity的View动画会被动画持有，而View又持有了Activity，最终Activity无法释放。下面的动画是无限动画，会泄漏当前Activity，解决方法就是在Activity的onDestory中调用animator.cancel()来停止动画。

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);

		Button mButton = (Button) findViewById(R.id.button1);
		ObjectAnimator animator = ObjectAnimator.ofFloat(mButton, "rotation",
				0, 360).setDuration(2000);
		animator.setRepeatCount(ValueAnimator.INFINITE);
		animator.start();
	}

1.你可以提醒系统定期回收，system.gc()，对于那些你不用的东西，你可以设置为null或者0，系统就会回收，还有其他的东西。
2.可以自己手动关闭，比如bitmap,就有bitmap.recycle（）；方法，还有cursor.close()；用完记得关闭。
3.如果是特殊的一些自己写的东西，你可以写一个回收的方法或者类，来回收，比如动画。

onPause中不用去释放，onStop里才要释放那些你的代码自己用的东西

Android内存泄漏就这样产生了：http://blog.csdn.net/sunchaoenter/article/details/7224926

如何避免内存泄漏：http://blog.csdn.net/sunchaoenter/article/details/7209635

4.响应速度优化

响应速度优化的核心思想就是避免在主线程中做耗时操作。

如果Activity5秒钟无法响应屏幕触摸事件或者键盘输入事件就会出现ANR，而BroadcastReceiver如果10秒之内还未完成操作，也会出现ANR。

5.LIstView优化

首先要采用ViewHolder并避免在getView中执行耗时操作；

要根据列表的滑动状态来控制任务的执行频率，比如当列表快速滑动时显示是不太合适开启大量的异步任务的；

最后可以尝试开启硬件加速来使ListView的滑动更加流畅。

ListView的优化策略完全适用于GridView。

6.线程优化

线程优化的思想就是采用线程池，避免程序中存在大量的Thread。线程池可以重用内部的线程，从而避免了线程的创建和销毁所带来的性能开销，同时线程池还能有效地控制线程池的最大并发数，避免大量的线程因互相抢占系统资源从而导致阻塞线程的发生。

7.其他建议

避免创建过多的对象；

不要过多使用枚举，枚举占用的内存空间要比整型大；

常量请使用static fianl来修饰；

使用一些Android特有的数据结构，比如SpareArray和Pair等，它们都具有更有的性能；

适当使用软引用和弱引用；

采用内存缓存和磁盘缓存；

尽量采用静态内部类，这样可以避免潜在的由于内部类而导致的内存泄漏。

综合技术

1.用户使用中，遇到crash，如何获得crash信息。

可以通过CrashHandler来监视应用的crash信息，给程序设置一个CrashHandler，这样当程序crash时就会调用CrashHandler的uncaughtException方法。在方法中获得crash信息，然后上传服务器。

2.Android有一个限制，就是整个应用的方法数不能超过65536，否则会编译错误，并且无法安装到手机上。Google提供了multidex方案解决这个问题，通过将一个dex文件拆分为多个dex文件来避免单个dex文件方法数越界的问题。（dex文件：Andorid平台上可执行文件类型）。

方法越界的另一种解决方案是动态加载。动态加载可以直接加载一个dex形式的文件，将部分代码打包到一个单独的dex文件中（也就是dex格式的jar或者apk），并在程序运行时根据需要去动态加载dex中的类，这种方式既可以解决环节方法数越界额问题，也可以为程序提供按需加载的特性，同时这还为应用按模块更新提供了可能性。

3.反编译：

在Android中反编译主要通过dex2Jar以及apktool来完成。dex2Jar可以将apk转换成一个jar包，这个jar包在通过反编译工具jd-gui来打开就可以查看到反编译后的Java代码了。Apktool主要用于应用的解包和二次打包。

1. Inent大多是应用层的功能整合，Binder则大多用在系统层的整合

2. 接口能不能继承接口：可以，因为手动创建一个aidl文件，会自动在gen目录下生成同名的 java文件，这个java文件本身就是接口，而且它还继承了android.os.IInterface，所以我认为接口可以继承接口。所以在Binder中传输的接口都需要继承IInterface接口。

3. 尽管Book类和IBookManager在相同的包下，但是在IBookManager中仍需导入Book类，这是AIDL的特殊之处。

4. java synchronized详解：http://www.cnblogs.com/GnagWang/archive/2011/02/27/1966606.html

5. 在android中的主线程也就是UI线程，UI线程中才可以操作界面元素。在主线程中执行耗时操作，会造成UI阻塞，导致ANR；在非主线程中更新UI，会直接报错。

案例：Serrvice向Activity发送广播，更新UI ：http://blog.csdn.net/u012975370/article/details/50033553#t0

6. android对单个应用所使用的最大内存做了限制，可以利用多进程模式增大一个应用可使用的内存。

7. android中使用多进程的方法：

1).给四大组件在AndroidManifest.xml中指定android：process属性。

2).非常规方法：通过JNI在native层去fork一个新的进程。

8. 使用多进程会造成如下的几个方面的问题：

    1) 静态成员和单例模式完全失效

    2) 线程同步机制完全失效  

    3) SharedPreferences的可靠性下降

    4) Application会多次创建

9. Thread的运行是独立于Acitivty的，当Accitivty被finish之后，如果你没有主动停止Thread或者Thread中的run方法没有执行完毕的话，Thread也会一直执行。

13. Android的动画类型：View Animation , Drawable Animation , Property Animation 。

View Animation 只是支持简单的缩放、平移、旋转、透明等基本属性，View动画对View的影响做操作，它并不能改变View的位置参数以及宽高。如果想要保留动画后的状态需要属性fillAfter，设置为true，否则动画完成后自动消失。 Property Animation解决了View Animation不能真正改变View属性的问题。

14. getX/getY返回的是相对于当前View左上角的x和y坐标，

getRawX/getRawY返回的是相对于手机屏幕左上角的x和y坐标。

15.

scrollTo()相对于初始位置滚动某段距离 

scrollBy()相对于当前位置滚动某段距离

17.使用Adapter的时候，如果你使用了ViewHolder做缓存，在getView的方法中无论这项的每个视图是否需要设置属性(比如TextView设置的属性可能为null，item的某一个按钮的背景为透明、某一项的颜色为透明等)，都需要为每一项的所有视图设置属性（textview的属性为空也需要设置setText(“”)，背景透明也需要设置），否则在滑动的过程中会出现内容的显示错乱。

18.不同API版本的AsyncTask实现不一样，有的是可以同时执行多个任务，有的API中只能同时执行一个线程，所以在程序中同时执行多个AsyncTask时有可能遇到一个AsyncTask的excute方法后很久都没有执行。调用AsyncTask的excute方法不能立即执行程序的原因分析及改善方案

19.系统上安装了很多浏览器，如何指定某个浏览器访问固定的网页

 	Intent intent =newIntent();        
         intent.setAction("android.intent.action.VIEW");    
         Uri content_url =Uri.parse("http://www.163.com");   
         intent.setData(content_url);           
         intent.setClassName("com.android.browser","com.android.browser.BrowserActivity");   
         startActivity(intent);

20.在Activity中弹出对话框，并不会执行onPause，所以对话框消失，也不会执行onResume方法。因为我们创建dialog的时候，需要传入一个Acitivity的上下文，既然使用者Activity的上下文，就认为Acitivity是在交互状态中所以，每一失去焦点，就不会执行onPause方法。

Java基础：

1.面向对象

面向过程：强调的是功能行为

面向对象：将功能行为进行封装，强调的是具备功能行为的对象。

例如：将大象装进冰箱

这个过程包括，打开冰箱->存储->关闭冰箱。

这三个行为的对象是冰箱

如果我们面向过程，就会执行打开、存储、关闭这三个操作。

但是我们面向对象，我们只需要记住冰箱，让冰箱去执行打开、存储、关闭的过程即可。

而且，我们从执行者变成了指挥者。

原来我们需要自己执行打开、存储、关闭操作。

现在我们只需要指挥冰箱去打开、存储、关闭。至于执行过程，怎么执行，我们不需要关心。

2.Java多线程

多线程尽可能利用CPU的资源，提高效率

只有运行状态的线程才会有机会执行代码，主线程的终止不会影响其他的正在运行中的线程，主线程终止也就是main()方法退出了，只有进程中的所有线程都终止了，进程(JVM进程)才会退出，只要有线程没有终止，进程就不会退出。

线程编程的两种方式：

1.Thread类

   线程(Thread)包含一个可以运行的过程：run()方法。

2.创建一个具体线程的步骤如下：

  第一，继承Thread类。

  第二，覆盖run方法，就是更新运行过程，实现用户自己的过程。

  第三，创建线程实例，就是创建一个线程。

  第四，使用线程实例的start()方法启动线程，启动以后线程会尽快的去并发执行run()。

方法一：继承Thread类

步骤：

 1).继承Thread类，覆盖run()方法，提供并发运行的过程。

 2).创建这个类的实例

 3).使用start()方法启动线程。

方法二：实现Runnable接口

步骤：

  1).实现Runnbale接口，实现run()方法，提供并发运程的过程

  2).创建这个类的实例，用这个实例作为Thread构造器参数，创建爱你Thread类

  3).使用start()方法启动线程

class MyRunnable implements Runnable {
	@Override
	public void run() {
	}
}
public class TestThread {
	public static void main(String[] args) {
		Runnable myRunnable = new MyRunnable();
		Thread thread = new Thread(myRunnable);
		thread.start();
	}
}

线程的常用方法和属性

1.线程的优先级

   t.setPriority(Thread.MAX_PRIORITY);

   默认有10级优先级，优先级高的线程获得running状态的机会多，机会的多少不能代码干预。默认的优先级是5.

2.后台线程

  t.setDaemon(true);

  Java进程的结束：当前所以前台线程都结束时，java进程结束。

  当前台线程全都结束时，不管后台线程有没有执行结束，都要被停止。

3.获得线程的名字

  geName()；

4.获得当前线程

  Thread main = Thread.currentThread()；

Thread的状态

New新建状态 -> Runnable可运行(就绪)状态 -> Running运行状态 -> Block阻塞(挂起)状态  -> Dead死亡状态

Sleep状态的打断唤醒

1.Thread.sleep(times)  Running->Block ->Runnable

2.Interrupt()方法打断/中断。

  使用该方法可以让一个线程提前唤醒另外一个sleep Block的线程。

3.被唤醒线程会出现中断异常。

Sleep()和wait()的区别

Sleep：Thread类中定义的方法，表示线程休眠，会自动唤醒

Wait：Object中定义的方法，需要手工调用notify()或者notifyAll()方法

Sleep就是正在执行的线程主动让出了cpu，cpu去执行其他的线程，在sleep指定的时间过后，cpu才会回到这个线程上继续执行，如果当前线程进入同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。Wait是指在一个已经进入同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到暂时的可以得到同步锁并运行。只有其他线程调用notify方法，（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了， 但不是马上得到锁，因为锁还在别人的手里，别人还没有释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notify方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会接触wait状态和程序可以再次得到锁后继续向下运行。

public class TestThread {
	public static void main(String[] args) {
		new Thread(new Thread1()).start();
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		new Thread(new Thread2()).start();
	}

	private static class Thread1 implements Runnable {

		@Override
		public void run() {
			synchronized (TestThread.class) {
				System.out.println("enter thread1...");
				System.out.println("thread1 is waiting");
				try {
					/*
					 * 释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字关下的代码范围，
					 * 另一种方式就是synchronized关键字关下的代码内部调用监视器对象的wait方法
					 * ，这里，使用wait方法释放锁。
					 */
					TestThread.class.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("thread1 is going on...");
				System.out.println("thread1 is being over !");
			}
		}
	}

	private static class Thread2 implements Runnable {

		@Override
		public void run() {
			System.out.println("enter thread2...");
			System.out
					.println("thread2 notify other thread can release wait status");
			/*
			 * 由于notify方法并不释放锁，即使thread2调用下面的sleep方法休息10毫秒，但thread1仍然不会执行，
			 * 因为thread2没有释放锁，所以thread1无法得锁
			 */
			TestThread.class.notify();
			System.out.println("thread2 is sleeping ren millisecond");
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("thread2 is going on...");
			System.out.println("thread2 is being over !");
		}
	}
}

在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成的。但是在使用Runnable定义的子类中没有start()方法，只有Thread类中才有，查看Thread元那么会发现，有一个构造函数public Thread(Runnable target)；此构造方法接受Runnable的子类实例。

由于java类有单继承多接口的特点，所以使用Runnable可以避免点继承的局限性；适用于资源共享。其实，Thread也是Runnable的子类。

http://mars914.iteye.com/blog/1508429

http://blog.csdn.net/wwww1988600/article/details/7309070

线程安全：

线程安全问题都是由全局变量及静态变量引起的。

若每个线程中对全局变量、静态变量只有读操作，没有写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

线程池：

Java线程池是通过hashmap获取当前的线程，保持线程同步。

子线程更新UI：

Android的UI是单线程的，为了避免拖住GUI，一些较费时的对象应该交给独立的线程去执行，如果幕后的线程来执行UI对象，Android就会发出错误讯息CalledFromWrongThreadException。

堆主要是用来存放对象的，栈主要是用来执行程序的。

Thread类中的start()和run()方法的区别：

Start()方法被用来启动新创建的线程，而且start()内部调用了run()方法，这和直接调用run()方法的效果是不一样的。当你调用run()方法的时候，只会在原来的线程中调用，没有新的线程启动，start()才会启动新线程。

Java内存模型对一个线程所做的变动能被其他线程可见提供了保证，它们之间是线程发生关系，这个关系定义了一些规则让程序员在并发线程时思路更清晰，比如，线程发生关系确保了：

1).线程内的代码能够按先后顺序执行，这被成为程序次序规则；

2).对于同一个锁，一个解锁操作一定要发生在时间上后发生的另一个锁定操作之前，也叫做管理锁定规则；

3).前一个对volatile的写操作在后一个volatile的读操作之前，也叫做volatile变量规则；

4).一个线程内的任何操作都必须在这个线程start()调用之后，也叫做线程启动规则；

5).一个线程的所以操作都会在线程终止之前，线程终止规则；

6).一个对象的终结才做必须在这个对象构造完成之前，也叫对象终结规则；

7).可传递性。

50个java多线程的面试题：http://www.androidchina.net/589.html

Java集合：

Collection

List

    LinkedList

    ArrayList

    Vector

        Stack

Set

Map

      Hashtable

      HashMap

      WeakHashMap

Map：提供key到value的映射

List：有序，可重复的集合

ArrayList：实质就是一个会自动增长的数组。

1).查询效率比较高，增删效率比较低，适用于查询比较频繁，增删动作比较少的元素管理的集合。

2).加载大批量的数据时，先进行手动扩容（调用ensureCapacity(int minCapacity)）

LinkedList:底层是用双向循环链表来实现的。

查询效率低，但是增删效率很高，适用于增删动作的比较频繁，查询次数较少的元素管理的集合。

Set：无序的，不允许有重复的元素集合。

HashSet：

      Object类中的hashCode()的方法是所有类都会继承的方法，这个方法会算出一个Hash码值返回，HashSet会用Hash码值去和数组长度取模，对象的模值(这个模值就是对象要存放在数组中的位置，和数组的下标相同)相同时才会判断数组中的元素和要加入的对象的内容是否相同，如果不同才会再找位置添加进去，相同则不允许添加。

      如果数组中的元素和要加入的对象的hashCode()返回了相同的Hash码值，才会用equals()方法来判断两个对象的内容是否相同。

      注意：要存入HashSet的集合对象中的自定义类必须hashCode()、euqals()两个方法，才能保证集合中元素不重复。

Map：存放key-value对(有关系的两个对象，一个叫做key，一个叫做value，同时存入)

HashMap：基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null键。

Hashtable：同HashMap，一般不使用

HashMap和Hashtable的区别：

HashMap:非线程安全，不支持并发控制，允许空的键值对。

Hashtable：是线程安全，支持并发控制，不允许有空的键值对。

Key一般是8中基本类型的封装类或者是String类，拿自己自定义的类作为key没有意义。

线性表List

List表示有先后次序的对象集合，比如歌曲列表。

1).ArrayList = Object[] + 线性表操作(增删改差)

2).StringBuilder = char[] + 操作(增删改查)

ArrayList和 StringBuilder相比，基本操作都差不多，但是ArrayList除了可以添加String类型，还可以添加其他对象。

StringBuilder打印出来是一个字符串，ArrayList打印出来，是一个类似于数组，用中括号包裹起来，中间用逗号隔开的一组内容。

对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector和Hashtable是旧的，是java一旦生就是提供的，它们是线程安全的，ArrayList和HashMap是java2时才提供的，它们是线程不安全的。所以，一般单线程的时候，用HashMap和ArrayList，因为不需要考虑线程安全，但是多线程时就需要用Vector和Hashtable。

Vector和ArrayList都有一个初始的容量大小，当存储进它们里面的元素超过容量时，就会自动增加大小，Vector默认增加为原来的两倍，ArrayList默认增加为原来的1.5倍。ArrayList都可以设置初始的空间大小，Vector可以设置增长的空间大小，而ArrayList则不可以设置。

LinkedList和ArrayList

ArrayList是使用变长数组算法实现的，ArrayList继承自List()；

1).ArrayList和Vector的比较：Vector线程安全的，效率较低，也是使用可变长数组算法实现的，继承自List接口。ArrayList，线程不安全的，效率高速度快，现在常用。

2).LinkedLIst和ArrayList的比较：LinkedList是采用双向循环链表实现的List。ArrayList是采用变长数组算法实现的List。

3).区别：ArrayList采用的数组形式保存对象，LinkedList基于链表的数据结构。对于随机访问get和set方法，ArrayList优于LinkedList，因为LinkedList要移动指针；对于新增add和删除remove操作，LinkedList比较占优势，因为ArrayList要移动数据。

Vector的放过是线程同步的，是线程安全的，而ArrayList的方式不是，由于线程的同步必然影响性能，因此ArrayList的性能比Vector好；当Vector或ArrayList中的元素超过它的初始化大小时，Vector会将它的容量翻倍，而ArrayList只会增加50%，所以，ArrayList有利于节约内存空间。

最后

以上就是粗犷小猫咪为你收集整理的android开发经验笔记总计四大组件：IntentHanlderListViewAndroid的线程和线程池 动画View子线程更新ui的三种方式Bitmap的加载和CacheJNIToastHTTPAndroid性能优化综合技术Java基础：Java集合：的全部内容，希望文章能够帮你解决android开发经验笔记总计四大组件：IntentHanlderListViewAndroid的线程和线程池 动画View子线程更新ui的三种方式Bitmap的加载和CacheJNIToastHTTPAndroid性能优化综合技术Java基础：Java集合：所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。