RecyclerView Multiple View Types in Android (Java)

By the end of this page, you will understand how a RecyclerView can display different row layouts in the same list. You will learn how getItemViewType() works, how to create different ViewHolder classes, and how to inflate and bind the correct layout for each item in Java.

Yes, a RecyclerView can absolutely support multiple view types.

The key idea is that a list item does not have to use the same layout for every row. Some items might be headers, some might be messages, some might be loading indicators, and others might be normal content rows.

In Android, this is done by:

1. Overriding getItemViewType(int position)
2. Returning a type value for each item
3. Checking that type inside onCreateViewHolder(...)
4. Creating the correct ViewHolder and inflating the correct layout
5. Binding the right data in onBindViewHolder(...)

This matters because real apps rarely show perfectly uniform lists. Common examples include:

• chat apps with sent and received messages
• feeds with posts, ads, and loading rows
• forms with different input row types
• settings screens with switches, text rows, and section headers

A RecyclerView is designed to reuse item views efficiently. When you use multiple view types, Android keeps recycling views of the same type correctly, which preserves performance while giving you flexible UI design.

Think of a RecyclerView like a hotel with different room categories.

• Some guests need a single room
• Some need a double room
• Some need a suite

The hotel does not put every guest in the same kind of room. Instead, it first checks what type is needed, then prepares the correct room.

A RecyclerView works the same way:

• getItemViewType(position) decides what kind of item this is
• onCreateViewHolder(...) creates the correct layout for that kind
• onBindViewHolder(...) fills it with data

So instead of asking, "How do I make one row design fit everything?", think, "How do I label each item with its type and give that type the right layout?"

The core method for multiple view types is:

@Override
public int getItemViewType(int position) {
    return ...; // return a constant representing the row type
}

A common pattern is to define constants:

private static final int TYPE_HEADER = 0;
private static final int TYPE_ITEM = 1;

Then return the correct type based on position or data.

Example: Header + normal items

public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {

    private static final int TYPE_HEADER = 0;
          ;

      String[] items;

      {
        .items = items;
    }

        .ViewHolder {
        TextView title;

        HeaderViewHolder(View itemView) {
            (itemView);
            title = itemView.findViewById(R.id.headerTitle);
        }
    }

        .ViewHolder {
        TextView text;

        ItemViewHolder(View itemView) {
            (itemView);
            text = itemView.findViewById(R.id.itemText);
        }
    }

    
       {
         (position == ) {
             TYPE_HEADER;
        }
         TYPE_ITEM;
    }

    
     RecyclerView.ViewHolder  {
           LayoutInflater.from(parent.getContext());

         (viewType == TYPE_HEADER) {
               inflater.inflate(R.layout.row_header, parent, );
              (view);
        }  {
               inflater.inflate(R.layout.row_item, parent, );
              (view);
        }
    }

    
       {
         (holder  HeaderViewHolder) {
               (HeaderViewHolder) holder;
            headerHolder.title.setText();
        }   (holder  ItemViewHolder) {
               (ItemViewHolder) holder;
            itemHolder.text.setText(items[position]);
        }
    }

    
       {
         items.length;
    }
}

Consider this small example:

@Override
public int getItemViewType(int position) {
    return position == 0 ? TYPE_HEADER : TYPE_ITEM;
}

Suppose the list has 3 rows:

• position 0 → header
• position 1 → item
• position 2 → item

Step-by-step flow

1. RecyclerView asks for item count

getItemCount()

The adapter returns 3.

2. RecyclerView needs row at position 0

It calls:

getItemViewType(0)

This returns TYPE_HEADER.

3. RecyclerView creates a header ViewHolder

It calls:

onCreateViewHolder(parent, TYPE_HEADER)

The adapter inflates row_header.xml and returns HeaderViewHolder.

Multiple view types are extremely common in Android apps.

Chat apps

• sent message layout
• received message layout
• date separator row

News or social feeds

• article card
• sponsored ad row
• loading spinner
• error retry row

E-commerce apps

• product item
• section header
• banner row
• empty state row

Settings screens

• plain text option
• switch toggle row
• category heading
• button row

Form builders

• text input field
• dropdown selector
• checkbox row
• validation message row

In all of these cases, one RecyclerView shows a mixed list of different UI blocks.

In real projects, developers usually do more than just switch on position. They often model each row as data with a type.

Common pattern: model-based item types

Instead of saying "position 0 is a header," a codebase may define item models like:

class ListItem {
    int type;
    String text;
}

Then getItemViewType(position) returns items.get(position).type.

This is better because it keeps UI logic connected to the actual data.

Common patterns in production

• Guard clauses: return early if data is missing
• Validation: ensure the item type is supported
• Constants or enums: avoid magic numbers like 0, 1, 2
• Base item models: store all rows in a single list
• Fallback handling: throw an error or log if an unknown type appears

Example:

@Override
public int getItemViewType(int position) {
    if (position < 0 || position >= items.size()) {
          ( + position);
    }
     items.get(position).getType();
}

1. Using only one ViewHolder type for all rows

If different rows need different layouts, forcing them into one holder becomes messy and error-prone.

Problematic code

public class MyAdapter extends RecyclerView.Adapter<MyAdapter.ViewHolder> {
    // hard to manage if rows are truly different
}

Better approach

Use:

RecyclerView.Adapter<RecyclerView.ViewHolder>

and create separate holder classes.

2. Forgetting to override getItemViewType()

If every row uses the default type, RecyclerView cannot distinguish between different layouts.

@Override
public int getItemViewType(int position) {
    return TYPE_ITEM;
}

This would make all rows the same type, even when they are not.

3. Casting the wrong ViewHolder

Broken example

ListView vs RecyclerView for multiple types

// 1. Define types
private static final int TYPE_HEADER = 0;
private static final int TYPE_ITEM = 1;

// 2. Return type for each position
@Override
public int getItemViewType(int position) {
    return position == 0 ? TYPE_HEADER : TYPE_ITEM;
}

// 3. Create correct ViewHolder
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    LayoutInflater inflater = LayoutInflater.from(parent.getContext());

    if (viewType == TYPE_HEADER) {
        View view = inflater.inflate(R.layout.row_header, parent, false);
        return new HeaderViewHolder(view);
    }

    View view = inflater.inflate(R.layout.row_item, parent, );
      (view);
}



   {
     (holder  HeaderViewHolder) {
        ((HeaderViewHolder) holder).title.setText();
    }   (holder  ItemViewHolder) {
        ((ItemViewHolder) holder).text.setText(items[position]);
    }
}

Can RecyclerView have different row layouts?

Yes. That is exactly what multiple view types are for. You return a type from getItemViewType() and inflate the matching layout.

Do I need a different ViewHolder for each layout?

Usually, yes. If layouts are meaningfully different, separate ViewHolder classes make the code cleaner and safer.

What does viewType mean in onCreateViewHolder()?

It is the value returned by getItemViewType(position). Android passes it back so you know which layout to create.

Can I use position to decide the type?

Yes, for simple cases like a fixed header. But for dynamic lists, using the item data itself is usually better.

Should I extend RecyclerView.Adapter<RecyclerView.ViewHolder> for multiple types?

Yes, that is a common approach because the adapter may return different ViewHolder subclasses.

Will RecyclerView still recycle views correctly with multiple types?

Yes. It recycles views by type, so a header row is reused for header rows and item rows are reused for item rows.

What happens if I return the wrong type?

You may inflate the wrong layout or cast the wrong holder type, which can cause crashes or incorrect UI.

• RecyclerView.Adapter — the class responsible for creating and binding list rows.
• ViewHolder pattern — improves performance by storing references to row views.
• getItemViewType() — the core method used to support multiple item layouts.
• LayoutInflater — used to create a View from an XML layout file.
• ListAdapter — a more modern adapter option often used with DiffUtil.
• DiffUtil — helps update RecyclerView lists efficiently when data changes.
• ItemDecoration — useful for styling mixed lists with spacing or dividers.
• ConcatAdapter — another way to combine different list sections in RecyclerView.