Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 01-03-24 - 3 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 3 de marzo de 2024 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Este es localizar al alumno y una vez que lo hemos localizado, le añadimos la asignatura a su lista. 00:00:02
Y localizar al alumno, pues bueno, si lo hacemos con el for para no liarnos y que sea lo que estamos acostumbrados, 00:00:09
que estamos acostumbrados al for de índice y no nos liamos, pues no pasa nada, hacemos con el for de índice. 00:00:18
Desde la posición 0, mientras yo no haya acabado con mi colección, 00:00:25
Pues si este alumno resulta que su número de matrícula es igual a la que me han dado, 00:00:40
pues ya tengo al alumno. 00:00:56
Recorro el for. 00:01:08
Cuando encuentro al alumno cuya matrícula es igual que la que me han dado, 00:01:12
es como el recorrido del array, igual, lo mismo, pues ya está, ya lo tengo. 00:01:16
ahora la pregunta es 00:01:21
¿qué hago con ese alumno GetDay? 00:01:22
¿qué hago con este? 00:01:27
¿qué se le ha encontrado? 00:01:28
¿qué hago con este? 00:01:29
pues añadirle a sus asignaturas la nueva 00:01:31
pues hombre, lo tengo muy fácil 00:01:33
cojo sus asignaturas 00:01:36
primero cojo al alumno 00:01:38
que es este 00:01:40
este es mi alumno ya encontrado 00:01:40
ahora, cojo sus asignaturas 00:01:43
que son estas 00:01:45
y a sus asignaturas cojo y les añado la nueva 00:01:46
y ya está 00:01:49
y he terminado el método 00:01:51
vale 00:01:53
ya está 00:01:55
localizo al alumno 00:01:59
cuando encuentro al alumno cuya matrícula es la que me han dado 00:02:01
pues ese alumno que acabo de encontrar 00:02:05
alumnos get i 00:02:07
cojo sus asignaturas con el get 00:02:08
correspondiente, cojo sus asignaturas 00:02:10
y añado la nueva 00:02:12
como get asignaturas 00:02:14
es una lista 00:02:17
lo tengo muy fácil, lo añado con el add y se acabó 00:02:17
y esta sería la versión más sencilla 00:02:20
sin preocuparse 00:02:25
de que de alguna manera 00:02:27
me avise de que aún no existe o no existe 00:02:29
etcétera, la versión más sencilla 00:02:30
sería esta, vamos a 00:02:32
probarla en nuestro main 00:02:35
vale 00:02:36
vamos a matricular al alumno que tenemos 00:02:40
al único 00:02:43
al alumno 1 de una asignatura 00:02:43
vamos a matricular 00:02:47
al alumno de la asignatura 00:02:51
lengua 00:02:55
venga, alumno 1 matriculado 00:02:56
de la asignatura lengua y vamos a ver si se 00:03:01
realmente se ha matriculado mostrando sus datos, claro 00:03:02
vamos a volver 00:03:04
a mostrar sus datos 00:03:06
le matriculamos 00:03:07
y mostramos los datos, a ver si se ha 00:03:14
matriculado realmente 00:03:16
pues sí, a ver, me lo muestra dos veces 00:03:17
porque es que aquí como lo he hecho de dos maneras 00:03:31
distintas 00:03:33
este de aquí, que otra cosa que se puede hacer 00:03:34
he hecho lo mismo, pues el string 00:03:37
el string es doble, vale 00:03:39
pero vamos a comentar esto 00:03:41
para que lo tengáis aquí 00:03:43
otra cosa que se puede hacer 00:03:45
Pero 00:03:46
Esto como era para 00:03:48
Comentar así, ¿no? 00:03:50
Ay, no 00:03:52
Como era para ponerlo comentado toda la vez 00:03:53
Siempre se me olvida 00:03:59
¿Eh? 00:04:02
Sí, para ponerlo todo comentado de golpe 00:04:07
Es que siempre se me olvida, jolines 00:04:09
Barra asterisco 00:04:13
¿Seguro? ¿Qué barra? 00:04:17
¿Eh? 00:04:20
Ah, no, no, no, pero 00:04:21
Quiero un atajo que hay 00:04:25
Para que me lo ponga así todo 00:04:27
Esto quería 00:04:29
Vale, que queda como más bonito 00:04:31
Son más habituales estos comentarios 00:04:33
¿Qué? Ahí 00:04:35
¿Me dio el ratón o qué? Ahí 00:04:37
Estos son como más 00:04:38
Más bonitos que 00:04:41
Es un estilo de comentario más habitual 00:04:42
Vale, entonces lo dejo comentado 00:04:46
Así, la otra cosa que se puede hacer 00:04:48
Vamos a volver a probar 00:04:50
pero sí, podía haberle puesto el barra asterisco 00:04:51
y ya está, y así se ve mejor 00:04:54
inicialmente no tenía nada 00:05:00
y ahora ya tiene 00:05:02
la asignatura de lengua 00:05:04
a ver, otro método 00:05:05
desmatricular 00:05:17
de una asignatura 00:05:24
dado el número de matrícula 00:05:27
y el nombre de la asignatura, hay que desmatricularle 00:05:29
cabecera 00:05:31
del método 00:05:33
pues nada, la cabecera del método 00:05:33
desmatricular 00:05:46
alumno de una asignatura 00:05:49
dado el número de matrícula 00:05:54
y dada la asignatura 00:05:57
que le queremos quitar 00:06:02
pues venga 00:06:04
esto será parecido pero en lugar de añadir 00:06:07
habrá que borrar 00:06:10
pues a ver como lo hacéis 00:06:11
venga, haced este método 00:06:14
bueno, pues este es como el de arriba 00:06:23
pero en lugar de 00:06:28
añadir una asignatura 00:06:29
eliminar una asignatura 00:06:32
entonces es lo mismo 00:06:34
copiamos y pegamos 00:06:37
una vez que he localizado 00:06:40
al alumno cuyo número de matrícula es ese 00:06:45
cojo su array 00:06:48
de asignaturas y como es una lista 00:06:49
puedo hacer todo lo que puedo hacer 00:06:52
con las listas, que que es 00:06:53
insertar, eliminar, etc 00:06:55
pues cambio el add por remove 00:06:57
y ya está 00:06:59
vale 00:07:01
he borrado la asignatura 00:07:04
de la lista get asignaturas 00:07:10
del alumno, ya está 00:07:12
vale, entonces si silencio 00:07:13
si lo probamos en nuestro 00:07:16
main, vamos a matricularle de dos 00:07:18
y luego le quitamos una 00:07:20
le matriculamos de lengua 00:07:23
y mates 00:07:26
mostramos los datos 00:07:28
y ahora le vamos a desmatricular 00:07:30
de lengua 00:07:31
no le he puesto public 00:07:33
ah el static 00:07:42
vale 00:07:46
desmatriculamos 00:07:46
a el alumno 00:07:56
de matricula 1 00:07:57
le vamos a desmatricular 00:07:58
de lengua 00:08:02
y vamos a mostrar otra vez los datos 00:08:03
sacamos otra vez 00:08:10
su certificado a ver que tiene 00:08:11
después de haberle 00:08:13
desmatriculado 00:08:15
vale, pues este es el alumno 00:08:16
inicial, sin asignaturas 00:08:25
luego le matriculamos 00:08:28
de lengua y mates, aquí las tiene 00:08:29
lengua y mates, y ahora le hemos 00:08:31
matriculado de lengua, pues aquí se ha quedado con mates 00:08:33
vale 00:08:35
hasta ahí bien, ¿no? 00:08:36
pero cuidadín, porque el 00:08:41
remove, el remove 00:08:43
tiene su cosa 00:08:45
¿cómo funciona el remove? 00:08:47
el remove, si tú le pasas una posición 00:08:51
no tiene ningún peligro 00:08:53
le pasas la posición 3 00:08:54
y te borra el elemento de posición 3 00:08:57
de la colección 00:08:59
es como el get 00:09:00
pero remove también tiene la 00:09:02
alternativa que estamos usando 00:09:05
porque es un método sobrecargado 00:09:07
pasa en un objeto 00:09:08
y te borra el primero que encuentra 00:09:10
que es igual a este 00:09:13
que es igual a ese 00:09:14
¿qué pasa? aquí estamos trabajando con string 00:09:16
porque esta colección es de string 00:09:19
entonces el string, la clase string tiene su equal ya hecho 00:09:20
y entonces el remove coge la asignatura 00:09:23
que yo le paso, mates, lengua 00:09:27
te va a buscar a raíz de asignaturas 00:09:28
la primera que se encuentra igual a esa 00:09:30
igual según el equals 00:09:33
de string, que es que la cadena sea igual 00:09:35
luego funciona perfectamente 00:09:36
no hay ningún problema, pero no nos olvidemos 00:09:38
que el remove lo que hace es 00:09:41
te recorre la colección, te la recorre 00:09:42
por dentro, te tiene su for dentro 00:09:45
no hay otra, el remove tiene su for dentro 00:09:47
te la recorre y en cuanto 00:09:49
se encuentra un objeto de esta colección 00:09:51
igual que este, te lo quita 00:09:53
solo el primero que encuentra igual 00:09:55
del resto ya pasa 00:09:58
¿vale? entonces en nuestro caso esta colección 00:09:59
¿de qué es? de string, de cadenas 00:10:02
yo le paso un string 00:10:03
la igualdad de cadenas está perfectamente ya 00:10:05
programada en la clase string, me puedo despreocupar 00:10:08
en cuanto encuentre la colección 00:10:10
de asignaturas una igual a esta 00:10:12
elimina esa 00:10:14
¿vale? 00:10:15
vale, eso por un lado, pero solo la primera 00:10:18
ocurrencia, imaginaos que 00:10:20
yo le matricula 00:10:21
para ver cómo funciona bien 00:10:23
voy a hacer la prueba matriculándole de lengua 00:10:24
dos veces 00:10:27
le voy a matricular 00:10:28
de lengua, de mates y de lengua 00:10:30
asignaturas es una lista 00:10:37
luego admite duplicados 00:10:40
con lo cual en su lista de asignaturas tendrá 00:10:41
lengua, mates y lengua 00:10:43
lengua y lengua son iguales 00:10:45
son objetos iguales, dos estén iguales 00:10:48
pero están en posiciones distintas 00:10:49
luego la lista de asignaturas las coge 00:10:51
vale, matricula de tres 00:10:53
muestro los datos, luego 00:10:54
ahora le voy a desmatricular de lengua 00:10:56
a ver que me muestra 00:10:58
vamos a volver a ejecutar 00:11:00
esto 00:11:03
¿veis? 00:11:03
me ha borrado solo 00:11:14
la primera ocurrencia que se ha 00:11:16
encontrado igual a lo que yo le paso 00:11:18
solo la primera 00:11:21
en cuanto ha encontrado esta que era 00:11:22
igual a la que yo le pasaba, la ha borrado 00:11:24
y ya deja de mirar 00:11:26
¿vale? luego solo me ha borrado la primera 00:11:28
la otra que estaba 00:11:30
también igual que lengua y esta no 00:11:33
vale, primera cosa 00:11:35
el remove funciona así 00:11:37
funciona así, el que lo hizo, lo hizo así 00:11:39
funciona así, remove te borra 00:11:41
solo la primera ocurrencia de esta lista 00:11:43
igual que esta 00:11:45
lo que pasa es que si uno 00:11:46
quiere borrarlas todas las que sean 00:11:51
iguales 00:11:53
el que hizo el remove 00:11:53
lo hizo, esto no 00:11:57
es relativamente fácil de entender pero bueno 00:11:58
te devuelve un boolean 00:12:01
te devuelve un boolean que es true 00:12:02
si encontró una y la borró 00:12:05
y false si no 00:12:07
entonces ¿cómo podemos usar ese boolean? 00:12:09
podemos usar ese boolean 00:12:12
para meter esto en un while 00:12:13
de tal forma que él borra 00:12:14
y te devolverá un true 00:12:17
y la colección se ha quedado sin eso 00:12:19
entonces como es un while 00:12:21
volverá a entrar 00:12:23
¿y qué borrará ahora? el siguiente que se encuentra 00:12:24
y te devolverá un true 00:12:28
entonces el while 00:12:29
vuelve a entrar, con lo cual vuelve a hacer remove 00:12:31
entonces si yo quiero 00:12:33
que me borre todas las ocurrencias 00:12:35
iguales a este, no solo la primera 00:12:37
lo tengo tan fácil como meter esto en un while 00:12:39
meto esto en un while 00:12:41
y divino, ya lo tengo 00:12:45
lo meto en un while 00:12:52
para que el remove se haga 00:12:54
muchas veces 00:12:56
eh, añado un while 00:12:57
delante y ya está, entonces 00:13:04
Entonces automáticamente he hecho un bucle, este bucle no tiene código, no tiene nada, 00:13:06
lo he terminado en punto y coma, no tiene nada, ¿veis? No tiene código, es como si 00:13:10
yo hiciera esto, como lo queráis hacer, un while sin código y como no tiene código, 00:13:15
así, punto y coma, un while que no tiene nada, si lo veis más claro así, un while 00:13:24
vacío, un while que no tiene nada, claro, es que lo que hace, lo hace en la condición, 00:13:29
Entonces, ¿este while qué hace? Primero, como dentro de la condición está hacer eso, borra el primero que haya y te devuelve true porque ha encontrado uno y lo ha borrado, te devuelve true, con lo cual vuelve a entrar en el while, vuelve a entrar en el while, ya no estaba ese que lo ha borrado, con lo cual el que va a borrar es el siguiente y te devuelve true porque ha borrado uno, con lo cual vuelve a entrar. 00:13:32
así hasta que no haya encontrado ninguno 00:13:55
porque cuando no haya encontrado ninguno para borrar 00:13:58
se volverá falso, con lo cual ya no 00:14:00
entra más en el while 00:14:02
luego la forma de forzar a que el remove 00:14:03
te borre todos los que sean iguales a este 00:14:06
es tan sencillo como meterlo 00:14:08
en un while 00:14:10
lo metes en un while sin código 00:14:10
con lo cual me da igual 00:14:14
ponerle llaves que cerrarlo con punto y coma 00:14:16
es lo mismo 00:14:18
lo metes en un while sin código y entonces ya 00:14:18
ese remove se va haciendo 00:14:22
tantas veces como necesite 00:14:23
hasta llegar a fase 00:14:25
¿vale? entonces cada método 00:14:26
cada método tiene sus peculiaridades 00:14:29
sus particularidades en las listas 00:14:31
es imposible conocer los detalles de funcionamiento 00:14:33
de todos 00:14:35
pero de algunos básicos 00:14:36
relacionados con insertar, eliminar 00:14:38
consultar, de algunos básicos 00:14:41
si tenemos que conocer algunos detalles de funcionamiento 00:14:43
pues todo esto 00:14:45
pues es lo que luego en casa 00:14:47
os repasáis, os miráis 00:14:49
y os aseguráis de que ya lo 00:14:51
lo incorporáis 00:14:53
entonces si volvemos a ejecutar 00:14:54
este código 00:14:57
este método ahora pero metido en el while esto 00:14:57
ya nos va a quitar 00:15:01
todas las lenguas 00:15:02
si es que lo hemos hecho bien 00:15:04
metido lengua, mates y lengua 00:15:06
vale 00:15:08
volvemos a ejecutar esto 00:15:11
espera un segundo 00:15:14
veis ya me ha quitado todas las lenguas 00:15:18
vale 00:15:20
como sería con 00:15:21
Ah, o el remove all 00:15:23
Pues el remove all 00:15:26
Sería igual, o sea, te borra todas 00:15:30
¿Vale? O sea, sería 00:15:40
No lo meterías en un while 00:15:41
Ah, que no estoy aquí, ya decía yo 00:15:43
Claro, no estoy aquí 00:15:45
Vale, entonces el remove all 00:15:47
Cambiaríais este while 00:15:49
Por todo esto y remove all ahí 00:15:52
¿Vale? 00:15:54
¿No te está dejando? Espérate, voy a hacerlo 00:15:57
Que igual te lo estoy diciendo mal, vamos a ver 00:15:59
remove all, a ver, los detalles del método, vamos a ver, alumnos.get y .get asignaturas, 00:16:01
ah, es que como no estoy en el for, no me lo coge, a ver, no, pero espera, voy a abrir 00:16:21
aquí una llave 00:16:39
y así lo tengo todo junto 00:16:39
vale, entonces con esto borraría todo 00:16:45
y vamos a ver el remove all este 00:16:47
como 00:16:50
get i.get 00:16:50
joder, tecladito de los 00:16:53
venga 00:16:56
get asignaturas que es una colección 00:16:57
y ahora vamos a ver el remove 00:16:59
all 00:17:02
a ver, lo que pasa es que el remove all es otra cosa 00:17:02
vale 00:17:06
el remove all lo que te borra, tú le tienes que 00:17:07
pasar un conjunto de objetos distintos 00:17:09
Es decir, yo aquí le puedo pasar 00:17:11
No sé si me va a dejar pasarle 00:17:15
O lo tengo que inicializar 00:17:17
Esto sería si le quiero pasar 00:17:18
Es para otra cosa 00:17:20
Vamos a ver 00:17:24
Imagínate que quieres matricularle de lengua y de mates 00:17:25
Le quieres matricularle de lengua y de mates 00:17:28
Entonces 00:17:31
Pero es otro uso 00:17:32
¿Vale? 00:17:34
Entonces imagínate que yo le quiero 00:17:35
Desmatricular de 00:17:37
claro, no, no, claro 00:17:38
claro, a ver 00:17:45
pero esto es para borrar 00:17:47
varios objetos distintos 00:17:49
de la colección 00:17:51
no, esto es el remove all 00:17:52
es cuando tú quieres borrar 00:17:55
varios objetos distintos de la colección 00:17:56
es decir, quieres desmatricular a la vez 00:17:59
de lengua y de mates 00:18:01
pero es otra cosa diferente, por ejemplo 00:18:02
imagínate que tú tienes aquí una lista de asignaturas 00:18:05
de las que quieres borrarle 00:18:07
a 6 00:18:09
como que no 00:18:11
vamos a ver, espera un momento, es que son cosas distintas 00:18:14
vale 00:18:17
vamos a hacerle una lista de asignaturas de las que queremos 00:18:20
borrarle, entonces tú le quieres 00:18:23
6.ad 00:18:25
lengua 00:18:30
a 6.ad 00:18:37
y ahora ya le borras 00:18:44
asics 00:18:53
vale, a ver, este es el uso del remove all 00:18:55
tú tienes varios objetos 00:18:59
que quieres borrar 00:19:01
quiero borrarle lengua, mates 00:19:02
pues en lugar de ir uno por uno borrándoles uno por uno 00:19:04
con el remove 00:19:07
los metes una colección 00:19:08
y le pasas la colección enterita 00:19:10
vale, pero es otra idea 00:19:12
diferente a esto, esto de aquí es que tú quieres 00:19:15
eliminar la lengua, pero es que lengua te aparece 00:19:17
varias veces, porque está duplicada. 00:19:19
Entonces, el remove 00:19:21
te elimina la primera ocurrencia. 00:19:22
Si quieres que te las elimine todas, lo metes en un 00:19:25
wall y te las elimina todas. 00:19:27
Y el remove all es, cuando tú quieres 00:19:29
varios objetos distintos. 00:19:31
Lengua, mates y física. 00:19:33
Los metes en una colección, lengua, mates y física 00:19:34
y toda esa colección 00:19:37
con objetos distintos 00:19:39
se va aquí. 00:19:40
No, a ver, si tienes cinco alumnos, tienes que irte alumno por alumno. 00:19:49
Sí, pero es diferente, pero tendrás que hacer eso para cada alumno. 00:19:52
O sea, si tú tienes cinco alumnos matriculados en lengua, 00:19:57
tienes que hacer el remove para este, y el remove para este, 00:20:01
el remove para este, el remove para este. 00:20:04
Son cosas independientes. 00:20:06
O sea, es que este de hecho me va a borrar, me va a desmatricular de lengua 00:20:10
a todos los alumnos cuyo número de matrícula es esta. 00:20:14
Si son cinco, me los voy a borrar de cinco. 00:20:17
Efectivamente, quita todos los ítems 00:20:19
Que están en esta colección de la lista 00:20:35
Lo que estamos diciendo 00:20:37
Te quita lengua y te quita mates 00:20:39
Claro, es justo lo que hemos dicho 00:20:41
Es decir, estos métodos son distintos 00:20:44
Remove, te quita 00:20:48
le das un único objeto 00:20:50
la diferencia esencial es que a este le das uno solo 00:20:53
y a este le das varios 00:20:56
con lo cual a este le tienes que dar una colección 00:20:57
a este le das uno 00:21:00
y a este le das varios, es la primera diferencia 00:21:02
vale, entonces a este le das uno 00:21:03
¿qué te hace con ese objeto? 00:21:06
te borra de la lista 00:21:08
el primero que se encuentra que es igual 00:21:09
si en la lista hay otros 00:21:12
que es igual no los toca 00:21:14
con lo cual si tú quieres que te borre todos 00:21:15
los que son igual a este al único 00:21:18
que le das, lo metes en un guay 00:21:19
y no pasa nada, vale 00:21:21
este es otro método, a este no le pasas uno 00:21:23
a este le pasas muchos 00:21:26
muchos, y que es lo que 00:21:27
hace, todos ellos 00:21:30
sus primeras ocurrencias 00:21:31
de todos ellos, te las borra de la lista 00:21:33
este es cuando quieres borrar 00:21:36
de golpe varios objetos 00:21:38
de una única lista 00:21:40
y este es cuando quieres borrar 00:21:41
un único objeto, que quieres borrar 00:21:43
un único objeto de esta lista 00:21:46
este, que quieres borrar 00:21:47
muchos objetos, este 00:21:49
en ambos casos las primeras 00:21:50
ocurrencias 00:21:53
claro, pero es que 00:21:53
es lo 00:22:05
pero vamos a ver 00:22:06
pero es que en cualquier caso, o sea, no es que sea 00:22:08
penoso, es que no sea penoso, o sea, que es que 00:22:14
ah, te había entendido 00:22:16
ah, no, esto no tiene nada de 00:22:17
peligroso, o sea, este 00:22:20
while te va a ir llamando a remove 00:22:22
Mientras haya hecho un eliminado 00:22:24
Que no ha hecho ninguno 00:22:27
Ya no te va a llamar a más 00:22:27
O sea, este while en concreto no tiene nada de peligroso 00:22:29
O sea, el remove te devuelve true o false 00:22:32
¿Vale? 00:22:35
Y si te devuelve 00:22:38
True 00:22:39
Es cuando va a volver a entrar 00:22:40
Entonces, ¿qué va a hacer? 00:22:42
Intentar el remove 00:22:44
Y el remove, si ya no encuentra ninguno 00:22:45
No hace nada, te devuelve false 00:22:46
Pues le quitas del while 00:22:48
pues entonces no pones el while 00:22:58
claro, pero tú tienes que saber 00:23:00
qué quieres hacer en tu código 00:23:02
o sea, tu código tiene que tener muy claros los requisitos 00:23:04
entonces tú antes de programar 00:23:06
a ver, sí, pero tú tienes que 00:23:08
cuando tú programas esto 00:23:12
pero vamos a ver 00:23:13
pero tú cuando 00:23:18
vale, escucha 00:23:18
sí, pero escucha 00:23:20
o sea, tú cuando escribes el código 00:23:22
lo que tienes que saber es exactamente 00:23:23
porque tú eres el analista 00:23:25
exactamente qué quieres que haga 00:23:26
entonces tú 00:23:27
te habrás juntado con el tío y le habrás dicho 00:23:28
oye, puede ocurrir 00:23:30
que tú hayas matriculado de lengua 00:23:31
dos veces a una persona 00:23:34
eso puede ocurrir, él te dirá 00:23:35
sí, tú te apuntas 00:23:38
en la lista puede aparecer dos veces 00:23:39
la misma asignatura, vale 00:23:42
una vez que te lo has apuntado, vuelves y le dices 00:23:43
cuando tú le desmatricules de lengua 00:23:45
¿qué quieres que ocurra? 00:23:47
¿que te desmatricules solo de la primera vez que lo hiciste? 00:23:49
¿o te desmatricule de todas? 00:23:52
dice, no, quiero que me desmatricule solo 00:23:53
de la primera vez que se encuentre 00:23:55
te lo apuntas y tú programas con lo que él te ha dicho. 00:23:57
Ah, no, pues quiero que me detecte si hay duplicado 00:24:01
y si los hay que lo arregle. 00:24:03
Vale, pues tú te haces la funcionalidad. 00:24:04
Tú tienes que programar lo que a ti te hayan pedido que hagas. 00:24:06
Entonces, lo que se trata es de entender 00:24:10
qué hace este método y cómo usarlo. 00:24:12
Pero claro, tú te habrás juntado con el que te lo ha pedido 00:24:14
y te haya dicho, oye, cuando yo le dé al botón desmatricular 00:24:18
quiero que pase esto y tú programas eso. 00:24:21
O sea, no es que sea mejor o peor, 00:24:25
es lo que él te haya pedido 00:24:26
¿vale? lo que él te haya pedido 00:24:27
y si aparecen 00:24:30
tres veces lengua, imagínate que aparecen 00:24:32
cinco veces lengua, si tú no pones 00:24:34
el while, te borra la primera 00:24:36
y sigue quedando cuatro veces lengua, tú le dices 00:24:38
oye, ¿es eso lo que quieres? 00:24:40
no, quiero que me hagas mejor un método 00:24:42
que me detecte si está matriculado de una varias veces 00:24:44
y me lo arregles, ah, vale 00:24:46
pues te hago el método que te haga eso 00:24:47
es que, claro, partimos de la base de que 00:24:49
uno tiene que tener muy muy muy claro, porque lo ha acordado 00:24:52
con el que le ha pedido, ¿qué quieres hacer? 00:24:54
Ahora mismo lo que nos importa a nosotros 00:24:57
es cómo funciona este método 00:24:58
y cómo usarlo. Entonces, remove, 00:25:00
le pasas un objeto, te borra 00:25:03
la primera ocurrencia igual a él. 00:25:04
¿Que tú quieres eso? Estupendo. 00:25:07
¿Que quieres borrar todas las 00:25:09
iguales? Lo metes en un while 00:25:10
y tú ya 00:25:13
usas eso como quieras. 00:25:14
¿Vale? 00:25:16
¿Que quieres borrar las dos primeras 00:25:18
ocurrencias? Pues ni una ni la otra. 00:25:20
No puedes hacerlo así. 00:25:23
pues tendrás que 00:25:23
con un contador, cuando ya hayas borrado 00:25:26
dos, sal de este while 00:25:28
por ejemplo, tú ya programas lo que te hayan pedido 00:25:30
¿vale? programas lo que te hayan pedido 00:25:32
pero claro 00:25:34
hay que tener 00:25:36
muy muy muy muy claro cuando se hace 00:25:38
una aplicación entera de principio a fin antes de empezar 00:25:40
a programarla, muy muy muy claro 00:25:42
exactamente que tiene que hacer 00:25:44
exactamente que tiene que hacer 00:25:46
y eso el que te la pide 00:25:48
es el que te lo dice 00:25:50
Oye, yo quiero que sea esto lo que haga 00:25:51
Esto lo vamos a poner así 00:25:53
Por ejemplo, para que 00:26:03
Si quisiéramos borrar varias asignaturas de golpe 00:26:05
Pues si quisiéramos borrar varias de golpe 00:26:09
Puedo meterle todas esas de golpe 00:26:27
Pero una colección 00:26:29
En esta le meto solo una 00:26:30
Si quisiéramos borrar varias de golpe 00:26:32
Lo pongo aquí 00:26:36
Vale, pues entonces 00:26:38
el remove, estos son sus detalles de funcionamiento 00:26:48
estos son, y uno ya los aplica 00:26:50
como quiera 00:26:52
en este caso no hemos tenido complicaciones 00:26:52
porque eran listas 00:26:56
de cadenas, porque estábamos trabajando con la lista 00:26:58
de asignaturas, ahí está la asignatura 00:27:00
las asignaturas eran cadenas 00:27:01
cuidado cuando estamos trabajando 00:27:02
con listas de otras cosas 00:27:06
que hemos hecho nosotros 00:27:07
por ejemplo, vamos a hacernos 00:27:10
un método para 00:27:12
eliminar a un alumno, eliminar a un alumno 00:27:13
de la lista, porque tenemos el de insertar alumno 00:27:15
este, insertar alumno 00:27:18
pero no tenemos uno que elimine un alumno 00:27:21
vamos a hacerlo el de eliminar un alumno de la lista 00:27:25
static, otra vez se me ha olvidado 00:27:27
eliminar alumno 00:27:43
vale, entonces 00:27:48
eliminar alumno dado el número de matrícula 00:27:49
vale, pues lo mismo 00:27:58
tenemos que localizar al alumno 00:28:05
con este número de matrícula 00:28:08
y lo eliminamos 00:28:10
pero aquí es mucho más fácil porque el método remove 00:28:15
yo le doy 00:28:17
alumnos remove 00:28:20
y le paso un alumno con ese 00:28:21
número de matrícula 00:28:23
me hago un alumno auxiliar 00:28:25
aquí, new alumno 00:28:27
es que como no tengo el 00:28:30
constructor solo con número de matrícula 00:28:34
y le pego el número de matrícula 00:28:36
que es este 00:28:38
ala, pues ya lo tendría 00:28:41
¿qué hace el remove? 00:28:53
con lo que hemos dicho antes 00:28:55
¿remove qué hace? 00:28:56
te busca un alumno igual que este 00:28:58
un objeto igual que este 00:29:01
y en cuanto encuentra un objeto igual que este 00:29:03
te lo borra 00:29:06
eso es lo que hace el remove 00:29:06
tal cual 00:29:07
busca en la lista 00:29:08
el primer objeto que se encuentra 00:29:11
igualito que este 00:29:13
y en cuanto encuentra un objeto igualito que este 00:29:15
fuera 00:29:17
pues como el equals nuestro de alumno 00:29:18
está en función de un matrícula 00:29:20
me hago yo uno cualquiera 00:29:23
con este número de matrícula y se lo paso 00:29:25
pues remove 00:29:26
en cuanto encuentre un objeto en la lista 00:29:28
igualito que este 00:29:31
o lo que es lo mismo, que su matrícula es la misma 00:29:32
porque el igual es igual 00:29:34
pues lo va a borrar 00:29:35
pues ya está, no tengo que hacer for ni nada 00:29:37
este de aquí 00:29:40
me borra el primer alumno con ese número de matrícula 00:29:42
solo el primero 00:29:45
si yo quiero borrar 00:29:47
a todos los que tienen ese número de matrícula 00:29:48
si estuviera más de uno, lo metería en un while 00:29:50
¿vale? 00:29:53
luego el remove ya te hace 00:29:58
el for dentro 00:29:59
que no, que no, que no 00:30:00
si lo que ves es que a veces no entiendo bien 00:30:03
lo que me decís 00:30:05
pero para, ¿y qué mete en esa colección? 00:30:06
si es que solo tengo un dato, que es el número de 00:30:11
eso lo quiero borrar 00:30:13
pero una colección de un elemento, ¿para qué? 00:30:14
si ya tengo un remove que le pasa un elemento 00:30:17
a ver, que el remove all también te borra 00:30:19
primeras ocurrencias de cada uno que le pasas. 00:30:21
O sea, no arreglas lo del while tampoco. 00:30:24
O sea, el remove all, lo que 00:30:26
tú le puedes hacer es pasarle varios a la vez. 00:30:27
Pero de cada uno de esos varios 00:30:30
te borra la primera ocurrencia solo. 00:30:31
Es decir, imagínate que tú tienes 00:30:33
lengua, lengua, mates, mates. 00:30:35
Claro, y le pasas lengua y mates. 00:30:38
Te borra la primera ocurrencia de lengua y la primera 00:30:40
de mates. O sea, que son problemas distintos. 00:30:41
¿Vale? 00:30:43
Entonces, aquí lo importante del remove es que recordéis 00:30:45
que él ya te hace el for dentro. 00:30:47
Y va recorriendo 00:30:50
y cuando encuentra un objeto 00:30:51
igual que este, lo elimina 00:30:52
y ya está 00:30:55
pero claro 00:30:56
hay que asegurarse de que 00:30:58
el criterio de igualdad está en la clase 00:31:00
correspondiente, en nuestro caso 00:31:03
alumno, como está el criterio de igualdad 00:31:05
funcionaría perfectamente 00:31:06
¿vale? 00:31:08
vamos a probarlo 00:31:18
en el main 00:31:19
vamos a meterle dos alumnos 00:31:20
y eliminamos uno 00:31:26
¿vale? vamos a mostrar 00:31:29
aquí los alumnos que hay operaciones.alumnos a.getNombre y vamos a mostrarlo antes y luego 00:31:44
después de haberlos borrado. Esto era operaciones.eliminaAlumno, el de dos. Vale, vamos a ejecutarlo. Vale, 00:32:11
estos eran los dos alumnos 00:32:40
y después de haber eliminado 00:32:42
el segundo, pues solo está 00:32:44
este. 00:32:46
¿Vale? Pero como última 00:32:48
comprobación, como yo quite el 00:32:54
equals de aquí, 00:32:55
el remove ya no funciona. 00:32:58
Si yo 00:33:01
comento el equals este 00:33:02
de alumno, 00:33:03
comento el equals de alumno, 00:33:08
al haber comentado el equals, el remove, 00:33:13
su criterio de igualdad ya no es la igualdad 00:33:15
de matrícula, porque he quitado el equals 00:33:17
de alumno, entonces el remove 00:33:19
su criterio de igualdad es el de object 00:33:21
que es misma dirección de memoria, luego no va a encontrar 00:33:23
uno igual que ese 00:33:25
así que si yo quito el equals de alumno 00:33:26
se me ha olvidado hacer y no lo tengo 00:33:29
me creo que esto elimina 00:33:31
y efectivamente no ha eliminado 00:33:33
el código 00:33:35
de mi aplicación es la misma 00:33:37
y uno se pone a pelearse con la aplicación 00:33:38
que he hecho mal, que he hecho mal, no está el problema en la aplicación 00:33:41
el problema está en que alumno no tiene 00:33:43
el equals, entonces si alumno no tiene 00:33:45
el equals, remove jamás va a encontrar 00:33:47
al alumno, ¿vale? 00:33:49
Pues eso, importancia de los equals en 00:33:53
colecciones, si no los métodos no funcionan 00:33:56
funcionan pero mal, ¿vale? 00:34:01
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
3 de marzo de 2024 - 19:05
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
34′ 10″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
165.35 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid