Saltar navegación

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

Clase 26-02-24 - 1 - Contenido educativo

Ajuste de pantalla

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

Subido el 26 de febrero de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a seguir avanzando un poquito, estamos muy atascados y muy parados. 00:00:01
¿Vale? 00:00:06
Bueno, pues esto sería otro tema, ¿vale? 00:00:17
Dejamos ahí ya esbozada la herencia y la implementación de interfaces, 00:00:21
que ya más o menos conocemos 00:00:25
primero 00:00:28
qué sentido tiene que exista 00:00:29
es lo más importante, qué sentido tiene que exista 00:00:31
y segundo 00:00:33
cómo se programa ya 00:00:35
usando herencia e implementación 00:00:38
pues bueno, ya que tenemos esbozado eso más o menos 00:00:39
pues vamos ya a introducir 00:00:41
más 00:00:43
conceptos 00:00:45
que usan precisamente herencia 00:00:47
e implementación 00:00:49
la usan 00:00:50
todas sus variantes 00:00:52
entonces 00:00:56
todo lo que se puede hacer en Java 00:00:57
todo lo que se puede hacer en Java 00:00:59
ya lo sabemos 00:01:01
ya lo sabemos hacer todo 00:01:03
lo que pasa es que claro, si uno lo hace 00:01:05
todo a mano 00:01:07
pues entonces tiene muchísimo 00:01:09
trabajo que hacer 00:01:11
entonces gracias a que Java es un lenguaje 00:01:12
de programación y de datos 00:01:15
el código 00:01:16
se distribuye en clases distintas 00:01:19
y ahora ya sabemos que esas clases 00:01:21
son muy fácilmente reutilizables 00:01:23
muy fácilmente 00:01:25
tú en una clase tienes un trozo 00:01:26
de código con un método que hace cosas 00:01:29
pues ahora ya 00:01:31
desde cualquier otra puedes llamar a ese método 00:01:33
para hacer eso, ¿vale? 00:01:35
eso ya es una reutilización 00:01:37
tú tienes una clase que hace cosas 00:01:38
y esa clase la utilizas ya el resto de tu vida 00:01:40
¿vale? reutilización 00:01:43
¿qué otras 00:01:45
formas de reutilización tenemos? 00:01:47
pues precisamente la herencia, tú tienes una clase 00:01:49
si heredas de ella 00:01:51
ya tienes mucho hecho 00:01:53
eso es otra forma de reutilización 00:01:55
entonces 00:01:57
los lenguajes de programación 00:01:59
en todos los objetos 00:02:01
sobre todo lo que han aportado 00:02:02
lo único que han aportado respecto a la programación 00:02:04
estructurada de 00:02:07
y variables una tras otra 00:02:08
lo que han aportado es 00:02:11
cómo organizar el código 00:02:12
y la facilidad para reutilizarlo 00:02:14
no tenerlo que hacer nosotros todo 00:02:17
así en plan chorizo 00:02:19
Bueno, pues todo lo que vamos a ver a partir de ahora 00:02:20
Y todo lo más que podáis ver en Java 00:02:24
Todo 00:02:26
Es precisamente cómo utilizar clases 00:02:26
Que están ya hechas 00:02:29
Ya está, cómo utilizar clases que están ya hechas 00:02:31
Y cómo están hechas por dentro 00:02:33
Con lo que sabéis 00:02:36
Porque no hay nada que no sepáis 00:02:37
¿Vale? 00:02:39
Lo que pasa es que efectivamente 00:02:41
Si uno tiene que hacerlo todo él 00:02:43
Le queda una aplicación inmanejable 00:02:45
Entonces siempre utilizamos clases que están ya hechas 00:02:47
como hasta ahora hemos hecho con la clase string 00:02:49
con la clase scatter y con algunas otras 00:02:52
pero luego 00:02:54
finalmente en última instancia 00:02:56
hacer un desarrollo de una aplicación 00:02:58
lenguaje de todo objeto se traduce en utilizar 00:03:00
un montón de cosas que ya están ya hechas 00:03:02
¿significa eso que esto es fácil? 00:03:03
en absoluto 00:03:06
en absoluto porque 00:03:08
para que las cosas funcionen hay que entender muy bien 00:03:09
que es lo que uno está usando 00:03:12
porque si no lo entiende bien 00:03:13
si no lo entiende bien 00:03:15
si no lo entiende 00:03:16
no lo va a usar bien 00:03:19
y le va a quedar una aplicación que no tiene ningún sentido 00:03:20
aunque no tenga errores de compilación 00:03:23
eso es lo de menos, hacer una aplicación sin errores de compilación 00:03:25
es muy sencillo 00:03:28
hacer una aplicación que haga lo que tiene que hacer 00:03:29
eso es lo complicado 00:03:31
que haga lo que tiene que hacer 00:03:33
y para eso no se trata de utilizar clases 00:03:34
como si fuera esto hacer un Petris 00:03:37
en absoluto, hay que entenderlas bien 00:03:39
y entenderlas más 00:03:41
de todo lo que hemos visto 00:03:43
bueno, pues entonces 00:03:44
esto de ahora es un poquito 00:03:46
vamos a aprender a utilizar clases que están ya hechas 00:03:49
para empezar a solucionarnos 00:03:51
problemas que hemos identificado 00:03:53
que están ahí y que hasta ahora hemos solucionado 00:03:55
a mano, o sea, hemos solucionado programándolos 00:03:57
nosotros directamente 00:03:59
pues resulta que hay clases que nos lo pueden solucionar 00:04:00
bueno, pues uno de esos problemas 00:04:03
que hemos identificado 00:04:05
que da mucha guerra, es el problema 00:04:06
del almacenamiento 00:04:09
almacenamiento de variables, ¿verdad? 00:04:11
el almacenamiento 00:04:22
de los datos de la aplicación. 00:04:23
Ese problema, en realidad, ya nos da 00:04:25
mucha guerra. Si uno tiene datos 00:04:27
sueltos, tres, cuatro numeritos, 00:04:29
una cadena, pues, hombre, 00:04:32
no es tan complicado resolver ese problema. 00:04:33
Se hace sus variables 00:04:36
y, bueno, y ya está. 00:04:37
Ahí va a tirar. Pero si uno tiene 00:04:43
una colección de datos enorme, muchísimos 00:04:45
datos, un montón de clientes, 00:04:47
un montón de números, 00:04:49
un montón de DNIs, que es lo habitual 00:04:51
en una aplicación que tenga un volumen 00:04:53
de datos enorme 00:04:55
pues esto ya sabemos que no 00:04:56
vale, pues que era el salto 00:04:58
que habíamos dado 00:05:01
el array, vale 00:05:02
que el array es una estructura 00:05:04
intrínseca a cualquier lenguaje 00:05:07
de programación 00:05:09
vale, pues bueno, dábamos el salto al array 00:05:09
dábamos el salto 00:05:13
al array 00:05:15
y a la 00:05:16
y ya con esto 00:05:17
ya con esto podíamos guardar 00:05:21
Muchos datos a la vez 00:05:23
Más que a la vez 00:05:25
Muchos datos bajo la misma referencia 00:05:28
Bajo el mismo nombre 00:05:30
¿Vale? Muchos datos bajo el mismo nombre 00:05:31
Pero del mismo tipo 00:05:34
Del mismo tipo 00:05:36
O de tipos heredados 00:05:38
Que eso es lo que nos ha quedado claro con la herencia 00:05:40
¿Verdad? Del mismo tipo de datos heredados 00:05:42
Bueno, pues vale 00:05:44
Ese problema ya lo tenemos resuelto 00:05:46
Y ya está, y es lo que hay, y no hay más 00:05:47
Y no hay otra manera de resolverlo 00:05:49
Ya está, no hay otra 00:05:52
lo que pasa es que 00:05:53
esto se nos hace un rollo 00:05:55
¿se nos hace un rollo por qué? 00:05:57
pues porque cada vez que cambiamos 00:06:00
el tamaño 00:06:02
tenemos que cambiar el array enterito 00:06:02
¿vale? tenemos que cambiarlo entero 00:06:05
no hay otra porque los arrays funcionan así 00:06:07
y no hay otra, no hay alternativa 00:06:09
los arrays funcionan así 00:06:10
si yo declaro este array 00:06:11
de 27 posiciones 00:06:13
ese array se ha quedado de 27 00:06:18
y nunca jamás va a poder ser de otro tamaño 00:06:20
nunca va a poder ser de otro tamaño 00:06:23
si yo quiero un array de otro tamaño 00:06:24
esto 00:06:27
me tengo que deshacer de él 00:06:28
y hacer otro nuevo 00:06:30
es lo único que puedo hacer, lo único 00:06:32
por eso es una estructura estática 00:06:34
¿vale? y eso es lo que hay 00:06:37
y no hay más, y no hay más que se pueda hacer 00:06:38
ya está, no hay más 00:06:41
lo que pasa es que uno puede decir 00:06:42
bueno, pues me voy a hacer yo clases 00:06:44
clases que ya 00:06:47
programen automáticamente 00:06:49
esto de destrozar el array 00:06:50
y hacer uno nuevo 00:06:52
y así no lo tengo que escribir yo a mano 00:06:53
todo el rato, como hemos hecho hasta ahora 00:06:56
¿vale? 00:06:57
pero esas clases lo único que hacen es meter 00:06:59
en métodos, tipo añadir 00:07:02
al array, recuperar, meter en métodos 00:07:04
exactamente lo que nosotros hemos 00:07:06
escrito a mano, nada más, porque no hay nada más 00:07:07
que se puede hacer para almacenar un montón 00:07:10
de datos de golpe 00:07:11
nada más que un array, no se puede hacer nada más 00:07:13
¿vale? pero bueno, hay clases 00:07:15
que envuelven esto 00:07:17
hay clases que te dicen 00:07:20
oye, venga, yo ya tengo 00:07:21
yo tengo un método add 00:07:22
tú dame una cadena 00:07:25
y yo 00:07:29
pues dentro de este método ya te 00:07:31
programo eso de hacer 00:07:33
una array temporal en una posición mayor 00:07:35
copiar uno en el otro, en la posición añadida 00:07:37
copiar esto, ahora 00:07:39
sustituir uno por otro, ya te lo hago yo 00:07:41
te lo hago yo y tú limítate a llamar a add 00:07:43
vale, eso es una cosa que 00:07:45
tenemos y que ya está hecha en una clase 00:07:47
que ahora veremos 00:07:49
que podemos programar y utilizar de forma sencilla. 00:07:51
Lo que pasa es que la gente que idea y piensa y dice, 00:07:57
uff, esto está muy bien para guardar un montón de datos del mismo tipo, 00:08:00
esta estructura de array está muy bien. 00:08:12
Mi problema es este, que yo tengo un montón de datos del mismo tipo 00:08:15
que necesito manejar de forma fácil todos juntos. 00:08:21
entonces 00:08:24
lo he ido a manejar de forma fácil 00:08:26
entonces ya 00:08:29
hemos dicho que declararlo en variables separadas 00:08:30
S1, S2, S3 00:08:33
S4, S5 00:08:35
esto es un rollo, declararlo en variables separadas es un rollo 00:08:36
¿no? ¿cómo hago yo 00:08:39
un recorrido? 00:08:41
¿variables separadas? no 00:08:43
vale, pues lo que hemos dicho es, venga, pues a una raíz 00:08:44
todas estas 00:08:51
variables 00:08:53
todas metiditas a una raíz 00:08:54
vale, esta es la solución 00:08:57
la única que tenemos 00:09:00
todas metidas a un array 00:09:01
entonces ahora este array ya tiene un único nombrecito 00:09:03
y al tener un único nombre 00:09:06
se me facilita el recorrido con sd0 00:09:07
sd1, etcétera, lo que ya sabemos 00:09:10
y luego el siguiente 00:09:11
paso que hemos dicho es, oye 00:09:14
si hay una clase 00:09:15
que ya tiene los métodos hechos 00:09:17
de insertar, eliminar 00:09:19
de forma que yo llamo 00:09:22
a esos métodos y ya 00:09:23
y me ahorro toda la parte de hacer una array 00:09:25
más grande, sustituir, pues fenomenal 00:09:27
vale, esa clase está 00:09:29
que se llama 00:09:30
ArrayList, vale 00:09:33
ya veremos como se usa y que 00:09:34
particularidades 00:09:37
tiene, que hay que entender 00:09:39
para usarla bien, vale, pues esa clase se llama 00:09:40
ArrayList y ya está 00:09:43
vale, pero bueno 00:09:44
esto está muy bien, pero jolines 00:09:46
ya hemos vivido en nuestras carnes que 00:09:49
a nosotros nos parece 00:09:51
que llamara el método add 00:09:53
de ArrayList 00:09:55
para añadir una nueva cadena 00:09:56
decimos add y nos creemos que es tan fácil 00:09:59
ya sabemos que no es tan fácil 00:10:02
porque ya sabemos que es lo que tiene este método dentro 00:10:03
porque lo hemos hecho un montón de veces 00:10:06
quitar el Array 00:10:07
hacer uno nuevo, copiar uno en otro 00:10:09
copiar uno en otro 00:10:11
implica consumir muchos ciclos 00:10:13
de CPU, es decir 00:10:15
hay mucho código 00:10:17
para nosotros al final se acaba traduciendo 00:10:18
en llamar a add de esta clase 00:10:21
pero hay mucho código debajo 00:10:23
que lo hemos hecho nosotros también 00:10:25
un montón de ciclos de CPU 00:10:26
copiando, pegando, etc 00:10:29
entonces, pues los que piensan y todo eso 00:10:30
dicen, ¿habría alguna otra manera? 00:10:33
¿habría alguna otra manera 00:10:35
de guardar un montón de datos del mismo tipo? 00:10:36
se me ocurriría con lo que sabemos 00:10:39
con lo que sabemos, no con nada nuevo 00:10:41
porque es que no hay nada nuevo 00:10:42
se me ocurriría con lo que sabemos 00:10:43
otra forma de guardar datos del mismo tipo 00:10:46
que sea un poquito más eficiente 00:10:48
a la hora de insertar 00:10:50
y eliminar que esta 00:10:52
porque es que esta es un rollo, repito 00:10:54
esta implica tirar esto 00:10:57
hacer otra, copiar 00:10:59
habría una forma de guardar varios 00:11:01
porque este es mi problema 00:11:03
yo tengo un montón 00:11:19
del mismo tipo 00:11:20
y quiero hacer una estructura 00:11:22
que me permita manejarlos 00:11:25
de forma sencilla a todos 00:11:27
bajo una misma referencia 00:11:29
ya hemos visto que una es 00:11:30
meterlos en la cajita del array 00:11:32
esa es una 00:11:33
bueno, pues se nos podría ocurrir otra 00:11:34
a ver, es una pregunta muy difícil 00:11:38
porque es muy complicado que a uno se le ocurra otra 00:11:43
precisamente esa otra forma 00:11:45
es la que voy a decir 00:11:48
pero el problema sería 00:11:48
¿qué otra cosa puedo hacer? 00:11:51
con un montón de datos sueltos 00:11:54
que no sea meterlos en un array 00:11:55
para trabajar con ellos 00:11:57
bajo una misma referencia, una única 00:11:59
y que sea sencillo 00:12:01
que solamente un único nombre 00:12:03
de variable, como ocurre con el array 00:12:05
con el array tenemos un único nombre de variable 00:12:07
el del array, y con eso ya accedemos a todo 00:12:09
la 0, la 1, la 2 00:12:11
pues se nos ocurre alguna otra forma 00:12:13
que con un único nombre de variable 00:12:15
me permita a mí hacer recorridos 00:12:17
acceder a todos, etc. 00:12:19
¿Pero una constante? 00:12:24
¿Eh? 00:12:26
¿Pero una constante? 00:12:27
¿Usándola de qué manera? 00:12:31
la de colección 00:12:32
¿perdón? 00:12:34
de colección 00:12:35
de array 00:12:36
pero no te entiendo, si no me das más detalles 00:12:37
o sea, la referencia única 00:12:43
¿cuál sería? 00:12:45
que no entiendo lo que quieres decir 00:12:49
o te explican mejor 00:12:50
porque una constante colección de array 00:12:54
no entiendo lo que quieres decir 00:12:56
bueno, el problema es, bajo una única referencia 00:12:58
poder recorrerlos 00:13:01
todos, poder tener la información 00:13:03
accesible bajo una única referencia 00:13:04
como hace el array, ¿verdad? 00:13:07
El array tiene bajo una única 00:13:09
referencia el nombre del array 00:13:11
bajo una única referencia 00:13:12
que es esta, una única declaración de variable 00:13:18
una única declaración 00:13:20
los tiene accesibles a todos 00:13:21
a través del corchete 00:13:23
S0, S1, S2 00:13:26
¿vale? 00:13:28
bajo una única referencia 00:13:29
bajo un único nombre de variable 00:13:32
ya los tiene todos, S0, S1, S2 00:13:33
pues eso es lo que queremos 00:13:35
habría alguna forma de bajo un único 00:13:37
nombre de variable 00:13:40
bajo un único nombre de variable 00:13:41
declarar algo 00:13:43
bajo un único nombre de variable que me permita 00:13:45
acceder a todo 00:13:47
y que no sea un array 00:13:48
no es fácil, que a uno se le ocurra 00:13:50
pero pues los que 00:13:55
piensan y enseñan estas cosas 00:13:57
dijeron, hombre, vamos a hacer un invento 00:13:59
vale, esta referencia 00:14:02
que sea la referencia 00:14:04
de uno de ellos 00:14:05
solo de uno, de este 00:14:06
este que sea ese 00:14:08
¿vale? y ahora este dato 00:14:09
le voy a pegar 00:14:12
le voy a pegar 00:14:15
la dirección del siguiente 00:14:18
o sea, tendrá el dato 00:14:21
el que sea 00:14:23
su dato, pero le voy a pegar 00:14:25
también la dirección 00:14:27
del siguiente elemento 00:14:28
vale, y ahora 00:14:30
este tendrá su dato, lo que sea 00:14:33
y le voy a pegar detrás 00:14:35
la dirección del siguiente 00:14:37
y ahora este 00:14:39
tendrá su dato 00:14:41
y le voy a pegar también detrás 00:14:42
la dirección del siguiente, la referencia 00:14:44
y ahora este 00:14:47
tendrá su dato y le voy a pegar 00:14:49
también la dirección del siguiente 00:14:51
si este es el último, pues que le estoy pegando 00:14:52
aquí 00:14:55
la dirección de un objeto que ya no existe 00:14:55
que le estaría pegando a ese 00:14:59
¿verdad? 00:15:00
vale, pues 00:15:03
una única referencia 00:15:04
S, los datos 00:15:06
están aquí guardaditos 00:15:08
¿qué nos hemos inventado? 00:15:09
vamos a pegar a cada dato 00:15:14
una especie de información de control 00:15:16
que no forma parte del 00:15:18
no es el dato así, si estos son cadenas 00:15:20
hola, adiós, lo que sea, nombres, Pepito, Juanito 00:15:22
pues es una información de control 00:15:24
que está aquí pegadita 00:15:26
que lo único que tiene es 00:15:27
la dirección del siguiente 00:15:29
y entonces bajo esta única referencia 00:15:31
según yo vaya metiéndome los datos 00:15:36
puedo llegar a este, si quiero llegar a este de aquí 00:15:39
pues me meto en este, a través de este me meto en este 00:15:41
y a través de este ya llego aquí 00:15:45
entonces bajo esta única referencia en realidad tengo accesibles todos 00:15:46
tengo accesibles todos, que es la idea 00:15:51
tener todos accesibles bajo una única referencia 00:15:53
incorporando 00:15:57
esta especie de información aquí pegadita 00:15:59
de control que va junto 00:16:02
con el dato en sí, el dato ya el que sea 00:16:04
el cliente, el nombre 00:16:06
del usuario 00:16:07
lo que sea, el dato que vaya ahí 00:16:09
¿vale? 00:16:12
pues esta estructura es una estructura 00:16:14
básica de almacenamiento de datos 00:16:16
en programación de toda la vida 00:16:18
básica 00:16:20
que es la lista enlazada 00:16:20
entonces la estructura de lista enlazada es básica 00:16:24
en programación, es la que se ha usado 00:16:32
siempre para guardar 00:16:34
datos como alternativa al array 00:16:36
¿vale? como alternativa al array 00:16:38
y uno diría 00:16:41
¿y qué me aporta esta? 00:16:44
respecto al array, si ya tengo 00:16:46
el array, ¿qué me aporta 00:16:48
esta? 00:16:50
hombre, pues esta me aporta que las 00:16:52
inserciones 00:16:53
y las eliminaciones de datos son mucho 00:16:55
menos costosas 00:16:58
computacionalmente 00:16:59
aquí añadir un dato nuevo implica 00:17:01
ala, hace aparecer el dato con el new 00:17:04
Y ahora ya, esta 00:17:05
La haces pasar de nula a este 00:17:07
O sea, no tienes que 00:17:10
Tirar nada a la basura 00:17:11
Volverlo a construir, copiar de uno en otro 00:17:14
Como con el array 00:17:16
Meter un dato nuevo en la lista es facilísimo 00:17:16
Llega uno a la lista y le da la mano al otro 00:17:20
¿Vale? Están todos dados de la mano 00:17:22
Cuando llega uno 00:17:24
Lo que haces, se da de la mano al último 00:17:26
Y ya está, no tienes que hacer nada 00:17:28
Para eliminar un dato 00:17:30
Con el array era un rollo 00:17:32
teníamos que hacer otro con una posición menos 00:17:34
copiar y pegar saltándonos el primero 00:17:36
todo eso tiene un coste computacional 00:17:38
aunque nos lo haga la clase 00:17:40
ArrayList ya porque ya lo tiene ya hecho 00:17:42
por dentro y yo llamo al método, pero lo hace 00:17:44
igual, eso es lo que se hace 00:17:46
me da igual que lo haya programado yo 00:17:48
que se lo encargue a la ArrayList 00:17:50
eso computacionalmente es 00:17:52
un rollo, sin embargo aquí 00:17:54
que yo quiero eliminar este dato 00:17:56
este se va de la lista 00:17:58
y ahora los que se dan la mano son 00:18:00
simplemente este y este 00:18:02
este se suelta de la mano 00:18:04
de ese se suelta y estos dos ya se la dan 00:18:06
y ya está, y lo han dejado y puenteado 00:18:08
no hay datos que copiar 00:18:10
ni que eliminar, ni que nada, no hay nada 00:18:12
entonces 00:18:14
insertar nuevos elementos 00:18:16
en esta colección 00:18:18
y sacar elementos de esta colección 00:18:20
a nivel computacional 00:18:23
de acciones 00:18:25
que hay que hacer es muchísimo 00:18:26
más sencillo que con el array 00:18:29
mucho más sencillo 00:18:31
¿Vale? Te estás durmiendo, Miguel 00:18:32
Cosa que, con lo interesante que es 00:18:35
No puedo entenderlo 00:18:37
Pero bueno, ¿eh? 00:18:38
Pero chico, que tienes 20 años 00:18:43
Y 19, 18 00:18:45
Yo tampoco 00:18:45
Ni aquí me tienes 00:18:48
Está claro 00:18:49
Bueno, a ver 00:18:52
Bueno, vale 00:18:54
Entonces 00:19:00
esto es lo que aporta 00:19:01
esto es lo que aporta 00:19:04
entonces dices, bueno, tampoco es tan crítico 00:19:05
hombre, pues sí que es crítico 00:19:08
en una aplicación 00:19:10
en la que tienes que estar 00:19:11
una aplicación que una de las funcionalidades principales 00:19:13
es insertar y quitar datos 00:19:16
en una en la que tienes que insertar 00:19:18
y quitar datos todo el rato 00:19:20
nunca cogerías un ArrayList 00:19:22
porque es que 00:19:24
metería mucha carga, si ya la máquina virtual 00:19:26
mete carga, si encima metes 00:19:28
un ArrayList en una aplicación en la que tú sabes 00:19:30
que los usuarios van a estar todo el rato insertando 00:19:32
y eliminando de los datos 00:19:34
pues ya hay colmo 00:19:36
ya sí que la ralentizas 00:19:37
en una aplicación en la que estés sobre todo 00:19:40
insertando y quitando datos 00:19:42
elegirás esta estructura 00:19:44
lo que pasa es que ¿qué pega tiene esta 00:19:46
estructura? que como ahora veremos, porque la vamos a 00:19:50
programar, como ahora veremos 00:19:52
el recorrido es más complicado 00:19:54
la consulta, con un Array 00:19:56
cuando tú quieres el dato 00:19:58
de posición 7 00:20:00
facilísimo 00:20:01
haces S7 00:20:03
y ya está, ya lo tienes 00:20:05
va por índice 00:20:07
en un array tú accedes con índice 00:20:08
das el índice, quiere la posición 3 00:20:10
ala, ya la tienes 00:20:13
accedes por índice, luego las consultas 00:20:16
el consultar lo que hay en un sitio 00:20:19
es mucho más rápido 00:20:21
pero una lista enlazada 00:20:23
para consultar lo que está en la posición 3 00:20:25
tienes que ir navegando 00:20:28
entrar por aquí, de aquí vas por aquí 00:20:31
de aquí vas por aquí, de aquí vas por aquí 00:20:34
luego consultar lo que tiene 00:20:35
un dato 00:20:38
es más costoso computacionalmente 00:20:38
porque tienes que ir avanzando aquí con las manitas 00:20:41
hasta que llegas 00:20:43
no va por índice como este 00:20:44
entonces cuál es mejor o cuál es peor 00:20:46
depende del uso 00:20:48
que vayamos a dar a esa estructura 00:20:51
de datos 00:20:53
si sobre todo la aplicación 00:20:54
va a necesitar 00:20:57
muchas inserciones y borrados 00:20:59
uno elegiría esta 00:21:01
pero si la aplicación sobre todo 00:21:03
va a hacer 00:21:07
muchas consultas, es sobre todo 00:21:08
para consultar y no para insertar 00:21:11
y borrar, pues elegiríamos esta 00:21:13
sin duda 00:21:15
cuando hay pocos datos 00:21:15
son diferentes criterios 00:21:21
cuando hay pocos datos, es una 00:21:23
aplicación mía que yo necesito 00:21:25
nada, tener ahí 10 numeritos 00:21:27
que voy a hacer cosas con ellos, pues con 10 numeritos 00:21:28
uno hace un ArrayList y ya está 00:21:31
no se complica, porque un Array de 10 00:21:33
no tiene ningún peso 00:21:34
pero una aplicación en la que estás trabajando 00:21:35
con 20.000 usuarios que tienes que 00:21:38
volcar de la base de datos 00:21:40
a una colección, pues nunca 00:21:42
usarías un ArrayList, un Array de 20.000 00:21:44
menudo coñazo, aunque tú 00:21:46
no lo notes, porque tú haces add, remove y ya está 00:21:48
aunque tú no lo notes, por debajo es muy pesado 00:21:50
no harías un ArrayList con 20.000 00:21:52
usuarios, harías un link 00:21:54
harías esto 00:21:56
harías esto que es 00:21:57
infinitamente más eficiente 00:21:59
cada vez que llega uno y se va 00:22:01
es facilísimo 00:22:02
hay más estructuras de datos 00:22:03
en programación que se han pensado 00:22:09
para facilitar precisamente 00:22:11
un uso eficiente 00:22:13
de los datos 00:22:15
hay una 00:22:17
que esa ya sí que no la vamos a programar nosotros 00:22:18
porque es un poco 00:22:21
lío 00:22:22
la vamos a usar sin más 00:22:24
sin programarla nosotros 00:22:27
la vamos a usar sin más, pero tenéis que conocerla 00:22:28
tenéis que conocer que es si esta 00:22:31
es la lista enlazada 00:22:32
lista enlazada ya os tiene que sonar a partir de ahora 00:22:34
grabado como tantas cosas que es una lista 00:22:36
enlazada, pues es una estructura 00:22:38
de almacenamiento de datos 00:22:41
en programación, donde cada dato 00:22:42
tiene la dirección del siguiente 00:22:44
la tiene dentro, con lo cual 00:22:46
con tener la dirección del primero es suficiente 00:22:48
con la del primero es suficiente 00:22:50
porque ya cada uno de ellos te va a dar la del siguiente 00:22:52
esa es la lista enlazada, eso ya 00:22:55
que no se os olvide, una estructura 00:22:56
de datos que se puede programar en cualquier lenguaje 00:22:58
de programación, bueno pues otra estructura 00:23:00
de datos 00:23:02
es el árbol 00:23:02
el árbol binario 00:23:04
en esta estructura de datos 00:23:07
los datos no se guardan en una listita 00:23:11
en otros datos de la mano 00:23:13
se guardan así 00:23:14
cada dato tiene 00:23:17
su valor, el nombre del cliente 00:23:21
lo que sea, su valor 00:23:24
y luego además tiene la dirección 00:23:25
del que está a su derecha 00:23:27
y la dirección del que está 00:23:30
a su izquierda. Tiene dos direcciones 00:23:32
metidas dentro. 00:23:34
Este tendrá su dato, 00:23:36
ese es el binario, pero vamos, podría haber árboles 00:23:38
no binarios, pero eso ya sí que no 00:23:40
tiene demasiada complejidad. 00:23:41
Este tendría su vez, 00:23:46
esta es la estructura 00:23:49
del árbol binario 00:23:50
de toda la vida. 00:23:51
¿Qué aporta respecto a la lista enlazada? 00:23:53
arregla un poquito las consultas 00:23:56
hemos dicho antes que ahí está enlazada, es un rollo 00:23:59
pues tienes 20.000 00:24:01
y tú tienes que recuperar el 19.000 00:24:02
pues tienes que 00:24:05
ir avanzando de la manita 00:24:07
hasta llegar al 19.000 00:24:09
¿vale? con el árbol binario 00:24:10
cada vez, paz, te quitas 00:24:13
la mitad de golpe, porque 00:24:15
estos se van almacenando con un 00:24:16
criterio de mayor a menor, aquí tienes un dato 00:24:19
todos los que sean mayores que él, se ponen para acá 00:24:21
y los menores para acá 00:24:23
y aquí lo mismo, todos los que sean mayores que este 00:24:24
para acá, los menores para acá 00:24:27
entonces las búsquedas son muy fáciles 00:24:28
tú buscas, vas navegando 00:24:31
y de golpe ya te has quitado la mitad 00:24:33
ahora te quedas aquí 00:24:35
de golpe te quedas la mitad 00:24:37
entonces es más fácil hacer una consulta 00:24:38
en un árbol binario y llegas antes 00:24:41
obviamente que en una fila 00:24:42
en una fila es que tienes que recorrer la fila enterita 00:24:44
en un árbol binario recorres la fila entera 00:24:46
entonces lo que aporta 00:24:49
esta estructura 00:24:51
es que las consultas son 00:24:51
más fáciles, más rápidas 00:24:54
que esta 00:24:56
¿vale? pero programar esto ya sí que es 00:24:57
un poquito más complicado, entonces esto sí que 00:25:01
lo usaremos 00:25:03
porque es una estructura que está ya programada 00:25:03
en Java hay un montón de clases que son las famosas 00:25:06
colecciones 00:25:09
hola, busco unos alumnos 00:25:09
pues tú dirás 00:25:13
¿ves pd's? 00:25:14
vale, bueno pues entonces 00:25:17
esta estructura 00:25:24
de lista enlazada 00:25:30
entonces al que se le ocurrió 00:25:32
que está muy bien porque 00:25:34
insertar y borrar como hemos dicho 00:25:36
es mucho más fácil computacionalmente 00:25:38
de un array 00:25:41
pues el que se le ocurrió la programó 00:25:41
y ya está 00:25:44
y vamos a programarla nosotros también 00:25:45
porque somos muy listos y somos capaces de hacerlo 00:25:48
el resto de colecciones que hay 00:25:50
que ya veremos 00:25:53
que hay muchas variantes luego de esto 00:25:54
hay muchas variantes de listas conjuntos 00:25:56
Veremos cómo se usan 00:25:58
No las programaremos por dentro 00:26:01
Pero esta sí, al menos una hay que programar 00:26:02
Porque tenéis que aprender a programar 00:26:04
Eso es lo que os van a pedir 00:26:06
Que sepáis programar 00:26:08
No que conozcáis la clase B y la clase C 00:26:09
Sino que sepáis programar 00:26:12
Es lo que os van a pedir 00:26:14
Vamos a programar la lista enlazada 00:26:14
Que os va a gustar mucho además 00:26:18
Porque os va a hacer pensar 00:26:22
Y eso es lo que más satisfacción se supone que os tiene que dar 00:26:28
si os habéis matriculado en este 00:26:30
ciclo, el tener la opción de pensar 00:26:33
de que se os mueva la cabeza 00:26:35
bueno pues 00:26:38
vale, pues vamos a pensar 00:26:40
nuestra lista enlazada es algo de este estilo 00:26:43
aquí habrá una referencia 00:26:45
vamos a llamarle inicio 00:26:47
por llamarle de alguna manera 00:26:49
y esta será la dirección 00:26:51
del primer objeto 00:26:55
del primer objeto 00:26:58
de la lista 00:26:59
Este objeto tendrá su dato y ahora aquí tendrá también otra propiedad, otra propiedad, esta propiedad será la dirección del siguiente de la lista, ¿vale? 00:27:00
Vamos a dejar, aquí tendrá su dato, vale, pues entonces lo primero que vamos a programar, vamos a programar estas clases, es decir, cada uno de estos objetos, cada uno de estos objetos pertenecerá a una clase, ¿verdad?, pertenecerá a una clase, cada uno de estos objetos va a pertenecer a una clase, vale. 00:27:18
vamos a darle nombre a esa clase 00:27:40
para programarla 00:27:42
bueno, el término habitual en informática 00:27:43
para los árboles 00:27:46
para las listas 00:27:48
es que esto se le llame nodos 00:27:50
es un nodo de una lista 00:27:52
un nodo de un árbol 00:27:54
bueno, pues para acostumbrarnos a esa terminología 00:27:55
la clase a la que 00:27:59
pertenecen estos objetos 00:28:00
de la lista, vamos a llamarle 00:28:02
nodo 00:28:04
vamos a programar esa clase lo primero de todo 00:28:05
clase nodo 00:28:08
Vale, la clase nodo tiene dos campos, tiene dos campos obligatoriamente, uno, el campo que tiene el dato en sí que guarde la lista, lo que sea, cliente, cadena de datos, número, lo que sea, el dato en sí. 00:28:15
vale, vamos a hacer 00:28:34
esta lista, vamos a tener que elegir 00:28:37
ahora mismo voy a tener que elegir 00:28:39
¿qué queremos que guarde esta lista? 00:28:40
vamos a hacer, vamos a programar 00:28:43
esta lista enlazada para que guarde 00:28:45
cadenas, por ejemplo, para que guarde 00:28:46
cadenas de texto, si queremos que 00:28:49
guarde cadenas, este primer campo 00:28:51
de este objeto, de los dos que tiene 00:28:53
este primer campo 00:28:55
será de tipo 00:28:57
string, ¿verdad? 00:28:58
bueno, pues el primer campo 00:29:00
será de tipo string 00:29:02
luego el campo 00:29:08
dato, este de aquí es de tipo 00:29:10
string, es donde está el dato 00:29:12
recordad que esta estructura es para guardar datos 00:29:13
no es para otra cosa 00:29:16
bueno, pues ese era el primer 00:29:17
campo de este objeto 00:29:20
pero vamos, que si quisiéramos que aquí 00:29:22
guardara un objeto cliente 00:29:26
pues aquí pondríamos cliente 00:29:27
si es que tuviéramos esa clase cliente hecha 00:29:29
si quisiéramos que guardara un número 00:29:31
aquí pondríamos int 00:29:33
eso depende de lo que queramos que guarde nuestra lista 00:29:35
es como el array 00:29:38
vale 00:29:38
pero tiene que tener 00:29:42
este objeto, tiene que pertenecer a una clase 00:29:44
nuestra clase nodo 00:29:47
que además tenga un segundo campo 00:29:48
porque ya hemos dicho que cada objeto 00:29:50
de la lista tiene que apuntar 00:29:53
a su siguiente 00:29:55
vale, pues a este campo le vamos a llamar 00:29:56
así, siguiente 00:29:59
y ahora la pregunta 00:30:00
más importante es 00:30:03
qué tipo de dato 00:30:05
tiene este campo 00:30:07
qué tipo de dato tiene ese campo 00:30:09
qué tipo de dato pongo aquí 00:30:12
este tiene que ser 00:30:14
una referencia 00:30:19
la dirección del siguiente objeto 00:30:21
de la lista 00:30:24
la referencia, su dirección de memoria, el siguiente objeto de la lista 00:30:24
luego, qué tipo de dato 00:30:28
pongo ahí 00:30:30
nodo, perfectamente, muy bien 00:30:30
claro 00:30:34
¿vale? 00:30:34
esto es un objeto 00:30:42
de tipo nodo, es la dirección del siguiente elemento 00:30:44
que es de esta clase 00:30:46
que es de esta, de esta, la misma toda, el nodo 00:30:48
¿vale? luego esta clase a la que pertenecen 00:30:54
mis datos 00:30:56
tiene esos dos campos 00:30:56
esos dos campos 00:31:00
¿vale? luego aquí ya, pues le puedo 00:31:01
poner el constructor, métodos 00:31:09
para acceder a 00:31:12
a esto de aquí, etcétera, pero bueno 00:31:13
eso ya, ahora mismo, get y sell 00:31:15
me refiero a eso ya ahora mismo, es lo de menos 00:31:17
¿cómo accedo yo a esto? si accedo con el punto, le pongo 00:31:18
eso nos da igual a la misma 00:31:21
lo que nos importa es la estructura 00:31:23
de este objeto 00:31:25
¿nodo es el primer objeto que has creado? 00:31:26
no, nodo es la clase a la que 00:31:30
pertenecen todos y cada uno de estos objetos 00:31:31
o sea, inicio 00:31:33
no, inicio es 00:31:35
como he llamado yo a la referencia 00:31:37
del primero de ellos, luego inicio es un 00:31:40
objeto de clase nodo 00:31:41
¿vale? inicio es un objeto 00:31:43
de clase nodo, pero solo uno 00:31:45
porque la dirección es el primero, esta es la clase 00:31:47
la clase a la que pertenecen todos 00:31:49
¿vale? 00:31:52
bueno, ya tenemos hecha una parte 00:31:54
pero claro, aquí lo que queremos es 00:31:55
aquí lo que queremos 00:31:58
es un objeto 00:32:00
un objeto que pertenezca a una clase 00:32:02
que me permita a mí 00:32:05
hacer las operaciones 00:32:07
de añadir, de eliminar 00:32:08
de todo eso 00:32:10
¿vale? eso es lo que yo necesito 00:32:11
bueno, pues 00:32:14
ese objeto, mi objeto de partida 00:32:16
mi objeto de partida, el objeto que vamos a usar 00:32:18
para insertar, eliminar, para todo 00:32:21
mi objeto de partida es este 00:32:22
es este 00:32:24
que pertenece a la clase 00:32:26
nodo también, ¿verdad? 00:32:29
vale, pues entonces nuestra 00:32:31
estructura de datos, la que ya 00:32:33
vamos a instanciar para trabajar, nuestra 00:32:35
estructura de datos 00:32:37
vamos a llamarla 00:32:37
lista enlazada 00:32:40
¿vale? esta es la 00:32:43
estructura de datos que vamos a crear 00:32:54
Se llama lista enlazada 00:32:56
Y aquí es donde vamos a meter los métodos 00:32:57
Relacionados con 00:32:59
Meter en la lista, sacar 00:33:01
¿Vale? En esta clase 00:33:03
Es donde vamos a meter toda la operativa 00:33:04
De insertar, borrar, consultar 00:33:06
Todo 00:33:09
Va a estar metido en esa clase 00:33:09
Ahí va a estar toda la operativa, lista enlazada 00:33:13
Vale, aquí meteremos, pues repito 00:33:15
Añaden la lista, borra de la lista, etc 00:33:17
Bueno, pues esta lista enlazada 00:33:19
¿Por qué se va a caracterizar? 00:33:22
¿Cuál va a ser su dato 00:33:24
más importante. 00:33:25
¿Cuál va a ser su dato más importante? 00:33:27
La dirección del primero. 00:33:30
Y con la dirección del primero 00:33:33
ya lo tiene todo. 00:33:35
Porque las direcciones de los siguientes están aquí dentro. 00:33:36
Lo acabamos de ver. 00:33:39
Con lo cual, mi estructura lista enlazada, 00:33:40
la única propiedad 00:33:43
que necesita, 00:33:45
lo único que la caracteriza, lo único que importa, 00:33:46
es la dirección del primero. 00:33:48
Lo único. La dirección del primero. 00:33:50
Porque a partir del primero yo puedo 00:33:53
llegar a los otros. 00:33:54
Luego, esta propiedad de inicio, que es la dirección del primero, es la que caracteriza a una lista enlazada concreta. 00:33:57
Esta es la clase lista enlazada, y luego cada lista enlazada concreta, cada objeto de esta, 00:34:06
cada objeto de esta se distinguirán unos de otros de su inicio. 00:34:12
Luego, inicio será la propiedad que caracteriza a cada lista enlazada concreta, cada lista enlazada, su dirección de inicio. 00:34:18
y ahora repito 00:34:24
esta propiedad 00:34:26
inicio, el inicio de mi lista 00:34:28
lo único que me hace a mi falta 00:34:30
para trabajar con la lista 00:34:32
esta propiedad, ¿de qué tipo la pondremos? 00:34:33
¿nodo? ¿de tipo nodo? claro 00:34:41
porque es la dirección del primero 00:34:42
y el primero es un objeto nodo 00:34:44
todos son un objeto nodo 00:34:47
luego esta era de tipo nodo 00:34:48
porque es la dirección de un objeto nodo 00:34:50
y esta también es de tipo nodo 00:34:52
porque es la dirección de un objeto nodo 00:34:54
luego esto en realidad 00:35:01
es las únicas 00:35:02
dos clases, no le hemos metido a operativa 00:35:05
de insertar y de todo eso, son las únicas 00:35:07
dos clases necesarias para 00:35:09
pintar, dibujar, reflejar 00:35:11
la lista enlazada 00:35:13
es decir, la lista enlazada es una 00:35:14
estructura como esta 00:35:17
que se caracteriza 00:35:19
¿por qué? 00:35:21
por la dirección del primero, ya está 00:35:23
porque con la dirección del primero llego a todo 00:35:25
vale 00:35:27
pues yo tengo mi clase lista enlazada 00:35:28
que se caracteriza exclusivamente 00:35:31
por la dirección del primero 00:35:34
y ahora ya la dirección del primero 00:35:35
es de tipo nodo 00:35:38
pues claro, tendré que programar la clase nodo 00:35:39
obviamente, tendré que programar la clase nodo 00:35:42
si la dirección del primero es de tipo nodo 00:35:44
tendré que decir, vale 00:35:46
¿y cada nodo qué tiene dentro? 00:35:47
pues lo estoy diciendo aquí 00:35:50
cada nodo tiene dentro un dato 00:35:51
y la dirección del siguiente 00:35:54
vale, luego esto ya es la descripción de la lista 00:35:56
esto describe completamente lo que es una lista enlazada 00:36:00
lo describe 00:36:02
ahora ya para poder usar 00:36:03
una lista enlazada para meter datos 00:36:06
sacar, consultar, etc 00:36:08
habrá que meter aquí los métodos correspondientes 00:36:09
por ejemplo 00:36:12
en este objeto lista enlazada 00:36:14
que se caracteriza por esta dirección 00:36:15
de inicio, sea la que sea 00:36:18
cada lista tendrá una suya 00:36:19
¿qué método me interesará 00:36:22
a mi programa? 00:36:25
pues el método añadir 00:36:26
al que yo le paso 00:36:28
un string, porque en este caso 00:36:30
si es una lista enlazada de strings 00:36:32
le paso un string 00:36:33
y me lo añade 00:36:35
a la lista, ala, pues este método 00:36:38
querremos programarle, un método 00:36:40
add, al que yo le paso un string 00:36:42
y me lo mete en la lista 00:36:44
¿vale? 00:36:46
ya este método tendrá que 00:36:48
encargarse de crear el dato 00:36:50
colocarlo, hacer los enlaces 00:36:51
etcétera, ¿qué más métodos 00:36:54
nos interesa programar aquí en esta lista? 00:36:56
pues en esta lista 00:36:58
cuya dirección de inicio es esta 00:36:59
cada una tendrá la suya 00:37:01
recordad que eso es una clase, luego ya habrá listas concretas 00:37:03
y cada lista concreta tendrá su propia dirección 00:37:06
pues en esta lista 00:37:08
cuya dirección de inicio es esta 00:37:10
también me interesa programar 00:37:11
un método remove 00:37:14
por ejemplo 00:37:16
al que yo le paso un string 00:37:16
y me elimina 00:37:19
el método, me elimina el nodo 00:37:22
que contenga este dato 00:37:24
por ejemplo 00:37:26
y así podemos añadir 00:37:27
un montón de métodos 00:37:28
el recuperar, ¿qué? 00:37:30
pues yo le paso una posición 00:37:32
y me lo recupera 00:37:34
¿vale? 00:37:37
pues se trata de programar estos métodos 00:37:38
que son más sencillos de lo que parecen 00:37:40
y esto es una lista enlazada 00:37:42
¿vale? 00:37:44
que son las dos 00:37:49
los únicos dos tipos de listas que hay 00:37:50
en Java 00:37:53
la lista basada en Array 00:37:54
y la lista basada en lista enlazada 00:37:56
Venga, vamos a parar aquí un momento, luego ya lo programamos y... 00:37:59
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
26 de febrero de 2024 - 18:46
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
38′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.22

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid