Saltar navegación

20260203 Colecciones_4_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 7 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues todo el mundo está situado, ¿no? 00:00:02
Nos habíamos hecho esta clase. 00:00:04
Para instanciarla yo ya desde mi main, que era este, 00:00:07
desde mi main voy a instanciar un objeto de esta clase 00:00:11
ya parametrizado para el tipo que yo quiera, 00:00:15
para el tipo que yo quiera en este ejemplo, pues de stream, por ejemplo. 00:00:20
Pero aquí en la clase está todavía genérico. 00:00:24
Vale, parametrizado. 00:00:27
Y cuando yo la instancie, lo único que quiero con este objeto es poder usarlo para meter cadenas, también me gustaría poder usarlo para recorrer las cadenas que he metido, habilitándome un método get que me permita recuperar por posición, habilitándome un método size. 00:00:28
Dime. 00:00:49
Sí, aquí lo puedes poner. 00:00:55
No, no, no, no, no, no, no hace nada negativo. 00:01:01
Vale, pues entonces, este es el uso. 00:01:04
Entonces, ¿qué oculta el uso? 00:01:10
El uso oculta esta complejidad que estábamos programando ayer. 00:01:12
¿Qué oculta? 00:01:16
Pues oculta que cuando uno instancia este objeto 00:01:17
para meter cosas, recuperarlas, etcétera, 00:01:19
cuando uno instancia este objeto, 00:01:23
lo que realmente está instanciando 00:01:24
es la dirección 00:01:28
de un primer nodo 00:01:30
es lo que realmente está instanciando 00:01:33
cuando instancia ese objeto 00:01:35
¿vale? 00:01:36
eso es lo que estamos instanciando 00:01:49
cuando instanciamos este objeto 00:01:50
esto 00:01:51
¿y esto qué es? 00:01:54
esto es 00:01:56
la dirección de un primer nodo 00:01:56
inicialmente 00:01:59
cuando se instancia este objeto 00:02:00
por primera vez 00:02:02
esto es lo que hemos instanciado 00:02:03
la propiedad inicio 00:02:06
que es la dirección de un objeto 00:02:08
nodo P sin inicializar 00:02:09
un objeto sin inicializar apuntando 00:02:11
vale 00:02:14
ahora cuando nosotros 00:02:14
llamamos 00:02:17
añadir una nueva cadena 00:02:21
añadir una nueva cadena 00:02:24
esa cadena se va dentro de la lista enlazada 00:02:25
y para el 00:02:28
main y para cualquiera que use ese objeto 00:02:30
la complejidad está ahí escondida 00:02:32
¿qué complejidad está ahí escondida 00:02:34
debajo de este add first? 00:02:36
pues lo que programamos ayer 00:02:38
debajo de este add first 00:02:39
está escondida 00:02:41
esta complejidad de aquí 00:02:42
¿qué es lo que hace? 00:02:45
con el dato que tú quieres meter 00:02:48
en este caso 00:02:50
en el caso de nuestro main con el string 00:02:52
el dato que tú quieres meter, este 00:02:53
hazte un nodo 00:02:56
que tenga ese dato 00:02:57
dentro, hazte un nodo 00:03:00
vale 00:03:02
y con la segunda propiedad de nodo 00:03:03
pues entonces se quedará apuntando a nul 00:03:06
ahora 00:03:08
¿qué haces con este nodo? 00:03:09
hacer que su siguiente 00:03:12
apunte a donde apuntaba 00:03:15
inicio, vale 00:03:16
el inicio original 00:03:18
estaba nul 00:03:20
en este caso 00:03:21
entonces cuando metes el primer elemento en la lista 00:03:23
cuando está todavía vacía 00:03:28
pues con esta sentencia en realidad no estás haciendo nada 00:03:29
porque inicio ya apunta a nul 00:03:32
pues al hacer nodo siguiente 00:03:33
esto es siguiente igual a inicio 00:03:35
le estás volviendo a dar nulo otra vez 00:03:37
y ahora 00:03:39
¿qué haces? a inicio 00:03:41
dale a la dirección inicio 00:03:43
dale la dirección de nodo 00:03:45
luego esto ya sí que lo haces 00:03:46
esto ya 00:03:48
estás borrando esto y a la dirección inicio 00:03:50
dale la del nodo que te has creado 00:03:53
¿vale? esto es la complejidad 00:03:55
que está escondida dentro de este add first 00:03:57
que volvemos a 00:03:59
llamar al add first como hemos 00:04:01
hecho aquí en el main 00:04:03
que volvemos a llamarle para otro más 00:04:04
pues el main le da igual 00:04:11
como está hecho, solo sabe que eso es hola 00:04:14
Dios, esas cadenas están cayendo dentro 00:04:16
sabe que están cayendo dentro 00:04:17
¿cómo? nosotros lo sabemos porque lo hemos programado 00:04:19
¿cómo están cayendo dentro? 00:04:22
pues la situación que teníamos 00:04:27
después del primer adfer será esta 00:04:28
teníamos el inicio 00:04:30
apuntando 00:04:32
al primer nodo dato que hemos metido 00:04:34
el hola 00:04:36
esta es la situación 00:04:37
que se había quedado 00:04:40
después del primer add first, se había quedado esta situación 00:04:41
ahora, hacemos el segundo 00:04:44
add first, ¿vale? pues que 00:04:46
con el adiós, pues que ha hecho 00:04:47
primero, se construye 00:04:50
un nodo, donde el 00:04:52
dato es, la cadena 00:04:55
esa, y el 00:04:57
campo siguiente, sin inicializar 00:04:59
lo que es lo mismo, anul 00:05:02
eso es lo que hacemos con la primera 00:05:03
línea, ¿qué hacemos con 00:05:05
la segunda línea? 00:05:07
que su siguiente, el siguiente de ese nodo 00:05:09
vaya a donde va Inicio. 00:05:11
Inicio va aquí. 00:05:14
Pues este deja de ir a Null 00:05:15
y empieza a ir aquí. 00:05:16
Vale. 00:05:21
A este primero, que era el primero, 00:05:21
le apuntan ya dos. 00:05:23
¿Y ahora qué es lo siguiente que hacemos? 00:05:25
Que Inicio empiece a ir 00:05:26
a donde iba Nodo. 00:05:29
¿Vale? Que es este. Este es Nodo. 00:05:31
Luego Inicio se borra de aquí 00:05:33
y empieza a ir aquí. 00:05:35
¿Vale? Pues efectivamente 00:05:38
ahora mi lista enlazada 00:05:40
tiene dos elementos. 00:05:41
Este primero 00:05:43
y este segundo. 00:05:44
Y así todo el rato. 00:05:47
Dime. 00:05:48
Perdón, hacer un... 00:05:58
A ver, es que 00:06:00
no hace falta 00:06:04
meter tanta complejidad 00:06:06
porque 00:06:07
ahora no estamos hablando 00:06:08
de entidades de un modelo. 00:06:09
de una aplicación que tiene cliente, factura. 00:06:11
Nodo, en realidad, es una clase 00:06:14
que su único uso va a ir asociado a mi LinkedIn List, 00:06:16
que es esta clase. 00:06:19
Entonces, esto no es una entidad modelo, en realidad, 00:06:21
que represente una entidad con la que trabaja mi aplicación. 00:06:23
Esta está oculta. 00:06:26
Esta la aplicación no la ve. 00:06:27
Esta sirve solo para que la use esta otra. 00:06:29
Van las dos como en pack. 00:06:33
Van las dos siempre juntas. 00:06:34
Entonces, el único uso de nodo va a ser desde esta. 00:06:36
Solo desde esta. 00:06:40
entonces ponerle get y set 00:06:41
solo lo va a usar esta, va a ir en pack 00:06:43
pues bueno, podríamos 00:06:45
pero pierde un poco su sentido 00:06:47
es más cómodo, escribamos directamente 00:06:48
la propiedad y ya está 00:06:51
lo de los get y los set son para entidades 00:06:52
de modelo, genéricas, que tú ofreces 00:06:54
yo expongo un modelo, expongo mi modelo 00:06:57
de lógica de negocio, de facturas de clientes 00:06:59
y ahora yo expongo mi modelo 00:07:01
que va a ser 00:07:03
accedido 00:07:05
desde mis sitios, desde un framework 00:07:09
de no sé qué, desde mis propias clases de mi mail 00:07:11
pues ahí expongo mi modelo con mis 00:07:13
get me set porque me ofrezco al mundo 00:07:15
y mi forma de ofrecerme al mundo 00:07:16
es con get me set, porque es la que tenemos 00:07:19
todos por convenio 00:07:21
que nos ofrecemos a los desconocidos 00:07:23
con get me set, pero nodo 00:07:26
no se ofrece a los desconocidos 00:07:27
nodo está pensada solo 00:07:29
solo para que la use 00:07:31
mi linked list, es el único 00:07:33
sentido de nodo, para que la use 00:07:36
la otra clase, Nodo está oculta, nadie la va a usar 00:07:38
¿vale? 00:07:40
de hecho, Nodo 00:07:41
es que no debería ser 00:07:43
ni pública 00:07:45
¿vale? 00:07:47
Nodo no debería ser ni pública 00:07:52
porque solo la va a usar mi linked list 00:07:54
que en principio van a estar en mi baquete 00:07:56
¿vale? 00:07:57
entonces esta no tiene que ofrecerse 00:08:00
al mundo 00:08:02
¿vale? pues entonces 00:08:03
ahora ya 00:08:09
añadir a la lista, añadir al principio 00:08:13
ya lo sabemos, pero claro 00:08:17
hicimos en el main, probamos esto 00:08:18
y vimos que efectivamente esto se ejecutaba 00:08:20
y no daba error 00:08:22
no daba error, pero hombre 00:08:23
para ver si le hemos hecho bien nuestra lista 00:08:25
que menos que añadir un get 00:08:28
y un size 00:08:30
para poder recorrerla y ver lo que tiene 00:08:31
dentro, y hacer una lista 00:08:34
mínimamente operativa 00:08:36
bueno, pues vamos a 00:08:37
hacer el método get 00:08:40
con el método get 00:08:42
ya vamos a ver el proceso de avanzar 00:08:43
por la lista y con el proceso de avanzar 00:08:46
uno ya puede hacer remove y lo que dé la gana 00:08:48
vale 00:08:50
pues como sería el método get 00:08:51
pues el método get 00:08:54
sería un método 00:08:55
de mi linked list 00:08:58
que esta si que tendría que ser pública 00:09:00
porque esta si que la puede usar cualquiera 00:09:01
esta clase la usa cualquiera para instanciarla 00:09:03
vale pues 00:09:06
esta el método get me tiene que devolver 00:09:09
un objeto de tipo T 00:09:11
get a partir 00:09:13
de una posición 00:09:15
vale, pues aquí 00:09:17
sentencia 00:09:28
de avance 00:09:31
vale, pues aquí 00:09:33
tenemos nuestra listita 00:09:48
con un dato 00:09:49
y siguiente 00:10:00
siguiente me lleva a otro objeto nodo 00:10:02
con el siguiente dato 00:10:06
de la lista 00:10:08
y siguiente 00:10:09
siguiente 00:10:12
me lleva 00:10:14
otro objeto 00:10:18
nodo y ya el último 00:10:21
con otro objeto de la lista y siguiente 00:10:22
que este ya nodo 00:10:27
el inicio es otro nodo 00:10:29
como cualquier otro 00:10:31
si el inicio es un objeto nodo igual que 00:10:32
siguiente es un objeto nodo es que la dirección 00:10:35
y el objeto a la hora de escribirlo en java es lo mismo 00:10:37
es decir de hecho inicio 00:10:39
está declarado 00:10:41
Inicio 00:10:42
está declarado 00:10:45
como 00:10:46
¿Ves? 00:10:47
¿Dónde está Inicio? 00:10:55
Aquí, ¿ves? 00:10:57
Inicio está declarado como nodo, porque es la dirección 00:10:59
de un nodo. 00:11:02
Inicio está declarado como nodo. 00:11:03
Vale. 00:11:06
A lo que íbamos. 00:11:08
Vale. Y esto 00:11:10
también está declarado como nodo, 00:11:12
porque es la dirección de un nodo. 00:11:14
Luego el campo siguiente de nodo... 00:11:15
¿Cómo lo pone distinto? 00:11:17
¿Cómo lo pone distinto? 00:11:19
Bueno, porque cuando representamos un objeto siempre lo hemos representado así. 00:11:23
Esto y el objeto con sus propiedades, siempre lo hemos representado así. 00:11:27
Entonces, este imagínate que es el objeto alumno. 00:11:31
Alumno A. 00:11:34
Alumno A. 00:11:37
Pues, ¿qué es A realmente? 00:11:38
A realmente es el espacio en memoria que contiene la dirección donde están los datos del alumno, ¿vale? Los datos del alumno, ¿vale? Es decir, A no es esto en realidad. A es el espacio en memoria que tiene la dirección que tiene ya sí que sí los datos, pero el objeto está en otra dirección de memoria, ¿vale? 00:11:40
Vale, pues entonces, vale, pues a ver, recuperar por posición. Esta es la parte complicada de la lista. Que yo tengo acceso solamente al primer dato, ¿vale? Yo puedo hacer, uy, puedo hacer inicio.dato e inicio.dato es el primero. 00:12:03
Pero el siguiente, ¿cuál sería? Pues sería inicio, punto, siguiente, punto, dato. Este sería este. Pero este, ¿cuál sería? Pues este sería inicio, punto, siguiente, punto, siguiente, punto, dato. 00:12:37
luego 00:12:59
¿qué tengo que hacer para avanzar 00:13:01
por la lista? ir encadenando 00:13:03
llamadas a siguiente todo el rato 00:13:05
no es tan sencillo 00:13:07
es decir, tengo que hacer un bucle 00:13:09
¿vale? ya preveo que tengo que hacer un bucle 00:13:10
que está avanzando 00:13:13
todo el rato 00:13:15
¿vale? pues ¿cómo hacemos esto? 00:13:16
vamos a hacernos 00:13:19
un objetito auxiliar aquí 00:13:20
que inicialmente apunte 00:13:22
donde apuntaba inicio 00:13:25
y yo lo voy avanzando 00:13:26
lo voy avanzando 00:13:28
y me paro donde me quiera parar 00:13:30
no debería poner al inicio también 00:13:32
¿eh? 00:13:35
al inicio no debería apuntar también 00:13:36
es que inicio no es un objeto, al inicio no le apunta a nadie 00:13:37
inicio es apuntador 00:13:41
al inicio nadie le apunta 00:13:42
inicio es el que apunta a este objeto 00:13:44
pero inicio también puede tener datos 00:13:47
no, inicio tiene una dirección de memoria 00:13:48
apunto pelota, no tiene más 00:13:50
inicio tiene una dirección de memoria 00:13:52
que es la dirección de memoria donde está 00:13:54
el dato y a su vez 00:13:56
otra dirección de memoria 00:13:58
donde está el dato y a su vez 00:13:59
otra dirección de memoria 00:14:02
claro, por eso significa 00:14:03
soy la dirección de un nodo 00:14:08
cuando tú haces 00:14:10
alumno a 00:14:11
estás diciendo 00:14:15
yo a soy 00:14:18
la dirección de un alumno 00:14:20
y cuando tú haces 00:14:22
a punto nombre 00:14:23
estás diciendo 00:14:25
el espacio nombre que está 00:14:27
en el cacho de memoria 00:14:29
a dónde llego 00:14:31
desde la dirección A, no dentro de A 00:14:32
sino a dónde llego 00:14:35
desde la dirección A 00:14:37
entonces cuando dices inicio 00:14:38
punto dato 00:14:40
estás diciendo 00:14:42
el cacho dato 00:14:44
que llego desde la dirección 00:14:46
de memoria que tengo yo 00:14:49
metida dentro 00:14:51
no dato es lo que 00:14:51
tengo yo metido dentro, no 00:14:55
porque inicio no tiene nada metido dentro, es una dirección 00:14:56
inicio es una dirección 00:14:59
que te lleva a un sitio 00:15:00
el punto sería como decir 00:15:02
navega hasta allí 00:15:04
el punto no significa métete dentro de inicio 00:15:05
y coge el dato, lo que pasa es que 00:15:09
como programamos así normalmente 00:15:10
pues ya como que tenemos interiorizado 00:15:12
pero inicio sería, estaría mejor 00:15:14
expresado si Java hubiera 00:15:17
decidido hacerlo así 00:15:18
significa, coge la dirección inicio 00:15:20
navega a través de ella 00:15:23
donde te lleve y a donde 00:15:24
te ha llevado, coge datos 00:15:27
¿vale? estaría mejor expresado así 00:15:28
que en los tiempos de C 00:15:31
se usaba más ese operador 00:15:32
¿vale? no es fácil esto de entender 00:15:35
la diferencia entre objeto 00:15:40
espacio y memoria, referencia 00:15:42
y espacio y memoria 00:15:45
pero bueno, más o menos 00:15:46
a fuerza de que nos veamos 00:15:47
con situaciones similares 00:15:51
pues lo entendemos 00:15:52
bueno, pues entonces 00:15:53
esta variable auxiliar 00:15:54
yo la inicializaría 00:15:57
con lo que tenga inicio 00:15:59
y ahora esta variable auxiliar 00:16:00
ya me va a permitir 00:16:04
consultar todos los 00:16:05
valores 00:16:08
por ejemplo 00:16:08
esto me permite ser 00:16:11
cóncavo, es alucinante 00:16:13
a ver si yo 00:16:15
si yo hago 00:16:17
esto, no me deja 00:16:23
una figura 00:16:32
cóncavo, vale 00:16:34
bueno, pues entonces yo aux 00:16:36
la inicializo a inicio 00:16:39
con lo cual se queda aquí apuntando 00:16:42
ahora, ya podría consultar 00:16:44
el dato de la primera posición 00:16:46
el de la primera posición está claro 00:16:47
sería aux.data 00:16:49
ese sería el de la primera 00:16:52
pero claro, para consultar el de la segunda 00:16:53
tengo que mover aux 00:16:57
para que apunte aquí 00:16:59
¿qué sentencia se os ocurre 00:17:01
que tengo yo que escribir? 00:17:04
para que aux deje de apuntar a este objeto 00:17:06
y empiece a apuntar a este otro. 00:17:09
Díctamela. 00:17:15
¿Qué sentencia tengo que poner yo ahí para que aux? 00:17:16
¿Qué le tengo yo que asignar a aux 00:17:22
para que aux salte de aquí 00:17:24
y empiece a apuntar aquí? 00:17:25
No, es aux la que quiero cambiar, 00:17:31
con lo cual la asignación es hacia aux. 00:17:33
¿Aux igual a? 00:17:34
Bueno, me estás llevando hasta aquí 00:17:37
Entonces 00:17:40
Inicio punto siguiente me lleva aquí 00:17:40
Sí 00:17:43
Inicio es esta 00:17:45
Inicio punto siguiente es esta 00:17:46
Vale, a ver, con lo que me habéis dicho 00:17:48
Inicio punto siguiente 00:17:53
Efectivamente 00:17:55
He cambiado aux 00:17:57
Y ahora aux 00:17:59
Ha pasado a apuntar aquí 00:18:00
¿Vale? 00:18:02
Lo que pasa es que si ahora quiero que me llevéis a la tercera 00:18:04
Pues tenéis que hacer inicio, punto y tiempo 00:18:07
O sea, es más fácil 00:18:09
Más compacta 00:18:10
O sea, si ahora quiero que me lleves a la tercera 00:18:12
Tendría que hacer esto 00:18:14
Inicio, punto siguiente, punto siguiente 00:18:15
¿Qué quiero decir? 00:18:19
No es la misma sentencia idéntica 00:18:21
No puedo meterla en un bucle 00:18:23
Yo quiero una que pueda meter en un bucle 00:18:24
Para repetirla tantas veces 00:18:27
Como haga falta 00:18:29
Porque esta no la puedo meter en un bucle 00:18:30
¿Aux igual a? 00:18:33
Pues inicio 00:18:36
Ya está 00:18:38
Ya está 00:18:45
Ya la he avanzado 00:18:47
Aux.siguiente es esta 00:18:48
Lo haces a Aux, saltó 00:18:51
Ahora Aux está aquí, vamos a volver a ejecutarla 00:18:53
Aux.siguiente es esta 00:18:56
Pues saltó 00:18:58
Ahora quiero avanzarla otra vez 00:18:59
Aux.siguiente es esta 00:19:02
Pues saltó 00:19:04
Es decir, cada vez que hagamos esta sentencia 00:19:05
Aux 00:19:09
da un salto y pasa a apuntar 00:19:10
de un nodo al siguiente. 00:19:12
¿Verdad? Cada vez que ejecutemos 00:19:14
esto, AUX, pum, da un salto al siguiente 00:19:16
nodo, pum, da un salto al siguiente, da un salto al siguiente. 00:19:18
Cada vez que hagamos esa sentencia. 00:19:20
Luego, 00:19:23
yo ya meto esa sentencia 00:19:24
en un bucle y puedo avanzar 00:19:26
las veces que me dé la gana. Puedo avanzar 00:19:28
las veces que quiera. 00:19:30
Depende de lo que quiera hacer, si quiero recorrer hasta el final 00:19:34
o si quiero quedarme en una posición como en el caso del 00:19:36
GET. En el caso del GET, pues hasta 00:19:38
un contador, ¿vale? 00:19:40
Un contador y avanzo tantas veces como me diga 00:19:42
en posición, que sería el caso 00:19:44
del get de aquí, ¿vale? 00:19:46
Entonces, ahora ya entendiendo esta sentencia, 00:19:53
vamos a meterla en el 00:19:56
en el get nuestro. 00:19:57
No, desde el gol del dato, porque 00:20:12
desde fuera tú los nodos ni los conoces 00:20:14
ni quieres saber nada de ellos, tú trabajas con datos. 00:20:16
De hecho, nuestro get 00:20:19
Yo lo he hecho para que te devuelva un P 00:20:20
Claro, en cada nodo solo hay un dato 00:20:23
El dato nuevo implica 00:20:29
Nodo nuevo 00:20:31
Enlazado al anterior 00:20:32
Vale, pues entonces getPosición 00:20:34
Pues vamos a hacernos este nodo aus 00:20:37
Pero para que quieres meterlo dentro de un nodo 00:20:51
No, es que para eso ya tenemos 00:20:53
el ArrayList 00:21:04
Claro 00:21:04
Para eso ya tenemos el ArrayList, esto está pensado 00:21:06
para que cada dato sea un nodo enlazado con su siguiente 00:21:09
Es que me da igual, el tipo T 00:21:12
ya será lo que sea, tú luego ahí 00:21:19
yo metí un string, pero podía meter 00:21:21
un objeto alumno que tuviera 00:21:23
mil cosas dentro, eso ya es otro tema 00:21:25
da igual, lo que tenga dato 00:21:27
eso da igual, eso ya estará metido ahí 00:21:28
en el campo dato, que a su vez puede tener 00:21:31
un montón de campos, pero eso ya 00:21:33
a esta estructura le da igual 00:21:35
¿vale? 00:21:36
pues como lo estamos haciendo ahora 00:21:46
estamos habilitando métodos 00:21:48
para poder acceder a esa información 00:21:50
ya hemos hecho el método de añadir 00:21:52
vamos a hacer el de recuperar un nodo 00:21:54
por una posición, vale, vamos a 00:21:56
programar lo que hemos escrito antes. 00:21:58
Mi nodo auxiliar, que inicialmente 00:22:00
está a inicio. Y ahora 00:22:02
vamos a avanzarlo 00:22:04
tantas veces como 00:22:05
posición me ha dicho. 00:22:08
¿Vale? 00:22:11
Este bucle ya sabemos que se ejecuta 00:22:14
posición veces, que es las veces que yo 00:22:16
quiero avanzar. 00:22:17
Si me han dado cero, no quiero avanzar ninguna. 00:22:19
Entonces devuelvo el propio aux 00:22:21
que está apuntando a inicio. 00:22:23
¿Vale? Pues aux igual 00:22:25
a aux punto siguiente. 00:22:27
Con este bucle de aquí 00:22:29
Estamos haciendo esa operación 00:22:33
De coger el aux y hacerle saltar 00:22:37
Una, otra, otra 00:22:39
¿Cuántas veces va a saltar? 00:22:40
Tantas como me diga el for 00:22:43
Que es lo que yo le he dicho 00:22:44
Si le digo devuélveme la posición 3 00:22:46
Me salta 3 veces 00:22:48
La primera me apunta a 0 00:22:50
1, 2 00:22:52
Entonces 00:22:53
Una vez que ya he avanzado 00:22:56
Tantas veces como hacía falta 00:23:00
el dato a devolver 00:23:02
ya sé dónde está, en aux.dato 00:23:03
pues ese es el que tengo que devolver 00:23:06
¿vale? una vez, después de haber acabado 00:23:09
este for, ya habiendo avanzado 00:23:12
todo lo que tengo que avanzar 00:23:14
ya está 00:23:17
ya puedo devolver 00:23:18
el dato 00:23:23
¿vale? aquí, para no dejarlo tan feo 00:23:24
convendría hacer 00:23:29
bueno, una validación 00:23:30
¿vale? y ya la 00:23:35
bueno, antes de 00:23:37
qué posición me la han dado 00:23:39
comprendida en el número 00:23:41
de nodos que tiene 00:23:43
pero bueno, espera, antes de hacerla 00:23:44
porque vamos a editar 00:23:47
yo ahora voy a usarla desde aquí 00:23:48
esto todavía 00:23:51
no porque el método 6 no lo tengo hecho 00:23:54
por ejemplo, vamos a ver si funciona 00:23:55
vamos a mostrar la cadena 00:23:57
de posición 0 00:24:00
a ver cuál me sale 00:24:03
y luego vamos a mostrar 00:24:05
la cadena que está en la posición 1 00:24:07
vamos a ver si 00:24:09
si esto me funciona 00:24:18
perfecto 00:24:21
en la posición 0 00:24:29
está la cadena a Dios 00:24:33
porque recordad que cada lo está colando 00:24:35
al principio 00:24:37
en la primera posición está a Dios 00:24:39
y en la siguiente está a Ola 00:24:42
y si yo metiera otra 00:24:46
pues esta estaría 00:24:48
ahora ya esto cambiaría 00:24:57
voy a mostrar las tres que tengo 00:24:59
ah, es que he puesto tres en vez de dos 00:25:01
vale, vale 00:25:12
ya está, otra, adiós y hola 00:25:13
las tres cadenas que he metido 00:25:18
esta se quedó 00:25:19
en la primera posición porque se cuela al principio 00:25:22
al hacer el add first 00:25:24
vale, lo que pasa es que efectivamente 00:25:25
este get lo queremos usar 00:25:30
dentro de un bucle de este estilo 00:25:32
yo quiero 00:25:34
en los arrays siempre recorremos 00:25:36
en función de su longitud, si tenemos un parámetro 00:25:38
length, hombre, pues aquí que menos 00:25:40
que ponerle un método a mi 00:25:42
ArrayList, que menos 00:25:44
que me devuelva la cantidad de posiciones que tiene 00:25:45
porque es que si no se lo pongo 00:25:48
pues hasta donde recorro 00:25:50
que menos, ¿no? 00:25:52
que hacer este método size, bueno, pero es que hacer este 00:25:54
pues no es tan complicado 00:25:56
porque se trata 00:25:58
de ir avanzando y contando hasta que 00:26:00
lleguemos a null 00:26:02
a ver 00:26:03
pero entonces 00:26:04
pero entonces ese led 00:26:11
lo tienes que mantener siempre 00:26:12
cada vez que hagas un add o un remove 00:26:14
si es que se hace el remove, mantenerlo sincronizado 00:26:16
entonces bueno, a ver 00:26:19
es una opción, ¿vale? 00:26:20
lo mantienes sincronizado siempre 00:26:22
y no te olvidas nunca de que si añades un método 00:26:24
que cambia el tamaño, pues de cambiarlo 00:26:26
se podría hacer así 00:26:29
¿vale? pero vamos a hacer el método size tal cual 00:26:30
para no poner una propiedad nueva 00:26:33
entonces 00:26:34
pues este método 00:26:35
¿qué tiene que hacer? 00:26:37
contar 00:26:43
la cantidad de saltos que hay que hacer 00:26:45
hasta llegar a nul, eso es lo que tiene que hacer 00:26:48
¿vale? 00:26:49
pues venga, vamos a parar aquí un momentito 00:26:51
lo hacéis 00:26:54
si os parece 00:26:57
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:
7 de febrero de 2026 - 18:42
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
27′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
649.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid