ArrayAdapter是继承BaseAdapter而来,还实现了Filterable接口,Filterable接口顾名思义,就是个过滤器,比如电话簿的查找功能,可以通过这个过滤器来得到查找结果,既然有过滤功能,那过滤器得到的数据,就应该被适配器获取并更新,所以ArrayAdapter还有类似数组的insert、add、addall、remove、clear等功能,可以对ArrayAdapter的数据进行插入、增加、移除、清除,比如通过过滤器进行了过滤以后,需要对ArrayAdapter的数据进行更新,那么就先把ArrayAdapter的数据进行清空(clear),再进行加载工作(add 、addall等),以下是ArrayAdapter.java的源码
package android.widget;
import android.content.Context;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class ArrayAdapter extends BaseAdapter implements Filterable {
private List mObjects; //用于保存适配器所获取的数据
private final Object mLock = new Object(); //一个锁,同步锁
private int mResource; //资源的id,一般是layout文件的id
private int mDropDownResource; //是mResource的一个拷贝
private int mFieldId = 0; //一般指layout文件里的一个id
private boolean mNotifyOnChange = true;
private Context mContext;
private ArrayList mOriginalValues; //是mObjects的一个拷贝,主要用于处理过滤器的数据
private ArrayFilter mFilter; //这就是传说中的过滤器了,查询功能得靠它来实现
private LayoutInflater mInflater; //一个LayoutInflater,用于导入一个layout
/*下面都是不同给构造函数,没啥好说的,重点在于init(……)函数*/
public ArrayAdapter(Context context, int textViewResourceId) {
init(context, textViewResourceId, 0, new ArrayList());
}
public ArrayAdapter(Context context, int resource, int textViewResourceId) {
init(context, resource, textViewResourceId, new ArrayList());
}
public ArrayAdapter(Context context, int textViewResourceId, T[] objects) {
init(context, textViewResourceId, 0, Arrays.asList(objects));
}
public ArrayAdapter(Context context, int resource, int textViewResourceId, T[] objects) {
init(context, resource, textViewResourceId, Arrays.asList(objects));
}
public ArrayAdapter(Context context, int textViewResourceId, List objects) {
init(context, textViewResourceId, 0, objects);
}
public ArrayAdapter(Context context, int resource, int textViewResourceId, List objects) {
init(context, resource, textViewResourceId, objects);
}
/*以下就是对适配器的数据进行类似数组的操作处理,插入、增加、清除、移除*/
public void add(T object) {
synchronized (mLock) {
if (mOriginalValues != null) {
mOriginalValues.add(object);
} else {
mObjects.add(object);
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
public void addAll(Collection extends T> collection) {
synchronized (mLock) {
if (mOriginalValues != null) {
mOriginalValues.addAll(collection);
} else {
mObjects.addAll(collection);
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
public void addAll(T ... items) {
synchronized (mLock) {
if (mOriginalValues != null) {
Collections.addAll(mOriginalValues, items);
} else {
Collections.addAll(mObjects, items);
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
public void insert(T object, int index) {
synchronized (mLock) {
if (mOriginalValues != null) {
mOriginalValues.add(index, object);
} else {
mObjects.add(index, object);
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
public void remove(T object) {
synchronized (mLock) {
if (mOriginalValues != null) {
mOriginalValues.remove(object);
} else {
mObjects.remove(object);
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
public void clear() {
synchronized (mLock) {
if (mOriginalValues != null) {
mOriginalValues.clear();
} else {
mObjects.clear();
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
public void sort(Comparator super T> comparator) {
synchronized (mLock) {
if (mOriginalValues != null) {
Collections.sort(mOriginalValues, comparator);
} else {
Collections.sort(mObjects, comparator);
}
}
if (mNotifyOnChange) notifyDataSetChanged();
}
@Override
public void notifyDataSetChanged() {
super.notifyDataSetChanged();
mNotifyOnChange = true;
}
public void setNotifyOnChange(boolean notifyOnChange) {
mNotifyOnChange = notifyOnChange;
}
/*这是其实就是对一些变量的初始化,上下文mContext,LayoutInflater,layout布局文件的id,还是适配器数据的原始数据mObjects,还有layout文件里的某个要显示的textview---mFieldId */
private void init(Context context, int resource, int textViewResourceId, List objects) {
mContext = context;
mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
mResource = mDropDownResource = resource;
mObjects = objects;
mFieldId = textViewResourceId;
}
/*以下都是从BaseAdapter继承过来的一些函数*/
public Context getContext() {
return mContext;
}
public int getCount() {
return mObjects.size();
}
public T getItem(int position) {
return mObjects.get(position);
}
public int getPosition(T item) {
return mObjects.indexOf(item);
}
public long getItemId(int position) {
return position;
}
public View getView(int position, View convertView, ViewGroup parent) {
return createViewFromResource(position, convertView, parent, mResource);
}
/*在这里要注意一点,别看这个类用到泛型类型,但是还是有限制的,就是ArrayAdapter中必须是TextView类,否则会出错*/
private View createViewFromResource(int position, View convertView, ViewGroup parent,
int resource) {
View view;
TextView text;
if (convertView == null) {
view = mInflater.inflate(resource, parent, false);
} else {
view = convertView;
}
try {
if (mFieldId == 0) {
// If no custom field is assigned, assume the whole resource is a TextView
text = (TextView) view;
} else {
// Otherwise, find the TextView field within the layout
text = (TextView) view.findViewById(mFieldId);
}
} catch (ClassCastException e) {
/*ArrayAdapter中必须是TextView类,否则会出错*/
Log.e("ArrayAdapter", "You must supply a resource ID for a TextView");
throw new IllegalStateException(
"ArrayAdapter requires the resource ID to be a TextView", e);
}
T item = getItem(position);
if (item instanceof CharSequence) {
text.setText((CharSequence)item);
} else {
text.setText(item.toString());
}
return view;
}
public void setDropDownViewResource(int resource) {
this.mDropDownResource = resource;
}
@Override
public View getDropDownView(int position, View convertView, ViewGroup parent) {
return createViewFromResource(position, convertView, parent, mDropDownResource);
}
public static ArrayAdapter createFromResource(Context context,
int textArrayResId, int textViewResId) {
CharSequence[] strings = context.getResources().getTextArray(textArrayResId);
return new ArrayAdapter(context, textViewResId, strings);
}
/*这个函数很有用,可以返回一个filter,此时这个函数又把适配器的原始数据刷新了一遍,得到了一个Filter实例之后,
就可以调用有参数的filter(……)函数来查询用户关心的数据了,具体下面会分析*/
public Filter getFilter() {
if (mFilter == null) {
mFilter = new ArrayFilter();
}
return mFilter;
}
private class ArrayFilter extends Filter {
/*这个方法就是在用户进行查询数据所要用到的,那么是怎么用的呢,就是前面用getFilter()返回一个Filter的实例,得到的实例
来执行方法filter(……)来查询用户关心的数据,filter(……)的形参,就是一些字符串*/
@Override
protected FilterResults performFiltering(CharSequence prefix) {
FilterResults results = new FilterResults();
if (mOriginalValues == null) {
synchronized (mLock) {
mOriginalValues = new ArrayList(mObjects);
}
}
if (prefix == null || prefix.length() == 0) {
ArrayList list;
synchronized (mLock) {
list = new ArrayList(mOriginalValues);
}
results.values = list;
results.count = list.size();
} else {
String prefixString = prefix.toString().toLowerCase();
ArrayList values;
synchronized (mLock) {
values = new ArrayList(mOriginalValues);
}
final int count = values.size();
final ArrayList newValues = new ArrayList();
for (int i = 0; i < count; i++) {
final T value = values.get(i);
final String valueText = value.toString().toLowerCase();
// First match against the whole, non-splitted value
if (valueText.startsWith(prefixString)) {
newValues.add(value);
} else {
final String[] words = valueText.split(" ");
final int wordCount = words.length;
// Start at index 0, in case valueText starts with space(s)
for (int k = 0; k < wordCount; k++) {
if (words[k].startsWith(prefixString)) {
newValues.add(value);
break;
}
}
}
}
results.values = newValues;
results.count = newValues.size();
}
return results;
}
/*函数performFiltering(CharSequence prefix) 顾名思义就是执行过滤功能,当执行new ArrayFilter()时,此函数就是执行
这就是为什么上面的执行方法getFilter() 时会适配器的原始数据刷新了一遍的原因,因为执行performFiltering(CharSequence prefix) 了,具体的会在下面的类Filter中讲到*/
@Override
protected void publishResults(CharSequence constraint, FilterResults results) {
//noinspection unchecked
mObjects = (List) results.values;
if (results.count > 0) {
notifyDataSetChanged();
} else {
notifyDataSetInvalidated();
}
}
}
}
以上,就是适配器ArrayAdapter的全部代码,总的来说,它就是一个有查询功能的BaseAdapter,而之所以具备了查询功能,是因为它实现了Filter接口,具有过滤功能,下面来看一下Filter接口的构造,代码如下:
package android.widget;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
public abstract class Filter {
private static final String LOG_TAG = "Filter";
private static final String THREAD_NAME = "Filter";
private static final int FILTER_TOKEN = 0xD0D0F00D;
private static final int FINISH_TOKEN = 0xDEADBEEF;
private Handler mThreadHandler;
private Handler mResultHandler;
private Delayer mDelayer;
private final Object mLock = new Object();
/*看到这里了,这个就是构造函数,上面调用getFilter()的时候,这里就会得到执行,而具体执行的是mResultHandler = new ResultsHandler();
具体的转到ResultsHandler里来看*/
public Filter() {
mResultHandler = new ResultsHandler();
}
/*就是一个发消息的一个延时时间*/
public void setDelayer(Delayer delayer) {
synchronized (mLock) {
mDelayer = delayer;
}
}
/*哈哈,查询方法就是这个入口,形参是一个CharSequence 类型的数据*/
public final void filter(CharSequence constraint) {
filter(constraint, null);
}
public final void filter(CharSequence constraint, FilterListener listener) {
synchronized (mLock) {
/*一个线程下的RequestHandler*/
if (mThreadHandler == null) {
HandlerThread thread = new HandlerThread(
THREAD_NAME, android.os.Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
//注意这里产生了一个RequestHandler对象,消息发出后调用performFiltering(CharSequence constraint);
mThreadHandler = new RequestHandler(thread.getLooper());
}
final long delay = (mDelayer == null) ? 0 : mDelayer.getPostingDelay(constraint);
//这个就是要发送的消息了,发出去的消息将会在RequestHandler中的handleMessage()得到处理
Message message = mThreadHandler.obtainMessage(FILTER_TOKEN);
RequestArguments args = new RequestArguments();
// make sure we use an immutable copy of the constraint, so that
// it doesn't change while the filter operation is in progress
args.constraint = constraint != null ? constraint.toString() : null; //把输入的查询信息转化成字符串
args.listener = listener;
message.obj = args;
/*先把消息FILTER_TOKEN和FINISH_TOKEN移除,然后再把上面得到的FILTER_TOKEN消息发送出去,发出去的消息将会在RequestHandler中 的handleMessage()得到处理*/
mThreadHandler.removeMessages(FILTER_TOKEN);
mThreadHandler.removeMessages(FINISH_TOKEN);
mThreadHandler.sendMessageDelayed(message, delay);
}
}
/*看,这里是一个抽象的方法,刚才已经在ArrayAdapter中得到具体的实现了,是在new RequestHandler中的 public void handleMessage(Message msg)被调用的*/
protected abstract FilterResults performFiltering(CharSequence constraint);
//看,这也是一个抽象的方法,也已经在ArrayAdapter中得到具体的实现了,这个是在用户查询时会被调用,也在ArrayAdapter中实现了
protected abstract void publishResults(CharSequence constraint,
FilterResults results);
public CharSequence convertResultToString(Object resultValue) {
return resultValue == null ? "" : resultValue.toString();
}
protected static class FilterResults {
public FilterResults() {
// nothing to see here
}
public Object values;
public int count;
}
public static interface FilterListener {
public void onFilterComplete(int count);
}
private class RequestHandler extends Handler {
public RequestHandler(Looper looper) {
super(looper);
}
/*处理从public final void filter(CharSequence constraint)中发出来的消息*/
public void handleMessage(Message msg) {
int what = msg.what;
Message message;
switch (what) {
case FILTER_TOKEN:
RequestArguments args = (RequestArguments) msg.obj;
try {
args.results = performFiltering(args.constraint);//这里就是上面的抽象方法了,在ArrayAdapter中得到实现了
} catch (Exception e) {
args.results = new FilterResults();
Log.w(LOG_TAG, "An exception occured during performFiltering()!", e);
} finally {
message = mResultHandler.obtainMessage(what);
message.obj = args;
message.sendToTarget();
}
synchronized (mLock) {
if (mThreadHandler != null) {
Message finishMessage = mThreadHandler.obtainMessage(FINISH_TOKEN);
mThreadHandler.sendMessageDelayed(finishMessage, 3000); /*处理完查询后,mThreadHandler停掉自己,延时3秒发送*/
}
}
break;
case FINISH_TOKEN:
synchronized (mLock) {
if (mThreadHandler != null) {
mThreadHandler.getLooper().quit();
mThreadHandler = null;
}
}
break;
}
}
}
private class ResultsHandler extends Handler {
@Override
public void handleMessage(Message msg) {
RequestArguments args = (RequestArguments) msg.obj;
publishResults(args.constraint, args.results);
if (args.listener != null) {
int count = args.results != null ? args.results.count : -1;
args.listener.onFilterComplete(count);
}
}
}
private static class RequestArguments {
CharSequence constraint;
FilterListener listener;
FilterResults results;
}
public interface Delayer {
long getPostingDelay(CharSequence constraint);
}
}
综上所述,ArrayAdapter就是一个具有对适配器进行查询、删除、排序、插入的BaseAdapter,这些功能在于ArrayAdapter的类似数组的接口,还有一个很重要的可以用来查询过滤数据的实例mFliter,从getFilter()方法中得到一个Filter,比如AFilter = getFilter();AFliter.filter("abc");就可以查询有关abc的有关内容了,最后条用notifyDataSetChanged()来更新得到的数据。