Saltar navegación

20260202 Colecciones_3_enlazada - 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 2 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues entonces esto que hemos visto 00:00:00
es como ya sabemos 00:00:11
una clase que ya está hecha 00:00:16
luego no tenemos que usar 00:00:18
nuestro miArrayList chulo 00:00:20
ni miArrayList nada 00:00:22
nada de eso, porque ya hay una clase 00:00:23
que está hecha 00:00:26
que es ArrayList 00:00:28
que está ya 00:00:33
en todas las clases 00:00:35
que distribuye 00:00:38
el JDK 00:00:39
para que nosotros las podamos usar 00:00:41
y que están en la JR 00:00:43
pues esa clase ya existe 00:00:44
¿vale? 00:00:47
que está en particular 00:00:48
dentro 00:00:49
del paquete Java útil 00:00:51
¿vale? 00:00:56
dentro del paquete Java útil 00:00:57
está esta clase 00:00:58
¿cómo pasa? 00:00:59
Vale, pues esto es un ejemplo de colección, ¿vale? Forma parte de lo que en Java entendemos por colecciones, ¿vale? Esto es un ejemplo de lo que llamamos colecciones. 00:01:02
Es un ejemplo 00:01:28
Que está hecho por dentro 00:01:29
Pues como hemos hecho nosotros 00:01:31
Tal cual 00:01:32
Lo que pasa es que, bueno, incorpora 00:01:33
Pues más métodos, más validaciones 00:01:35
Temas de excepciones 00:01:37
Que nosotros no hemos visto todavía 00:01:40
Está más pulida 00:01:41
Nuestra versión está muy cutre, obviamente 00:01:42
Pero es lo mismo, conceptualmente es lo mismo 00:01:45
Es un array, es lo mismo 00:01:47
Pero está más pulido 00:01:49
Pues es el ArrayList 00:01:50
Y forma parte 00:01:51
Y forma parte 00:01:54
de lo que en Java 00:02:00
llamamos colecciones 00:02:02
vale, pues que son las colecciones 00:02:03
las colecciones son 00:02:06
clases que están 00:02:08
pensadas, diseñadas 00:02:11
para 00:02:13
guardar 00:02:17
datos 00:02:18
vale, esas 00:02:20
son las colecciones, clases que están 00:02:28
diseñadas para guardar datos, como 00:02:30
ArrayList 00:02:32
vale, pero ArrayList no es 00:02:32
la única 00:02:36
hay muchas 00:02:36
no hay tampoco tantas 00:02:38
hay unas cuantas 00:02:42
y esencialmente las podemos dividir 00:02:43
en dos tipos 00:02:46
¿vale? 00:02:47
entonces las colecciones en Java 00:02:51
se dividen en dos tipos 00:02:53
tenemos 00:02:59
listas y conjuntos 00:03:01
¿vale? 00:03:11
lo que viene a ser 00:03:13
las list y los set 00:03:14
Eso serían las colecciones, ¿vale? Listas y conjuntos. Vale, hay dos tipos en función de cómo funcionan por debajo, cómo estén implementadas por debajo, ¿vale? Pero ¿en qué se traduce eso de vistas hacia afuera? ¿En qué se traduce? 00:03:18
¿Cuál es la distinción que nosotros vemos desde fuera cuando las usamos? 00:03:37
Pues que las listas tienen orden 00:03:42
Y los conjuntos no tienen orden 00:03:46
Esa es la diferencia entre las listas y los conjuntos 00:03:58
Es decir, una lista tenemos que verla 00:04:03
como una filita 00:04:07
de cosas 00:04:10
en esa filita van los elementos 00:04:11
¿vale? ahí van los elementos 00:04:14
y cada elemento 00:04:16
está en una posición 00:04:18
eso significa que tiene orden, que está en una posición 00:04:19
este elemento está en la cero 00:04:22
y este está en la uno y este está en la dos 00:04:24
los elementos tienen una posición asociada 00:04:26
con tener orden 00:04:28
quizá es más 00:04:30
se entiende mejor el decir 00:04:31
que tienen 00:04:34
posición asociada, ¿vale? 00:04:36
Se entiende mejor así. 00:04:40
Cada elemento está en una posición de la caja. 00:04:49
La 0, la 1, la 2. 00:04:52
Y los elementos ya cada uno es el que sea. 00:04:54
Eso ya nos da igual, ¿vale? 00:04:56
Sin embargo, en un conjunto los elementos 00:04:58
están todos ahí, pum, a mogollón. 00:05:00
Ninguno tiene una posición asociada. 00:05:02
Es un conjunto 00:05:05
de toda la vida. 00:05:05
Cuando metemos un elemento al set 00:05:10
o conjunto, ahí va. 00:05:11
Sin una posición. 00:05:14
¿Vale? Luego, 00:05:16
esto ya se traduce en muchos 00:05:19
pequeños aspectos prácticos, por ejemplo 00:05:22
en las listas 00:05:25
podemos meter dos elementos 00:05:27
iguales, imaginaos que es 00:05:29
de números, yo puedo meter 00:05:31
el 3 y aquí puedo meter 00:05:33
el 3, no pasa nada 00:05:35
porque se distinguen 00:05:37
por la posición, este es 00:05:39
el 3 que está en la posición 0 00:05:41
y este es el 3 que está en la 00:05:42
posición 4 00:05:45
es decir 00:05:46
el que los elementos 00:05:49
de la lista tengan una 00:05:51
posición asociada 00:05:53
implica automáticamente que puede 00:05:54
haber 00:05:57
elementos duplicados 00:05:59
esa es la implicación 00:06:01
puede haber 00:06:03
elementos 00:06:04
duplicados, ¿vale? 00:06:06
vale, en un conjunto 00:06:16
no puede haber elementos duplicados 00:06:18
si yo al conjunto le hago un add 00:06:19
y le meto el 3, por aquí 00:06:21
y ahora 00:06:23
le vuelvo a intentar meter el 3 00:06:26
vuelvo a hacer add de 3 00:06:29
no lo va a meter 00:06:31
porque ya ve que hay uno 00:06:33
entonces no puede meterlo 00:06:35
porque el otro 3 se confundiría 00:06:37
con este, porque no tiene posición asociada 00:06:39
¿y si te avisaría de alguna manera o directamente no lo hace? 00:06:41
no lo hace 00:06:43
luego ya los usos concretos de cada una 00:06:44
ya lo vamos viendo 00:06:46
no puede 00:06:47
haber en un conjunto, no puede haber 00:06:51
dos elementos iguales, porque directamente 00:06:53
el segundo elemento 00:06:55
no lo inserta 00:06:56
ve que hay uno igual, no lo inserta 00:06:58
¿por qué? porque habría una 00:07:00
habría aquí una ambigüedad 00:07:01
yo ya tengo un 3, ese otro 3 00:07:04
¿qué hago con él? es que no lo puedo distinguir del otro 00:07:06
es imposible, no puedo distinguirlo 00:07:08
aquí los puedo distinguir por posición 00:07:10
aquí al no haber posiciones 00:07:12
no puedo distinguirlo, luego no admite 00:07:14
duplicados 00:07:16
esa es la diferencia entre los 00:07:17
sets 00:07:20
y los conjuntos, y las listas 00:07:22
Entonces, en aplicaciones en las cuales la posición para mí no tenga ningún interés, porque yo no necesito duplicados, en las que no tenga ningún interés la posición, yo quiero meter los elementos ahí y ya está, para luego recorrer, a ver los que hay, eliminarlos si quiero, lógicamente. 00:07:24
Si yo quiero simplemente tener un almacén de datos y ese almacén, pues luego ya para recorrerlo, para eliminar uno, eliminar el tres, para insertar otro nuevo, una colección sin más, donde el hecho de que estén en filita no me aporta nada, pues entonces siempre cogeré un set. 00:07:49
¿por qué? porque su implementación 00:08:06
interna es más eficiente 00:08:09
porque aquí 00:08:11
la implementación interna tiene que 00:08:13
gestionar las posiciones 00:08:15
porque cada elemento se caracteriza 00:08:16
en una posición 00:08:19
entonces siempre hay más 00:08:20
complejidad 00:08:23
en la gestión y el uso 00:08:24
de una lista 00:08:27
que de un conjunto, porque no tienes 00:08:29
aquí 00:08:31
no hay que gestionar las posiciones 00:08:32
entonces si que haya duplicados 00:08:34
que estén en filita 00:08:36
no me aporta nada, no es algo 00:08:39
que yo necesite para mi aplicación 00:08:40
por las características de lo que mi aplicación 00:08:42
tiene que hacer, nunca se habían peinado 00:08:44
mientras daba clase, nunca jamás 00:08:46
la primera vez que me ocurre eso 00:08:48
¿cómo va a ser lo siguiente que me pase? 00:08:52
que me peine yo 00:08:55
¿qué otra cosa? 00:08:56
no tienes ninguna necesidad 00:08:56
ya me refiero 00:09:05
bueno, da igual 00:09:08
no de peinarte 00:09:08
sino de tener pelo 00:09:11
quiero decir 00:09:12
bueno, depende 00:09:12
y las gorras 00:09:14
bueno, pues entonces 00:09:16
siempre cogeríamos un 6 00:09:20
¿vale? 00:09:22
los detalles de implementación 00:09:23
y de uso 00:09:24
y de todo eso 00:09:25
ya los veremos 00:09:26
lógicamente 00:09:27
ya los veremos 00:09:27
ahora estamos solamente 00:09:28
describiendo 00:09:29
de qué va el rollo 00:09:32
ya los detalles 00:09:32
de implementación 00:09:33
los ejemplos que hay 00:09:34
ya los iremos viendo 00:09:35
¿vale? 00:09:36
bueno pues tenemos 00:09:37
estos dos tipos 00:09:38
listas y conjuntos 00:09:39
el ArrayList 00:09:40
que hemos hecho nosotros 00:09:42
que es ya digo 00:09:43
similar al ArrayList 00:09:44
que está hecho 00:09:46
porque son iguales 00:09:47
en cuanto a que los dos 00:09:49
tienen un Array por debajo 00:09:49
con los métodos 00:09:50
que incorpora 00:09:52
es una lista 00:09:52
es una lista 00:09:54
porque los elementos tienen una posición 00:09:56
asociada, yo los puedo recuperar por posición 00:09:58
de hecho hemos hecho el get 0 00:10:00
para recuperar el 0, el get 1 para recuperar el 1 00:10:02
luego la clase que hemos hecho 00:10:04
miArrayList tiene una posición 00:10:06
asociada, luego es una lista 00:10:08
¿vale? 00:10:10
no es la única 00:10:13
implementación posible de listas 00:10:14
que tenemos 00:10:16
hay otro tipo 00:10:17
de lista que podemos hacer 00:10:23
luego, vámonos 00:10:25
ahora las listas, ¿vale? 00:10:31
Listas, conjuntos, los dos tipos 00:10:33
de colecciones que tenemos. Vámonos ahora 00:10:35
más en detalle a las listas, ¿vale? 00:10:37
La lista 00:10:42
es un objeto que uno puede instanciar 00:10:42
para meter elementos 00:10:45
en ella y cada elemento con una posición, 00:10:47
¿vale? 00:10:49
Bueno, pues, ¿qué listas tenemos ya hechas en 00:10:50
Java para usar? Tenemos 00:10:52
el ArrayList, que ya 00:10:57
sabemos cómo está hecha por dentro, tiene un 00:11:01
Array genérico, luego tú cuando 00:11:03
lo instancias le das el tipo, o sea, es una clase 00:11:05
como la que hemos hecho nosotros 00:11:07
añade más métodos 00:11:08
lógicamente 00:11:10
para poder hacer más cosas 00:11:11
y gestiona excepciones 00:11:12
que eso no lo hemos gestionado nosotros 00:11:14
pues no sabemos 00:11:15
pero salvo eso 00:11:16
es la que hemos hecho 00:11:17
luego tenemos el ArrayList 00:11:18
que uno instancia 00:11:20
y mete cosas 00:11:21
y cada cosa cae 00:11:22
en una posición sí o sí 00:11:23
pero ¿qué le pasa al ArrayList? 00:11:24
que precisamente 00:11:28
como nosotros sabemos programar 00:11:28
pues sabemos 00:11:30
que cuando uno hace add 00:11:32
se queda tan tranquilo 00:11:33
hecho add 00:11:35
que a gusto, una línea de código 00:11:36
que programa más corto, de corto nada 00:11:38
ese add 00:11:41
ahora, menudo pifostio 00:11:42
que ha hecho él 00:11:45
ese add ha creado 00:11:46
otro array, ha copiado 00:11:49
ha sobrescrito el otro array 00:11:50
en este, este se tira a la basura 00:11:53
o sea, lo que para nosotros se llamara add 00:11:54
del array list, es un montón 00:11:57
de líneas de código y muy 00:11:59
complejas, son muy complejos 00:12:00
crear otro array, borrar otro 00:12:03
O sea, están, en un momento dado, van a estar coexistiendo dos arrays que pueden ser enormes. 00:12:04
Imaginaos que tengo una lista, una array list de 300 posiciones y que voy a añadir el 301. 00:12:11
Pues en un momento dado están coexistiendo dos arrays de 300. 00:12:16
O sea, lo que para mí es hacer add no es trivial. 00:12:21
El método add tiene dentro un montón de cosas. 00:12:25
Y si llamamos a delete, pues ya ni te cuento. 00:12:29
lo que para mí es 00:12:31
oye elimina de la lista el número 00:12:34
lo que para mí es escribir delete usando 00:12:37
este objeto ArrayList que he creado 00:12:40
esto pues es un rollo 00:12:42
porque es llamar aquí un método 00:12:44
que ya sabemos lo que tendrá que hacer 00:12:46
crear otro Array, copiar, ver si es 00:12:48
un rollo 00:12:50
bueno a cambio cuando hagamos get 00:12:51
para recuperar por posición 00:12:55
que bien como nos gusta 00:12:57
el ArrayList porque ya sabemos que lo que 00:13:01
haces, retúr la posición 7. 00:13:03
Magnífico. 00:13:05
Eso está muy bien. 00:13:07
Vale. Pues, ¿qué quiero decir 00:13:09
con todo esto? Que la ArrayList 00:13:11
está estupendo 00:13:13
para recuperar cuando yo quiero 00:13:14
hacer consultas por posición, 00:13:17
pero para insertar y borrar 00:13:19
es un verdadero 00:13:21
rollo, computacionalmente hablando. 00:13:22
¿Vale? Si yo tengo 00:13:26
pocos registros, perdón, pocos 00:13:27
elementos, da un poco igual. Pero yo tengo 00:13:29
muchos elementos, computacionalmente 00:13:31
esto empieza a complicarse. 00:13:33
Hay que crear arrays, romperlos. 00:13:35
Luego, computacionalmente, 00:13:38
cuando ya estamos ejecutando 00:13:40
el programa, los ArrayList 00:13:41
son muy poco eficientes 00:13:43
para inserciones y borrados. 00:13:45
¿Vale? 00:13:48
Para inserciones y borrados son muy poco eficientes. 00:13:48
Entonces, claro, 00:13:54
¿va a ser esta la única 00:13:55
lista que tengamos para guardar 00:13:57
un montón de elementos con orden? 00:13:59
¿Vale? 00:14:00
que ya sé que computacionalmente 00:14:00
es muy costosa para insertar 00:14:03
y borrar, va a ser la única 00:14:05
pues no, afortunadamente 00:14:06
hay gente muy lista que se le ocurren 00:14:08
otras cosas, de almacenar 00:14:11
un montón de datos juntos, todos 00:14:13
del mismo tipo 00:14:15
de tal forma que las inserciones y los borrados 00:14:16
sean mucho más 00:14:19
cómodos que con un array 00:14:21
y esa es la que se llama 00:14:22
la linked list 00:14:25
que son las dos listas que tenemos 00:14:30
¿vale? 00:14:32
Las dos valen para lo mismo 00:14:34
Para tener un montón de datos 00:14:36
Meter dentro datos 00:14:38
Recorrerlos, sacarlos por posición 00:14:40
Eliminarlos, las dos valen para lo mismo 00:14:43
Pero la implementación interna 00:14:45
Es distinta 00:14:47
El ArrayList ya sabemos como está 00:14:48
Hecho por dentro, ya lo sabemos, de hecho lo hemos hecho 00:14:50
Y el ArrayList 00:14:53
¿Cómo está hecho por dentro? 00:14:55
Pues 00:14:59
Qué mal rollo 00:15:02
Pues a ver, pregunto 00:15:03
yo, si os ocurre 00:15:08
no pongáis 00:15:12
a teclar rápido el mensaje 00:15:14
otra manera a nivel 00:15:15
teórico, ahora es una pregunta muy 00:15:19
muy compleja, si uno no lo ha visto antes 00:15:21
el concepto, vale, no es que espera que me digan 00:15:23
uy pues ya me ocurre esto, no, pero bueno 00:15:25
igual os suena el concepto, lo habéis visto antes 00:15:27
o lo que sea, otra forma 00:15:29
de guardar un montón de datos 00:15:31
porque este es nuestro problema, imaginaos que tenemos 00:15:33
alumnos que guardar 00:15:35
mi alumno con tres propiedades 00:15:37
mi alumno 00:15:39
mi alumno 00:15:40
mi alumno 00:15:42
los queremos guardar todos juntos 00:15:45
bajo una única referencia 00:15:47
que esa es la idea 00:15:49
para luego poder tratarlos conjuntamente 00:15:49
para recorrer 00:15:51
una de las ideas ya está 00:15:52
ya está vista 00:15:55
ya la conocemos 00:15:56
que es ala todos a un array 00:15:57
vale una de las ideas ya está 00:15:58
todos a un array 00:16:00
ahí están todos juntitos 00:16:02
bajo la referencia de mi objeto array 00:16:04
ala todos ahí 00:16:07
esa solución 00:16:08
es la del array list 00:16:09
¿Vale? Todos a la raíz 00:16:11
Ahí están 00:16:14
Ahí recorro, meto uno nuevo 00:16:15
Lo que quiera 00:16:18
Pero esta solución, pues ya hemos dicho 00:16:19
Que es costosa 00:16:22
Para inserciones y borrados 00:16:23
Entonces, ahora 00:16:25
Pregunto yo 00:16:30
¿Se nos ocurriría otra manera de guardar 00:16:31
Un montón de datos como estos 00:16:34
Bajo una única referencia 00:16:36
Que me permita a mí 00:16:38
Bajo esa referencia 00:16:39
objeto, como lo queréis llamar, referencia 00:16:41
objeto, tenerlos todos ahí accesibles 00:16:43
para recorrerlos, para meter 00:16:45
uno nuevo, una pregunta 00:16:47
complicada, ¿verdad? A ver, es una 00:16:52
pregunta complicada 00:16:57
la idea de fondo 00:16:58
es el concepto 00:17:01
de informática de toda la vida 00:17:04
que es el de una lista enlazada 00:17:05
es decir 00:17:08
¿qué idea es la más natural? 00:17:09
¿vale? pues que cada uno 00:17:12
o sea, que tenga yo 00:17:13
aquí mi objeto. Esta es mi referencia. 00:17:15
Debajo de esta es de la que 00:17:20
quiero que cuelguen todos. A través de 00:17:21
ella quiero poder acceder a todos, como la de la 00:17:23
array, que a través de la referencia de la array accedo a 00:17:25
todos. Pues a través de esta 00:17:27
quiero poder acceder a 00:17:29
todos. Vale, pues ¿cómo podemos 00:17:31
hacer? Yo 00:17:33
accedo al primero, 00:17:35
que mi referencia me lleve al primero 00:17:39
y cada uno que lleve 00:17:41
de la manita al siguiente. 00:17:43
Podemos llevar, 00:17:46
sacar de excursión a los niños de primero de infantil 00:17:46
los podemos meter a todos 00:17:50
en el autobús, pum, y van todos en el autobús 00:17:51
o los podemos 00:17:54
o podemos coger al primero 00:17:55
y que el primero dé de la mano al segundo y vayan todos de la manita 00:17:57
y nosotros llevamos al primero 00:18:00
o los llevamos en un autobús 00:18:01
o llevamos de la mano al primero y cada uno lleva de la mano 00:18:03
al siguiente 00:18:05
y si están bien educados no se van a soltar 00:18:06
entonces van a llegar todos a su destino 00:18:09
¿que yo quiero 00:18:11
ver cómo está el quinto? 00:18:14
pues hombre es un rollo, tengo que pasar 00:18:15
por uno, por otro, por otro hasta que llego al quinto 00:18:17
¿vale? pero desde luego están 00:18:19
todos ahí accesibles, todos accesibles 00:18:21
todos los dados de la manita 00:18:23
van a llegar todos a su destino 00:18:24
correctamente, pues aquí lo mismo 00:18:26
cada objeto 00:18:29
que se envuelva en un objeto 00:18:30
joder 00:18:35
que asustos 00:18:36
que se envuelva en un objeto 00:18:38
que además de sus propiedades 00:18:40
tenga la referencia del siguiente 00:18:42
Ahora este 00:18:45
A su vez 00:18:49
Tiene la referencia del siguiente 00:18:50
Este a su vez 00:18:53
Tiene la referencia del siguiente 00:18:56
Este a su vez 00:18:59
Tiene la referencia del siguiente 00:19:01
Como él es el último 00:19:03
Él su referencia esta del siguiente 00:19:04
Ya apunta a mí 00:19:07
Pues así los tengo a todos 00:19:09
Perfectamente accesibles 00:19:12
Desde esta 00:19:14
pero es que yo no sé por qué se me mueve con esto 00:19:15
a veces y a veces no, bueno no lo sé 00:19:21
podría ser, no lo sé 00:19:23
igual se roza 00:19:27
esto y no me doy cuenta 00:19:30
vale, pues así podemos perfectamente 00:19:31
ya están todos 00:19:34
accesibles desde aquí 00:19:36
¿qué ventaja tengo con esta estructura? 00:19:37
que insertar uno nuevo 00:19:43
es facilísimo 00:19:45
insertar uno nuevo es llegar y darse de la mano 00:19:47
ya está, no tiene que hacer nada más 00:19:50
insertar uno nuevo es 00:19:52
tengo este objeto, si yo lo quiero meter en un array 00:19:53
tengo que hacerme un autobús 00:19:57
es como cambiarlos, si llega uno 00:19:58
la filita de niños, uno, hostia 00:20:00
que este llega tarde, pues se da la mano 00:20:02
y se acabó, vale 00:20:04
pero si llega uno y mi autobús 00:20:06
era para 20 y me ha llegado el niño 00:20:08
21, tengo que contratar un autobús nuevo 00:20:10
cambiarlos a todos 00:20:13
montar al 21, pues un rollo 00:20:14
sin embargo así me llega uno nuevo 00:20:17
uy que fácil, pues tú dejas de apuntar a null 00:20:19
y empiezas a apuntar al nuevo y ya está 00:20:22
luego acoger elementos nuevos en esta estructura 00:20:25
no cuesta nada, se trata de hacer una asignación 00:20:28
de una referencia, se acabó 00:20:32
no hay que crear nada, destruir nada 00:20:34
luego esta estructura es muchísimo más eficiente 00:20:36
para insertar elementos nuevos 00:20:40
que el ArrayList 00:20:44
el ArrayList, ya sabemos lo que implica 00:20:45
¿que quiero yo eliminar un elemento? 00:20:47
facilísimo 00:20:52
no tengo que crearme un autobús 00:20:53
nuevo con una posición menos 00:20:55
moverlos a todos, dejar fuera 00:20:57
el niño que me sobra 00:20:59
no, aquí el niño que me sobra 00:21:00
pues se va afuera 00:21:03
o sea, este enlace 00:21:05
y este cambia de mano 00:21:07
este le da la mano 00:21:09
a uno, le da la mano al de atrás 00:21:11
ya está, se trata de darle la mano al otro 00:21:12
y el que se ha quedado fuera sin nadie que le dé la mano 00:21:15
pues ya se lo llevará al recolector de basura 00:21:18
luego 00:21:20
inserciones y borrados 00:21:22
computacionalmente 00:21:24
inmejorables 00:21:26
con una lista enlazada 00:21:27
¿pero es solo para objetos? 00:21:29
¿o sirve para otros servicios? 00:21:31
no, no, para objetos también 00:21:33
igual que la raíz 00:21:35
claro, porque tiene que tener 00:21:36
no, no, te ha preguntado 00:21:39
si sirve para otros servicios 00:21:41
Bueno, si lo envuelves en el integer, sí 00:21:42
Las colecciones solamente pueden tener datos objeto 00:21:45
¿Vale? Datos objeto 00:21:48
Pero si tú quieres números, pues integer 00:21:50
¿Vale? De hecho 00:21:52
Normalmente 00:21:53
A partir de cierto momento, ya tú no vas a ver 00:21:55
En las aplicaciones 00:21:58
Tipos primitivos como indavel, sueltos 00:21:59
Vas a ver siempre el envolvente 00:22:01
Porque computacionalmente te da igual, lo usas igual 00:22:03
Y es más flexible 00:22:06
Por si en un momento dado tienes que meterlo 00:22:08
En una colección, por ejemplo 00:22:09
¿Vale? 00:22:11
Te va a ser más habitual en aplicaciones grandes 00:22:13
Ver siempre el envolvente que ver el primitivo 00:22:15
¿Vale? 00:22:18
Entonces en una lista enlazada 00:22:19
Que sería el linked list 00:22:21
Insertar y eliminar 00:22:23
Facilísimo, que era justo lo que era complicado 00:22:27
En el array list, justo lo que era complicado 00:22:30
Pero ostras 00:22:32
Recorrer, es decir 00:22:35
Recuperar un elemento 00:22:37
consultar 00:22:39
un elemento 00:22:42
pues en el ArrayList era inmediato 00:22:43
era un retún get el que fuera 00:22:45
porque el ArrayList es que ya 00:22:47
al ser un Array tú vas a la posición 00:22:50
y vas tal cual, es de acceso directo 00:22:51
a la posición en el Array, tal cual 00:22:53
tú tienes tus corchetes para acceder 00:22:55
a la posición 00:22:57
pero este, aquí no hay corchetes 00:22:58
para acceder, si yo quiero ver 00:23:02
elemento en la posición 3, yo que sé 00:23:03
este por ejemplo 00:23:06
mi referencia apunta al primero solo 00:23:06
el que manda, que es la referencia 00:23:10
que está en el main, apunta al primero 00:23:12
luego del primero tengo que ir al segundo 00:23:14
y del segundo al tercero, ah, que ya ha llegado 00:23:16
luego 00:23:18
la recuperación por posición, el get 00:23:20
es la que es 00:23:22
pesada, la que tarda 00:23:24
partimos del primero siempre 00:23:25
partimos del primero y del primero hay que ir navegando 00:23:28
hasta que lleguemos al que queremos ver 00:23:30
luego son complementarias 00:23:32
no es que una sea mejor que otra 00:23:35
ArrayList 00:23:36
está basada en un array que es la mejor estructura 00:23:38
que hay, pero a partir 00:23:41
de cierto tamaño 00:23:43
las inserciones y borrados cuestan 00:23:44
mucho 00:23:47
sin embargo en un LinkedList 00:23:47
si vamos a hacer muchas inserciones y borrados 00:23:50
y mi aplicación sobre todo 00:23:53
sus casos de uso, sus servicios 00:23:54
son de insertar y borrar 00:23:57
son sobre todo eso 00:23:59
y tengo ya una cantidad de datos respetable 00:24:01
pues un LinkedList 00:24:03
si mi aplicación 00:24:04
tiene los datos de partida ya 00:24:07
construidos y lo único 00:24:09
que va a hacer, va a ser consultarlos 00:24:11
pues hombre, estar 00:24:13
consultando todo el rato en esta es un rollo 00:24:15
un ArrayList mejor 00:24:17
en cualquier caso 00:24:18
para una cantidad de datos manejable 00:24:21
pequeñita 00:24:22
pues por defecto siempre usaríamos un ArrayList 00:24:24
porque es un Array que ya sabemos que es muy 00:24:27
robusto 00:24:28
es la estructura nativa 00:24:30
de Java, de hecho el Array 00:24:32
para una estructura de datos 00:24:33
para una colección un poquito más anchota 00:24:36
más grandota, que yo preveo 00:24:38
que voy a tener muchos datos 00:24:40
pues esta ya 00:24:41
empieza a ser más 00:24:43
eficiente 00:24:45
pero las dos valen para lo mismo 00:24:46
para guardar datos con posición 00:24:53
y las dos ofrecen los mismos métodos 00:24:54
con matices 00:24:58
este ofrece algunos más porque este te permite 00:24:59
simular una pila y una cola 00:25:01
pero eso ya lo dejamos para después 00:25:03
pero te ofrecen lo mismo 00:25:05
las mismas posibilidades, que es insertar 00:25:07
uno nuevo con el add, recuperar 00:25:09
con el get, borrar con el 00:25:11
remove, te permiten lo mismo 00:25:13
¿vale? pero están construidas por dentro de forma 00:25:14
distinta y eso hace que 00:25:17
su funcionamiento sea distinto 00:25:19
¿entendido? 00:25:21
pues 00:25:28
dicho esto 00:25:29
si tuvierais que hacer mi linked list 00:25:31
no la chula, mi linked list 00:25:42
sin chula, genérica 00:25:45
desde ya, ahorrémonos tiempo 00:25:56
genérica para que sea cualquier tipo de dato 00:25:58
vale, pues como la programaríamos 00:26:01
como programaríamos la lista enlazada 00:26:06
es la única colección 00:26:08
que vamos a programar 00:26:10
no va en los conjuntos y esos 00:26:12
ya no, son demasiado complejos 00:26:14
pero esto es una lista enlazada que junto con un árbol 00:26:15
binario son las estructuras básicas para 00:26:18
cualquier informático 00:26:20
o cualquiera que quiera ser programador 00:26:22
vale, pues si yo quiero programar este concepto que he hecho aquí 00:26:23
esta sería 00:26:26
mi referencia que tiene 00:26:27
pues el inicio, ¿vale? 00:26:29
Sí, yo creo que es que roza con esto 00:26:33
cuando se mueve. 00:26:35
Vale, pues entonces 00:26:37
¿esto me apunta 00:26:41
directamente a un objeto 00:26:44
de tipo T? 00:26:45
No. 00:26:48
Esto me apunta a un objeto 00:26:49
que lo envuelve un poquito 00:26:51
más complejo, porque 00:26:53
además de las propiedades de T 00:26:55
tiene que tener 00:26:57
la dirección del 00:26:59
siguiente. 00:27:01
y este ya 00:27:03
me apuntará 00:27:13
a otro objeto que no es 00:27:15
directamente un objeto de tipo T 00:27:17
porque además tendrá 00:27:19
una propiedad 00:27:23
siguiente 00:27:25
luego para programar esto 00:27:26
me aparece aquí 00:27:29
adiós 00:27:31
cuando los funcionarios se nos calbolen 00:27:34
es que los tenemos aquí 00:27:40
me aparece 00:27:40
esa clase 00:27:44
que esta clase 00:27:44
es una clase, podemos llamarla 00:27:47
nodo, ¿vale? 00:27:49
que tendrá dentro dos cosas 00:27:53
el objeto de tipo T 00:27:55
y un objeto 00:27:57
siguiente que a donde te apunta 00:27:59
a su vez a un nodo 00:28:01
luego vamos a tener que hacer esta clase 00:28:03
la hacemos ahora, y ahora 00:28:04
mi lista, mi objeto 00:28:07
lista, el objeto que yo voy a instanciar 00:28:09
para meter los elementos 00:28:11
en la lista enlazada, ¿por qué se va a 00:28:13
caracterizar. Se va a caracterizar 00:28:15
exclusivamente por la dirección 00:28:17
de un 00:28:19
objeto de tipo T, de un nodo. 00:28:21
Este nodo 00:28:24
como también va a depender de T, porque esto 00:28:25
es T, también va a ser un nodo genérico. 00:28:27
Entonces, mi lista enlazada 00:28:29
se va a caracterizar 00:28:31
exclusivamente por esto. 00:28:34
Por la dirección del primer nodo. 00:28:40
Ya está. 00:28:43
Por eso se va a caracterizar 00:28:45
mi lista enlazada. Por la dirección 00:28:46
del primero, recordad que esto es un objeto 00:28:49
de nodo T, no necesita nada más 00:28:50
para caracterizarse mi lista 00:28:52
mi lista va a ser la dirección del primero 00:28:54
ya está 00:28:57
bueno, dirección de objeto es que es lo mismo 00:28:58
o sea, es el primero 00:29:01
el objeto, cuando a lo que llamamos 00:29:02
objeto, es a su dirección en memoria 00:29:05
vale, lo que pasa es que 00:29:06
aquí nos falta 00:29:09
nos falta declarar 00:29:09
esta clase 00:29:13
nos falta 00:29:13
bueno, pues no pasa nada 00:29:15
¿cómo será la clase 00:29:17
nodo T? 00:29:23
clase nodo 00:29:27
será genérica 00:29:29
su primera propiedad 00:29:29
será de tipo T 00:29:35
es el dato en sí 00:29:36
esta será su primera propiedad 00:29:37
porque recordad que cada nodo de la lista 00:29:43
tiene el dato de tipo T 00:29:47
y la dirección del siguiente 00:29:49
la dirección del siguiente 00:29:50
es un objeto de tipo nodo 00:29:53
T, porque el siguiente es otro nodo. 00:29:55
Pues estas son las dos clases 00:30:02
involucradas 00:30:03
en la lista enlazada, estas dos. 00:30:04
La clase que te dice 00:30:08
lo que hay en cada nodo, 00:30:10
que es el propio dato, 00:30:12
el propio dato y el objeto siguiente, 00:30:13
el objeto siguiente, 00:30:16
el propio dato y el objeto siguiente, 00:30:18
que es este, 00:30:20
la lista en sí, que la lista en sí 00:30:23
es el primer elemento, 00:30:26
o la dirección del primero. 00:30:28
Recordad que un objeto y su dirección es lo mismo. 00:30:30
O sea, un objeto, en realidad, 00:30:36
cuando escribimos el nombre de un objeto en Java, 00:30:37
estamos escribiendo, en realidad, 00:30:41
su dirección de memoria. 00:30:46
Entonces, Java, cuando ve el nombre de un objeto escrito 00:30:48
y entra dentro, sabe que lo que hay ahí es la dirección 00:30:50
y a través de la dirección, pues llega ya el objeto. 00:30:53
vale, bueno pues esta es 00:30:55
la dirección del primer nodo 00:30:58
y ahora ya 00:31:00
cada nodo tiene el propio 00:31:02
dato y la dirección del 00:31:04
siguiente, vale, el propio objeto 00:31:06
siguiente, son las únicas 00:31:08
clases involucradas 00:31:10
y ahora aquí 00:31:11
habrá que hacer los métodos 00:31:15
correspondientes 00:31:18
public void 00:31:19
add del dato 00:31:24
t, claro aquí 00:31:28
¿Y qué pasa? Que aquí el problema 00:31:31
ya no es tan sencillo. Añadir 00:31:33
a la lista, ahora 00:31:35
ya implica mover 00:31:37
los enlaces y hacer las cosas 00:31:39
que hagan falta, ¿vale? 00:31:41
Esto no es 00:31:48
como lo del array. 00:31:48
Entonces, vamos a hacer el de añadir, por ejemplo. 00:31:50
¿Cómo lo podríamos hacer? 00:31:52
El de, ¿vale? El método de añadir 00:31:54
a la lista. Vamos a hacer 00:31:56
ese, más o menos para intuir la idea, 00:31:58
pero tampoco vamos a hacerlos todos 00:32:00
para no 00:32:02
nos volváis demasiado locos 00:32:03
vale, pues como haríamos el método de añadir 00:32:05
voy a borrar aquí para hacer un poco de hueco 00:32:08
vale, método de añadir 00:32:10
a ver 00:32:18
pensad que nuestra lista 00:32:19
es esta, tenemos inicio 00:32:22
inicio 00:32:24
que es este, que me lleva 00:32:32
el primero que tiene T 00:32:36
el dato de tipo T 00:32:38
siguiente 00:32:40
que me lleva este 00:32:41
y este 00:32:44
imaginaos que me lleva a luz 00:32:46
es private y todo, ¿no? 00:32:48
sí, lo que pasa es que bueno 00:32:50
lo estoy, vamos, por no hacer 00:32:51
la línea muy larga, estoy quitando el 00:32:54
modificador y, ¿vale? 00:32:56
entonces hay una forma muy fácil de añadir 00:32:58
si cada vez que añadamos 00:33:00
en lugar de añadir por la cola 00:33:02
colamos aquí al principio 00:33:03
ahí el método add se hace muy sencillo 00:33:06
en lugar de dar la mano al último 00:33:08
nos colamos en el primero 00:33:10
hay una forma muy sencilla de hacer ese método 00:33:12
que sería, este es el nuevo, que tengo que añadir 00:33:14
el nuevo, con su siguiente 00:33:17
que inicialmente no apuntará a nada 00:33:20
inicialmente esto será un no 00:33:22
vale, pues hay una forma muy sencilla 00:33:23
de colarlo 00:33:26
al principio, que es 00:33:27
a este elemento 00:33:30
punto siguiente, a su propiedad 00:33:32
siguiente, a este nodo 00:33:34
punto siguiente 00:33:36
vamos a asignarle lo que tenga inicio 00:33:38
Sería la primera sentencia, ¿vale? Que sería este. T dato. Primero, ¿qué nos haríamos? Nos haríamos un nodo T, ¿vale? Aquí le vamos a meter un nuevo dato. Primero construimos un nodo con él. 00:33:40
nodo T, nodo 00:33:56
ahora lo escribimos ahí que se va a ver mejor 00:34:00
igual 00:34:02
nos hacemos un nuevo 00:34:03
nodo T 00:34:06
¿vale? 00:34:07
pasándole el dato que fuera 00:34:10
¿vale? es decir 00:34:12
aunque lo escriba faltándome cosas 00:34:16
lo que importa es la idea, ahí me pasan 00:34:17
un dato, me pasan esto 00:34:20
me pasan esto 00:34:21
primero que hace el método 00:34:23
construye con él un nodo 00:34:25
es decir, hace un nodo 00:34:27
donde pone aquí el dato 00:34:30
y aquí lo pone a nudo 00:34:31
es lo primero que hace, se construye un nodo nuevo 00:34:33
para colar en la lista 00:34:36
se construye un nodo nuevo, vale, ya he metido 00:34:37
el dato ahí, vale 00:34:40
ahora que hacemos 00:34:42
a inicio 00:34:43
perdón 00:34:46
que el siguiente 00:34:47
nodo de este sea el que tenga 00:34:50
inicio, luego 00:34:52
si es 00:34:56
podríamos hacer 00:34:58
nodo punto siguiente 00:34:59
igual a inicio 00:35:04
¿qué estaríamos 00:35:05
consiguiendo con nodo punto siguiente 00:35:08
igual a inicio? pues estaríamos consiguiendo hacer este enlace 00:35:09
ese enlace ya lo tendríamos 00:35:12
este es nodo 00:35:15
el que acabamos de hacer 00:35:17
pues al hacer nodo punto siguiente 00:35:18
igual a inicio 00:35:21
este deja de apuntar a null y empieza a apuntar 00:35:23
donde apunta inicio, ese enlace ya está 00:35:26
¿y qué nos falta? 00:35:28
Pues hacer inicio 00:35:29
Igual a nodo 00:35:32
Al hacer inicio igual a nodo 00:35:33
Inicio deja de apuntar a este 00:35:37
Y pasa a apuntar a este de aquí 00:35:39
Luego con 00:35:42
Dos sentencias 00:35:46
Hemos metido este dato 00:35:48
En la lista enlazada 00:35:51
¿Vale? 00:35:53
Hemos metido el dato en la lista enlazada 00:35:55
Mucho más fácil que en un array 00:35:57
Este es el código para meter en la lista enlazada 00:35:59
mucho más sencillo que el array 00:36:03
lo único que le hemos colado al principio 00:36:04
porque para ponerlo al final no es tan fácil 00:36:09
hay que ir avanzando 00:36:11
pero colarlo al principio 00:36:12
este es el método que el linked list original 00:36:14
lo llama, no lo llama 00:36:19
lo llama add first 00:36:21
que es añade al principio 00:36:23
porque el add normal 00:36:25
lo usa para añadir al final 00:36:27
que habría que hacerlo de otra manera, claro 00:36:29
pero añadir al principio es tan sencillo 00:36:31
como esto, entonces es un buen ejemplo 00:36:33
para ver que insertar 00:36:35
en una lista enlazada es mucho más fácil 00:36:37
que insertar en un array 00:36:39
no es sencillo 00:36:40
la idea de lista enlazada 00:37:00
no es sencilla tampoco, porque es meter un objeto 00:37:03
en un nodo, ese nodo 00:37:05
añade la dirección del siguiente objeto 00:37:07
de la lista y todo eso 00:37:09
está oculto 00:37:10
el que usa mi linked list 00:37:12
instancia un objeto, mi linked list para un tipo 00:37:14
y luego llama add, llama lo que sea 00:37:17
y el que lo usa ni ve nodo ni ve nada 00:37:19
Más o menos procesado 00:37:21
Es que yo lo que no entiendo 00:37:25
O sea, tú en el nodo 00:37:28
O sea, cuando haces el new node 00:37:29
Sí, me creo un objeto 00:37:31
Nodo nuevo donde meto el dato 00:37:33
Vale, metes el dato 00:37:35
Y a la dirección siguiente la pongo a null por ahora 00:37:36
Luego ya se la cambio 00:37:39
Para que apunte aquí 00:37:41
Y luego ya inicio 00:37:43
La hago llevar aquí arriba 00:37:46
Pero es que el siguiente 00:37:47
Está apuntando al inicio, no está apuntando a la nueva 00:37:49
O sea, primero es nudo 00:37:51
Pero luego le pones que apunte inicio 00:37:53
No, no le pongo que apunte inicio 00:37:55
Le pongo que apunte a donde apunta inicio 00:37:57
Esta sentencia 00:37:59
Significa 00:38:01
Que nodo siguiente 00:38:03
Apunte a donde apunta inicio 00:38:05
E inicio donde apunta 00:38:08
Aquí 00:38:10
No, pero 00:38:10
Tú en la clase nodo 00:38:11
Tienes dos atributos 00:38:14
Sí, el dato 00:38:16
Y la dirección del siguiente 00:38:18
o el objeto siguiente 00:38:20
pero claro, ahí tú 00:38:22
entonces el siguiente 00:38:24
o sea, en el nodo nuevo que has creado 00:38:26
le estás diciendo 00:38:29
que su atributo siguiente sea inicio 00:38:30
claro, e inicio es 00:38:33
esto 00:38:35
inicio es a quien apunto yo 00:38:35
claro, inicio es 00:38:39
e inicio apunta aquí 00:38:41
entonces si yo digo que 00:38:42
nodo siguiente igual a inicio, estoy diciendo que 00:38:44
nodo siguiente igual a esta misma flecha 00:38:46
le estoy diciendo, oye, tu flecha 00:38:49
que sea esta flecha 00:38:51
y ahora la flecha inicio 00:38:52
que deje de ser esta, para ahora ser 00:38:57
la flecha 00:38:59
que te lleva 00:39:01
el objeto nuevo 00:39:02
vale, pero no es fácil 00:39:04
entender un poco lo de la 00:39:07
referencia, o sea, la dirección de objeto 00:39:09
objeto 00:39:11
pero bueno, sí que deberíais dedicar 00:39:11
tiempo a pensarlo un poco para tener claves 00:39:15
porque muchos de los errores 00:39:17
de ejecución que salen 00:39:18
es porque uno a veces no tiene 00:39:20
simplemente la idea 00:39:22
de que es realmente un objeto 00:39:24
¿vale? 00:39:26
entonces tenéis que entender muy bien 00:39:29
las bases de todo, porque 00:39:30
programar no es hago código y llamo a métodos 00:39:31
no, es tratar de hacer aplicaciones 00:39:34
que funcionen 00:39:36
y para que las aplicaciones hagan lo que tienen que hacer 00:39:37
hay que entender la esencia 00:39:40
de lo que 00:39:42
programa, ¿vale? 00:39:43
si escribir líneas de código es fácil 00:39:45
que hagan exactamente lo que realmente 00:39:47
se espera que hagan, ya no es tan fácil 00:39:50
¿Quieres aprender otra cosa? 00:39:51
Lo voy a poner 00:39:55
Bueno, más o menos 00:39:56
¿Qué significa? 00:39:58
Si queremos hacer otro node 00:40:03
Sí, otro objeto 00:40:05
O sea, otro add, llamar a add otra vez 00:40:09
Sí, llamar a add otra vez 00:40:12
Pues se colaría aquí 00:40:13
se llama otro add, pues ese otro add 00:40:15
empezaría a apuntar a donde apuntaba 00:40:18
inicio y lo apunta a este 00:40:20
inicio empezaría a apuntar a este nuevo 00:40:22
cada vez que yo haga 00:40:25
un add, se cuela delante 00:40:28
del que había 00:40:29
pensaba que 00:40:30
iba al último 00:40:33
no, no, no, claro 00:40:34
podríamos hacer el método add last 00:40:37
añadir al final, pero este no es tan fácil 00:40:40
pero hay que ir avanzando, entonces la operación de avance 00:40:41
la vamos a ver ahora con el get 00:40:43
porque nos faltaría un recuperar 00:40:44
entonces, a ver 00:40:46
vamos a, si lo programamos 00:41:03
aquí igual se ve un poco mejor 00:41:05
ahora ya, escrito bien en código 00:41:07
vale, me voy a hacer otro paquete 00:41:09
que se llame ahora 00:41:15
linked list para 00:41:17
las clases relacionadas con esto 00:41:18
linked list, vale 00:41:21
primero vamos a hacernos la clase nodo 00:41:27
la clase nodo es la que tiene el dato 00:41:30
junto con la dirección del siguiente 00:41:35
la clase nodo es la que envuelve al dato 00:41:38
entonces la clase nodo tiene 00:41:40
el dato 00:41:42
que será genérico 00:41:44
de un tipo el que sea 00:41:45
luego la clase nodo depende de t 00:41:48
y aquí está el dato 00:41:50
pero el objeto nodo 00:41:53
el objeto que pertenece a esa clase 00:41:55
el nodo, también tiene que tener 00:41:57
la dirección del siguiente 00:42:00
elemento. Y el siguiente 00:42:02
elemento es un nodo a su vez. 00:42:04
Llamémosle siguiente, por ejemplo. 00:42:12
Vale. Vamos a hacernos un constructor 00:42:16
que nos va a ir muy bien. Construir un nodo 00:42:18
con un dato en particular, poniendo 00:42:20
la dirección del siguiente a nulo. 00:42:22
Vamos a hacernos un constructor 00:42:24
para el nodo. 00:42:26
Como al constructor solo le va a llamar 00:42:32
mi linked list, esto ni lo ve el main 00:42:34
ni lo ve nada, no lo voy a hacer public 00:42:36
el constructor 00:42:38
nodo 00:42:39
a ver, t dato 00:42:42
this.dato 00:42:46
igual a 00:42:52
dato 00:42:53
y siguiente 00:42:54
igual a nulo 00:42:57
vale, este constructor pues me va a ser útil 00:42:58
me crea un nodo 00:43:01
por ahora que tiene el dato dentro pero 00:43:03
no está enlazado con nadie 00:43:05
enlazarlo ya será un problema 00:43:06
de la linked list 00:43:09
Sí, ya sería null, pero bueno, para que quede 00:43:11
más claro. Cualquier objeto 00:43:15
si no lo inicializamos específicamente 00:43:17
se queda inicializado como null. 00:43:19
¿Vale? Entonces 00:43:21
no le voy a poner ni get ni set 00:43:23
voy a quitarle los 00:43:27
private, porque esta clase 00:43:29
va a ir asociada a la otra 00:43:31
y quiero que se comuniquen fácilmente entre sí 00:43:33
esto no es para 00:43:35
ser accedida desde la main 00:43:37
ni nada de eso, esto no es una entidad 00:43:39
es una clase operativa de trabajo 00:43:41
entonces vamos a dejar el nodo así 00:43:43
vale, ahora nos vamos a hacer 00:43:44
ahora ya sí la lista enlazada 00:43:47
mi linked list 00:43:49
la lista enlazada 00:43:58
esta 00:44:01
solo necesita, solo se caracteriza 00:44:02
por la dirección del primer elemento 00:44:06
que será de nodo T 00:44:10
luego al depender 00:44:12
de T 00:44:16
la estoy haciendo dependiente de t por aquí 00:44:16
pues entonces va a ser genérica ya también 00:44:20
también va a ser genérica 00:44:21
vale 00:44:23
y ahora 00:44:25
vamos a hacerle el método 00:44:34
al que yo le paso un dato 00:44:36
de tipo t, vale 00:44:45
pues cada vez que queramos añadir algo 00:44:50
at first a la lista 00:44:52
que yo instancie 00:44:54
¿qué habrá que hacer? pues 00:44:55
se crea un nodo 00:44:58
con ese dato 00:44:59
¿vale? 00:45:09
creo un nodo con ese dato 00:45:14
por ahora está desenlazado 00:45:15
el nodo con ese dato 00:45:18
está desenlazado 00:45:20
¿vale? 00:45:21
así 00:45:25
de nodo T, puedo poner aquí la T o no 00:45:25
esto es como lo que hemos visto antes 00:45:32
creo un nodo 00:45:33
con ese dato 00:45:35
¿vale? 00:45:37
ahora, ¿qué es lo que hacemos? 00:45:38
el siguiente 00:45:41
de ese nodo que sea 00:45:42
el primero de la lista 00:45:44
es decir, a donde apunte inicio 00:45:46
el primero de la lista 00:45:49
y ahora una vez que el siguiente de ese nodo 00:45:50
es el primero de la lista 00:45:55
ahora que el primero de la lista 00:45:56
pase a ser este nodo 00:45:58
que yo he hecho 00:46:01
y ya está, se acabó el método 00:46:01
se acabó el método 00:46:03
vamos a hacer un main para ver al menos 00:46:10
que no salen errores, aunque no vamos a poder todavía 00:46:13
comprobar si lo ha metido porque no tenemos un get 00:46:15
pero vamos a ver por lo menos 00:46:18
si no nos saltan errores 00:46:22
¿Cómo lo usaríamos esto ahora en nuestro main? 00:46:23
Pues yo me quiero hacer una lista enlazada 00:46:30
Para meter, pues yo que sé 00:46:32
Cadenas, venga 00:46:33
Pues me hago mi lista enlazada 00:46:35
Quiero meter cadenas 00:46:39
Pues que sea de stream 00:46:41
Ahí la tengo 00:46:42
Mi lista enlazada 00:46:55
Tal y cual la he creado 00:46:56
Ahora mismo 00:47:00
Se ha creado una, mi linked list 00:47:02
Con inicio apuntando a null 00:47:04
La lista está vacía 00:47:06
Inicio, apunta, anul 00:47:08
Lista muy vacía 00:47:09
Vamos a hacer un par de add 00:47:10
Comprobar que no da errores 00:47:12
Y nos vamos 00:47:12
Vale, vamos a usarla 00:47:13
Cadenas.addFirst 00:47:15
Hola 00:47:18
Cadenas.addFirst 00:47:19
Adiós 00:47:24
Ahora mismo 00:47:27
No puedo hacer más con la lista 00:47:30
Solo puedo meter 00:47:32
No puedo comprobar con get 00:47:33
No puedo borrar 00:47:35
Porque no lo he hecho 00:47:36
Porque no lo he hecho 00:47:37
Solamente puedo hacer esto 00:47:38
es decir, no podemos comprobar si lo ha metido 00:47:40
realmente, pero no tenemos un get, pero al menos vamos a ver 00:47:43
si nos da errores, excepciones 00:47:45
de ejecución, porque algo ya hayamos programado mal 00:47:47
o no, vale 00:47:49
no da errores, con lo cual tiene toda la pinta 00:47:56
de que, a ver, programado, está bien 00:47:59
programado, pero 00:48:01
necesitaríamos tener un método get 00:48:02
para comprobar, a ver si 00:48:05
lo ha metido, necesitaríamos tener esto 00:48:07
desde igual a cero, mientras si 00:48:09
sea menor que 00:48:11
cadenas.size 00:48:12
Estos dos métodos los necesitaría 00:48:15
Como poco 00:48:16
Cadenas.size 00:48:17
Incrementando y más más 00:48:20
Pues iso 00:48:23
Cadenas.get 00:48:26
De i 00:48:29
Es decir, jolín 00:48:31
Quiero un size en mi linked list 00:48:33
Y quiero un get 00:48:36
¿Vale? 00:48:37
Bueno, pues el que se anime 00:48:40
Que haga el size 00:48:42
y el get 00:48:44
aquí en esta clase 00:48:45
si no lloraremos mañana 00:48:46
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
2 de febrero de 2026 - 19:17
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
48′ 50″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
2.25

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid