Saltar navegación

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

Clase 05-04-24 - 1 - 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 7 de abril de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

y así te quedas en casa en la cama 00:00:00
y me ves ahí desde la cama, mira que bien 00:00:04
pues el año pasado lo hacían algunos 00:00:06
a ver 00:00:08
bueno 00:00:09
a ver, este es nuestro main 00:00:12
entonces 00:00:15
el objetivo de este pequeño programa 00:00:16
es simplemente trabajar 00:00:19
con productos 00:00:20
entonces como siempre hemos dicho 00:00:21
una misma aplicación se puede hacer con un montón de 00:00:24
se me distraigo 00:00:26
con un montón de diseños posibles 00:00:28
entonces lo que importa es 00:00:30
que identifiquemos 00:00:32
con qué entidades vamos a trabajar 00:00:35
eso lo primero 00:00:36
y luego ya que identifiquemos 00:00:39
qué necesitamos hacer 00:00:41
entonces recordad que 00:00:42
el problema siempre se divide en dos partes 00:00:44
una 00:00:46
con qué trabajamos el diseño, la descripción 00:00:47
la foto de lo que tenemos 00:00:50
y otra, qué requisitos tenemos que satisfacer 00:00:51
qué requisitos 00:00:55
que eso ya es las funcionalidades 00:00:56
lo que ya programamos mediante 00:00:59
métodos, funciones, etc. 00:01:00
Bueno, pues aquí esta aplicación, la foto 00:01:02
de lo que va a trabajar es 00:01:04
productos, pues a partir de ahí 00:01:07
tenemos que entrar en el diseño para 00:01:08
muy bien, como reflejamos 00:01:10
los datos de los productos 00:01:13
pues podríamos haber hecho una clase producto 00:01:14
que reflejara las propiedades 00:01:17
que interesan de los productos 00:01:19
en las cuales habría que 00:01:20
entrevistarse, ¿qué te interesa a ti el producto? 00:01:23
todo esto, lo ideal sería 00:01:24
que al menos una de las propiedades 00:01:26
lo identificara de forma única 00:01:28
porque si no hay algo que lo identifique 00:01:30
de forma única, la aplicación seguro 00:01:32
que luego va a funcionar 00:01:34
teniendo comportamientos 00:01:36
extraños 00:01:38
bueno, pues en este caso, solo nos interesan 00:01:40
el código y el precio 00:01:43
pues podríamos hacer una clase producto con código y precio 00:01:44
o si la aplicación es 00:01:46
sencilla y pequeña y es para 4 chorradas 00:01:48
pues hombre, tenemos 00:01:51
la colección map 00:01:52
que nos facilita muchísimo el trabajo con los datos que contiene, 00:01:53
nos lo facilita muchísimo porque gracias a que contiene los datos 00:02:00
en modo clave-valor, a través de esa clave podemos recuperar por clave 00:02:04
y modificar por clave, eliminar por clave. 00:02:09
Gracias a esa estructura de par clave-valor, 00:02:14
solo por esa chorrada de que los datos se guarden en dos partes, 00:02:16
clave y valor, solo por esa chorrada 00:02:21
se nos facilita la gestión 00:02:23
de esos datos muchísimo 00:02:25
bueno, pues en este caso uno puede pensar 00:02:27
como mis productos solo se caracterizan 00:02:29
por dos cosas 00:02:31
pues en lugar de una clase producto 00:02:32
y hacer un list de productos, un set de productos 00:02:34
pues es igual de eso 00:02:37
me hago un map con los dos valores 00:02:38
y ya está, y me olvido de la clase 00:02:41
producto, pues en este caso 00:02:43
es un diseño que va a hacer que sea todo más 00:02:44
cómodo, si programáis esta 00:02:47
misma aplicación 00:02:49
con una clase producto 00:02:51
y trabajando con una lista de productos 00:02:52
o con un set de productos 00:02:55
estos métodos vais a ver 00:02:56
ya de partida que son más líneas 00:02:58
no es que eso sea un problema 00:03:01
en sí, pero bueno, ya para empezar 00:03:03
son más líneas de código, sin embargo 00:03:04
con un map va a ser más fácil 00:03:06
bueno, pues entonces 00:03:08
una vez que uno ha decidido eso 00:03:09
pues ya decide que mete sus datos aquí 00:03:12
en un map 00:03:15
y ahora tiene que decidir que funciona como clave 00:03:17
y que funciona como valor, en este caso estaría 00:03:19
claro que la clave es el código 00:03:20
y el valor es el precio 00:03:23
pues uno decide el tipo de 00:03:25
dato para eso 00:03:27
que decidimos string para la, pues string 00:03:28
que el precio está en float, pues float 00:03:31
eso el tipo de datos que sea 00:03:33
recordad que los 00:03:35
tipos primitivos 00:03:37
no pueden sustituir a datos 00:03:38
genéricos, nunca 00:03:41
no pueden sustituir, aquí no podemos poner la f 00:03:42
con minúscula, por eso 00:03:45
existen los bloopers envolventes 00:03:47
el float, el integer, el label con mayúscula 00:03:49
para cuando 00:03:52
necesitamos trabajar 00:03:53
con números como si fueran 00:03:55
objetos, pues este es 00:03:57
uno de esos casos, necesitamos 00:03:59
trabajar con el número como si fuera un objeto 00:04:01
pues el envolvente, bueno pues 00:04:03
esta va a ser mi lista de productos, repito 00:04:05
podría haber sido una lista 00:04:07
de clase producto 00:04:09
pues nos habría complicado un pelín 00:04:11
el desarrollo del código, mejor que 00:04:13
sea un map de clave 00:04:15
precio, clave, precio, clave, precio 00:04:17
bueno, pues una vez ya con el diseño hecho 00:04:19
y ya la representación 00:04:22
de nuestros datos 00:04:24
ya hecha, ahora ya 00:04:25
uno ya se plantea que requisitos tiene que hacer 00:04:27
bueno y aquí nos han dicho 00:04:30
los requisitos de tu aplicación son esos 00:04:31
introducir producto, modificar, consultar 00:04:33
y eliminar 00:04:36
las tareas típicas con cualquier 00:04:36
conjunto de datos, las tareas de acceso 00:04:39
a datos siempre son esas 00:04:41
consultar, eliminar 00:04:43
insertar 00:04:45
y modificar. 00:04:49
Esta de aquí, esto. 00:04:51
¿Vale? 00:04:56
Consultar, 00:04:59
leer, no. 00:05:00
Crear, jolín. 00:05:02
Crear, consultar, 00:05:03
actualizar y borrar. Esas son 00:05:05
las cuatro tareas que se hacen 00:05:07
con los datos. Bueno, pues son las que 00:05:09
hay que hacer aquí. Y ahora, para eso 00:05:11
se hacen unos métodos 00:05:13
para insertar, guardar 00:05:14
producto. ¿Qué necesitamos para insertar un producto? Pues los dos datos que tiene y en este 00:05:17
caso como la lista de productos es una variable local del main, desde fuera del main es inaccesible, 00:05:24
entonces guardar producto la va a necesitar como parámetro. Si esta lista de productos estuviera 00:05:36
fuera declarada como variable estática del main 00:05:44
no habría que pasarla 00:05:47
porque el método tendría acceso a ella 00:05:49
si estuviera en otra clase 00:05:50
como variable estática 00:05:53
pues también podría acceder esa función 00:05:54
a esa variable 00:05:56
como está como variable local 00:05:57
aquí sí que no hay tutía 00:05:59
para poder acceder desde fuera del main 00:06:01
que es lo que va a tener que hacer 00:06:03
guardar producto 00:06:05
pues hay que pasársela 00:06:06
bueno pues ahora probamos guardar producto 00:06:07
pues guardar producto 00:06:10
una línea. 00:06:17
Esto es guardar producto, ¿no? 00:06:20
¡Hala! Entonces, aquí se 00:06:38
inserta un par con este código 00:06:39
y este precio, ¿vale? 00:06:41
Si ocurriera... 00:06:44
Ahora ya, a partir de aquí, uno puede 00:06:45
hacer esto contemplando 00:06:47
todos los casos raros que quiera. 00:06:49
¿Vale? Podríamos 00:06:52
decir, oye, pues, si el código ya 00:06:53
existe, me apetece 00:06:55
o me han pedido que 00:06:57
avise, no, cuidado que ya está 00:06:59
no se ha insertado uno nuevo 00:07:01
y así no se crea confusión 00:07:03
por ejemplo, podríamos hacer esto 00:07:05
porque que hace el put 00:07:07
que hace el put, si no existe 00:07:08
el par, inserta un par 00:07:11
con este código y este precio 00:07:13
y si ya existe 00:07:15
y si ya existe, lo que hace es 00:07:17
cambiarle el precio al que existe 00:07:19
entonces 00:07:21
bueno, depende de lo que nos hayan pedido 00:07:23
si nos han pedido, oye 00:07:25
el que llame a este método, el que lo llame 00:07:27
asume que no existe 00:07:29
con lo cual si está equivocado 00:07:31
avísale 00:07:33
porque si se cree que has metido 00:07:34
uno nuevo y lo que has hecho 00:07:37
era borrar uno de antes 00:07:39
cambiar uno de antes y con eso a lo mejor la lías 00:07:40
el resto de la aplicación ya 00:07:43
hace otras cosas 00:07:44
que no son las que se esperan 00:07:47
entonces bueno, todo eso de nuevo 00:07:49
depende de que uno se haya sentado 00:07:51
con el que le ha pedido la aplicación y le haya dicho 00:07:53
a ver, vamos parte por parte, guardar producto 00:07:54
Pues no, guardar producto tiene muchas ramificaciones 00:07:57
¿Qué es? Vamos a ver 00:08:00
¿Y qué pasa si tu gestor pone a guardar un producto 00:08:01
Y ese producto ya está? 00:08:05
¿Qué quieres tú que ocurra? 00:08:07
Y el tío te lo tiene que decir 00:08:08
Ah, pues en ese caso quiero que le avises 00:08:09
O en ese caso quiero que guardes el producto igualmente 00:08:11
Aunque el precio se quede modificado y se lo cuentes 00:08:14
Bueno, pues lo que él te haya dicho 00:08:16
Ya está, lo que él te haya dicho 00:08:18
Lo que nos importa a nosotros ahora mismo 00:08:20
Es que conozcamos los métodos de la estructura 00:08:21
Y ya está 00:08:25
bueno, pues guardar producto 00:08:25
dejémoslo así, que es lo que habréis hecho 00:08:28
y no os habréis encontrado ningún problema 00:08:30
si pongo alguna burrada me lo decís 00:08:31
vale, el famoso modificar 00:08:34
precio, entonces a 00:08:36
modificar precio 00:08:45
pues aquí como 00:08:46
en el enunciado no tengo puesto 00:08:48
que se le pase 00:08:51
el nuevo precio 00:08:53
modificar precio 00:08:54
se supone, se sobreentiende que habrá que pedirlo 00:08:56
dentro, se sobreentiende que habrá que pedirlo dentro 00:08:59
Vale, bueno, pues entonces 00:09:00
Vamos a pedirlo aquí dentro 00:09:03
Bueno, aunque aquí yo creo que tenía 00:09:08
La clase esa teclado ya puesta 00:09:17
Sí, pues la voy a usar y ya está 00:09:20
Vale 00:09:23
Por ejemplo, voy a hacer esto 00:09:30
Cio igual a 00:09:34
Vale 00:09:39
Entonces, ahora 00:09:45
Ahora se trata de ver 00:09:47
el map que me ofrece 00:09:49
para hacer esto 00:09:51
entonces es una clase que ya está hecha 00:09:52
y me ofrecerá muchas cosas 00:09:55
pues entonces uno se va 00:09:56
a la documentación 00:09:58
del proveedor, de Oracle o lo que sea 00:10:00
o lo mira en la ayuda aquí en línea 00:10:03
y ve a ver si hay algún método 00:10:05
que le permita hacer lo que quiere hacer 00:10:07
entonces esa es 00:10:08
nuestra situación habitual 00:10:10
normalmente estamos usando siempre clases 00:10:12
que ya están hechas 00:10:15
pues esas clases sabemos que tendrán métodos que harán cosas 00:10:15
Pues vamos a usarlos 00:10:19
Entonces aquí, si uno se va 00:10:20
Al map este 00:10:22
Lista 00:10:25
Lista productos 00:10:30
Pues si uno se va al map este 00:10:32
Pues ve que hay muchas cosas escritas 00:10:39
Y de repente una por nombre 00:10:41
Le suena 00:10:43
Que es lo que quiere hacer 00:10:45
Una por nombre le suena 00:10:46
Dice, hay un replace, hay un reemplazar 00:10:47
Vale 00:10:50
Pues entonces 00:10:51
Lo pinchamos 00:10:54
y miramos aquí 00:10:56
si esto hace lo que queremos 00:10:58
y esto lo hace, dice 00:10:59
oye, el par correspondiente 00:11:02
a esta clave, la reemplaza 00:11:04
con este valor, pero solo 00:11:06
si existe un elemento con esa clave 00:11:08
solo si existe, pues hombre 00:11:10
parece que es justo 00:11:12
lo que queremos hacer 00:11:14
¿no? 00:11:15
entonces además 00:11:18
además, cuando un método 00:11:20
está bien 00:11:22
programado, está bien programado 00:11:23
tiene que permitir 00:11:26
además de hacer lo que tiene 00:11:28
que hacer, normalmente 00:11:30
tiene que permitir algún mecanismo 00:11:31
para informar al que usa 00:11:33
el método de lo que ha pasado 00:11:36
porque este método, el que lo programó 00:11:37
cuando hizo las colecciones, el que programó el map 00:11:39
podría haber hecho que devolviera 00:11:41
void y punto pelota 00:11:43
es decir, este método si nos vamos 00:11:45
a la clase hasMap 00:11:48
Hola 00:11:51
Y nos vamos aquí 00:11:53
Y buscamos el 00:11:57
Replace 00:11:58
Vamos a buscar 00:11:59
Replace 00:12:02
¿Qué habías entendido? 00:12:03
¿Habías entendido putas? 00:12:07
Pues no ha dicho eso 00:12:09
De verdad, eh 00:12:11
Qué mal está 00:12:12
Replace 00:12:14
Vale 00:12:16
Esto como 00:12:17
¿Esto cómo se hace para avanzar? 00:12:18
Joder, ¿cómo avanzo al siguiente replace? 00:12:24
Ah, sí, vale, vale 00:12:34
Boolean replace 00:12:36
No, este no quería 00:12:41
Este, vale 00:12:43
Este es el método que estamos usando 00:12:47
Este es el que estamos usando de map 00:12:49
Este es el que vamos a usar 00:12:52
Que ya está hecho en map 00:12:54
Que se le pasa una clave 00:12:55
Y se le da un valor 00:12:57
aquí por supuesto está con los tipos genéricos 00:12:58
claro, aquí está con los tipos genéricos 00:13:01
en nuestro caso 00:13:03
cuando nosotros le llamemos en nuestro caso 00:13:04
k va a ser 00:13:07
string y v va a ser 00:13:09
float, en nuestro caso, claro 00:13:11
pero aquí está programado como genérico 00:13:13
bueno, entonces este método 00:13:14
el que lo programó 00:13:16
podría haber puesto ahí un void, ¿vale? 00:13:18
no me deja obviamente 00:13:24
ni siquiera, aunque luego no me guarde 00:13:25
ni siquiera me deja, podría haber puesto ahí un void 00:13:27
y decir, ya está, el método lo que hace es sustituir 00:13:29
sustituye y se acabó 00:13:32
y no tiene que devolver nada 00:13:33
porque el efecto ya se queda en el map 00:13:34
no tiene que devolver nada 00:13:36
bueno, podría haber decidido hacer eso 00:13:38
pero hombre, está programando a lo cutre 00:13:41
lo ideal, cuando uno desarrolla software 00:13:43
hace métodos 00:13:46
es que el método, a lo que tenga que hacer 00:13:47
y si además le permite 00:13:49
al que llama el método 00:13:51
una manera de averiguar 00:13:53
si ha funcionado correctamente 00:13:55
si lo ha podido hacer, si no lo ha podido hacer 00:13:57
pues mejor, porque así el que llama 00:13:58
al método podrá hacer algún tipo de verificación 00:14:00
entonces 00:14:03
por eso el que programó esto 00:14:04
puso un valor de retorno 00:14:06
y ese valor de retorno, ¿para qué nos 00:14:08
sirve? para extraer información 00:14:11
si queremos, sobre qué es lo que ha pasado 00:14:12
¿vale? nos sirve para eso 00:14:15
podemos ignorarlo, podemos hacer 00:14:17
el replace y se acabó, ignoramos ese valor 00:14:19
pero si queremos hacer algún tipo de verificación 00:14:20
a ver si realmente 00:14:23
ha encontrado esta clave 00:14:24
la ha sustituido, si no la ha encontrado 00:14:26
pues podemos usar este valor 00:14:28
vale 00:14:30
entonces esa es una manera buena de programar 00:14:31
cuando uno hace métodos para otros 00:14:35
aparte de que el método funcione y haga lo que tenga que hacer 00:14:36
pues que ofrezca información 00:14:39
para afuera de oye si 00:14:40
esto ha funcionado o no te lo he podido hacer 00:14:43
por lo que fuera 00:14:45
vale, bueno pues entonces 00:14:45
esto todo venía a cuento de que si uno mira 00:14:48
la ayuda 00:14:51
del replace all este de aquí 00:14:54
replace all no, perdón 00:14:56
del replace 00:14:58
si uno mira esta ayuda 00:14:59
aquí te lo explica 00:15:02
te dice, a ver 00:15:03
te hace el 00:15:05
te reemplaza el valor 00:15:06
para el par con esta clave 00:15:09
te reemplaza el valor 00:15:11
para esta clave solo si existe 00:15:13
es lo que queremos, solo si existe 00:15:15
y luego además te dice 00:15:17
oye, te devuelve 00:15:18
te devuelve por si quisieras usarlo 00:15:21
para algo, te devuelve 00:15:23
el valor que tenía antes 00:15:25
el precio antiguo te lo devuelve 00:15:26
o te devuelve nul 00:15:28
si no lo encontró 00:15:30
entonces, hombre, eso es útil 00:15:31
pues no solo puedo sustituir sin más 00:15:33
sino además puedo decirle al usuario 00:15:36
no te lo pude sustituir porque no había 00:15:38
o te lo he sustituido y se queda eliminado 00:15:40
el precio tal, por ejemplo 00:15:42
entonces así nos queda más bonito 00:15:44
entonces repito 00:15:46
en conclusión, los métodos hacen cosas 00:15:48
y muchas veces no hace falta 00:15:50
que devuelvan nada, a veces sí porque 00:15:52
el resultado es lo que nos devuelve 00:15:54
pero las veces en las que no hace falta 00:15:56
que devuelvan nada, lo normal es que siempre 00:15:58
nos devuelvan cosas para que podamos 00:16:00
hacer a lo mejor comprobaciones 00:16:02
y esto en particular te evita 00:16:04
todo el chorizo ese de iteración 00:16:06
para ver si existía, si no existía 00:16:08
no hace falta, ya tienes ese valor de retorno 00:16:10
para ver si existía o no existía 00:16:12
¿vale? entonces con todo este 00:16:14
rollo que os he soltado 00:16:16
pues por ejemplo uno podría 00:16:18
en lugar de limitarse 00:16:20
hacer el replace este 00:16:23
Y poner para este código 00:16:24
Le pongo el nuevo precio 00:16:28
Que acabo de leer 00:16:29
Que aquí lógicamente me dice 00:16:30
Eh, cuidado, que es que es float, no puedo 00:16:39
Es que lo guardan doble porque 00:16:41
Ah, le hago un casting, voy a perder cifras decimales 00:16:43
Pero bueno, ya ves tú 00:16:46
Vale 00:16:47
Pues podemos limitar, hacer el replace y ya está 00:16:49
O podemos ser muy exquisitos y decir 00:16:55
Oye, voy a verificar lo que me devuelve 00:16:57
Voy a guardarlo, si es null le digo 00:16:59
no existía, lo que sea 00:17:01
pues por ejemplo 00:17:03
entonces podríamos hacer aquí 00:17:04
si lista 00:17:06
de productos.replace 00:17:09
esto, resulta que 00:17:11
esto es igual a null 00:17:13
pues entonces 00:17:14
podemos 00:17:17
decir 00:17:19
podemos decir 00:17:20
nos encontró 00:17:22
por ejemplo 00:17:24
vale, pues nos permite hacer ese 00:17:26
pequeño control, ya está, si es que queremos hacerlo 00:17:35
bueno pues entonces 00:17:37
como veis 00:17:47
esto en realidad 00:17:50
es más corto que si hubiéramos hecho 00:17:51
el programa con una clase producto 00:17:53
una lista, localizar el producto 00:17:55
y una vez que tenemos el producto 00:17:57
hacerle un set de su propiedad 00:17:59
valor, eso habría sido más largo 00:18:01
que trabajar con el pares 00:18:03
trabajar con un diccionario facilita 00:18:05
mucho las cosas por el hecho de que tenemos una clave 00:18:07
una clave para tirar de todo 00:18:09
entonces siempre que podamos hacer un math pues lo hacemos 00:18:11
Bueno, pues modificar el precio y ya está 00:18:13
¿Vale? 00:18:16
Entonces habrá veces 00:18:19
Que no podremos 00:18:20
Que no podremos usar el valor de retorno 00:18:22
De algo como 00:18:24
Forma de control, porque ese valor de retorno 00:18:25
Tiene el propio 00:18:28
Resultado del método 00:18:30
Si uno tiene un método 00:18:31
Obtener factorial, pues el valor de retorno 00:18:33
Tiene que ser factorial 00:18:36
¿Vale? Entonces hay veces que 00:18:36
No podemos usar el valor de retorno cuando programamos 00:18:39
un método para que nos dé información 00:18:41
porque es que ya tiene el resultado 00:18:44
bueno, pero aún así 00:18:46
podemos transmitir información de lo que ha pasado 00:18:48
vía excepciones 00:18:50
vía excepciones, lo adelanto ahora 00:18:52
porque es lo siguiente que vamos a ver 00:18:54
porque 00:18:55
lo estáis deseando 00:18:57
a ver 00:19:00
vamos a ver, modificar precio, ya lo hemos hecho 00:19:01
y lo demás es que 00:19:05
pues bueno, esto no 00:19:07
mostrar productos 00:19:08
Pues aquí sí que tenemos que iterar 00:19:12
Aquí tenemos que iterar por la lista de productos 00:19:15
Bueno, pues iterar, ya iteramos el otro día 00:19:17
De todas las variantes posibles 00:19:20
Iterar por el conjunto de pares 00:19:22
Directamente no podemos 00:19:24
Tenemos que trasladarlo a un set 00:19:25
Y ya iteramos por el set 00:19:27
O bien iteramos a un set de claves 00:19:28
Y luego recorremos las claves 00:19:31
O bien iteramos a un set de objetos envolventes 00:19:32
Entry, iteramos por los entries 00:19:35
Vamos a iterar por los entries 00:19:37
y esto era, pues si tenemos nuestra lista 00:19:40
lista productos, vale, si tenemos nuestra lista 00:19:47
productos teníamos el método entrySet, que este método 00:19:56
entrySet nos devuelve un set de estos objetos raros 00:20:00
de esta clase rara, entry de string 00:20:04
float, vale, nos devuelve 00:20:07
un set de esta clase rara, entonces 00:20:22
importamos 00:20:24
entry e importamos set 00:20:27
vale, a ver 00:20:29
que 00:20:32
era esto, esto era un conjunto 00:20:34
de objetos que ahora ya 00:20:37
podemos iterar por él y cada objeto 00:20:39
tiene dentro 00:20:41
los dos elementos del par 00:20:42
la clave y el valor, pues entonces 00:20:44
iteremos por este set y en 00:20:46
cada uno de esos conjuntos saquemos su clave 00:20:49
y su valor y ya está 00:20:51
pues eso es lo que hicimos el otro día 00:20:52
Vamos a iterar por este set 00:20:54
Como nos dé la gana iterar 00:20:56
Y como podamos y proceda, claro 00:20:57
Pues vamos a iterar por este set 00:20:59
Que pertenece a este tipo extraño 00:21:01
Pues iteramos con un for each 00:21:03
Pues ahora aquí 00:21:06
Cada p 00:21:13
Cada p es un objeto de esta clase 00:21:15
Que tiene dentro 00:21:18
La clave y el valor del par que envuelve 00:21:20
Pues si lo que queremos es mostrar 00:21:22
La clave y el valor 00:21:24
Pues venga 00:21:25
Código 00:21:26
Código es P punto 00:21:29
Y para eso tenemos el get key 00:21:36
Y ahora 00:21:37
Precio 00:21:40
Y aquí tenemos 00:21:45
Get value 00:21:50
Ahí 00:21:58
Vale, estoy haciendo yo algo raro 00:22:03
Ah, claro, que no he puesto la llave 00:22:06
Y entonces 00:22:07
Vale 00:22:09
Bueno, pues ya está 00:22:11
Entonces 00:22:20
¿qué ventaja tiene este objeto? 00:22:23
si es que tiene alguna 00:22:26
vale, no lo iba a decir, pero como ha salido 00:22:27
con el eso tuyo, pues ahora lo digo 00:22:30
por tu culpa 00:22:32
bueno, tiene una ventaja extraña 00:22:32
este objeto entry 00:22:35
no es útil solamente 00:22:37
para envolver los pares 00:22:39
en un único objeto y así 00:22:41
poder yuterar por él y mostrarlo, no es útil 00:22:43
solo para eso, sino que es útil 00:22:45
porque está declarado de tal manera 00:22:47
que cuando lo instanciamos 00:22:49
se queda conectado al map 00:22:51
al que lo hemos asociado, se queda conectado 00:22:53
entonces si yo ahora 00:22:55
en cada uno de estos objetos 00:22:56
cambio a través de los métodos correspondientes 00:22:58
la clave o el valor 00:23:01
se van a cambiar en el 00:23:02
bueno, está pensado que se cambia en el valor 00:23:03
se van a cambiar en el valor 00:23:05
entonces, si yo aquí además de recorrer 00:23:06
quisiera cambiar el precio 00:23:11
de alguno de ellos 00:23:12
podría a través de este objeto P 00:23:13
hacer el cambio y el cambio que yo haga en P 00:23:16
se va a quedar reflejado en la lista 00:23:19
de productos a la que está enganchado 00:23:21
es un funcionamiento extraño 00:23:22
pero bueno, ocurre 00:23:24
vale, nada más 00:23:26
pero bueno, dejémoslo aquí y ya está 00:23:27
no tiene mayor 00:23:33
vale, y ya está 00:23:34
entonces tenemos ya mostrar productos 00:23:37
modificar precio, guardar producto 00:23:40
y eliminar 00:23:42
pues eliminar 00:23:43
aquí es que claro 00:23:48
siempre nos invade 00:23:50
la tentación cuando tenemos que 00:23:52
eliminar de una caja 00:23:54
en general, que es lo que hacemos aquí 00:23:56
cuando eliminamos de una lista, de un map 00:23:59
parece como que intuitivamente nos invade 00:24:00
la tentación de empezar a coger 00:24:03
uno por uno hasta que encuentro 00:24:05
el que sea y cuando lo he encontrado fuera 00:24:07
pero es que no hace falta 00:24:08
ir uno por uno 00:24:10
y cuando lo he encontrado fuera 00:24:14
no hace falta 00:24:15
porque en el map 00:24:16
si tenemos el código al que eliminar 00:24:19
tenemos el método de eliminar por código 00:24:21
eliminas por código y fuera 00:24:23
cuando tengo un set 00:24:25
o tengo un list 00:24:27
también tenemos un remove 00:24:29
que tú le das un objeto 00:24:31
y te elimina el que es igual a ese 00:24:33
no hay que recorrer y cuando encuentras 00:24:34
el que es igual, borrarlo, no hay que recorrer 00:24:37
tienes el remove, punto pelota 00:24:39
remove y le pasas el objeto que es igual 00:24:41
y el remove por dentro 00:24:43
y ahí te dará, ¿vale? 00:24:45
pero siempre tenemos como la tentación de 00:24:47
uy, tengo que borrar de una colección 00:24:48
pues voy a recorrerla hasta que 00:24:51
encuentre y borro, no, es que ya tenemos 00:24:53
los métodos que por dentro 00:24:54
ya recorrerán hasta que encuentren 00:24:57
entonces llamamos al método, le decimos 00:24:58
lo que hay que borrar y él ya 00:25:01
recorrerá por dentro 00:25:03
pues en el map igual, el map tendrá 00:25:03
algún método, si está bien 00:25:06
hecho, tendrá algún método 00:25:10
para borrar, como efectivamente 00:25:12
tiene 00:25:14
tiene un remove 00:25:15
que 00:25:17
tiene varias variantes, está sobrecargado 00:25:19
pero esta 00:25:22
si le pasamos 00:25:24
un código 00:25:26
la ayuda ya nos dice lo que hace 00:25:27
nos dice, te quita 00:25:30
el par cuyo código 00:25:32
es este, pues ya está 00:25:34
esa es la ventaja de los map, que por código podemos hacerlo 00:25:35
todo, entonces este método 00:25:38
además imagino que devolverá un valor 00:25:40
que te permita verificar 00:25:42
si es que quieres, si el par existía 00:25:44
si no existía, etc, etc 00:25:46
vamos a mirarlo 00:25:47
remove object 00:25:49
pues removeObject la ayuda es esta 00:25:52
y te dice 00:25:54
a ver 00:25:55
te dice, borra el par 00:25:59
para esta clave especificada 00:26:05
si es que existe, lógicamente, si no existe 00:26:06
¿cómo lo va a borrar? 00:26:08
y luego te dice, ¿qué devuelve? 00:26:10
devuelve el valor 00:26:13
que tenía 00:26:14
ese par, devuelve el valor que tenía 00:26:16
o null si no lo había, pues de nuevo 00:26:18
el valor de retorno de ese método 00:26:20
te permite verificar si existía o no 00:26:22
no tienes que recorrerlo antes para verificarlo 00:26:25
entonces 00:26:27
podríamos, si así nos lo han pedido 00:26:28
pues podríamos hacer 00:26:31
otra vez aquí un if 00:26:33
de esta manera 00:26:34
si lista producto, removeCódigo 00:26:36
es igual a null 00:26:39
eso significa que no lo ha encontrado 00:26:40
y podríamos poner 00:26:43
pues lo mismo 00:26:45
no existe producto 00:26:46
y ya está 00:26:52
vale, pues bueno, estos en realidad son todas las 00:26:56
opciones 00:27:03
que nos da el map 00:27:05
para recuperar, borrar, eliminar 00:27:06
y no hay más 00:27:09
aquí el map 00:27:11
era de dos clases 00:27:13
que no hemos tenido que hacer nosotros 00:27:15
porque ya están hechas, que son la clase C 00:27:17
y la clase Float, pero podrían ser de clases 00:27:19
nuestras, esta podría ser 00:27:21
de una clase cliente, esta podría 00:27:23
ser de una clase 00:27:25
factura, por ejemplo 00:27:27
una aplicación que trabaja con clientes 00:27:29
y facturas, tenemos la clase 00:27:31
cliente y la clase factura 00:27:33
y tenemos una asociación 00:27:34
de clientes a facturas 00:27:38
cada cliente tiene su factura 00:27:39
pues podríamos 00:27:41
guardarlos en un map 00:27:43
en ese map la clave sería 00:27:44
el cliente, el objeto cliente 00:27:47
y el valor sería su factura 00:27:49
por ejemplo 00:27:51
entonces estos tipos de datos 00:27:52
serán del tipo que sean 00:27:57
y aquí recordad que claro 00:27:59
la implicación que tiene es 00:28:01
que la clave, el tipo de dato 00:28:03
al que pertenece la clave 00:28:06
si es un hash map 00:28:07
el tipo de dato 00:28:10
al que pertenece la clave se guarda en un hash set 00:28:12
con lo cual este tipo de dato 00:28:14
tendrá que tener el hash code y el equals 00:28:16
y si es un tree map 00:28:18
si es un tree map 00:28:20
las claves se guardan en un tree set 00:28:21
con lo cual la clase 00:28:24
a la que pertenecen las claves 00:28:25
tiene que tener el comparable 00:28:27
¿vale? esos son los matices 00:28:29
que hay, porque si no tiene el comparable 00:28:32
el trimar, cuando 00:28:34
lo instanciemos hay que pasarle un comparador 00:28:35
etcétera, bueno 00:28:38
lo que vimos el otro día, vale 00:28:39
venga, vamos a parar aquí un 00:28:41
segundinito 00:28:43
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
7 de abril de 2024 - 13:46
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
28′ 45″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
128.10 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid