I want to know the difference between using BaseAdapter and ArrayAdapter.
I have been achieving what I want through ArrayAdapters.
Does it affect the performance of the ListView on the adapter interface in which it is implemented ?
And, the last question is, can i achieve anything doing with ListView using any of these Adapters, or, there are certain cases where specific adapter only can be used?
Here is the difference:
BaseAdapter is a very generic adapter that allows you to do pretty much whatever you want. However, you have to do a bit more coding yourself to get it working.ArrayAdapter is a more complete implementation that works well for data in arrays or ArrayLists. Similarly, there is a related CursorAdapter that you should use if your data is in a Cursor. Both of these extend BaseAdapter.If your data is in a specialized collection of some sort or if you don't want the default behavior that ArrayAdapter provides, you will likely want to extend BaseAdapter to get the flexibility you need.
The performance of each really depends on how you implement them or change their behavior. At their core, either one can be just as effective (especially considering that an ArrayAdapter is a BaseAdapter).
You can do pretty much whatever you want with any adapter, but keep in mind that BaseAdapter is abstract, so you can't use it directly.
BaseAdapter is abstract while ArrayAdapter extends BaseAdapter (it is a concrete implementation of a BaseAdapter). If you extends for ArrayAdapter you are inheriting all the ArrayAdapter's features and, override its implementation you can modify the ArrayAdapter behavior. If you extends BaseAdapter you must implements all the Abstract methods, that ArrayAdapter already implements.
Also, does it affects the performance of the ListView
no it does not.
And, the last question is, can i achieve anything doing with ListView using any of these Adapters, or, there are certain cases where specific adapter only can be used ?
If the implementation in the SDK fulfill your needs why you need to override it and re-invent the wheel?
The main difference between them is that BaseAdapter can not be instantiate while ArrayAdapter can
In response to your 3 questions:
(1) BaseAdapter, according to the Android docs, is just a superclass of a number of adapter types, one of which is ArrayAdapter. There are a number of other adapters that are derived from BaseAdapter that fit different purposes. As a result it is unlikley there is any difference in efficiency between the two; you just get access to a different set of functions/methods with the various subclasses.
(2) The efficiency of your ArrayAdapter depends on the efficiency of what you're doing inside that class, i.e. the processing of bitmaps and other data.
(3) You could probably figure out a way to work your ListView using a different kind of adapter, however, the reason ArrayAdapter works is because it usually makes sense given the goal is to build an interactive list. The ArrayAdapte takes an Array, usually an ArrayList of objects, that it then processes to create the backing information for the ListView. In that sense the set up of ArrayList --> ArrayAdapter --> ListView just logically makes sense.
One more difference between BaseAdapter and ArrayAdapters is, if you extend array adapter you have to call super class constructor in the subclass constructor.
UserListAdapter extends ArrayAdapter<String>{
List<String> UserList;
Context context;
public UserListAdapter(Context context, int resource,List<String> listUsers) {
super(context, resource, listUsers); /* Super class constructor is called */
UserList = listUsers;
this.context = context;
}
}
But there is no super class for BaseAdapter. As BaseAdapter serves as super class for all other adapters
UserListAdapter extends BaseAdapter{
List<String> UserList;
Context context;
public UserListAdapter(Context context, int resource,List<String> listUsers) {
/* No super class constructor */
UserList = listUsers;
this.context = context;
}
}
private static final String[] COUNTRIES = new String[]{
"Afghanistan", "Angola", "Australia", "Bangladesh", "Belgium",
"Bhutan", "Brazil", "Canada", "China", "Denmark"
};
ArrayAdapter<String> adapter = new ArrayAdapter<>(this, android.R.layout.simple_dropdown_item_1line, COUNTRIES);
AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.countries_list);
textView.setAdapter(adapter);
Here we can't use BaseAdapter like ArrayAdapter.
BaseAdapters are more minimal and customizable. ArrayAdapters implement the most general uses of ListAdapters, but sometimes they are not enough.
However, almost everything can be achieved by the use of ArrayAdapters. If your lists are already working by using ArrayAdapter correctly, you have nothing to gain from BaseAdapter.
However, if you are storing your Context, Arrays or Lists in your ArrayAdapter implementation, maybe you'll want to switch to BaseAdapter, as ArrayAdapter already has them implemented.
Anyway, if you're doing that, you can always remove those items, and resort to using getItem() to get the Array items, getCount() to get the size of the array, and getContext() to inflate your views.
