Saltar navegación

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

Clase 26-02-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 26 de febrero de 2024 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos 00:00:00
¿Te refieres a mí? 00:00:03
Que yo tengo preparadas el que 00:00:08
Justo, en casa me dedico a eso 00:00:09
A preparar las frases 00:00:16
Que digo aquí 00:00:18
Hombre, estarían más curradas 00:00:19
Si me las preparara en casa estarían más curradas, te lo juro 00:00:20
Esa ha salido del alma 00:00:23
No ha salido de casa la de cortarte la cabeza 00:00:26
ha salido de las ganas 00:00:28
bueno, venga 00:00:30
a ver, esta clase 00:00:33
repito, pues habéis visto 00:00:35
de qué manera tan sencilla se puede programar 00:00:37
una estructura dinámica y tan fácil 00:00:38
para ahora en un main, pues 00:00:41
yo meto, saco, hago lo que me da la gana 00:00:42
vale, pero 00:00:44
¿cuál es el problema de esta estructura 00:00:47
dinámica? 00:00:49
que solo me vale para guardar cadenas 00:00:50
string, y si yo quiero 00:00:52
guardar objetos clientes, tengo que hacer 00:00:54
una poniendo aquí en nodo 00:00:57
cliente 00:00:59
pues sí, vaya rollo 00:01:00
y si quiero guardar enteros, tengo que poner ahí 00:01:03
una poniendo ahí int, pues sí 00:01:05
o sea, tengo que tener una versión de esta 00:01:07
estructura clase y nodo 00:01:09
para cada 00:01:10
tipo de dato que quiera guardar 00:01:12
pues con lo que sabemos hasta ahora, sí 00:01:14
menudo rollo, no podríamos 00:01:16
hacer una genérica 00:01:19
eso es lo que nos pide el cuerpo 00:01:20
hacer una genérica 00:01:22
hacer una que me valga para cualquier tipo de dato 00:01:24
pues claro que podemos 00:01:27
hacer clases genéricas 00:01:29
clases genéricas 00:01:31
son clases que dependen de un tipo 00:01:33
de dato que yo no quiero 00:01:35
concretar toda vida, todavía 00:01:37
lo dejo como incógnita 00:01:39
se queda como incógnita, ya lo concretaré 00:01:40
en el futuro 00:01:43
una clase genérica es como 00:01:43
la función matemática de toda la vida 00:01:47
es como esto 00:01:49
esto os dice algo, ¿no? 00:01:50
esto es una función 00:01:59
que depende de una incógnita 00:02:05
esta es la incógnita 00:02:07
pues una clase genérica es lo mismo 00:02:08
es una clase que depende 00:02:11
de un tipo de dato que es incógnita 00:02:13
ya lo concretaré yo 00:02:15
cuando quiera usar esa clase 00:02:17
cuando quiera usarla 00:02:19
pero por ahora la voy a declarar 00:02:21
en función de una incógnita 00:02:23
y es justo 00:02:24
lo que nos gustaría hacer con esta clase 00:02:26
nodo, declararla en función 00:02:29
de una incógnita, que string 00:02:31
sea una incógnita, sea 00:02:33
algo genérico, de ahí viene el nombre 00:02:35
de clases genéricas 00:02:36
entonces una clase genérica 00:02:37
si hacemos una clase genérica cualquiera 00:02:40
en otro paquete por aquí 00:02:42
para no ensuciar este 00:02:45
vale, vamos a hacernos una clase 00:02:46
clase genérica, vamos a llamarla 00:02:59
una clase genérica 00:03:06
que tiene, por ejemplo 00:03:09
una propiedad entero, por ejemplo 00:03:10
tiene un código, vamos a suponer que tiene una propiedad código 00:03:12
y luego tiene un dato aquí, tiene otra propiedad 00:03:15
dato, pero que yo 00:03:18
no sé de qué tipo me interesa todavía que sea 00:03:20
no sé si yo quiero que ese dato sea un entero 00:03:23
un stream, un cliente, un alumno 00:03:27
no lo sé todavía, qué tipo de dato quiero que sea, no lo sé 00:03:30
vale, pues lo dejo como incógnita 00:03:33
¿y cómo se escribe la incógnita? aquí, pues 00:03:35
como cualquier letra mayúscula 00:03:39
pongo ahí cualquier letra mayúscula 00:03:41
habitualmente se usa una T 00:03:44
o una V 00:03:46
a veces 00:03:48
o una, ¿vale? 00:03:49
vamos a llamarla T 00:03:53
por eso de tipo 00:03:54
porque esto es un tipo incógnita 00:03:55
esto es un tipo incógnita 00:03:57
y yo digo, pues venga, este es mi dato 00:03:58
mi dato pertenece 00:04:01
a un tipo incógnita 00:04:04
yo no lo conozco todavía 00:04:06
ese tipo es una incógnita 00:04:07
T mayúscula, no es nada 00:04:09
entonces, al haber dejado esta clase 00:04:10
en función de un tipo incógnita 00:04:13
esta clase se convierte 00:04:15
en una clase genérica, que se llama 00:04:17
y tengo que especificarlo 00:04:19
poniendo aquí esto 00:04:21
¿vale? 00:04:22
poniendo aquí eso 00:04:28
y ahora, poniendo eso significa 00:04:29
oye, que esta clase 00:04:32
depende de un tipo de dato que es incógnita 00:04:34
un tipo de dato que es incógnita 00:04:36
depende 00:04:39
y yo puedo trabajar, hacer métodos 00:04:39
y hacer aquí lo que me dé la gana 00:04:42
arrastrando ese tipo incógnita. 00:04:43
¿Vale? 00:04:47
Y podría incluso depender de dos. 00:04:49
No tiene por qué depender de uno. 00:04:52
Imaginaos que son dos los que yo quiero, 00:04:53
que sean incógnitas. 00:04:57
Pues estupendo, esta clase genérica 00:05:05
depende de dos incógnitas. 00:05:07
Y podría depender de más, pero bueno, 00:05:09
las cosas se hacen para facilitar, 00:05:10
no para complicar. 00:05:12
Entonces ya que depende de más de dos. 00:05:13
¿Vale? Y esta clase podría tener 00:05:16
métodos, por ejemplo, pues imaginaos 00:05:17
Que yo le quiero hacer un método 00:05:20
Mostrar 00:05:23
Pues yo que sé, un método cualquiera 00:05:25
Vamos a hacerlo para 00:05:28
Mostrar 00:05:29
El contenido, yo que sé 00:05:31
Como si fuera un toString, pero bueno 00:05:35
Más que un toString, pues 00:05:37
Contenido 00:05:39
Y ahora concateno aquí con dato1 00:05:44
Y concateno también aquí con 00:05:47
Dato2, por ejemplo 00:05:51
y podría yo hacer aquí más métodos 00:05:53
más cosas, lo que pasa es que 00:05:59
claro, como esas variables son genéricas 00:06:02
yo no puedo invocar a nada 00:06:03
que no esté en object 00:06:06
porque lo que yo sí que sé de cualquier clase 00:06:07
es que le da de object, eso lo sé seguro 00:06:09
eso lo sé seguro 00:06:12
entonces cualquier método de object 00:06:13
lo puedo utilizar para estos datos 00:06:15
¿vale? 00:06:18
es decir, si yo hago aquí 00:06:20
dato1. 00:06:21
pues me salen 00:06:29
los de object 00:06:30
porque 00:06:31
no sé qué datos 00:06:32
será 00:06:33
no tengo 00:06:34
perdón 00:06:34
no sé qué clase será 00:06:35
no tengo ni idea 00:06:35
pero va a heredar 00:06:36
de object sí o sí 00:06:37
entonces lo más 00:06:38
que puedo hacer yo 00:06:39
aquí a nivel de código 00:06:40
es llamar a métodos 00:06:41
de object 00:06:42
por ejemplo está 00:06:43
el toString 00:06:44
que el toString 00:06:45
es el que habrá usado 00:06:46
el system out 00:06:47
cuando yo se lo he pasado aquí 00:06:48
pero no puedo hacer 00:06:49
más que llamar a esto 00:06:50
a menos que yo haga 00:06:51
un casting 00:06:53
si hago un casting sí 00:06:53
pero hacer un casting 00:06:54
es peligroso 00:06:56
porque vete a saber 00:06:56
qué tipo de dato es 00:06:57
¿vale? 00:06:58
entonces hacer un casting por las buenas 00:06:59
pero yo puedo hacer una clase que dependa de un tipo 00:07:01
genérico y hacer cosas con ella 00:07:04
como por ejemplo esta 00:07:05
como por ejemplo esta 00:07:07
ahora ya la duda sería, oye y esta clase 00:07:09
¿cómo la usamos ahora? 00:07:12
vamos a hacer un main, aquí dentro de este mismo 00:07:14
paquete vamos a hacer un main 00:07:16
una clase main para usarla 00:07:17
vale, ahora 00:07:19
vamos a instanciar un objeto de esta clase 00:07:29
clase genérica 00:07:31
venga 00:07:35
pues este objeto de aquí 00:07:37
vale, yo puedo declarar un objeto 00:07:38
de esta clase 00:07:41
vale, entonces 00:07:42
aquí ya vemos que se le pone en amarillo 00:07:45
me dice, no pasa nada 00:07:47
puedes crear, declarar 00:07:49
e incluso instanciar 00:07:51
si te da la gana 00:07:53
¿veis? él me deja sin ningún 00:07:54
problema, porque el constructor 00:08:05
sin parámetros obviamente existe, pero yo no he hecho 00:08:07
ningún constructor, luego está sin parámetros 00:08:09
yo puedo y ya tengo 00:08:11
ahí obj, mi objeto 00:08:13
bj que tiene 00:08:15
espacio para un objeto 00:08:17
de tipo int 00:08:19
para uno de tipo t y para uno de tipo v 00:08:20
pero diríamos, uy, ¿y qué ha reservado 00:08:23
ahí? si yo no le he dicho t y v 00:08:26
¿qué son? pues ha reservado 00:08:27
dos espacios para dos, algo 00:08:29
que sea object, un object, o sea 00:08:31
el objeto object que no tiene nada 00:08:33
eso es lo que ha reservado, que no tiene nada 00:08:34
¿vale? 00:08:37
lo normal es no usarlo así 00:08:39
no es lo normal, si yo he hecho 00:08:41
una clase genérica, es para 00:08:43
En el momento de crear un objeto, decirle, ojo, 00:08:45
que yo quiero un objeto concreto de esa clase, 00:08:48
pero ahora te voy a decir qué dos tipos son los que me 00:08:51
interesan. 00:08:54
Te lo voy a decir ahora. 00:08:55
¿Vale? 00:08:57
Aquí está declarada de forma genérica. 00:08:57
Di, tú me puedes instanciar. 00:08:59
Yo voy a tener estas 3 propiedades. 00:09:02
Estas van a ser de tipos incógnitas. 00:09:04
Cuando me instancies, dime ya qué tipos quieres. 00:09:06
Dímelo ya. 00:09:08
Porque si no, te voy a tener que crear 2 espacios para object 00:09:09
que no vale para nada. 00:09:12
¿Vale? 00:09:13
Pues la forma de decirle, oye, sí, créame ya, para estos concretos es ponérselo aquí, entre corchetes, los dos tipos que a ti te interesan. 00:09:14
Pues, oye, quiero que el primero sea string y quiero que el segundo sea integer, por ejemplo, que es el tipo de dato para los números enteros, pero envueltos en ala. 00:09:24
Y ahora aquí ya le tenemos que poner también los corchetes porque si no, no lo coge como... 00:09:37
¿Veis? Ya se me ha quitado el amarillo. 00:09:42
porque el amarillo era un aviso 00:09:44
cuando yo no tenía esto 00:09:46
el amarillo me decía, cuidado 00:09:48
que clase genérica es 00:09:49
una clase genérica, deberías parametrizarla 00:09:51
etcétera, es lo que me dice 00:09:55
porque si no te voy a generar una cosa con object ahí que no valga nada 00:09:56
de eso me estaba avisando 00:09:58
el amarillo 00:10:01
ahora ya la estoy usando y diciendo, eh tú 00:10:01
que sí 00:10:04
que 00:10:06
créame un objeto clase genérica 00:10:07
y donde pone t que sea string 00:10:09
y donde pone v que sea entero 00:10:11
Bueno, pues es un ejemplo concreto 00:10:13
¿Vale? Y ahora ya, pues yo que sé 00:10:15
Uno podría ahora ya perfectamente 00:10:19
Pues hacer, venga, obj.dato1 00:10:21
Ni get ni set por rapidez 00:10:24
Como esto va a ser un string 00:10:26
Pues a la 00:10:28
obj.dato2 00:10:28
Pues este es un numerito 00:10:35
Un entero, pues 4 00:10:40
A la y perfectamente 00:10:42
Pero eso sí 00:10:43
Dato1 ya solamente va a poder ser string 00:10:45
Y dato 2 va a poder solo ser número 00:10:48
Ahora yo puedo llamar tranquilamente 00:10:50
A obj.mostrar 00:10:53
¿Vale? Y me mostrará 00:10:54
Bueno, pues las dos cosas 00:11:00
Que ahora resulta 00:11:02
Que yo quiero crear 00:11:04
Otro objeto clase genérica 00:11:06
Pero ya no me interesan que los tipos sean estos 00:11:08
Ahora me interesan que sean otros 00:11:11
Pues no tengo que cambiar la clase 00:11:12
No tengo que tocarla 00:11:14
No tengo que tocarla 00:11:15
Ahora digo, venga, créame otro 00:11:17
créame otro 00:11:19
objeto 2 00:11:23
pero ahora este primero quiero que sea 00:11:26
double, como no tengo ni cliente 00:11:29
ni alguno ni nada 00:11:31
y este quiero que sea 00:11:32
string, ala pues ya está 00:11:34
ya tenemos otro objeto 00:11:37
de esta misma clase genérica 00:11:39
pero ahora hemos concretado 00:11:40
los dos tipos genéricos 00:11:43
los hemos concretado a que sean esos dos 00:11:45
porque para este nos interesa que sean esos dos 00:11:47
bueno pues 00:11:49
esto es una clase genérica 00:11:58
que es tremendamente útil 00:12:00
para programar 00:12:03
muchos modelos de cosas 00:12:08
una clase que tiene 00:12:09
propiedades que yo no quiero comprometer 00:12:12
el tipo de dato 00:12:14
quiero que lo puedan elegir en tiempo de 00:12:15
instanciación 00:12:18
quiero que cuando se cree el objeto 00:12:19
se pueda elegir el tipo de alguna 00:12:22
de las propiedades 00:12:24
no quiero elegirlo desde ya 00:12:25
bueno pues 00:12:27
esa posibilidad de poder elegir el tipo 00:12:29
en tiempo de instanciación 00:12:31
el que yo quiero, pues me abre 00:12:33
ya la opción de hacer cosas 00:12:36
más genéricas 00:12:37
y me soluciona el problema 00:12:39
que teníamos, que es, oye mi lista enlazada 00:12:41
no quiero que sea de stream 00:12:44
siempre, a veces 00:12:45
querré que sea de stream, a veces querré que sea 00:12:47
de integer, a veces querré que sea de cliente 00:12:49
a veces querré que sea de lo que sea 00:12:52
bueno, pues entonces 00:12:54
como nos va a quedar ya bonita 00:12:56
esta clase 00:12:58
es si 00:12:59
a nodo, la clase nodo 00:13:00
la cambiamos 00:13:04
y este tipo stream 00:13:06
le decimos, no, de stream nada 00:13:10
genérico 00:13:12
el que sea, en el momento 00:13:13
de hacer la lista 00:13:16
el tipo que a ti te dé la gana 00:13:17
para que puedas guardar en la lista lo que tú quieras 00:13:19
entonces ese string 00:13:21
se cambia por t 00:13:24
al cambiarse por t, nodo pasa a ser 00:13:25
una clase genérica 00:13:31
y nodo ahora ya 00:13:33
depende de t, se convierte en t 00:13:35
y ahora ya al haber cambiado 00:13:36
el nombre de la clase, ya todas 00:13:40
las referencias cambian 00:13:42
ahora esto será así también 00:13:43
vale, esto será 00:13:46
también así 00:13:48
ahora el nombre de la clase ha cambiado 00:13:49
ahora el nombre de la clase es este, porque es genérica 00:13:52
porque depende de T, pues la sustituyo 00:13:54
en todas partes. 00:13:57
Este string ya no es string. 00:14:00
Este string es T también. 00:14:03
Este dato del constructor no es string. 00:14:06
Es T, es ese tipo genérico. 00:14:10
Entonces ya esta clase ya la tengo 00:14:14
cambiada para que sea genérica. 00:14:15
La tengo cambiada. 00:14:18
El tipo T es genérico. 00:14:19
No se convierte a depender de T. 00:14:21
con lo cual lo cambio aquí, lo cambio aquí 00:14:23
y ahora ya el dato que yo paso 00:14:26
al constructor no es un string 00:14:28
es del tipo que sea, t 00:14:30
o sea, esta clase se convierte en una 00:14:31
función de t, es una función de t 00:14:34
donde t es la incógnita 00:14:36
y depende de t aquí y aquí y ahí 00:14:37
y depende de t 00:14:40
eso ya no es string, es t 00:14:41
lo que sea 00:14:44
¿vale? entonces la clase nodo ya está 00:14:44
modificada para que sea general 00:14:48
genérica, lo que pasa es que 00:14:50
Y ahora lista, como depende de nodo, pues lista también cambia, claro. 00:14:52
Ahora lista, ¿qué le ocurre? 00:14:57
Que lista, esto, de nuevo es así, ¿vale? 00:14:59
El inicio es un puntero a nodo T, porque esta clase ha cambiado, ya no es nodo, es nodo de T, es un nodo genérica. 00:15:07
Entonces, tengo que cambiar todas las referencias, esto me va a cambiar. 00:15:15
con lo cual al haber aparecido aquí la T 00:15:18
ahora es la clase lista enlazada 00:15:20
la que se hace dependiente de T también 00:15:23
se hace dependiente de T 00:15:25
porque me ha aparecido aquí esa T 00:15:27
se hace dependiente de ella 00:15:29
depende de T 00:15:31
entonces tengo que indicar que es dependiente de T 00:15:32
poniéndolo a su vez así 00:15:35
ala 00:15:37
lista enlazada 00:15:39
también depende de T 00:15:41
y ahora me toca cambiar todas las referencias 00:15:42
string 00:15:45
Ya no es string, esto es T 00:15:47
Nodo 00:15:49
Esto será así 00:15:52
Nodo T 00:15:54
¿Vale? 00:15:56
Entonces, esto 00:15:59
New nodo T 00:16:00
Aquí no tengo que cambiar nada 00:16:06
Esto ya está todo bien 00:16:08
Int posición, nodo, aquí lo mismo 00:16:09
Esto no será string, sino que esto será T 00:16:12
Esto será 00:16:14
Nodo de T 00:16:17
ya está aquí 00:16:19
todo cambiado 00:16:25
aquí lo mismo, esto es nodo de T 00:16:26
aquí el remove cuando 00:16:29
lo hiciéramos 00:16:34
aquí habría que ponerle T, claro 00:16:35
vale, pues ya he puesto 00:16:37
todas las referencias ya están 00:16:40
bueno, esto es lo mismo, añadir, habría que pasarle 00:16:42
un T 00:16:44
y aquí habría que pasarle un T también 00:16:45
vale, pues lista enlazada 00:16:48
ya es genérica, depende de un tipo 00:16:52
genérico, depende de T 00:16:54
Y ahora ya 00:17:00
Esto se queda mucho más bonito 00:17:05
Ahora ya 00:17:08
Esto ahora ya se queda completamente general 00:17:09
Yo digo, vamos a ver 00:17:15
Yo tengo, vamos a hacerlo para que 00:17:16
Dentro de mi paquete main 00:17:19
Vamos a hacer rápidamente una clase cliente 00:17:21
Para no estar tirando 00:17:22
Y ver como podemos guardar clientes 00:17:23
Lo que nos dé la gana 00:17:26
Vamos a hacer un cliente 00:17:27
Con un código 00:17:29
y un nombre 00:17:37
vale, y vamos a hacer un constructor 00:17:40
bueno, los get y set 00:17:48
de los cuatro 00:17:52
y vamos a hacer 00:17:56
constructor 00:17:58
con parámetros por lo menos 00:17:59
para poder 00:18:02
instanciarlo rápido 00:18:04
vale, constructor con parámetros 00:18:05
vale, pues ahora 00:18:09
yo tengo ya mi vista enlazada 00:18:11
en la que voy a guardar 00:18:13
objetos cliente, pues estupendo 00:18:15
Me voy a estanciar mi lista enlazada 00:18:17
Pero ojo 00:18:19
¿Para qué la queremos? 00:18:21
Pues esta lista enlazada 00:18:23
Ahora queremos que guarde 00:18:24
Cliente 00:18:26
Que el tipo T sea cliente 00:18:29
Lo queremos ya particularizar 00:18:31
Ya estamos instanciando 00:18:33
Pues estupendo 00:18:34
Mi lista enlazada de clientes 00:18:35
Va a ser esta 00:18:40
Adiós 00:18:41
Ya tengo mi lista enlazada 00:18:45
Pero de objetos cliente 00:18:51
la instancia, claro, lista 00:18:53
enlazada 00:18:55
aquí podéis poner 00:18:57
cliente dentro o no ponerlo 00:19:03
da igual, es lo mismo 00:19:05
pero sí que tenéis que poner los corchetillos estos 00:19:06
porque si no asume que no 00:19:09
le habéis puesto nada adelante y le tenéis que 00:19:11
meter object 00:19:13
lo convierte a object 00:19:14
ya no saldrá más 00:19:16
vale, ya tenemos una lista de clientes 00:19:19
y ahora yo ya uso mi lista 00:19:21
pues venga, vamos a 00:19:23
meter un cliente nuevo 00:19:25
pues venga 00:19:26
lista clientes 00:19:28
punto add first, el único que tenemos hecho 00:19:31
porque atlas no lo tenemos 00:19:35
venga, vamos a meter un cliente nuevo 00:19:36
un cliente nuevo 00:19:38
que es este de aquí 00:19:44
ala, venga, vamos a meter 00:19:46
unos cuantos más clientes 00:19:48
en mi lista 00:19:50
y esto mucho más fácil que un array, yo los voy añadiendo 00:19:51
y me despreocupo del tamaño 00:19:54
del array, me despreocupo de todo 00:19:56
Venga, vamos a añadir otro cliente 00:19:58
Ala, Juan 00:20:01
Vamos a añadir otro cliente 00:20:03
Ala 00:20:06
Y así podría añadir todos los que me dieran la gana 00:20:07
Venga, vamos a recorrer la lista 00:20:09
Ahora 00:20:11
Para cada 00:20:12
Mientras 00:20:18
Y sea menor que lista 00:20:19
Clientes 00:20:22
Ala 00:20:23
Pues que vamos a hacer, vamos a mostrar los nombres solo 00:20:32
pues lista 00:20:35
clientes.get 00:20:37
get 00:20:42
he abusado demasiado 00:20:45
get i que será el cliente 00:20:47
punto get nombre 00:20:49
porque el get i 00:20:51
ahora que me va a devolver 00:20:53
el get i me va a devolver 00:20:55
el cliente entero 00:20:57
el get i me devuelve el cliente enterito 00:20:58
porque la lista es de clientes 00:21:00
no, o sea, mi get 00:21:02
que es este de aquí 00:21:22
mi get me devuelve 00:21:23
el objeto que está en la lista 00:21:26
en mi caso el objeto es el cliente, me devuelve el objeto 00:21:28
enterito, pues nada 00:21:30
el get y me devolverá al cliente, voy a mostrar el nombre 00:21:32
solamente 00:21:34
bueno, pues vamos a probarlo ya a la versión genérica 00:21:35
a esta lista 00:21:39
le digo el tipo concreto de 00:21:40
t y ya trabajo 00:21:42
trabajo con 00:21:44
con objetos te para todo 00:21:46
a todos los efectos 00:21:48
vale y aquí están todos mis clientes 00:21:49
obviamente en orden inverso a como los metí 00:21:55
porque estamos usando el add first 00:21:57
bueno pues 00:21:58
con esta clase 00:22:06
y con los métodos que faltan 00:22:07
que repito no son tan complicados 00:22:10
y al menos uno hace 00:22:12
ya está 00:22:13
ya tenemos la lista enlazada de toda la vida 00:22:16
que me vale para guardar 00:22:19
cualquier tipo de dato 00:22:22
esto uno lo mete ya en un 00:22:24
jar y lo importa 00:22:27
desde cualquier proyecto 00:22:28
y puede usarla para 00:22:30
guardar de forma dinámica 00:22:32
datos, mucho más cómodo que 00:22:34
un array, que tenemos una lista 00:22:36
de alumnos, pues me hago 00:22:39
una lista de alumnos que sea lista de alumnos, lista 00:22:40
enlazada y ya está, y le voy metiendo alumnos 00:22:42
le saco lo que sea 00:22:45
vale, entonces que ocurre 00:22:45
que esto está muy bien 00:22:52
está estupenda y está 00:22:54
estupendamente hecha 00:22:55
pero ya existe 00:22:57
claro, existe esta 00:22:59
que es la 00:23:01
linked list 00:23:03
es decir, la JRE 00:23:05
hemos dicho que da un montón de cosas 00:23:12
la JRE 00:23:14
que da un montón de clases ya hechas 00:23:17
pues en concreto 00:23:18
en el paquete Java útil 00:23:20
tiene un montón 00:23:22
de clases 00:23:25
que son las que se llaman las colecciones 00:23:25
las colecciones 00:23:29
las colecciones son un montón de clases 00:23:30
que valen para guardar 00:23:33
de esta forma sencilla 00:23:35
de manera dinámica 00:23:36
entrar, salir, datos 00:23:38
¿de qué se diferencian unas de otras? 00:23:40
pues de cómo funcionan por dentro 00:23:43
y algunas se adaptan más que otras 00:23:45
a determinadas situaciones 00:23:46
bueno, pues una de ellas es la LinkedList 00:23:47
que es exactamente la que hemos hecho 00:23:50
que es esta 00:23:52
me la he pasado, esta 00:23:54
la LinkedList es esta 00:23:57
¿vale? que es una clase genérica 00:24:06
como la nuestra 00:24:13
y que implementa 00:24:15
una lista enlazada 00:24:17
implementa una lista enlazada y tiene aquí 00:24:19
los métodos para hacer las cosas 00:24:21
¿vale? 00:24:23
tiene aquí un montón 00:24:26
de métodos y de morraya y de todo 00:24:27
para hacer mil cosas, de los que al final uno acaba usando 00:24:29
pues añadir al principio 00:24:31
añadir al final 00:24:33
si contiene, ahora con estos 00:24:35
hay que meterse en profundidad 00:24:37
Porque luego usarlos se pueden usar bien o se pueden usar mal 00:24:39
¿Vale? 00:24:42
El añadir, que el añadir funciona igual 00:24:43
Que el añadir al final 00:24:46
Add y at last son iguales 00:24:47
¿Por qué existen dos? 00:24:49
Pues ya os lo diré también, pero son iguales 00:24:51
Añadir a doll 00:24:54
Le das un montón en una colección 00:24:57
Y te los añade todos a la vez 00:24:59
Bueno, pues tiene aquí un montón de cosas implementadas 00:25:01
¿Vale? 00:25:03
Tendrá clear para borrarlos todos 00:25:05
Este 00:25:08
para recuperar por posición 00:25:09
¿vale? que devuelve el tipo 00:25:11
genérico e, es lo que hemos 00:25:13
hecho nosotros, lo que pasa es que bueno, lo hace de otra 00:25:15
manera, más bonita 00:25:17
o no, o no más bonita 00:25:19
bueno, pues esa clase 00:25:21
es nuestra clase con más métodos 00:25:26
nada más, pero es eso 00:25:28
y luego está ArrayList 00:25:29
ArrayList 00:25:31
es esta 00:25:34
que ArrayList 00:25:35
otra 00:25:38
estructura como esta 00:25:40
pero que la forma de guardarlo todo es en un array 00:25:43
entonces antes de irnos 00:25:45
vamos a suponer que hiciéramos el array list 00:25:47
y ya dejamos ya introducido el tema de colecciones 00:25:49
para verlo mañana 00:25:51
estructuras dinámicas 00:25:52
tenemos el paquetillo con 00:25:59
lista enlazada 00:26:01
vamos a hacer otro paquete 00:26:03
que se llame lista array 00:26:04
pues lista array 00:26:07
que es el array list 00:26:16
de java ss 00:26:17
Es una clase mucho más fácil de programar 00:26:19
Sería esta 00:26:22
Vamos a llamarle miArrayList 00:26:23
Le voy a llamar 00:26:26
Y al otro lo podríamos haber llamado miLinkedList 00:26:27
Esta, miArrayList 00:26:32
Esta es una clase más fácil de programar 00:26:34
Esta, ¿dónde guarda los datos dentro? 00:26:36
Los guarda en un array 00:26:39
Los guarda en un array 00:26:40
¿Vale? Los guarda en un array 00:26:42
¿De qué tipo? 00:26:44
¿Vale? 00:26:46
Vale, aquí guarda los datos 00:27:00
y ahora habría que programar 00:27:01
los métodos que es que son 00:27:04
los que hemos programado mil veces en realidad 00:27:06
el de añadir 00:27:08
uno le mete un dato t 00:27:11
pues que hay que hacer aquí 00:27:15
crea la raya auxiliar 00:27:18
copiar uno en otro 00:27:20
añadir, pues el añadir sería 00:27:21
ese 00:27:23
creamos una raya auxiliar 00:27:24
pues ala 00:27:27
que sea 00:27:30
a ver 00:27:35
datos.length 00:27:37
más 00:27:53
uno 00:27:55
más uno, vale, entonces 00:27:56
aquí el problema 00:27:59
que te da el compilador es que te dice 00:28:02
el compilador no te deja 00:28:03
poner un tipo genérico detrás 00:28:05
de un new, porque te dice 00:28:08
oye, que te es genérico, no lo puedo instanciar 00:28:10
no te dejo, patatín, patatán 00:28:12
entonces, ¿cómo hace uno esto? 00:28:13
hace un object 00:28:16
y luego le hace un casting 00:28:18
a este. 00:28:21
Tiene que hacer esta cosa. 00:28:23
Vale, pero esto es solo 00:28:26
para que viéramos cómo sería. 00:28:27
Luego no vamos a usar esto. 00:28:29
Luego usamos el ArrayList 00:28:30
que ya está hecho. 00:28:31
No vamos a usar el nuestro. 00:28:32
Tendríamos que estarlo arrastrando 00:28:33
por todos lados. 00:28:34
¿Vale? 00:28:37
O igual que aquí. 00:28:37
Aquí lo querríamos instanciar a cero 00:28:38
para evitar un null pointer exception. 00:28:40
Querríamos hacer esto 00:28:43
y no nos deja. 00:28:44
Pues lo hacemos así 00:28:46
Y luego lo convertimos 00:28:48
A esto 00:28:54
Esto ya si me deja hacer el casting 00:28:55
Vale 00:28:59
Entonces el añadir, el añadir lo hemos hecho mil veces 00:28:59
Sería copiar uno en el otro 00:29:02
Copiar la adicional y 00:29:04
Pues esto que hemos hecho 00:29:06
Tantas veces 00:29:08
Mientras si sea menor 00:29:09
Que datos.led 00:29:13
Incrementando y 00:29:15
Pues aquí tendríamos que hacer 00:29:18
Aux 00:29:20
De i 00:29:21
Igual a datos 00:29:23
De i 00:29:26
Vale, una vez que ya hemos copiado 00:29:30
En la que falta 00:29:32
Que sería 00:29:33
Aux.length 00:29:35
Menos uno, el dato nuevo 00:29:37
Que es el dato que me pasan por parámetro 00:29:40
Y ahora ya sobre escribir 00:29:42
A datos 00:29:44
Le paso aux 00:29:45
Ah, ya tendríamos el añadir 00:29:47
La añadida ya la tenemos 00:29:50
Del miArrayList 00:29:51
Es lo que hemos hecho siempre 00:29:52
El borrar 00:29:55
Pues lo que hemos hecho 00:29:57
Devolver el tamaño, el get 00:29:58
Pues el get este sería más fácil todavía 00:30:00
Public 00:30:02
Int, el size, perdón 00:30:05
Tamaño de la colección 00:30:06
¿Qué devolveríais aquí? 00:30:10
¿Qué pondríais ahí? 00:30:15
Para devolver el tamaño 00:30:17
¿Cuántos datos tiene esta colección que yo estoy haciendo? 00:30:18
¿Qué pondríais? 00:30:21
Recordad que los datos están en este array 00:30:24
Los datos están ahí 00:30:26
Luego, ¿cuántos datos va a haber? 00:30:29
¿Qué pongo ahí? 00:30:30
Datos.length 00:30:32
Datos.length 00:30:33
Podríamos hacer el remove 00:30:37
Todos, y este es el array list 00:30:40
El array list genérico 00:30:42
Que lo uso yo en mi main porque ahora me quiero hacer yo 00:30:43
Unos clientes 00:30:46
Pero guardados en un array list 00:30:48
Que ya no quiero lista enlazada 00:30:49
Pues me hago mi array list 00:30:51
mi array list de cliente 00:30:53
o de lo que a mí me dé la gana 00:30:58
importo 00:30:59
y ya está, y a mí ya me da igual 00:31:19
cómo esté hecho esto por dentro 00:31:25
me da lo mismo, yo la uso para añadir 00:31:26
para lo que quiera 00:31:28
vamos a añadirle clientes a esta lista también 00:31:29
a esta estructura 00:31:32
pues venga, clientes.add 00:31:34
new cliente 00:31:37
ala de código 1 00:31:44
y nombre javi 00:31:46
ala, vamos a añadirle otro más 00:31:48
a esta estructura 00:31:50
el 2 00:31:52
ala, luis 00:31:59
que ahora quiero recorrer 00:32:03
mi estructura, pues para eso 00:32:05
tengo mi 00:32:07
for, pues recorro 00:32:08
mi lista de clientes 00:32:16
que está aquí 00:32:18
con mi método size, muestro 00:32:24
clientes 00:32:26
con el método, ah es que no me he hecho el get 00:32:27
Pero el get aquí, este sí que sería 00:32:30
Lo más sencillo del mundo 00:32:33
¿Cómo sería el get? 00:32:34
Public t get al que le pasamos una posición 00:32:40
El get tendría una línea 00:32:43
Retún que 00:32:48
Los datos están en el array 00:32:50
En este de aquí 00:32:53
¿Cómo devuelvo el dato de posición? 00:32:54
Fijaos aquí 00:33:06
Qué fácil sería el get 00:33:07
De esta estructura 00:33:09
Devuelvo el dato de esa posición 00:33:10
Facilísimo 00:33:12
entonces ya tengo aquí mi main 00:33:13
donde estoy usando 00:33:16
esta otra, vale, voy a poner aquí 00:33:18
un separador 00:33:21
un separador, entonces 00:33:23
en este main, he usado primero 00:33:33
la de arriba, para añadir 00:33:35
recorrer, ahora uso la de abajo 00:33:37
para añadir, recorrer 00:33:39
y me da 00:33:41
y el main 00:33:42
no ha visto como están hechas por dentro 00:33:44
ni le importa, ni nada 00:33:46
Sabe que tiene esas estructuras para guardar datos 00:33:48
Vamos a usarlas, no vaya a ser que hayamos hecho algo mal 00:33:50
En el ArrayList 00:33:53
Y aquí los tengo 00:33:55
Este es mi ArrayList con sus datos 00:33:58
¿Vale? 00:34:00
Tan cómodo 00:34:03
Entonces pues tengo dos posibilidades 00:34:05
La lista enlazada 00:34:07
La LinkedList que ya está hecha 00:34:08
Y el mi ArrayList que se llama ArrayList 00:34:11
¿Cómo se usan? 00:34:13
Se usan igual, uno lo instancia 00:34:15
mete, saca, borra y ya está 00:34:17
se usan igual 00:34:20
porque hay dos 00:34:21
porque uno se adapta mejor, funciona mejor 00:34:22
en una situación y otro funciona mejor en otra 00:34:26
y como ya sabemos cómo están hechos por dentro 00:34:27
porque los acabamos de hacer, los hemos hecho los dos 00:34:30
no todos los métodos, pero los hemos hecho 00:34:32
pues ya sabemos cuál va a funcionar 00:34:33
mejor en una situación y cuál va a funcionar mejor en otra 00:34:36
la linked list ya hemos dicho 00:34:38
es magnífica 00:34:40
para insertar y eliminar 00:34:41
lo único que hay que hacer es mover enlaces 00:34:43
no hay que hacer nada más 00:34:46
¿Vale? 00:34:47
Pero para consultar es un rollo 00:34:49
Porque tenemos que ir navegando 00:34:50
El ArrayList es maravilloso 00:34:52
Para consultar, lo acabamos de ver 00:34:55
Para consultar es estupendo 00:34:56
Es esto 00:34:58
Es hacer el Array 00:34:59
Pero sin embargo la lista enlazada 00:35:01
Para consultar, el get de la lista enlazada 00:35:03
Tiene que hacer todo esto 00:35:06
Entonces aplicaciones que sobre todo 00:35:08
Con los datos hagan consultas 00:35:10
Mejor el ArrayList 00:35:13
Los que hagan muchas inserciones y borrados 00:35:14
mejor el linked list 00:35:16
¿vale? pero las dos se usan 00:35:17
igual, una vez hechas 00:35:20
ofrecen sus métodos, añadir, borrar 00:35:21
eliminar y ya está 00:35:25
¿vale? 00:35:26
y son clases que ya están hechas y podemos usar 00:35:28
incorporando los matices 00:35:30
que ya iremos incorporando mañana 00:35:33
¿vale? 00:35:35
bueno, pues entonces 00:35:37
hacer 00:35:38
al menos un método 00:35:41
de estos 00:35:43
¿vale? un método de estos 00:35:43
en realidad es 00:35:45
similares todos, cualquiera de los tres primero 00:35:51
bueno, yo haría o este 00:35:54
o este, que son los que 00:35:56
más os van a ayudar a ver si realmente 00:36:00
habéis entendido un poco el fundamento de la lista enlazada 00:36:02
o el de borrar 00:36:04
por posición o el de añadir 00:36:06
al final, pero bueno son un poco 00:36:08
parecidos los cuatro, en realidad hacer uno de ellos para entender 00:36:10
bien que consiste 00:36:12
vale, entonces 00:36:13
aquí lo que hemos visto es 00:36:15
¿qué es una estructura dinámica? 00:36:17
no es nada que no conozcamos, es una clase más 00:36:19
que uno ha construido 00:36:21
para hacer cosas de forma sencilla 00:36:22
pero lo que está hecho por debajo 00:36:25
es lo que hemos hecho siempre, es que no hay otra 00:36:27
¿vale? y como esas clases 00:36:29
ya están, pues las podemos usar 00:36:31
tranquilamente y de forma cómoda 00:36:33
¿vale? 00:36:35
y por último 00:36:37
revisad bien qué es esto de 00:36:39
las clases genéricas 00:36:41
entender lo que es 00:36:42
porque, a ver, usarlo 00:36:44
cuando uno instancia una lista puede decir 00:36:50
yo instancio una lista, le pongo el tipo y ya está 00:36:51
y se queda tan ancho y puede trabajar con eso 00:36:54
sin saber nada más 00:36:56
pero hombre, hay que entender que es 00:36:57
hay que entender que es un tipo genérico 00:36:59
bueno, pues venga, vamos a 00:37:01
parar aquí entonces 00:37:05
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
26 de febrero de 2024 - 18:50
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
37′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
170.39 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid