Java - Evitar duplicados en una lista

<<>>
 
Vista:

Evitar duplicados en una lista

Publicado por Mónica (5 intervenciones) el 01/07/2024 11:21:00
Buenos días:
Como estoy empezando con Java estoy haciendo algo que debería ser sencillo: una lista de nombres y apellidos.

Lo que estoy intentando hacer ahora es impedir que si un nombre ya está grabado no se pueda volver a grabar. Con nombre me refiero a la combinación de nombre + apellido. Pero quizás no estoy utilizando la estructura correcta. ¿Sería mejor utilizar un ArrayList...?

Y abusando un poco de vuestra paciencia. El código tiene una public class y una final class. Como lo hice hace un tiempo y luego tuve que aparcarlo, ahora no entiendo por qué declaré una final class. Supongo que en su momento lo vi en el código de alguien y lo tenía muy claro, pero ahora no. ¿Es necesaria esa final class o sólo es un estorbo?.

Este código lo he hecho con NetBeans y al introducir un nuevo nombre, primero pregunta el nombre y después el apellido. Pero le he ejecutado en Windows PowerShell y ya no pregunta por el nombre. No sé por qué.


Gracias.
Mónica


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
public class ListaNombres{
 
    final class haciendoLista {
        String nombre;
        String apellido;
 
        public String getNombre() {
            return nombre;
        }
 
        public void setNombre(String nombre) {
            this.nombre = nombre;
        }
 
        public String getApellido() {
            return apellido;
        }
 
        public void setApellido(String apellido) {
            this.apellido = apellido;
        }
 
    @Override
    public String toString() {
       return "nombre " + nombre + "apellido " + apellido;
    }
    }
    final static int MAX_NOMBRES = 5;
 
    haciendoLista[] nombres = new haciendoLista[MAX_NOMBRES];
 
    int numNombres = 0;
 
        public void nuevoNombre() throws ArrayIndexOutOfBoundsException {
            try {
                Scanner scanner = new Scanner(System.in);
 
                nombres[numNombres] = new haciendoLista();
 
                System.out.print("Nombre: ");
                nombres[numNombres].nombre = scanner.nextLine();
 
                System.out.print("Apellido: ");
                nombres[numNombres].apellido = scanner.nextLine();
 
                System.out.println("Nombre añadido");
                numNombres++;
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("Error: no se poden añadir más nombres");
            }
        }
 
        public void listaNombres() {
            System.out.println();
        for(var indice = 0; indice < numNombres; indice++)
        System.out.println((indice + 1) + " -> " + nombres[indice].nombre + " " + nombres[indice].apellido);
            System.out.println();
        }
 
    enum Opcion {NUEVO, LISTA, SALIR};
 
    void bucleApp(){
        Opcion opcion;
 
        do {
            muestraListaOpciones();
            opcion = solicitaOpcion();
 
            switch (opcion) {
                case NUEVO-> {
                    nuevoNombre();}
                case LISTA -> {
                    listaNombres();}
            }
            } while (opcion != Opcion.SALIR);
    }
 
    void muestraListaOpciones() {
        for (Opcion unaOpcion : Opcion.values()) {
            System.out.printf("\t%d -> %s\n", unaOpcion.ordinal(), unaOpcion.name());
        }
    }
// Solicitar al usuario la opcion que quiere ejecutar
 
    Opcion solicitaOpcion()throws InputMismatchException, ArrayIndexOutOfBoundsException {
        try {
        Scanner scanner = new Scanner(System.in);
        int opcion;
 
        System.out.print("\nIntroduce el numero de opcion: \n");
        opcion = scanner.nextInt();
        return Opcion.values()[opcion];
        } catch (InputMismatchException | ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: opcion incorrecta");
        }
    return solicitaOpcion();
    }
 
    public static void main(String[] args) {
        (new ListaNombres()).bucleApp();
    }
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

Evitar duplicados en una lista

Publicado por Mónica (5 intervenciones) el 02/07/2024 09:57:21
Buenos días:

Creo que debo aclarar un poco mi pregunta.

¿Podría utilizar el método contains(), por ejemplo, para evitar duplicados en la lista? Es que al ser una combinación de dos campos (nombre y apellido) no tengo muy claro cómo se podría hacer.

No pido el código hecho y masticado, pero me vendría muy bien algo de orientación.

Gracias.
Mónica
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Evitar duplicados en una lista

Publicado por Kabuto (1383 intervenciones) el 02/07/2024 17:27:52
Hola.

Sobre lo de "final class".
El modificador "final" es para indicar que dicha clase es la última, o la única, clase en una línea de herencia.
Es decir, al marcarla como "final", va a ser imposible crear otra clase que herede de esa "clase final".

Supón que tenemos la clase Empleado y de esta heredan otras dos clases Tecnico y Administrativo.

La clase Empleado no podemos declararla como "final", si lo hiciéramos, luego sería imposible crear Tecnico y Administrativo.

Las clases Tecnico y Empleado sí podríamos declararlas como "final", ya que de estas clases no vamos a querer que hereden ninguna otra.
No es obligatorio ponerle el modificador "final", pero puede ser útil para asegurarte de que ni tú, ni otras personas que trabajen en este proyecto, cometáis un error al añadir nuevos tipos de empleados al proyecto (Servicios, Formacion, Directivo...) y los pongáis heredando de Administrativo o de Técnico.
Si cometéis ese error y dichas clases tienen el modificador "final", el compilador enseguida lanzará una alerta indicando que esa relación de herencia es imposible. Y así os daréis cuenta de que habéis errado al indicar la superclase.


Sobre usar contains() para evitar duplicados.
Sí, puedes usarlo, pero necesitas indicarle al ArrayList como debe comparar los objetos de la clase HaciendoLista, ya que él no puede saberlo.

Una forma de hacerlo es sobreescribiendo el método equals() que tiene la clase HaciendoLista (todas las clases lo tienen).
Este método es de tipo boolean y en él lo que hacemos es "explicar" como se han de comparar dos objetos de esta clase.

Ahí le diremos que si coinciden nombre y apellido, retornaremos TRUE para indicar que son dos objetos IGUALES.(es más correcto decir EQUIVALENTES)
En cambio, si hay diferencias en nombre y apellido, o si el objeto con el que comparamos es de una clase distinta, retornaremos FALSE para indicar que son objetos DISTINTOS.

De esta forma, el ArrayList sabrá cómo ha de comparar los objetos para indicar si ya contiene(contains()) un determinado objeto.

El método equals() dentro de la clase HaciendoLista quedaría así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class HaciendoLista {
 
    String nombre;
    String apellido;
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public String getApellido() {
        return apellido;
    }
 
    public void setApellido(String apellido) {
        this.apellido = apellido;
    }
 
    @Override
    public String toString() {
       return "nombre " + nombre + "apellido " + apellido;
    }
 
	@Override
	public boolean equals(Object objeto) {
		if (objeto instanceof HaciendoLista) {
			HaciendoLista otro = (HaciendoLista) objeto;
			if (otro.nombre.equals(this.nombre) && otro.apellido.equals(this.apellido))
				return true; //Ambos objetos tienen mismo nombre y apellido, son IGUALES
			else
				return false; //Nombre y/o apellido, son distintos
		}
		else
			//El objeto no es de la clase HaciendoLista
			return false;
	}
 
 
}

De esta manera, antes de añadir un nuevo objeto al ArrayList, puedes usar contains() para previamente averiguar si ya existe un objeto con mismo nombre y apellido.

Por ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
ArrayList<HaciendoLista> lista = new ArrayList<HaciendoLista>();
 
HaciendoLista nombre1 = new HaciendoLista();
nombre1.nombre= "Pepe";
nombre1.apellido = "Sancho";
 
lista.add(nombre1);
 
 
HaciendoLista nombre2 = new HaciendoLista();
nombre2.nombre= "Pepe";
nombre2.apellido = "Sancho";
 
 
if(lista.contains(nombre2)){
   lista.add(nombre2);
   System.out.println("Admitido");
}
else
    System.out.println("Rechazado");
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.665
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Evitar duplicados en una lista

Publicado por Billy Joel (876 intervenciones) el 02/07/2024 19:26:58
Si puedes utilizar un
1
List<haciendoLista> nombres = new ArrayList<>();

en lugar de:
1
haciendoLista[] nombres = new haciendoLista[MAX_NOMBRES];

Pero algo me dice que el objetivo es recorrer un arreglo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * Evalúa si el nombre y apellido están en la lista de nombres
 *
 * @param nombre
 * @param apellido
 * @return
 */
private boolean isInLista(String nombre, String apellido) {
    for (HaciendoLista n : nombres) {
        if (n == null) {
            break;
        } else {
            if (n.getNombre().equals(nombre) && n.getApellido().equals(apellido)) {
                return true;
            }
        }
    }
    return false;
}

Este método recorre el arreglo y compara nombres y apellidos.
A continuación el código queda así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import java.util.InputMismatchException;
import java.util.Scanner;
 
public class ListaNombres {
 
    final class HaciendoLista {
 
        String nombre;
        String apellido;
 
        public String getNombre() {
            return nombre;
        }
 
        public void setNombre(String nombre) {
            this.nombre = nombre;
        }
 
        public String getApellido() {
            return apellido;
        }
 
        public void setApellido(String apellido) {
            this.apellido = apellido;
        }
 
        @Override
        public String toString() {
            return "nombre " + nombre + "apellido " + apellido;
        }
    }
    final static int MAX_NOMBRES = 5;
    HaciendoLista[] nombres = new HaciendoLista[MAX_NOMBRES];
    int numNombres = 0;
 
    public void nuevoNombre() throws ArrayIndexOutOfBoundsException {
        if (numNombres >= MAX_NOMBRES) {
            System.out.println("Error: no se poden añadir más nombres");
            return;
        }
        try {
            Scanner scanner = new Scanner(System.in);
 
            System.out.print("Nombre: ");
            String nombre = scanner.nextLine();
 
            System.out.print("Apellido: ");
            String apellido = scanner.nextLine();
 
            if (isInLista(nombre, apellido)) {
                System.out.println("El nombre ya está dentro de la lista");
            } else {
                nombres[numNombres] = new HaciendoLista();
                nombres[numNombres].setNombre(nombre);
                nombres[numNombres].setApellido(apellido);
                System.out.println("Nombre añadido");
                numNombres++;
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: no se poden añadir más nombres");
        }
    }
 
    /**
     * Evalúa si el nombre y apellido están en la lista de nombres
     *
     * @param nombre
     * @param apellido
     * @return
     */
    private boolean isInLista(String nombre, String apellido) {
        for (HaciendoLista n : nombres) {
            if (n == null) {
                break;
            } else {
                if (n.getNombre().equals(nombre) && n.getApellido().equals(apellido)) {
                    return true;
                }
            }
        }
        return false;
    }
 
    public void listaNombres() {
        System.out.println();
        for (int i = 0; i < numNombres; i++) {
            System.out.println((i + 1) + " -> " + nombres[i].nombre + " " + nombres[i].apellido);
        }
        System.out.println();
    }
 
    enum Opcion {
        NUEVO, LISTA, SALIR
    };
 
    void bucleApp() {
        Opcion opcion;
        do {
            muestraListaOpciones();
            opcion = solicitaOpcion();
            switch (opcion) {
                case NUEVO -> {
                    nuevoNombre();
                }
                case LISTA -> {
                    listaNombres();
                }
            }
        } while (opcion != Opcion.SALIR);
    }
 
    private void muestraListaOpciones() {
        for (Opcion unaOpcion : Opcion.values()) {
            System.out.printf("\t%d -> %s\n", unaOpcion.ordinal(), unaOpcion.name());
        }
    }
 
    // Solicitar al usuario la opcion que quiere ejecutar
    private Opcion solicitaOpcion() {// throws InputMismatchException, ArrayIndexOutOfBoundsException {
        try {
            Scanner scanner = new Scanner(System.in);
            int opcion;
            System.out.print("\nIntroduce el numero de opcion: ");
            opcion = scanner.nextInt();
            return Opcion.values()[opcion];
        } catch (InputMismatchException | ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: opcion incorrecta");
        }
        return solicitaOpcion();
    }
 
    public static void main(String[] args) {
        (new ListaNombres()).bucleApp();
    }
}

Saludos,
Billy Joel
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Richtofen

Evitar duplicados en una lista

Publicado por Richtofen (19 intervenciones) el 06/07/2024 13:30:46
Usa cualquier implementacion de Set
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar