---
title: Ordenar un ArrayList en Java
url: https://jarroba.com/ordenar-un-arraylist-en-java/
author: Richard [Admin Jarroba]
date: 2013-11-26
modified: 2026-10-21
language: es
license: CC BY-NC-SA 3.0 (https://creativecommons.org/licenses/by-nc-sa/3.0/) — attribution: "Ordenar un ArrayList en Java", Richard [Admin Jarroba], jarroba.com
categories: Lenguajes de Programación
repository: https://github.com/jarroba/SortArrayList
---

# Ordenar un ArrayList en Java

> Aprende a ordenar un ArrayList en Java con Collections.sort, de menor a mayor y a la inversa, y a ordenar objetos por un atributo con Comparator.

El proyecto de este post lo puedes descargar pulsando [AQUI](https://github.com/jarroba/SortArrayList).

 

Una de las funcionalidades más interesantes a la hora de trabajar con estructuras de datos tipo «pila», «cola», «lista» etc. es su ordenación. En el post de «[Ordenar Arrays en Java (Con sus indices)](https://jarroba.com/ordenar-arrays-en-java-con-sus-indices/)» implementamos un API que nos permitía ordenar Arrays y sus indices, que es una funcionalidad muy importante que no ha sido implementada por ninguna API conocida y de forma sencilla.

 

En este post vamos a mostrar como ordenar ArrayList, bien sea con un ArrayList de datos atómicos o con un ArrayList de objetos.

 

Para realizar estas operaciones necesitaremos trabajar con la Clase «Collections» de Java. No vamos a explicar las características de esta clase, sino que simplemente vamos a utilizarla para ordenar ArrayList’s. Como suele ser habitual en esta web, pasamos a mostrar esta funcionalidad con un ejemplo:

 

Vamos a tener un ArrayList llamado «arrayListInt» que es un array de enteros y que le pondremos los siguientes valores (si no sabéis el método add, mirar el post «[ArrayList en Java, con ejemplos](https://jarroba.com/arraylist-en-java-ejemplos/)«):

 

```java
private static ArrayList arrayListInt = new ArrayList<>();

	// Guardo datos en el ArrayList
	arrayListInt.add(3); 	arrayListInt.add(4);
	arrayListInt.add(2);	arrayListInt.add(6);
	arrayListInt.add(5);	arrayListInt.add(1);
	arrayListInt.add(7);
```

 

Si imprimimos este ArrayList en el orden en el que hemos guardado los elementos, tendremos que el primer elemento será el número ‘3’, el segundo el número ‘4’ y si seguimos el orden, el último será el número ‘7’.

 

Para ordenar este ArrayList de menor a mayor, vamos a utilizar el método «sort» de la clase Collections:

 

```java
Collections.sort(arrayListInt);
```

 

Con este método nos devolverá el ArrayList ordenado de menor a mayor, siendo la salida la siguiente (en el proyecto que os podéis descargar, podéis ver los métodos que imprimen por pantalla los ArrayList):

 

```text
Posicion(1) = 1
Posicion(2) = 2
Posicion(3) = 3
Posicion(4) = 4
Posicion(5) = 5
Posicion(6) = 6
Posicion(7) = 7
```

 

Para ordenarlo de mayor a menor, tenemos que crearnos un objeto de la clase Comparator para que compare los elementos y los ponga en orden inverso. Esto lo hacemos de la siguiente manera:

 

```java
Comparator<Integer> comparador = Collections.reverseOrder();
Collections.sort(arrayListInt, comparador);
```

 

Ejecutando esta parte del programa e imprimiendo por pantalla el ArrayList resultante, tenemos el ArrayList ordenado de mayor a menor:

 

```text
Posicion(1) = 7
Posicion(2) = 6
Posicion(3) = 5
Posicion(4) = 4
Posicion(5) = 3
Posicion(6) = 2
Posicion(7) = 1
```

 

Pero ¿qué pasa si lo que tenemos es un ArrayList de objetos de una determinada clase y lo que queremos es ordenar ese ArrayList por el valor de un determinado atributo?. Bueno pues hay una sencilla solución que vamos a mostrar a continuación y que consiste en sobreescribir un método de la clase Comparator.  
 Supongamos que tenemos una clase «Persona» de la siguiente forma:

 

```java
class Persona {

	private String nombre;
	private int edad;

	public Persona() {
	}

	public Persona(String nombre, int edad) {
		this.nombre = nombre;
		this.edad = edad;
	}

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public int getEdad() {
		return edad;
	}

	public void setEdad(int edad) {
		this.edad = edad;
	}

	@Override
	public String toString() {
		return this.getNombre() + "  -  " + this.getEdad();
	}
}
```

 

Supongamos que tenemos un ArrayList llamado «personas» con los siguientes objetos de la clase persona:

 

```java
private static ArrayList personas = new ArrayList<>();
................
................
personas.add(new Persona("Pepe", 28));
personas.add(new Persona("Juan", 32));
personas.add(new Persona("Paco", 40));
personas.add(new Persona("Susi", 24));
personas.add(new Persona("Lola", 20));
personas.add(new Persona("Jose", 28));
personas.add(new Persona("Dani", 24));
personas.add(new Persona("Sara", 36));
```

 

Este ArrayList lo queremos ordenar (de menor a mayor edad) en función de la edad de las personas, por tanto tenemos que sobre escribir el método «compare» de la clase Comparator y llamar al método «sort» de la clase collections. Esto lo hacemos de la siguiente forma:

 

```java
Collections.sort(personas, new Comparator<Persona>() {
	@Override
	public int compare(Persona p1, Persona p2) {
		return new Integer(p1.getEdad()).compareTo(new Integer(p2.getEdad()));
	}
});
```

 

Como vemos lo que hace el método «compare» es comparar dos edades dadas. En este caso estamos comparando dos atributos de tipo «Integer». Si lo queremos hacer con un String, Double, etc. solo tenemos que cambiar el tipo de dato. Como salida a este código tenemos lo siguiente:

 

```text
Posicion(1) = Lola  -  20
Posicion(2) = Dani  -  24
Posicion(3) = Susi  -  24
Posicion(4) = Pepe  -  28
Posicion(5) = Jose  -  28
Posicion(6) = Juan  -  32
Posicion(7) = Sara  -  36
Posicion(8) = Paco  -  40
```

 

Si ahora queremos ordenarlo de mayor a menor edad, solo tenemos que cambiar el método «compare» poniendo la comparación al revés:

 

```java
Collections.sort(personas, new Comparator<Persona>() {
	@Override
	public int compare(Persona p1, Persona p2) {
		// Aqui esta el truco, ahora comparamos p2 con p1 y no al reves como antes
		return new Integer(p2.getEdad()).compareTo(new Integer(p1.getEdad()));
	}
});
```

 

Como resultado de esta ordenación obtenemos lo siguiente:

 

```text
Posicion(1) = Paco  -  40
Posicion(2) = Sara  -  36
Posicion(3) = Juan  -  32
Posicion(4) = Pepe  -  28
Posicion(5) = Jose  -  28
Posicion(6) = Dani  -  24
Posicion(7) = Susi  -  24
Posicion(8) = Lola  -  20
```

 

Esto es en resumen todo lo necesario para ordenar ArrayList, bien sean por un atributo de una serie de objetos o con datos atómicos (en realidad son objetos que representan datos atómicos, Integer, Double, etc.). No hemos entrado en detalle de explicar las clases Comparator y Collections ya que en principio la finalidad de este post es la de dar una solución a la ordenación de ArrayList.