Comparación entre dos listas de String
Hoy nos toca ver cómo se puede realizar una comparación entre dos listas de String. Obviamente, hay muchos caminos que llevan a Roma, pero en este post vamos a repasar una forma sencilla de comparar las dos listas y extraer las diferencias entre ellas. Puede parecer una operación muy básica, pero la verdad es que no lo resulta tanto cuando un programador principiante se enfrenta por primera vez a este problema. Y la verdad es que suele ser una operación bastante necesaria en la mayoría de las aplicaciones, pues no resulta raro que se requieran funcionalidades que detecten discrepancias entre dos tablas o dos listados...
Por definir con claridad el escenario, el problema planteado partirá de dos listas (lista A y lista B) cada una con una serie concreta de objetos String. El objetivo del desarrollador consistirá en comparar los objetos de ambas listas y determinar cuáles son las diferencias entre las mismas. Como resultado, se podrán extraer otras dos listas (lista X y lista Z) donde se indicará cuáles son los String que no coinciden. Esto es, acabaremos con una lista X que contendrá los objetos de lista A que no existen en lista B y con otra lista Z que contendrá los objetos de lista B que no existen en lista A. Puede parecer un poco complejo, pero se verá más claro con un ejemplo.
Comparación entre dos listas de objetos String
Para realizar la comparación, vamos a usar el siguiente ejemplo en el que se parte de dos listas (listOct y listNov) y se termina con otras dos listas (listOctFiltrada y listNovFiltrada) que contienen las diferencias entre las dos listas iniciales.
// **************************************************
package com.universo.sort.defecto;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class AppComparaListas {
public static void main(String[] args) {
// TODO Auto-generated method stub
// Creacion de listas que deben ser comparadas
List<String> listOct = new ArrayList(Arrays.asList("Tesla", "Nvidia", "Intuit", "Kla", "Google", "Microsoft", "Intuitive", "Costco", "Automatic", "Apple"));
List<String> listNov = new ArrayList(Arrays.asList("Tesla", "Intuit", "Google", "Microsoft", "Intuitive", "Costco", "Automatic", "Apple", "Facebook", "Charter"));
// Creacion de listas que contendran las diferencias
// listOctFiltrada --> objetos de listOct que no existen en listNov
// listNovFiltrada --> objetos de listNov que no existen en listOct
List<String> listOctFiltrada = new ArrayList(listOct);
List<String> listNovFiltrada = new ArrayList(listNov);
// En listOctFiltrada eliminamos los objetos existentes en listNov
listOctFiltrada.removeAll(listNov);
// En listNovFiltrada eliminamos los objetos existentes en listOct
listNovFiltrada.removeAll(listOct);
System.out.println("listOct inicial: " + listOct);
System.out.println("listNov inicial: " + listNov);
System.out.println("listOct filtrada y faltan en listNov: " + listOctFiltrada );
System.out.println("listNov filtrada y faltan en listOct: " + listNovFiltrada );
// Recorremos listOct
System.out.println("*** Recorremos listOct ***");
for (String item : listOct) {
if (listNov.contains(item)) {
System.out.println("Item existente en ambas listas");
} else {
System.out.println("Item de listOct no existe en listNov: " + item);
}
}
// Recorremos listNov
System.out.println("*** Recorremos listNov ***");
for (String item : listNov) {
if (listOct.contains(item)) {
System.out.println("Item existente en ambas listas");
} else {
System.out.println("Item de listNov no existe en listOct: " + item);
}
}
}
}
// **************************************************
A continuación, vamos a revisar la lógica anterior con un poco de detalle, por si hay algo que se nos escapa en una primera lectura.
1º) Creamos las dos listas iniciales que posteriormente deberán ser comparadas (aquí hemos usado nombres de empresa, pero podríamos usar cualquier cadena de texto):
List<String> listOct = new ArrayList(Arrays.asList("Tesla", "Nvidia", "Intuit", "Kla", "Google", "Microsoft", "Intuitive", "Costco", "Automatic", "Apple"));
List<String> listNov = new ArrayList(Arrays.asList("Tesla", "Intuit", "Google", "Microsoft", "Intuitive", "Costco", "Automatic", "Apple", "Facebook", "Charter"));
2º) A continuación, nos creamos las dos listas que, tras la ejecución del proceso, contendrán las diferencias entre las dos listas de partida. Como vemos, en un primer momento estas dos nuevas listas las generamos con el mismo contenido que las listas iniciales.
List<String> listOctFiltrada = new ArrayList(listOct);
List<String> listNovFiltrada = new ArrayList(listNov);
3º) Operamos sobre la lista listOctFiltrada y eliminamos de la misma todos aquellos objetos contenidos en la lista listNov. De este modo, básicamente nos estaremos quedando únicamente con los objetos de la lista listOct que no existan en listNov.
// En listOctFiltrada eliminamos los objetos existentes en listNov
listOctFiltrada.removeAll(listNov);
4º) Posteriormente, repetimos la misma operación con la otra lista. Operamos sobre la lista listNovFiltrada y eliminamos de la misma todos aquellos objetos contenidos en la lista listOct. Con esta operación, en realidad nos estaremos quedando únicamente con los objetos de la lista listNov que no existan en listOct.
// En listNovFiltrada eliminamos los objetos existentes en listOct
listNovFiltrada.removeAll(listOct);
5º) Finalmente, imprimimos el contenido de las dos nuevas listas generadas, para validar que se han generado de forma correcta.
System.out.println("listOct filtrada y faltan en listNov: " + listOctFiltrada );
System.out.println("listNov filtrada y faltan en listOct: " + listNovFiltrada );
6º) Si ejecutamos el proceso anterior, al final deberíamos tener dos listas que almacenen las diferencias entre las dos listas iniciales. La salida del proceso debería ser algo así.
listOct inicial: [Tesla, Nvidia, Intuit, Kla, Google, Microsoft, Intuitive, Costco, Automatic, Apple]
listNov inicial: [Tesla, Intuit, Google, Microsoft, Intuitive, Costco, Automatic, Apple, Facebook, Charter]
listOct filtrada y faltan en listNov: [Nvidia, Kla]
listNov filtrada y faltan en listOct: [Facebook, Charter]
*** Recorremos listOct ***
Item existente en ambas listas
Item de listOct no existe en listNov: Nvidia
Item existente en ambas listas
Item de listOct no existe en listNov: Kla
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
*** Recorremos listNov ***
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item existente en ambas listas
Item de listNov no existe en listOct: Facebook
Item de listNov no existe en listOct: Charter
Como se observa, las dos listas finales nos están indicando correctamente cuáles son los objetos discrepantes de las dos listas iniciales.
listOct filtrada y faltan en listNov: [Nvidia, Kla]
listNov filtrada y faltan en listOct: [Facebook, Charter]
Una vez explicado, vemos que el proceso para comparar dos listas de objetos realmente es algo sencillo. En realidad, no requiere el empleo de ningún algoritmo complejo. Por tanto, ya no tenemos excusa para no comenzar a utilizar esta funcionalidad en nuestras aplicaciones. Cualquier duda, ya sabéis que podéis dejármela aquí abajo.
Saludos.
Comentarios
Publicar un comentario