Saltar navegación

20250128 Colecciones_2 - 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 29 de enero de 2025 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

Yo, siéntate 00:00:00
Y tú también 00:00:06
Venga, sí, como todo el mundo 00:00:07
A ver 00:00:09
Cristian 00:00:12
Calla 00:00:13
Porque eres el que estás hablando 00:00:14
Y tú estás paseando 00:00:17
A los de los izquierdos 00:00:19
Ana 00:00:21
Bueno, pues entonces 00:00:22
Lo que hemos hecho 00:00:27
Está claro, ¿no? 00:00:30
hemos hecho una clase 00:00:31
claro 00:00:33
pero ya, pero la idea 00:00:35
es hacer una clase que lo enmascare 00:00:37
ya no me refiero tanto al código de los métodos 00:00:40
sino la filosofía es 00:00:44
hacer una clase que enmascara 00:00:45
eso en unos métodos 00:00:48
y entonces, para nosotros ahora 00:00:49
esas cajitas en las que meter datos 00:00:51
ya no van a ser arrays 00:00:53
esas cajitas van a ser objetos 00:00:55
de esas clases 00:00:57
Y cada objeto será una caja para meter datos y a través de los métodos que ese objeto me ofrece, yo ya meto, saco, lo que sea. 00:00:58
E internamente, esa referencia, ese objeto internamente ya tendrá unas propiedades para tener ahí todos los objetos dentro que hagan falta. 00:01:07
Pero están todos bajo una única referencia, la del objeto. 00:01:15
Y a través de los métodos, pues yo ya decido si añado, borro, lo que sea. 00:01:19
Esa es la idea de las colecciones. 00:01:23
enmascarar 00:01:25
todo un volumen de datos 00:01:26
enmascararlo en una única referencia 00:01:29
yo instancio ese objeto y a través de los métodos 00:01:31
accedo a esos datos 00:01:34
para insertar, borrar, etc. 00:01:35
¿Vale? 00:01:37
Pablo, para una vez que vienes, cállate 00:01:39
No, digo yo 00:01:41
Hablar, pues sí 00:01:42
Bueno 00:01:45
Vale 00:01:47
Entonces 00:01:49
Esta lista que hemos hecho 00:01:50
cumple todo lo 00:01:52
todos los requisitos de una lista 00:01:54
que es, yo puedo meter 00:01:56
aparentemente es dinámico 00:01:58
yo hago add y remove 00:02:01
y me da la sensación de que se estira 00:02:03
y se encoge y es dinámico aparentemente 00:02:04
¿vale? y además 00:02:07
existe una posición, la del array 00:02:08
está claro, y de hecho mi get puede ser 00:02:11
por posición, porque cada elemento 00:02:13
tiene una posición 00:02:14
bueno, entonces vale, con esta nos valdría y uno podría tirar 00:02:15
y ya está, y ya no habría por qué inventarse 00:02:19
más colecciones en la vida, y esta colección 00:02:20
existe y en lugar de llamarse miArrayList 00:02:23
se llama ArrayList. 00:02:24
Salvo el salto de que es genérica 00:02:27
que eso lo incorporaremos. Es decir, 00:02:28
que la que hemos hecho nosotros solo vale para stream. 00:02:30
Entonces tendríamos que ser capaces 00:02:33
de hacer una que va a ir a para cualquier cosa. 00:02:34
Eso no es tan sencillo 00:02:37
pero ya veremos cómo hacerlo. Pero bueno, 00:02:39
con ese ArrayList que 00:02:41
equivale a nuestro 00:02:42
miArrayList uno ya podría, venga, tiramos para adelante. 00:02:44
Pero es que 00:02:47
fijaos en los métodos. 00:02:48
Cada vez que hemos hecho un app 00:02:51
madre de Dios, crear un array nuevo 00:02:53
copiar uno en otro 00:02:55
una jodienda, cada vez que hemos 00:02:56
borrado un elemento, hacemos un 00:02:59
array nuevo, copiamos uno en otro 00:03:01
es decir, cada app 00:03:03
es un montón de código muy costoso 00:03:05
para la máquina virtual 00:03:07
cada remove es un montón de código muy 00:03:09
costoso, cada get no 00:03:11
el get es sencillísimo, recuperas por posición 00:03:13
que es lo bueno que tienen los arrays, el get 00:03:15
facilísimo, pero cada app y cada 00:03:17
remove es algo que 00:03:19
computacionalmente cuesta mucho 00:03:21
luego con esto, bien, podríamos ya 00:03:23
tirar millas 00:03:25
pero si se nos ocurriera 00:03:27
otra manera 00:03:29
de guardar un montón de objetos a mogollón 00:03:30
de tal manera 00:03:34
bajo una única referencia 00:03:36
como esto, que estaba bajo la referencia 00:03:37
del objeto, mi Arraylis 00:03:39
a partir de él, bajo una única referencia 00:03:40
de manera que 00:03:44
insertar nuevos 00:03:45
y sacar no fuera tan costoso 00:03:47
Pues eso sería maravilloso 00:03:50
¿Vale? 00:03:51
Y ese sería el linked list 00:03:53
Eso es lo que os voy a preguntar 00:03:56
El linked list no usa RISE 00:04:01
No usa RISE 00:04:03
Sino que usa la 00:04:05
Imaginación 00:04:07
Pues que le he hecho 00:04:09
La imaginación que le he hecho a un tío 00:04:10
Hace 50 años 00:04:13
Porque el linked list es una 00:04:15
Es una implementación de un concepto informativo que ya existe 00:04:16
que viene lista enlazada 00:04:19
lo único que hay que hacer es traducirlo 00:04:21
entonces 00:04:23
¿qué idea se nos podría ocurrir? 00:04:24
¿qué idea se os ocurriría? 00:04:27
para tener un montón de datos 00:04:29
recogidos bajo una única referencia 00:04:30
y que además 00:04:34
fuera facilísimo 00:04:35
incorporar uno nuevo y eliminar 00:04:36
que era la PRA list 00:04:39
en realidad no tienes la lista 00:04:41
no tienes un array con los datos 00:04:42
tienes un array con las misiones de memoria de los datos 00:04:44
entonces cambias 00:04:46
A ver, lo que tú dices es... 00:04:48
Pero eso es un array. 00:04:53
Un array lo que tú tienes son las direcciones del dato. 00:04:56
Eso es un array, en realidad. 00:04:59
Sí, pero bueno, 00:05:03
lo que hemos hecho antes, que era en string, 00:05:04
también teníamos eso, porque era en string, 00:05:07
entonces ya teníamos eso. En cualquier caso, si es un array, 00:05:08
en cuanto haces uno nuevo, 00:05:12
es que ya necesitas 00:05:13
otro array para esa dirección extra. 00:05:14
Entonces, ni crear ni borrar uno nuevo. 00:05:17
Entonces, esto no utiliza 00:05:19
Arrays ni nada que se le parezca. 00:05:21
Di. 00:05:23
Dime, dime. 00:05:26
Bueno, con variables tienes que hacerlo así. 00:05:31
Pero esas variables, ¿dónde están? ¿En Arrays o cómo? 00:05:32
Un momento, que no oigo. 00:05:37
Pero sueltas, ¿dónde? Porque si están sueltas, 00:05:40
cada una tiene su propia 00:05:43
referencia. Luego, la ventaja 00:05:45
de las colecciones es que yo tengo una única referencia 00:05:47
que es el nombre de la caja, un nombre 00:05:49
único, nombre de la caja, y con ese 00:05:51
nombre digo, mete esto, mete lo otro. 00:05:53
Con lo que tú me dices, yo te he 00:05:56
entendido, y eres un montón de 00:05:57
nombres, uno por variable. 00:05:59
¡Qué chica! 00:06:07
O sea que los nombres de las 00:06:15
variables, compartían una raíz común 00:06:17
y a partir de... 00:06:18
Pero, en cualquier caso 00:06:21
es que tendrías ahí 00:06:23
varias variables, tú dices que la raíz común 00:06:23
fuera como si fuera el nombre de la caja 00:06:26
y tú decís, vale, pero 00:06:28
¿y cuándo? 00:06:30
Pero es que eso es implanteable de programar. 00:06:32
Entonces, cuando tú haces una variable nueva, 00:06:34
construyes su nombre, 00:06:36
es que el nombre lo tienes que poner por código, 00:06:38
no puedes construir el nombre y darse un... 00:06:40
Tú intenta programar eso y te das cuenta 00:06:42
que no puedes programar eso. 00:06:44
Que el nombre de una variable 00:06:47
Tenga la I 00:06:59
¿Qué tienes que hacer? 00:07:01
Que tenga el nombre de otra variable 00:07:13
Pero ese nombre luego no lo puedes usar 00:07:16
Para ver si es real 00:07:18
Esa idea no la puedes 00:07:20
Suplementar en Java 00:07:22
Vale 00:07:24
El tío desde hace 80 años 00:07:26
¿Creó esto con lo que ya sabemos? 00:07:28
¿O nos falta algo por saber? 00:07:30
Por supuestísimo con lo que ya sabéis 00:07:32
Estos son 00:07:34
Por supuestísimo con lo que ya sabéis 00:07:35
Vale, a ver, os doy la primera pista 00:07:38
Es como una serpiente 00:07:40
Va siguiendo 00:07:42
Sí, es como una serpiente 00:07:43
Tiene razón 00:07:46
A ver, es una forma de verlo 00:07:47
Vale, a ver 00:07:51
Primera pista 00:07:53
Primera pista 00:07:55
A ver, yo lo que creo es que 00:07:57
Él ha puesto en internet linked list 00:08:00
Y ha visto eso 00:08:02
Vale 00:08:03
A ver, primera pista 00:08:05
La traducción 00:08:09
Lista, enlazada 00:08:10
enlazada 00:08:13
suena que cada elemento está enlazado 00:08:16
con el otro 00:08:19
bueno, pues a ver 00:08:19
la idea es, que es una idea muy sencilla 00:08:24
de programación 00:08:26
la lista enlazada, que es 00:08:26
yo tengo, mis datos son estos 00:08:29
mi dato 1 00:08:32
mi dato 2 00:08:34
mis cadenas 00:08:36
los que sean 00:08:38
mis datos son estos 00:08:39
tengo que decidir dónde los guardo 00:08:41
ya hemos descartado el array 00:08:44
una opción sería la que hemos dicho 00:08:46
todos al array 00:08:48
esa es la versión 00:08:49
de ArrayList que hemos dicho 00:08:52
no, al array no va 00:08:53
¿cómo los guardo bajo una referencia común? 00:08:55
y que esa referencia le permita hacer el A 00:08:59
¿cómo los guardo? 00:09:00
vale, pues a ver 00:09:02
la referencia común 00:09:03
selecciono que sea 00:09:05
la del primero de todos 00:09:07
la dirección del primero 00:09:10
si estos son objetos, recordad que un objeto 00:09:11
en realidad, en Java 00:09:14
cuando accedemos 00:09:15
a su referencia 00:09:18
a su nombre, sabemos que es la dirección 00:09:20
bueno, pues la referencia común 00:09:21
que sea la dirección del primero 00:09:22
esa es la referencia común 00:09:25
ya la pregunta es 00:09:27
bueno, el nombre que tenga este objeto 00:09:28
si este objeto es alumno 1 00:09:33
pues alumno 1 00:09:35
esa es la referencia común, en principio, es la idea 00:09:36
Vale, y la pregunta sería ya, pero ahora con esta referencia yo puedo acceder a este sin problema, lógicamente, porque es su propia referencia, pero si quiero acceder al tercero, o quiero insertar uno nuevo, o quiero, ¿cómo hago? Vale, pues lo que se incorpora es esta idea muy sencilla, y es, cada objeto se le mete en un objeto un poquito más grande, que se le llama nodo, 00:09:38
que además del dato en sí 00:10:01
tenga la dirección 00:10:04
del siguiente 00:10:06
tenga la referencia 00:10:08
la referencia del siguiente 00:10:10
este se le mete 00:10:13
en una cajita un pelín más grande 00:10:15
que tiene dos partes 00:10:17
el dato en sí, el objeto 00:10:18
y la dirección del siguiente 00:10:21
este se le mete 00:10:24
en otra cajita 00:10:28
llamémosla nodo 00:10:29
que aparte del propio objeto, 00:10:30
tiene la dirección del siguiente. 00:10:35
¿Que este es el último en este caso? 00:10:40
Pues estará en su cajita, 00:10:42
pero esta dirección siguiente, 00:10:44
ahora en particular lo que tendrá es null. 00:10:46
Vale, pues esta es la estructura de lista enlazada. 00:10:50
Una lista enlazada es 00:10:52
un montón de objetos nodos, 00:10:53
que se llaman nodos, ¿vale? 00:10:56
Entonces, cada nodo tiene 00:10:59
el dato en sí, el dato que yo quiero 00:11:00
el alumno 00:11:03
la cadena, lo que sea el dato 00:11:05
pero además de tener este nodo, el dato en sí 00:11:07
tiene otra parte 00:11:09
y esa otra parte es la dirección 00:11:10
la referencia al siguiente 00:11:13
nodo, al siguiente nodo 00:11:15
al completo 00:11:17
no solamente a este objeto, la referencia al siguiente 00:11:18
nodo al completo 00:11:21
vale, este nodo tiene el objeto en sí 00:11:22
que me interesa, alumno, cadena, lo que sea 00:11:25
y además tiene 00:11:27
esta otra propiedad que es la referencia 00:11:29
del siguiente nodo 00:11:31
cuando borras uno se sustituye la del anterior 00:11:33
justo, exacto 00:11:35
claro, entonces 00:11:37
la estructura es esta, con lo cual la primera parte 00:11:38
que es tener un montón 00:11:41
de datos recogidos 00:11:43
bajo una referencia común 00:11:45
ya está 00:11:46
¿por qué? porque si yo quiero recuperar 00:11:48
este, por ejemplo, quiero consultar 00:11:51
el de posición 3, como antes 00:11:53
pues yo me cojo 00:11:55
mi referencia común y voy avanzando 00:11:57
me quedo con la segunda parte 00:11:59
de esta 00:12:02
y ahora de esta me quedo a su vez 00:12:04
con su segunda parte 00:12:06
y ahora de esta me quedo a su vez con su segunda parte 00:12:07
y ya estoy 00:12:10
pero no puedes añadir en una posición 00:12:11
tendrías que hacer 00:12:13
eso es lo más sencillo 00:12:15
de hacer con la lista precisamente por eso inventaron 00:12:18
para añadir 00:12:20
añadir al fondo me parece bien 00:12:21
claro pero 00:12:24
añadir en una posición intermedia 00:12:26
entonces tú ahora quieres insertar 00:12:28
aquí un dato, en la posición 3 00:12:33
vale, pues 00:12:35
hay que construir la cajita nodo 00:12:36
y le metes el dato 00:12:39
y lo único que hay que hacer es 00:12:40
dos asignaciones 00:12:42
esta asignación es una asignación 00:12:44
sencilla, que se va aquí 00:12:47
y esta asignación 00:12:49
que se va aquí 00:12:51
vale 00:12:52
entonces, insertar en una posición 00:12:55
no es como un array que tienes que hacer uno nuevo 00:12:57
copiar el viejo en el nuevo 00:13:00
sino es, nodo nuevo 00:13:01
este, muy bien, y dos asignaciones 00:13:03
esta dirección 00:13:06
pasa de apuntar aquí a apuntar aquí arriba 00:13:07
y esta de aquí 00:13:10
pasa a apuntar a este, a la que apuntaba el otro 00:13:11
luego con dos asignaciones 00:13:14
tienes el nuevo 00:13:16
nodo metido, entonces por eso si es como 00:13:17
una serpiente, porque estos nodos 00:13:20
están en memoria donde sea, y bueno, cada uno 00:13:22
va enlazando al siguiente, va enlazando y ya está 00:13:24
¿vale? 00:13:26
eliminar en un array 00:13:27
eliminar era muy costoso 00:13:29
porque eliminar era hacer otro array 00:13:30
con una posición menos, copiar todo el viejo en el nuevo 00:13:33
sobre escribir 00:13:35
aquí eliminar es sencillísimo 00:13:37
eliminar es hacer una asignación 00:13:39
que es, por ejemplo 00:13:41
queremos eliminar este 00:13:43
queremos eliminar 00:13:44
este primero, para no emborronar esta zona 00:13:47
este primero, pues se trata de 00:13:49
a esta dirección de aquí 00:13:51
la sobre escribo 00:13:53
con la del siguiente 00:13:55
con lo cual una única asignación 00:13:56
y se acabó, eliminado 00:13:59
eso que va a implicar que este pobre nodo 00:14:00
se ha quedado sin que nadie lo apunte 00:14:03
porque el único que le apuntaba 00:14:05
que era este 00:14:08
ahora está apuntando al siguiente 00:14:09
luego un objeto 00:14:11
que se ha quedado sin que nadie lo apunte 00:14:13
ha perdido toda su referencia 00:14:15
y el recolector de basura lo elimina 00:14:17
casi instantáneamente 00:14:19
en cuanto un objeto se queda sin nadie 00:14:21
que lo apunte 00:14:23
el objeto no es que desaparezca 00:14:24
el proceso recolector de basura 00:14:26
pum 00:14:29
lo libera de memoria 00:14:30
lo hace desaparecer 00:14:33
luego 00:14:34
insertar es muy fácil 00:14:36
hacer dos asignaciones 00:14:39
eliminar es muy fácil 00:14:40
hacer una asignación 00:14:43
sin embargo aquí lo que se hace muy pesado 00:14:44
es consultar 00:14:47
porque en una raíz de inmediato 00:14:49
consultar posición y 00:14:51
te vas a esa posición del Array 00:14:52
inmediato, pero aquí tienes que ir 00:14:54
haciendo pa pa pa pa 00:14:56
entonces 00:14:58
una lista enlazada está 00:14:59
fenomenal en una aplicación en la cual 00:15:02
lo que sobre todo se hace con los datos 00:15:04
es incorporar y borrar 00:15:05
incorporar y borrar, cuando se hacen muchas 00:15:08
incorporaciones y borrados de los datos 00:15:09
esta va a ser muchísimo mejor que un ArrayList 00:15:11
pero cuando se 00:15:14
hacen muchas consultas 00:15:16
un ArrayList va a ser mucho más rápido 00:15:17
aquí consultar 00:15:20
una dirección que está toda por tu lado 00:15:21
claro, claro, entonces 00:15:23
cuando tú tienes a lo mejor una aplicación 00:15:25
en la que vas a tener siempre 00:15:27
27 datos y luego ya 00:15:29
con esos 27 ya no los mueves más 00:15:31
como mucho mueves a uno más 00:15:34
dos más y luego estar consultando, pues harías 00:15:35
una ArrayList, pero 00:15:37
si vas a tener que estar 00:15:39
haciendo todo el rato inserciones y eliminaciones 00:15:41
pues cogerías esta 00:15:44
esencial, sí, esencialmente 00:15:45
esa es la diferencia 00:15:48
desde fuera, uno cuando las usa 00:15:50
las va a usar igual, llamando a 00:15:52
llamando a no se que, pero como sabemos 00:15:53
como se comportan por dentro, pues podemos hacer 00:15:56
seleccionar de forma 00:15:58
seleccionarlas, particularizarlas en la que estén 00:15:59
vale 00:16:02
pues vamos a programar la lista enlazada 00:16:03
que es un pelín más 00:16:06
difícil de entender que la array list 00:16:07
pero tampoco tiene, pues aquí habrá que 00:16:09
programar una clase para 00:16:11
empezar, la clase 00:16:14
nodo, la clase nodo 00:16:15
que tendrá dos partes, el tipo de 00:16:18
dato que sea 00:16:19
y la dirección del siguiente nodo 00:16:20
la clase nodo 00:16:23
y luego ya la clase colección concreta 00:16:24
la clase en mi linked list 00:16:27
que es la que tendrá la dirección del primer nodo 00:16:29
pero la clase nodo 00:16:32
habrá que programarla 00:16:33
y luego habrá que programar 00:16:34
mi clase colección 00:16:37
la que ya ofrece los métodos y lo hace todo 00:16:38
pues venga 00:16:41
vamos a programarla 00:16:42
si pero para usar ese ejemplo 00:16:43
la vamos a programar por primero. 00:16:49
Si no la programamos, ¿cuándo la vamos a usar? 00:16:50
A programar, ¿qué por eso estás aquí? 00:16:53
Vaya, por Dios. 00:17:03
Nodo tiene dos propiedades. 00:17:06
Vale, a ver. 00:17:22
Venga, pues 00:17:25
a ver, la colección 00:17:26
ahora se va a llamar 00:17:30
Mi Linked List. 00:17:32
paciencia 00:17:35
aunque ahora sí 00:17:39
y no os bajéis la sábana 00:17:40
¿algo más? 00:17:42
¿no? 00:17:43
un café 00:17:43
¿no sirve un café? 00:17:43
¿cafés no sirve? 00:17:49
¿quieres un curasal? 00:17:50
un mantequilla 00:17:51
bueno 00:17:51
pues eso luego 00:17:52
venga 00:17:54
mi linked list 00:17:55
finish 00:17:57
esta va a ser mi lista 00:17:58
la que tiene dentro los datos 00:18:01
la equivalente a mi array list que lo que tenía el array 00:18:03
pero mi linked list con que tenga la dirección 00:18:07
del primer nodo es suficiente 00:18:11
la dirección del primer nodo es una referencia 00:18:12
a la clase nodo que tendremos que hacer 00:18:16
vamos a llamarla inicio por ejemplo 00:18:19
inicio lista para que quede más claro 00:18:22
entonces mi linked list lo único que tiene que tener dentro 00:18:24
es la dirección del primer nodo 00:18:28
la que se llama inicio lista 00:18:30
vale 00:18:32
nos falta la clase nodo, claro 00:18:33
pues vamos a hacer la clase 00:18:35
nodo, la clase 00:18:39
nodo es la que tiene dos partes 00:18:47
una la que tiene el dato 00:18:49
vale 00:18:51
vamos a 00:18:52
como las dos van a ir en pack, aquí no tiene 00:18:57
sentido que pongamos private porque esto no es una 00:19:01
entidad de 00:19:03
string 00:19:04
dato 00:19:07
esta propiedad es para el dato en sí 00:19:08
para la cadena y nos falta 00:19:11
otra propiedad que es la 00:19:13
segunda parte de la cajita 00:19:15
que es la dirección del siguiente nodo 00:19:17
vale 00:19:20
luego la clase nodo está 00:19:28
clara ¿no? la clase nodo tiene 00:19:30
una propiedad que es el dato 00:19:31
y otra que es la dirección del siguiente 00:19:33
y la clase 00:19:35
mi linked list tiene 00:19:46
la dirección del primero 00:19:48
en cuanto a representación de la situación 00:19:50
ya está 00:19:53
a lo que hay es que hacer los métodos para que esto se 00:19:53
comporte como hemos dicho 00:19:56
vale, pues 00:19:57
vamos a hacer 00:20:02
el método insertar 00:20:05
añadir, vamos 00:20:06
añadir un dato 00:20:08
un string, porque estamos trabajando con 00:20:10
string, vale, a ver 00:20:12
no vamos a complicarnos 00:20:18
mucho la vida, vale 00:20:19
porque lo único que quiero es que se 00:20:22
refleje la idea de cómo funciona 00:20:24
esto 00:20:26
y luego ya vamos a usar linked list, lógicamente 00:20:26
vale, pues para 00:20:30
añadir el dato 00:20:32
Vamos a pensar un momento 00:20:33
Clase de pain 00:20:35
Clase de pain 00:20:39
Que me vendría muy bien 00:20:41
Una clase de pain 00:20:42
O un ordenador 00:20:43
Eso sí que me vendría 00:20:45
Vale, pero ya tengo wifi 00:20:48
Ya, hombre 00:20:50
Claro 00:20:52
Después de 8 años que llevo aquí 00:20:54
Venga 00:20:57
Pues a ver 00:20:59
Por eso por la wifi del instituto 00:21:00
No sé si había una que nunca llegó 00:21:02
A mí nunca me llegó a funcionar 00:21:07
A ver, formas aquí 00:21:08
No, no, a ver, le funciona igual que los demás 00:21:12
Él no nos ocultaba la password 00:21:18
Lo que pasa es que no 00:21:21
La password la sabíamos, pero 00:21:22
Tirar de ella era tontería 00:21:23
Vale, pues a ver 00:21:26
Esta es 00:21:29
este sería 00:21:31
el primer nodo, el inicio 00:21:34
famoso 00:21:37
que inicialmente 00:21:37
está apuntando a nul, ¿verdad? 00:21:40
¿Vale? 00:21:49
Este sería 00:21:51
inicialmente cuando la lista arranca 00:21:52
y yo la instancie, 00:21:54
cuando la instanciemos, inicio lista será nul 00:21:56
porque está sin inicializar. 00:21:58
Será nul, ¿vale? 00:21:59
Entonces, 00:22:01
cuando vamos a suponer 00:22:02
vamos a hacer un añadir asumiendo 00:22:05
que la lista ya tiene cosas 00:22:07
para que sea más fácil 00:22:09
no contemplamos el caso inicial que luego 00:22:10
vale, entonces 00:22:13
vamos a suponer que la lista ya tiene cosas 00:22:15
vamos a hacer el add asumiendo que tiene cosas 00:22:16
entonces 00:22:18
la lista 00:22:20
tiene aquí 00:22:23
el dato 00:22:23
y la dirección del siguiente 00:22:26
y hacemos 00:22:32
solo uno más 00:22:38
y este nodo que tiene 00:22:39
que tiene el dato 00:22:43
y la dirección del siguiente 00:22:50
y este ya 00:22:54
este ya me lleva a nul 00:22:56
vamos a poner una situación de la lista 00:23:00
en la que estoy así 00:23:03
vale, y este nul 00:23:06
como si no existiera 00:23:12
vale, a ver, relax 00:23:13
chicas, por favor 00:23:28
vale 00:23:29
reírse, ¿te parece poco? 00:23:31
ya, pero es que 00:23:39
lo tuyo es fuera de categoría 00:23:40
por eso te vamos a llevar 00:23:42
a un sitio tan bonito 00:23:44
venga 00:23:45
a ver, ¿no ves que se ha abierto 00:23:48
un perímetro de seguridad alrededor tuyo? 00:23:50
¿se ha abierto un perímetro? 00:23:53
no, ya vi, ya vi 00:23:54
bueno, silencio 00:23:55
vale, vamos a suponer que la situación 00:23:59
de la lista es esta, vale, el método 00:24:00
añadir un dato 00:24:02
que implicará, implicará 00:24:04
varias cosas, mi dato llega por aquí, yo al 00:24:06
método de añadir, me limito a darle 00:24:08
un dato, este dato, un 00:24:10
string, una cadena. Y ahora el 00:24:12
método de añadir tiene que hacer todo lo necesario 00:24:14
para coger este dato, 00:24:17
meterlo en un nodo, insertarlo en la lista, 00:24:18
etcétera. Vale, pues 00:24:21
entonces, lo primero que tendría que hacer el método, 00:24:22
crear un 00:24:25
objeto nodo y 00:24:26
meter el dato en el objeto nodo. 00:24:28
Eso es lo primero que tiene que hacer el método add. 00:24:31
Vale, pues vamos a hacerlo. 00:24:32
Lo primero que tiene que hacer el método add 00:24:34
No, pero si tú no viajas 00:24:36
Si tú has hecho un new dato 00:24:48
Ahí está, para el infinito 00:24:49
Vale, tenemos un nuevo nodo 00:24:51
Vale 00:24:53
Este nodo, su dato 00:24:55
Que sea 00:24:58
El dato que me han dado 00:25:01
O sea, el dato que me han dado 00:25:03
se va a la propiedad 00:25:06
dato de este nodo 00:25:08
que he creado. 00:25:10
Eso es lo primero que tendremos que hace el método A 00:25:12
de este de aquí. Lo primero. 00:25:14
¿Verdad? 00:25:15
Claro. 00:25:18
Pues lo primero que es esta parte. 00:25:20
Crear el objeto nodo, 00:25:23
la cajita grande y meter el 00:25:24
dato ahí dentro. ¿Qué es lo siguiente 00:25:26
que tiene que hacer? Pues la otra 00:25:28
parte del nodo, que ahora mismo está. 00:25:30
Esta parte del nodo 00:25:33
tiene que apañárselas 00:25:35
para que apunte 00:25:36
a donde yo quiera que apunte 00:25:38
vamos a hacer la versión fácil de add 00:25:40
que es añadir al final 00:25:42
la versión fácil de add 00:25:44
que es añadir al final 00:25:48
perdón, no, no, no 00:25:49
la versión fácil de add que es añadir al principio 00:25:51
al final no es nada fácil, es complicada 00:25:53
es añadir al principio, que es insertar aquí 00:25:55
la versión fácil sería 00:25:57
hombre, pues lo tengo muy fácil 00:25:59
a este de aquí 00:26:01
primero 00:26:03
le pongo 00:26:04
lo que tiene la lista en ese 00:26:07
momento. O sea, le asigno 00:26:09
a este, le asigno a esto. 00:26:11
Con lo cual, lo primero que consigo es 00:26:13
esto de aquí. 00:26:15
Lo primero que hacemos es este enlace. 00:26:17
Es decir, 00:26:20
a la dirección de inicio de mi lista, 00:26:20
perdón, a la dirección siguiente del 00:26:23
nodo nuevo, le asigno el inicio 00:26:25
de mi lista. Vamos a hacer este enlace el primero de todos. 00:26:27
Este enlace el primero. 00:26:29
Vale, pues este enlace se 00:26:31
corresponderá hacer esta sentencia, nodo punto siguiente, dirección siguiente, igual a inicio 00:26:33
lista, ¿vale? Ya hemos hecho ese enlace, hemos hecho este, al siguiente del nodo que he hecho 00:26:43
le asigno lo que tenía inicio lista, luego he construido este enlace y ahora ¿qué es lo 00:26:57
Siguiente y último que hacemos, al inicio lista le quito lo que había, se lo quito y le hago que apunte al nuevo, le hago ahora que apunte a este, pataplón, y este se ha quedado insertado en la lista al principio, a inicio, luego lo único que me falta es a inicio lista darle la dirección de este nodo que he creado, es lo único que me falta, 00:27:04
a inicio 00:27:30
lista 00:27:32
asignarle nodo. 00:27:33
¿Vale? Porque nodo es la dirección 00:27:41
del nodo que he creado. 00:27:43
Pues ya está. El método add ya está. 00:27:45
Es el add 00:27:48
al principio. ¿Vale? Lo podríamos 00:27:49
llamar, si queremos ser más... 00:27:51
Añade al principio de la lista. 00:27:53
Añade al primero. 00:27:59
Ya está. 00:28:02
Pues lo hemos metido ahí. 00:28:03
Entonces, luego 00:28:09
uno tendría que comprobar si en los casos 00:28:10
extremos, cuando la lista está vacía, cuando 00:28:11
no funciona. Pero claro que funciona, porque cuando 00:28:13
esta apunta null, ¿qué estaremos haciendo? 00:28:15
A este le damos null, perfecto. 00:28:18
Y a este le damos el nuevo. Luego 00:28:19
para el caso particular, lista vacía, 00:28:21
este addFirst también funciona. 00:28:24
Entonces este addFirst es el más. 00:28:26
¿Vale? 00:28:28
Entonces ya tenemos 00:28:29
y claro, luego a esta colección se le pueden 00:28:31
añadir más métodos. Vamos a 00:28:33
añadirle solo dos más 00:28:37
para poder recorrerla y ver que lo que metamos 00:28:39
esta, vale 00:28:41
vamos a darle 00:28:44
recuperar el elemento de una 00:28:47
posición 00:28:49
tenemos que ir avanzando 00:28:49
en las direcciones 00:28:59
claro 00:29:00
entonces 00:29:02
a mi 00:29:04
linked list le vamos a dar el método get 00:29:07
hasta que ese número sea pos 00:29:09
entonces aquí lo importante 00:29:10
es entender que la sentencia clave 00:29:13
coger 00:29:16
una referencia auxiliar 00:29:18
un nodo auxiliar 00:29:20
un nodito auxiliar que lo podemos poner por aquí 00:29:21
por cualquier lado, o sea una referencia 00:29:24
a nodo auxiliar 00:29:26
¿vale? que inicialmente 00:29:28
que apunte al principio 00:29:34
y la vamos avanzando 00:29:36
con la siguiente 00:29:38
sentencia, vamos a suponer que hacemos 00:29:40
un nodo auxiliar, este de aquí 00:29:42
un nodo auxiliar que apunta al primero 00:29:44
vamos a hacernos un auxiliar 00:29:45
que apunte al principio de la lista 00:29:47
un nodo auxiliar, vale 00:29:52
y ahora, fijaos 00:29:56
que cada vez que hacemos esta sentencia 00:29:58
aux igual a 00:30:00
aux.dir siguiente, que esta es la 00:30:02
clave, la importante 00:30:04
cada vez que hagamos 00:30:05
esta sentencia, ¿qué hacemos con 00:30:08
este nodo auxiliar? de aquí 00:30:10
lo estamos haciendo que 00:30:12
apunte al siguiente nodo 00:30:14
luego este nodo auxiliar inicialmente 00:30:15
apunta al primero 00:30:18
pero cada vez que hagamos 00:30:19
aux igual a aux.dir siguiente 00:30:21
cada vez que hagamos esto 00:30:24
este nodo 00:30:26
se quedará apuntando a uno 00:30:28
posterior y a uno posterior 00:30:30
lo único que tenemos que hacer es un for 00:30:31
que ejecute esa sentencia de avance 00:30:34
tantas veces como posiciones 00:30:36
y ya está 00:30:37
entonces si pos me dan 0 00:30:39
no se ejecutará nunca 00:30:52
luego aux será la del primero, justo 00:30:54
que me dan 1, se ejecutará 00:30:56
una vez, luego aux se quedará 00:30:58
apuntando al primero 00:31:00
al siguiente 00:31:02
¿vale? entonces esta 00:31:04
sentencia avanza el nodo 00:31:06
auxiliar una vez, cada vez que la ejecuto 00:31:08
luego si lo meto en un for 00:31:10
la sentencia de avanzar se va a 00:31:12
hacer pos veces, que es justo lo que quiero 00:31:14
luego cuando este for ha terminado 00:31:16
cuando este for acabó, yo ya 00:31:18
sé que mi auxiliar estará 00:31:20
apuntando al nodo pos que me 00:31:22
interesa, lo único que tengo que hacer 00:31:24
es sacar el dato, porque 00:31:26
el nodo es la caja completa, lo único que me 00:31:28
falta sacar el dato. Una vez que el 00:31:30
nodo auxiliar ya ha ido avanzando, ha ido avanzando 00:31:32
por la lista, ya se ha 00:31:34
quedado ahí, pues ahora ya 00:31:36
return aux.dato 00:31:38
y punto 00:31:40
pelota. Se acabó el get por posición. 00:31:43
Vale. 00:31:54
El size 00:31:56
pues sería hacer un 00:31:57
for que hace esto hasta que 00:31:59
mientras aux sea diferente de null 00:32:01
y contar. Vale. 00:32:02
Vamos a hacer ese y ya hacemos más métodos de la linked list. 00:32:05
el size 00:32:07
public int size 00:32:12
este que tenemos que hacer 00:32:14
pues hacemos de nuevo 00:32:17
un nuevo auxiliar 00:32:19
que apunte al primero 00:32:19
y ahora un contador 00:32:24
porque vamos a contar 00:32:28
cuantos avances hemos hecho 00:32:29
hasta que ha llegado a valer 00:32:32
null ese aux 00:32:34
y ahora ya hacemos un contador 00:32:35
para contar 00:32:37
y ahora podemos hacer 00:32:38
mientras aux 00:32:42
sea diferente 00:32:43
de null 00:32:45
avánzalo 00:32:47
que no atino 00:32:52
vaya diferente que he puesto más original 00:33:04
así mejor 00:33:08
vale 00:33:10
de hecho 00:33:11
si la lista estuviera vacía 00:33:13
inicio lista sería null 00:33:16
no entraría nunca aquí con lo cual me devolvería 0 00:33:17
que es lo que me tiene que devolver 00:33:20
si tuviera solo una posición avanzaría una vez me devolvería 1 00:33:21
y ahora ya 00:33:24
Y bueno, me falta incrementar el contador, lógicamente 00:33:25
Entonces 00:33:28
Aquí voy a tener que poner unas llavecitas 00:33:29
Y ahora 00:33:32
Una vez que mi bucle ha terminado 00:33:38
Pues ya me devuelvo 00:33:40
Vale 00:33:41
Y sería un ejercicio maravilloso, lo vamos a dejar planteado 00:33:46
Que hicierais el remove, no sé qué, no lo vamos a hacer aquí 00:33:49
Vamos a usarlo 00:33:52
En un ejemplo para ver si esta lista enlazada 00:33:54
Efectivamente me permite meter cosas 00:33:55
Y si realmente están dentro 00:33:57
Entonces, como veis 00:34:00
El código es muy sencillo 00:34:08
Esto es mucho más fácil computacionalmente 00:34:09
Que recorrer un array entero 00:34:11
Copiar uno en otro, muchísimo más 00:34:13
Es hacer cuatro asignaciones 00:34:15
Dos, una 00:34:17
El add de aquí 00:34:18
Se ha quedado en nada 00:34:21
Sin embargo, el add del array list 00:34:22
Era un rollo 00:34:24
De arrays para un lado y para otro 00:34:25
El del end lo vas a hacer tú 00:34:27
el remove no lo vamos a hacer 00:34:32
pero 00:34:35
hombre claro que está 00:34:35
pero estaría muy bien 00:34:39
que lo programaréis vosotros 00:34:42
habría que avanzar aux igual a aux siguiente 00:34:44
una vez que habéis llegado pues cambiar las direcciones 00:34:46
para que puenten 00:34:48
este pues 00:34:49
lo hacéis vosotros 00:34:56
que tiene su cosita, sí pero no ahora 00:34:59
porque vamos a probar ahora mismo 00:35:01
que esto que me he hecho está bien 00:35:02
vosotros que sois listos 00:35:04
y espabilados 00:35:07
Vosotros, especie inferior 00:35:09
Vais a hacer esto 00:35:12
Venga, vámonos al main 00:35:13
Venga, el main 00:35:15
Nuestro ArrayList ha funcionado estupendamente 00:35:18
Lo voy a hacer en mi main 00:35:20
Como voy a subir esto, voy a hacerlo aquí en un 00:35:24
Método aparte, prueba 00:35:26
ArrayList, prueba LinkedList 00:35:27
Vale, prueba mi ArrayList 00:35:29
Metemos el código que hemos hecho 00:35:41
Antes 00:35:43
Ahí, vale 00:35:43
y aquí lo dejamos 00:36:03
comentado 00:36:04
para ver que lo habíamos probado y que funcionaba 00:36:06
vale, y ahora vamos a hacernos 00:36:09
la prueba de esta estructura 00:36:14
a ver si la hemos hecho bien 00:36:16
vale 00:36:17
pues vamos a hacer 00:36:33
lo mismo saltándonos el borrar 00:36:35
lo mismo pero con un linked list 00:36:37
entonces el mismo código 00:36:40
código 00:36:42
copia y pega, el mismito 00:36:43
el mismito código 00:36:46
pero ahora en este mismito código 00:36:52
el mismito para que veamos la plasticidad 00:36:55
de las colecciones 00:36:57
el mismo código, lo que pasa es que ahora 00:36:58
en lugar de una estructura, mi ArrayList 00:37:00
he decidido que cambio y que voy a usar 00:37:02
una LinkedList, pero lo demás es igual 00:37:05
bueno, los nombres de los métodos han cambiado 00:37:07
pero tendrás que crearlo 00:37:09
claro, sí, sí 00:37:10
claro 00:37:13
pero es una caja de nombres igual 00:37:14
pero ahora funciona por dentro de otra manera 00:37:17
vale 00:37:19
mi linked list que la 00:37:21
importamos 00:37:23
y ahora 00:37:25
yo en lugar de add 00:37:27
como lo he llamado add first pues bueno lo cambio 00:37:30
add first 00:37:32
mostramos el primero 00:37:32
mostramos el último remove no lo tenemos 00:37:35
implementado así que no lo 00:37:38
va a eliminar voy a quitarlo de hecho 00:37:40
esta parte de código porque no haría 00:37:42
nada y en lugar 00:37:44
de los que quedan voy a poner los que hay 00:37:47
vale pues he cambiado 00:37:49
la cajita, el que usa esto 00:37:53
le da igual como está hecho por dentro 00:37:55
pero simplemente ha usado 00:37:57
una cajita 00:37:59
¿dónde estamos? aquí, mi linked list 00:38:00
porque a él le interesa una cajita, mi linked list 00:38:03
pues usa esta cajita, va metiendo 00:38:05
va recuperando 00:38:07
y ya está 00:38:09
y ha cambiado una caja 00:38:11
por otra 00:38:13
los detalles internos de la implementación 00:38:13
no importan 00:38:17
pues vamos a ver 00:38:19
si esto lo hemos hecho bien o mal 00:38:21
venga, vamos a probar 00:38:22
A, A, B, B, C, C, D, E 00:38:33
vale, pues he metido los 10 nombres 00:38:41
el primero 00:38:51
el último AA 00:38:55
a ver, está bien, porque es que 00:38:57
recordad que es un at first 00:38:59
entonces 00:39:00
los va introduciendo 00:39:01
al principio de la lista 00:39:04
Entonces, el BB se cuela por delante de la A, el CC se cuela por delante, el DD se cuela por delante, se están colando por delante, luego cuando el primero me muestra el último que he metido, porque nuestro adverses se están colando, cada uno que metemos se cuela el primero, luego efectivamente está bien, el último que he metido es este, que se ha quedado el primero de la lista, el último de la lista se ha quedado el primero que metí, que es este, 00:39:06
Y cuantos tengo 00:39:33
Pues tengo estos en el orden 00:39:35
Que tienen que aparecer 00:39:37
Cada uno que he metido se ha colado 00:39:38
A ver, esta nuestra no 00:39:40
Porque no hemos 00:39:45
Habilitado eso 00:39:47
En una colección normal sí 00:39:48
No lo sé 00:39:49
Para que con el for each 00:39:55
Conecte con esto, no lo sé 00:39:57
Tendríamos que mirar a ver como está hecho en el link 00:39:58
No lo sé 00:40:01
vale, pues esta es la idea 00:40:02
de las colecciones, hemos hecho unas versiones 00:40:06
muy muy muy reducidas 00:40:08
de la ArrayList y del LinkedList 00:40:09
que la idea de fondo es esta, lo que pasa es que luego 00:40:12
la versión real incluye 00:40:14
muchos más métodos 00:40:16
y no solo incluye muchos más métodos 00:40:17
sino que incluye algo que no todos hemos pasado 00:40:20
por alto, que esto que hemos hecho 00:40:22
solo nos vale para stream 00:40:23
entonces nos tiene que servir para todo, entonces para que se haga por todos los datos 00:40:25
hay que dar el salto a genéricos 00:40:28
que es poner 00:40:30
el, no exactamente 00:40:32
no, eso exactamente 00:40:34
no, pero cuando ves una T por ahí 00:40:36
o una V mayúscula suelta, tiene más 00:40:38
que ver con eso, eso que dices 00:40:40
del obvio es más de los opcional 00:40:42
dime 00:40:44
claro, pero si estamos 00:40:44
metiendo al principio, con lo cual se cuela al principio 00:40:50
claro 00:40:52
vale 00:40:54
vale 00:40:56
vale, pues el próximo día 00:40:57
Vemos las listas reales 00:41:00
Para ver 00:41:03
No, hemos dicho que al final del día de hoy 00:41:04
Que estaríais cansados 00:41:06
Y retomamos lo del ejercicio de ayer 00:41:07
A ver qué es lo que habíais hecho 00:41:09
Antes de qué 00:41:11
De que el mundo acabe y explote 00:41:14
Pues espero que sí 00:41:16
A ver 00:41:18
yo estoy más harta que tú 00:41:28
de estar aquí, seguro 00:41:30
pero claro, a mí me pagan 00:41:31
y tengo una responsabilidad 00:41:34
y la responsabilidad es que vosotros os quedéis aquí 00:41:35
o sea que aprovechéis las 10 horas que tenéis 00:41:37
venga 00:41:39
bueno, pues el próximo día 00:41:41
entonces ya conectamos con 00:41:44
lo ampliamos a datos 00:41:45
genéricos y luego ya vemos 00:41:48
las versiones reales y como 00:41:50
se usan, porque ahí ya tenemos que empezar a 00:41:52
meter cuestiones que no podemos olvidar 00:41:54
Pues, como el equals, etcétera, ¿vale? 00:41:56
Venga, pues, ¿cuál era nuestro ejercicio? 00:42:02
A ver, a ver. 00:42:06
Sí, pero lo retomamos el próximo día. 00:42:08
Ejercicio, ¿dónde estaba eso? 00:42:15
Alumnos, títulos. 00:42:17
Menudo cuñazo. 00:42:18
Vamos a ver. 00:42:19
Lo compó. 00:42:20
Con todas las letras. 00:42:21
Vale. 00:42:27
¿Necesitáis parar dos, tres minutos? 00:42:29
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:
13
Fecha:
29 de enero de 2025 - 13:11
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 33″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
597.82 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid