---
title: ListView o listado en Android
url: https://jarroba.com/listview-o-listado-en-android/
author: Ramón Invarato
date: 2013-02-13
modified: 2026-10-21
language: es
license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "ListView o listado en Android", Ramón Invarato, jarroba.com
categories: Aplicaciones Móviles
---
# ListView o listado en Android
> Aprende como crear ListView o listado en Android de una manera muy rápida y eficaz. Todo lo que necesitas saber sobre ListView y Adapter en Android.
Este tutorial está indicado para todos los que ya hayan buceado un poco en Android. Sobre todo para adentrarnos en los ListView o listado en Android. Se dará por sentado ciertos conocimientos muy básicos, cuyo apoyo pueden servirse de tutoriales anteriores como el de saber [qué es una Actividad](https://jarroba.com/activity-entender-y-usar-una-actividad/). Si no tienes mucho tiempo o quieres un Snippet de código para hacer un listado rápidamente, entonces [te recomiendo que vayas directamente al artículo de listado en pocas líneas](https://jarroba.com/listview-de-android-en-pocas-lineas/); si por el contrario quieres aprenderlo todo sobre listados de Android continuar leyendo es la opción correcta.
“Aunque todo en el universo tienda al caos, siempre es bueno ponerle un orden para saber interpretarlo”. No es la mejor definición de listado, pero si una bonita alegoría al mismo. Un listado es eso, un conjunto de datos ordenados, para que sea sencillo indagar en ellos.
Este tutorial se basará en describir como hacer un listado en Android: en el que tenemos un número arbitrario de datos -número exacto de entradas que no conocemos, bien porque obtengamos los datos de Internet, o estén en una base de datos que va creciendo, etc- de aves que queremos ordenar en un listado. Cuyas entradas queremos hacer a nuestro antojo con el nombre del ave como titular, una pequeña descripción y una imagen asociada a cada uno (Véase la imagen siguiente, para entender de un vistazo lo que se quiere conseguir).
[](https://jarroba.com/wp-content/uploads/2013/02/Ejemplo-de-listado-final-www.jarroba.com_.png)
Y no contentos con esto, queremos que además sea seleccionable cada elemento del listado.
[](https://jarroba.com/wp-content/uploads/2013/02/Ejemplo-de-listado-final-seleccionado-un-elemento-www.jarroba.com_.png)
Para mostrar más información en un Toast (también podríamos abrir otra Activity con información extra, o lo que queramos) del elemento seleccionado.
[](https://jarroba.com/wp-content/uploads/2013/02/Ejemplo-de-listado-final-seleccionado-un-elemento-2-www.jarroba.com_.png)
Vamos, que construiremos un ListView de generación dinámica de contenidos (Un ejemplo estático lo tienes en [la página oficial de desarrolladores de Android](http://developer.android.com/guide/topics/ui/layout/listview.html)), deseable el 90% de las veces por un programador Android. Y sí, las imágenes y textos del ejemplo están obtenidos de la [Wikipedia](es.wikipedia.org/).
Como haremos esto de una manera sencilla y óptima. Primero lo entenderemos y luego lo haremos.
¿Qué es lo que queremos hacer? Queremos un listado de todos los elementos/entradas individuales que me den la gana (entre cero e infinito 😉 ). De lo real al concepto mental sería la siguiente imagen.
[](https://jarroba.com/wp-content/uploads/2013/02/Idea-de-listView-www.jarroba.com_.png)
Todas las entradas son iguales, ¿Sería maravilloso que se pudiera diseñar una única entrada y luego que el resto sean «un copiar y pegar»? Aunque sea por vaguería, la respuesta es: debemos como buenos programadores.
[](https://jarroba.com/wp-content/uploads/2013/02/Descomponer-ListView-en-entradas-www.jarroba.com_.png)
Ya tenemos dividido lo que queremos hacer. Ahora, la lógica nos dice que en el diseño hacia delante, tendremos dos Layouts uno principal que contendrá varias veces la copia del segundo:
- Uno con la **entrada** suelta, con el diseño que queramos. Será la unidad que se copiará en el interior del listado. Lo llamaremos en este ejemplo “entrada.xml”.
- Otro con el **listado**, que solo dispondrá de tal. Con los “huecos” esperando para contener la copia del diseño de la entrada; y cada entrada con unos datos diferentes. A este contenedor de entradas lo llamaremos “listado.xml”.
[](https://jarroba.com/wp-content/uploads/2013/02/Copia-de-la-View-para-el-ListView-www.jarroba.com_.png)
Haremos el diseño de “**entrada.xml**”. Para el ejemplo haremos el siguiente Layout, que evidentemente podremos hacer a nuestro antojo, con los campos que queramos, imágenes, botones, checkbox, spinner, etc. Al diseñar éste, pensemos, no en el contenido de cada entrada, sino como haremos todas las entradas para que salgan iguales. Pues este será replicado para todas las entradas.
Para el ejemplo, la idea de una entrada es la siguiente:
[](https://jarroba.com/wp-content/uploads/2013/02/View-de-la-entrada-descompuesto-www.jarroba.com_.png)
Y su código asociado para generar la vista de una entrada sería este (Nota: por reducir código y que se entienda mejor, hemos optado por poner los Strings directamente; esto está mal hecho y deberían ir al fichero “strings.xml”). Evidentemente ponemos los “id” para luego referenciarlos y llenar cada una de las entradas con sus datos correspondientes.
```xml
```
¿Fácil? No. Más fácil es “**listado.xml**”. En este ejemplo nos bastará con que usemos ListView, que será el contenedor de las entradas.
```xml
```
Falta que hagamos la lógica del programa. La lógica que nos cargará los datos y nos construirá el listado. Para esto tendremos una Actividad que será la que muestre el listado. Para no liar las cosas lo haremos en el ejemplo en la clase “MainActivity.java”. Esta hará uso de otras dos. Una que encapsule los datos de la entrada, cuyo nombre pondremos como “Lista_entrada.java”. Y otra que será la que adapte las entradas a la lista, y será nombrada como “Lista_adaptador.java”.
Terminaremos teniendo los siguientes archivos en el explorador de paquetes. Donde los marcados serán los que usaremos en este ejemplo. Cabe indicar que las imágenes las estamos insertando directamente para no complicar más el ejemplo, pero esta forma de construir el listado dinámicamente también funcionaría si las imágenes se descargaran de internet, se obtuvieran de la memoria del teléfono, etc.
[](https://jarroba.com/wp-content/uploads/2013/02/Lista-proyecto-ListView-www.jarroba.com_.png)
Empezaremos a definir “**Lista_entrada.java**”. ¿Para qué sirve? Sabemos que nos llegarán unos datos, y que nos interesan los siguientes para cada entrada: imagen, título y descripción. Por lo que haremos unos paquetes de datos para cada uno de los conjuntos de la entrada. Estos paquetes serán objetos de la clase “Lista_entrada.java”.
[](https://jarroba.com/wp-content/uploads/2013/02/Clase-adaptador-ListView-www.jarroba.com_.png)
Para hacernos una idea, imaginemos que tenemos tres pájaros. Cada uno con: título, descripción e imagen. Tendremos tres objetos de la clase “Lista_entrada.java”, cada uno almacenará sus datos. Pero no confundamos, esto no está asignado todavía a la entrada de la vista -de la interfaz- sino que son grupos para separar la información. Estos grupos se suelen llamar manejadores o en inglés “handler”.
[](https://jarroba.com/wp-content/uploads/2013/02/Objetos-clase-adaptador-www.jarroba.com_.png)
El código siguiente contiene lo que es la encapsulación de los datos, que coinciden con los explicados:
- Título, con nombre de variable como “textoEncima” para especificar en cuál de los dos TextViews de la vista tendrá que ser colocado.
- Descripción, la variable la llamaremos como “textoDebajo”.
- Imagen, y almacenaremos la variable “idImagen”, para referenciar a la imagen. Solo guardaremos el id, ya que solo guardaremos el identificador de la imagen y no la imagen en sí (para este ejemplo no lo complicamos y guardamos el identificador, pero si queremos podremos guardar un Drawable, un Bitmap, etc).
Este manejador tendrá las variables de los View que hayamos declarado en el Layout “entrada.xml”. Repito, aquí no lo referenciaremos, es solo un contenedor que separa unos datos de otros.
Si nos fijamos en su código, solo son variables, con sus getters y de setter el mismo constructor. No tiene más la clase, es así de simple (aquí, para que se entienda mejor, ponemos los getters y setters; Android recomienda por optimizar hacer variables globales publicas y olvidarnos de getters y setters, con lo que sería todavía mucho más simple este código).
```java
package jarroba.ramon.listado;
public class Lista_entrada {
private int idImagen;
private String textoEncima;
private String textoDebajo;
public Lista_entrada (int idImagen, String textoEncima, String textoDebajo) {
this.idImagen = idImagen;
this.textoEncima = textoEncima;
this.textoDebajo = textoDebajo;
}
public String get_textoEncima() {
return textoEncima;
}
public String get_textoDebajo() {
return textoDebajo;
}
public int get_idImagen() {
return idImagen;
}
}
```
¿Cómo encapsulamos los datos que queramos en este Handler? Muy sencillo, ya verás.
Si **creamos el objeto “Lista_entrada”** tal cual, lo haríamos de la siguiente manera:
```java
new Lista_entrada(R.drawable. imagen, "TÍTULO", "Descripción");
```
¿Dónde asignamos el objeto? ¿Cuántos objetos vamos a tener de estos? La respuesta es en una lista de Java, más concretamente en un ArrayList.
En este ejemplo lo haremos directamente sobre la clase “MainActivity.java” como ejemplo la siguiente (Nota: lo que se muestra a continuación es un trozo de la clase “MainActivity.java”, se muestra completa al final del artículo). Aquí un ejemplo de como **añadir la información de las tres aves al ArrayList:**
```java
package jarroba.ramon.listado;
import java.util.ArrayList;
import android.app.Activity;
import android.os.Bundle;
import android.widget.ListView;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.listado);
ArrayList datos = new ArrayList();
datos.add(new Lista_entrada(R.drawable.im_buho, "BUHO", "Búho es el nombre común de aves de la familia Strigidae, del orden de las estrigiformes o aves rapaces nocturnas. Habitualmente designa especies que, a diferencia de las lechuzas, tienen plumas alzadas que parecen orejas."));
datos.add(new Lista_entrada(R.drawable.im_colibri, "COLIBRÍ", "Los troquilinos (Trochilinae) son una subfamilia de aves apodiformes de la familia Trochilidae, conocidas vulgarmente como colibríes, quindes, tucusitos, picaflores, chupamirtos, chuparrosas, huichichiquis (idioma nahuatl), mainumby (idioma guaraní) o guanumby. Conjuntamente con las ermitas, que pertenecen a la subfamilia Phaethornithinae, conforman la familia Trochilidae que, en la sistemática de Charles Sibley, se clasifica en un orden propio: Trochiliformes, independiente de los vencejos del orden Apodiformes. La subfamilia Trochilinae incluye más de 100 géneros que comprenden un total de 330 a 340 especies."));
datos.add(new Lista_entrada(R.drawable.im_cuervo, "CUERVO", "El cuervo común (Corvus corax) es una especie de ave paseriforme de la familia de los córvidos (Corvidae). Presente en todo el hemisferio septentrional, es la especie de córvido con la mayor superficie de distribución. Con el cuervo de pico grueso, es el mayor de los córvidos y probablemente la paseriforme más pesada; en su madurez, el cuervo común mide entre 52 y 69 centímetros de longitud y su peso varía de 0,69 a 1,7 kilogramos. Los cuervos comunes viven generalmente de 10 a 15 años pero algunos individuos han vivido 40 años. Los juveniles pueden desplazarse en grupos pero las parejas ya formadas permanecen juntas toda su vida, cada pareja defendiendo un territorio. Existen 8 subespecies conocidas que se diferencian muy poco aparentemente, aunque estudios recientes hayan demostrado diferencias genéticas significativas entre las poblaciones de distintas regiones."));
}
}
```
Todavía no hemos acabado con la clase “MainActivity.java”. Faltaría decirle que queremos hacer con el ArrayList, que será enviárselo a la lista para que lo reconstruya y la de forma.
A toda ListView hay que pasarle un adaptador con los datos y que herede de “BaseAdapter” (Son cosas de Android…).
Antes un inciso. Hemos trabajado y conocemos la pesadez de hacer el adaptador de un listado de manera dinámica. Por eso [www.jarroba.com](http://www.jarroba.com/) quiere haceros un regalo, con el siguiente ahorro de tiempo y de comerse la cabeza. En todos los ejemplos que he visto por ahí, construyen un adaptador independiente para cada handler para este tipo de listas simples. Y yo he dicho: no, nunca más, no es necesario, un solo adaptador vale para todas las listas con entradas personalizadas que queramos (o al menos todas con las que he trabajado). A continuación les regalo el código, que en apariencia es sencillo; lo que sí es muy fácil de utilizar. Es el trabajo de mucho tiempo, errores y experiencia. Puede que sea mejorable, por lo que si descubres y nos lo quieres contar, o descubro una manera mejor actualizaré este tutorial. Pero por ahora no he visto nada más cómodo para trabajar con listas. Por supuesto, eres libre de modificarlo, proponer mejoras y de usarlo. Nota: este adaptador «universal» es solo para listas simples con vistas complejas, lo que es que van a cargarse una vez los elementos de la lista y ya no se van a modificar más mientras el usuario interaccione con la lista; si queremos añadir o eliminar elementos mientras el usuario toca la lista, requerimos de otro tipo de adaptador ([Puedes aprender como utiliza inflate() el método getView() del Adapter en este otro tutorial](https://jarroba.com/inflate-en-android-inflar-y-adjuntar-views/)).
**Código de la clase “Lista_adaptador.java”**:
```java
package jarroba.ramon.listado;
import java.util.ArrayList;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
/** Adaptador de ListView universal, para www.jarroba.com
* @author Ramon Invarato Menéndez
*/
public abstract class Lista_adaptador extends BaseAdapter {
private ArrayList entradas;
private int R_layout_IdView;
private Context contexto;
public Lista_adaptador(Context contexto, int R_layout_IdView, ArrayList entradas) {
super();
this.contexto = contexto;
this.entradas = entradas;
this.R_layout_IdView = R_layout_IdView;
}
@Override
public View getView(int posicion, View view, ViewGroup pariente) {
if (view == null) {
LayoutInflater vi = (LayoutInflater) contexto.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
view = vi.inflate(R_layout_IdView, null);
}
onEntrada (entradas.get(posicion), view);
return view;
}
@Override
public int getCount() {
return entradas.size();
}
@Override
public Object getItem(int posicion) {
return entradas.get(posicion);
}
@Override
public long getItemId(int posicion) {
return posicion;
}
/** Devuelve cada una de las entradas con cada una de las vistas a la que debe de ser asociada
* @param entrada La entrada que será la asociada a la view. La entrada es del tipo del paquete/handler
* @param view View particular que contendrá los datos del paquete/handler
*/
public abstract void onEntrada (Object entrada, View view);
}
```
Este código lo que hace es crear un adaptador para ListView. En el constructor hay que pasarle el contexto de la aplicación, el id del layout de la entrada (en este ejemplo “R.layout.entrada”), y el ArrayList que construimos anteriormente con los handler con los datos. Como es obvio, ya que pide los datos del ArrayList, este código irá justo después de la creación del ArrayList. Al crear el objeto se nos pedirá sobrescribir el método “onEntrada”, que será donde asignaremos cada parte del handler de la clase “Lista_entrada.java” a cada una de las copias de las vistas “entrada.xml”. “onEntrada” da de información: el objeto con solo los datos de la entrada que va a construir y la vista donde lo va a meter. Te sorprenderá el escaso código que hay que usar y lo simple que es su uso, a continuación lo veremos.
Una vista rápida de donde se usa este adaptador.
[](https://jarroba.com/wp-content/uploads/2013/02/Partes-de-un-ListView-de-Android-www.jarroba.com_.png)
En el ejemplo lo situaremos dentro del “MainActivity.java” en el “onCreate”, después del código que ya había (Nota: como comentamos anteriormente, al final publicaremos el código completo). **Código para usar el adaptador**:
```java
ListView lista = (ListView) findViewById(R.id.ListView_listado);
lista.setAdapter(new Lista_adaptador(this, R.layout.entrada, datos){
@Override
public void onEntrada(Object entrada, View view) {
TextView texto_superior_entrada = (TextView) view.findViewById(R.id.textView_superior);
texto_superior_entrada.setText(((Lista_entrada) entrada).get_textoEncima());
TextView texto_inferior_entrada = (TextView) view.findViewById(R.id.textView_inferior);
texto_inferior_entrada.setText(((Lista_entrada) entrada).get_textoDebajo());
ImageView imagen_entrada = (ImageView) view.findViewById(R.id.imageView_imagen);
imagen_entrada.setImageResource(((Lista_entrada) entrada).get_idImagen());
}
});
```
Este poco de código usa el adaptador. Se asigna cada View con su dato en el momento justo en el que se construye cada entrada ¿No dije que era fácil?.
Ya solo queda **capturar el evento de Click para cada una de las entradas y hacer lo que sea con esta**. En este ejemplo recogemos la descripción y la mostramos en un Toast. Esto lo hacemos al devolver el adaptador y conociendo la posición nos habrá devuelto la entrada pulsada. Después del anterior código escribimos el escuchador del evento click como se hace normalmente:
```java
lista.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView pariente, View view, int posicion, long id) {
Lista_entrada elegido = (Lista_entrada) pariente.getItemAtPosition(posicion);
CharSequence texto = "Seleccionado: " + elegido.get_textoDebajo();
Toast toast = Toast.makeText(MainActivity.this, texto, Toast.LENGTH_LONG);
toast.show();
}
});
```
Y ya al fin, **el código completo del “MainActivity.java”**, es el siguiente:
```java
package jarroba.ramon.listado;
import java.util.ArrayList;
import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity {
private ListView lista;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.listado);
ArrayList datos = new ArrayList();
datos.add(new Lista_entrada(R.drawable.im_buho, "BUHO", "Búho es el nombre común de aves de la familia Strigidae, del orden de las estrigiformes o aves rapaces nocturnas. Habitualmente designa especies que, a diferencia de las lechuzas, tienen plumas alzadas que parecen orejas."));
datos.add(new Lista_entrada(R.drawable.im_colibri, "COLIBRÍ", "Los troquilinos (Trochilinae) son una subfamilia de aves apodiformes de la familia Trochilidae, conocidas vulgarmente como colibríes, quindes, tucusitos, picaflores, chupamirtos, chuparrosas, huichichiquis (idioma nahuatl), mainumby (idioma guaraní) o guanumby. Conjuntamente con las ermitas, que pertenecen a la subfamilia Phaethornithinae, conforman la familia Trochilidae que, en la sistemática de Charles Sibley, se clasifica en un orden propio: Trochiliformes, independiente de los vencejos del orden Apodiformes. La subfamilia Trochilinae incluye más de 100 géneros que comprenden un total de 330 a 340 especies."));
datos.add(new Lista_entrada(R.drawable.im_cuervo, "CUERVO", "El cuervo común (Corvus corax) es una especie de ave paseriforme de la familia de los córvidos (Corvidae). Presente en todo el hemisferio septentrional, es la especie de córvido con la mayor superficie de distribución. Con el cuervo de pico grueso, es el mayor de los córvidos y probablemente la paseriforme más pesada; en su madurez, el cuervo común mide entre 52 y 69 centímetros de longitud y su peso varía de 0,69 a 1,7 kilogramos. Los cuervos comunes viven generalmente de 10 a 15 años pero algunos individuos han vivido 40 años. Los juveniles pueden desplazarse en grupos pero las parejas ya formadas permanecen juntas toda su vida, cada pareja defendiendo un territorio. Existen 8 subespecies conocidas que se diferencian muy poco aparentemente, aunque estudios recientes hayan demostrado diferencias genéticas significativas entre las poblaciones de distintas regiones."));
datos.add(new Lista_entrada(R.drawable.im_flamenco, "FLAMENCO", "Los fenicopteriformes (Phoenicopteriformes), los cuales reciben el nombre vulgar de flamencos, son un orden de aves neognatas, con un único género viviente: Phoenicopterus. Son aves que se distribuyen tanto por el hemisferio occidental como por el hemisferio oriental: existen cuatro especies en América y dos en el Viejo Mundo. Tienen cráneo desmognato holorrino, con 16 a 20 vértebras cervicales y pies anisodáctilos."));
datos.add(new Lista_entrada(R.drawable.im_kiwi, "KIWI", "Los kiwis (Apterix, gr. 'sin alas') son un género de aves paleognatas compuesto por cinco especies endémicas de Nueva Zelanda.1 2 Son aves no voladoras pequeñas, aproximadamente del tamaño de una gallina. Antes de la llegada de los humanos alrededor del año 1300, en Nueva Zelanda los únicos mamíferos que había eran murciélagos, y los nichos ecológicos que en otras partes del mundo eran ocupados por animales tan diversos como caballos, lobos y ratones fueron utilizados en Nueva Zelanda por pájaros (y en menor proporción por ciertas especies de reptiles). La denominación kiwi es maorí, idioma del pueblo homónimo de linaje malayopolinesio que colonizó Nueva Zelanda antes de la llegada de los europeos."));
datos.add(new Lista_entrada(R.drawable.im_loro, "LORO", "Las Psitácidas (Psittacidae) son una familia de aves psitaciformes llamadas comúnmente loros o papagayos, e incluye a los guacamayos, las cotorras, los periquitos, los agapornis y formas afines."));
datos.add(new Lista_entrada(R.drawable.im_pavo, "PAVO", "Pavo es un género de aves galliformes de la familia Phasianidae, que incluye dos especies, el pavo real común (Pavo cristatus) y el pavo real cuelliverde (Pavo muticus).1"));
datos.add(new Lista_entrada(R.drawable.im_pinguino, "PINGÜINO", "Los pingüinos (familia Spheniscidae, orden Sphenisciformes) son un grupo de aves marinas, no voladoras, que se distribuyen únicamente en el Hemisferio Sur, sobre todo en sus altas latitudes."));
lista = (ListView) findViewById(R.id.ListView_listado);
lista.setAdapter(new Lista_adaptador(this, R.layout.entrada, datos){
@Override
public void onEntrada(Object entrada, View view) {
if (entrada != null) {
TextView texto_superior_entrada = (TextView) view.findViewById(R.id.textView_superior);
if (texto_superior_entrada != null)
texto_superior_entrada.setText(((Lista_entrada) entrada).get_textoEncima());
TextView texto_inferior_entrada = (TextView) view.findViewById(R.id.textView_inferior);
if (texto_inferior_entrada != null)
texto_inferior_entrada.setText(((Lista_entrada) entrada).get_textoDebajo());
ImageView imagen_entrada = (ImageView) view.findViewById(R.id.imageView_imagen);
if (imagen_entrada != null)
imagen_entrada.setImageResource(((Lista_entrada) entrada).get_idImagen());
}
}
});
lista.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView pariente, View view, int posicion, long id) {
Lista_entrada elegido = (Lista_entrada) pariente.getItemAtPosition(posicion);
CharSequence texto = "Seleccionado: " + elegido.get_textoDebajo();
Toast toast = Toast.makeText(MainActivity.this, texto, Toast.LENGTH_LONG);
toast.show();
}
});
}
}
```
Esperamos que haya sido aclaratorio y para entender muchas cosas sobre cómo se construye una lista.
Aquí dejo para**descargar el proyecto entero: [Listado](https://jarroba.com/wp-content/uploads/2013/02/Listado.zip)**
En respuesta a las preguntas más comunes de nuestros lectores. Si quieres hacer otra cosa con los listados, así como si has visto cosas que no has sabido como solucionar; e incluso, con lo aquí aprendido, como hacer un GridView o un Spinner completamente personalizados. Te recomiendo que eches una ojeada al artículo que expande los conocimientos de ListView, se solventan muchas dudas y enseña mucho más, en: [https://jarroba.com/expansion-listview/](https://jarroba.com/expansion-listview/)
También puede ser muy interesante el artículo sobre [programar para diferentes dispositivos Android con la arquitectura de Fragments](https://jarroba.com/fragments-fragmentos-en-android/), en el que extiendo un poco más el ejemplo de listado y añado conceptos avanzados.