How to lazy load images in ListView in Android


When developing an Android application that includes a ListView with images, it is important to consider the performance implications of loading and displaying those images. Loading images directly in the main UI thread can lead to a blocked UI, resulting in a poor user experience. One solution to optimize the image loading process is to implement lazy loading, where images are only loaded and displayed when they are actually needed.

What is Lazy Loading?

Lazy loading is a technique that delays the loading of images until the point where they are needed, rather than loading all images at once. This allows the UI to remain responsive while the images are being downloaded from the Internet. As the user scrolls through the ListView, new images are loaded and displayed, and previously loaded images are reused when they come back into view.

Implementing Lazy Loading in ListView

There are various libraries and approaches available to implement lazy loading in a ListView in Android. One popular library is Universal Image Loader, which provides a flexible and efficient way to load, cache, and display images.

Step 1: Add the Universal Image Loader library to your project

To start using Universal Image Loader, you need to add its dependency to your project. This can be done by adding the following line to your app's build.gradle file:

implementation 'com.nostra13.universalimageloader:universal-image-loader:1.9.5'

Step 2: Set up the ImageLoader configuration

Before using Universal Image Loader, you need to set up its configuration. This includes defining the caching options, the loading options, and any custom configurations you may need. Here's an example of how to set up the ImageLoader configuration:

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)


Step 3: Create a custom adapter for your ListView

In order to implement lazy loading, you'll need to create a custom adapter for your ListView. This adapter will be responsible for loading and displaying the images as they are needed. Here's an example of how to create a custom adapter:

public class CustomAdapter extends BaseAdapter {
    private List imageUrls;
    private LayoutInflater inflater;
    private ImageLoader imageLoader;

    public CustomAdapter(Context context, List imageUrls) {
        inflater = LayoutInflater.from(context);
        this.imageUrls = imageUrls;
        imageLoader = ImageLoader.getInstance();

    public int getCount() {
        return imageUrls.size();

    public Object getItem(int position) {
        return null;

    public long getItemId(int position) {
        return 0;

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

        if (view == null) {
            view = inflater.inflate(R.layout.list_item, parent, false);
            holder = new ViewHolder();
            holder.imageView = (ImageView) view.findViewById(;
        } else {
            holder = (ViewHolder) view.getTag();

        imageLoader.displayImage(imageUrls.get(position), holder.imageView);

        return view;

    static class ViewHolder {
        ImageView imageView;

Step 4: Implement the ViewHolder pattern

The ViewHolder pattern is used to optimize the ListView performance by reusing views as they scroll off the screen. It involves creating a static inner class that holds references to the views in each list item, and using the setTag() and getTag() methods to save and retrieve the ViewHolder object. This prevents the need for the findViewById() method to be called multiple times as the ListView is scrolled. Here's an example of how to implement the ViewHolder pattern:

 static class ViewHolder {
    ImageView imageView;


Lazy loading images in a ListView can significantly improve the performance of your Android application. By only loading and displaying images as they are needed, the UI remains responsive and the user experience is enhanced. Universal Image Loader is a popular library that provides an efficient and flexible way to implement lazy loading in your ListView. By following the steps outlined in this article, you can easily integrate lazy loading into your Android application and provide an optimal user experience.