Saltar navegación

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

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues vamos a avanzar un poquito 00:00:00
y vamos a introducir las colecciones, ¿vale? 00:00:05
Porque ya nos las está pidiendo el cuerpo. 00:00:17
Ya estamos hartos de los Arrays. 00:00:19
Porque son un rollo, los Arrays, realmente. 00:00:23
¿Vale? 00:00:27
¿Para qué hemos usado los Arrays? 00:00:30
Han sido imprescindibles 00:00:32
cuando necesitábamos guardar muchos datos 00:00:33
del mismo tipo 00:00:37
del mismo tipo 00:00:38
o de la misma superclase 00:00:40
todos ellos, ¿vale? 00:00:43
en ambos casos los podíamos guardar en el mismo array 00:00:44
ese array se queda 00:00:46
declarado como la superclase 00:00:47
y ya está, ¿vale? 00:00:51
entonces, ha sido imprescindible 00:00:55
si yo quiero guardar 00:00:56
un montón de empleados 00:00:58
un montón de ellos 00:01:00
10, 100 00:01:03
no puedo guardarlos en variables independientes 00:01:04
podría, por supuesto 00:01:07
pero ¿cuántas variables hago? 100 00:01:08
y si luego aparece uno, me meto en el código 00:01:10
y hago una variable más 00:01:12
cuando tenga luego que recoger los empleados 00:01:13
para procesarlos 00:01:16
como hago, son variables sueltas 00:01:19
obviamente, así no podíamos 00:01:20
trabajar 00:01:22
entonces cuando teníamos que usar un montón 00:01:23
de datos del mismo tipo 00:01:27
o de la misma super clase 00:01:28
o de la misma super clase 00:01:30
pues usábamos el array 00:01:32
y esa estructura es una estructura imprescindible 00:01:33
para poder hacer cualquier programa de programación estructurada 00:01:37
y está en todos los lenguajes de programación estructurados 00:01:41
ya sabemos cómo se maneja y todo eso 00:01:43
y también sabemos que es un poco rollo 00:01:46
porque cuando uno la declara 00:01:50
tiene que comprometerse a definir un tamaño 00:01:52
uno, no hay otra 00:02:00
porque así funcionan los arrays 00:02:04
Entonces, si yo pongo 10 en el momento de instanciar ese objeto Array, si yo pongo 10, esto se ha convertido en un Array de 10 posiciones y así va a ser para siempre. 00:02:06
Entonces, una vez construido, es una estructura muy rápida de acceder. Yo accedo por su índice 0, 1, 2 y el acceso es muy rápido. Doy el índice y accedo. 00:02:23
Pero, que quiero incorporar un dato nuevo que me ha aparecido posteriormente, pues este array ya no me vale, es imposible. Tenemos que hacer otro y no hay otra. Es así sí o sí. 00:02:37
a ese otro moveré 00:02:51
a ese otro moveré 00:02:54
moveré lo viejo 00:03:07
añadiré lo nuevo 00:03:13
y este se va a la basura porque no hay otra 00:03:17
y la referencia antigua 00:03:20
ahora empieza a apuntar a esto 00:03:22
y no hay otra manera de trabajar con Arrays 00:03:24
¿vale? entonces en realidad 00:03:26
no es un problema 00:03:28
no es un problema, lo que pasa es que a nivel de código 00:03:30
a nivel de escritura de código es un rollo 00:03:33
porque a nivel de escritura de código tenemos que hacer todo esto 00:03:36
que hemos hecho mil veces, crear el array nuevo 00:03:39
con las nuevas posiciones, más posiciones 00:03:42
o menos posiciones, depende de si queremos 00:03:46
insertar o eliminar, hacer las copias 00:03:48
que procedan y luego ya sustituir 00:03:52
la referencia que apuntaba aquí, sustituirla por esta 00:03:55
Entonces este, el viejo 00:03:58
Ya sabemos que entonces se queda 00:04:00
Desapuntado 00:04:03
Ahí ya nadie le quiere 00:04:05
No hay manera de acceder a él 00:04:07
No pasa nada, durante unos milisegundos 00:04:09
No más 00:04:12
Se va a quedar ahí en memoria, ocupando memoria 00:04:12
Durante unos milisegundos 00:04:15
Pero al cabo de ciertos milisegundos 00:04:16
El recolector de basura, pipipi 00:04:18
Ese proceso demonio, pues despierta 00:04:20
Y dice, uy, aquí hay algo en memoria 00:04:22
Que no tiene ni una sola referencia 00:04:25
en el código, en el proceso, ni una 00:04:27
pues hala, fuera 00:04:30
y lo quita 00:04:32
¿vale? 00:04:33
sí, puedes 00:04:36
¿vale? 00:04:37
bueno, pues entonces 00:04:44
nos es pesado trabajar con Arrays 00:04:45
a nivel de escritura de código 00:04:47
esa es la conclusión, nos es pesado 00:04:50
porque tenemos que hacer todo el rato 00:04:51
esa creación nueva 00:04:53
copiado y eliminado 00:04:54
entonces, ¿qué 00:04:56
soluciones podemos adoptar 00:04:59
vale, pues vamos a 00:05:02
encerrar esta complejidad 00:05:05
en un objeto 00:05:07
que me ofrezca métodos 00:05:08
que ya me lo haga 00:05:10
pero que me haga eso, porque es que no hay otra que me lo haga 00:05:12
voy a encerrar esto en una clase 00:05:15
en una clase 00:05:17
que me ofrezca 00:05:19
métodos para hacer estas cosas 00:05:21
y que ya lo haga 00:05:23
esa clase por dentro 00:05:24
entonces yo llamo a esa clase 00:05:26
llamo a esos métodos 00:05:27
y ya está. Lo que está ocurriendo 00:05:29
en Java por dentro es lo mismo. 00:05:31
Pero al meter yo esto en una clase 00:05:34
encerradita, con unos 00:05:36
métodos, puedo usar esa clase 00:05:37
llámala los métodos y a nivel de escritura 00:05:39
de código es más sencillo. 00:05:41
Vale, pues esa clase, ¿cuál es? 00:05:44
Es la famosa 00:05:47
clase ArrayList que tanto os gusta. 00:05:47
¿Vale? Entonces, 00:05:55
¿qué es una ArrayList? Primer 00:05:57
ejemplo de colecciones. Primer ejemplo. 00:05:59
Para que entendamos la idea, 00:06:01
los colecciones no es que sea algo 00:06:02
nuevo, no, no hay nada nuevo 00:06:04
todo lo que hay en Java 00:06:06
todo, ya lo conocemos 00:06:08
porque solamente hay variables 00:06:10
primitivas y arrays 00:06:12
no hay más 00:06:14
y sentencias de control como 00:06:15
if, for, while, switch 00:06:18
ya está, no hay más, todo lo que hay 00:06:20
a partir de ahí es meter esas cosas 00:06:22
en clases 00:06:24
para usarlas nosotros 00:06:25
muchas de esas clases 00:06:27
lógicamente se distribuyen 00:06:30
en la librería que acompaña a la máquina 00:06:32
virtual, la que nosotros llamamos la JRE 00:06:34
ahí sabemos que hay como 2.000 millones de clases 00:06:36
¿vale? 00:06:38
pues como Scanner 00:06:40
como System.out, como un montón 00:06:41
de clases, pues todas esas clases 00:06:44
tienen dentro lo único que se puede 00:06:46
hacer, que es 00:06:48
combinación de variables primitivas 00:06:50
Arrays y sentencias de control como 00:06:52
EFIFOR, no hay más 00:06:54
entonces aparte de las clases que ya 00:06:55
vienen incorporadas en la máquina 00:06:58
virtual a las que yo llamo 00:07:00
desde mi programa 00:07:02
uno se hace ya sus propias clases 00:07:03
para crearse datos más complejos 00:07:06
datos objetos 00:07:08
¿vale? datos objetos 00:07:09
y no hay más que eso 00:07:10
bueno, pues las colecciones son eso 00:07:12
clases que ya están hechas 00:07:15
que podríamos hacer nosotros 00:07:18
y alguna la vamos a hacer ahora 00:07:20
podríamos hacer nosotros 00:07:22
clases que ya están hechas 00:07:23
que ocultan 00:07:25
encapsulan dentro de ellas 00:07:28
una forma de guardar objetos 00:07:31
que yo puedo usar desde fuera 00:07:33
y por tanto me olvido de la complejidad 00:07:36
de cómo están almacenados 00:07:39
yo me limito a una caja 00:07:40
mete en la caja, saca, recorre 00:07:43
¿vale? esas son las colecciones 00:07:45
las colecciones son como si fueran 00:07:46
cajas 00:07:49
para meter datos 00:07:50
es decir, en realidad 00:07:54
como si fuera un array, un array es eso, una caja para meter datos 00:08:01
pero las colecciones 00:08:04
me envuelven toda esa complejidad 00:08:06
me la encierran dentro y me ofrecen unos 00:08:08
métodos para que yo llamando 00:08:10
a los métodos se hagan esas 00:08:12
cosas sin que yo las tenga 00:08:14
que hacer directamente por código 00:08:16
ya está, simplemente eso, sin que yo 00:08:18
las tenga que hacer por código, nada más 00:08:20
bueno, pues cajitas de estas 00:08:21
es decir, colecciones, clases de estas 00:08:24
que envuelven esa complejidad de meter 00:08:26
cosas en las cajas y sacarlas 00:08:28
hay muchas 00:08:30
muchas posibilidades 00:08:32
en función de qué tipo de almacenamiento me interese a mí 00:08:34
o qué tipo de uso voy a hacer yo de ese almacenamiento. 00:08:38
Hay muchas posibilidades, ¿vale? 00:08:41
Ahora las vamos a ver en detalle. 00:08:44
Ahora las vamos a ver en detalle. 00:08:45
Pero antes de nada, para motivar un poquito 00:08:47
de dónde sale todo esto, 00:08:49
vamos a ver, hemos puesto el ejemplo del ArrayList, ¿vale? 00:08:52
Entonces, ¿qué es un ArrayList? 00:08:56
Un ArrayList es una clase que ya está hecha en Java, 00:08:58
pero que podríamos hacer nosotros perfectamente. 00:09:01
que me envuelve la complejidad 00:09:04
de meter cosas en el array y sacarlas 00:09:06
eso es un ArrayList, no es más que eso 00:09:08
entonces si nosotros hiciéramos un 00:09:10
ArrayList nuestro 00:09:14
pues porque se nos podría haber ocurrido a nosotros 00:09:15
en lugar de usar el ArrayList que ya viene en Java 00:09:26
se nos podría haber ocurrido 00:09:28
jolines, cada vez que meto en un Array 00:09:30
estoy todo el rato repitiendo 00:09:32
el mismo código, que es 00:09:34
crea array auxiliar con una posición más 00:09:36
copia, añade el nuevo 00:09:38
elimina el anterior y sustituye 00:09:41
Cada vez que estoy eliminando de una vez es lo mismo, crear uno con una posición menos, copia saltándote el de eliminar, estoy haciendo eso todo el rato. Otro principio de desarrollo es no repetirse, no te repitas, no te repitas, no te repitas, si lo puedes evitar no te repitas, ¿vale? 00:09:43
bueno, pues se nos podría 00:10:01
haber ocurrido, se nos podría haber ocurrido 00:10:04
y decir, jolines, me voy a hacer yo una clase 00:10:06
que pueda usar 00:10:09
siempre que quiera usar un array 00:10:10
y que esa clase tenga métodos 00:10:12
dentro para encerrar esa complejidad 00:10:15
de insertar en el array 00:10:17
y sacar del array, y así no tengo que repetirme 00:10:18
todo el rato con el mismo código 00:10:20
¿vale? se nos podría haber ocurrido 00:10:22
hacer esa clase a nosotros 00:10:24
lo que pasa es que, bueno, que ya está hecha, es el array list 00:10:26
si se nos hubiera ocurrido 00:10:28
hacer esa clase a nosotros 00:10:30
pues podríamos haber hecho por ejemplo esta clase 00:10:31
¿vale? esta clase que está pensada 00:10:34
para ser una cajita 00:10:36
una cajita con datos 00:10:37
y además con la 00:10:40
posibilidad de tener un comportamiento 00:10:42
del tipo pues meter 00:10:44
sacar 00:10:46
o sea consultar 00:10:49
eliminar 00:10:52
a ver 00:10:53
se me ha roto el roto 00:10:58
bueno pues si se nos hubiera ocurrido hacer a nosotros 00:10:59
esa caja 00:11:14
que habríamos dicho, vale 00:11:15
los objetos 00:11:17
miArrayList, los objetos 00:11:20
cada vez que yo instancie 00:11:22
un objeto miArrayList 00:11:23
es decir, cada vez que hagamos 00:11:25
esto en mi código 00:11:28
cada vez que yo instancie 00:11:28
un objeto miArrayList 00:11:31
cada vez que yo lo instancie 00:11:33
lo que querré que se cree 00:11:36
lo que querré 00:11:39
que se cree, lo he dicho bien 00:11:41
lo que querré crear 00:11:42
es una caja para meter datos 00:11:44
eso es lo que querré crear 00:11:47
cuando instancio mi ArrayList 00:11:49
vale 00:11:51
pues para que este objeto 00:11:51
me sirva para meter muchos datos 00:11:54
tendrá que tener 00:11:57
dentro una propiedad 00:11:59
que lo permita 00:12:01
pues mi ArrayList no le queda más remedio 00:12:02
que tener dentro una propiedad 00:12:05
Array 00:12:07
porque ese es el objeto mi ArrayList 00:12:07
el objeto mi ArrayList es un objeto 00:12:10
que me tiene que servir 00:12:12
para guardar dentro un montón de cosas. 00:12:13
Para guardar dentro un montón de cosas. 00:12:16
Vale, pues tendrá que tener aquí un array de cositas. 00:12:18
¿Vale? 00:12:28
Entonces, ah, nos vendía la primera pregunta, 00:12:28
que es, pero espérate, yo cuando declaro un array 00:12:30
tengo que poner aquí siempre el tipo de dato, 00:12:34
siempre, lógicamente. 00:12:36
Entonces, este mi array list no me va a valer 00:12:38
para cualquier tipo de dato, 00:12:43
porque yo aquí si pongo string 00:12:45
solo me va a valer para una caja 00:12:47
de muchos string, si pongo int 00:12:49
solo me va a valer para una caja 00:12:51
de muchos int 00:12:52
pues sí, efectivamente, no hay otra 00:12:54
tendríamos que dar el salto 00:12:57
a genérico 00:12:59
que lo daremos más tarde 00:13:00
para que esto me valga para todo 00:13:03
pero ese salto a genérico no es trivial tampoco 00:13:04
bueno, vamos a suponer que 00:13:07
nosotros queremos hacernos 00:13:09
nuestra propia colección 00:13:11
para guardar solamente 00:13:12
cadenas, por ejemplo, cadenas 00:13:15
porque todavía no sabemos dar el salto genérico 00:13:16
cadenas, pues entonces nos haríamos 00:13:18
nuestra clase miArrayList 00:13:21
y esto, y aquí 00:13:22
pondríamos el string 00:13:24
¿vale? 00:13:25
bueno, pues cada vez 00:13:32
que yo instancie un objeto miArrayList 00:13:34
estoy instanciando una cajita 00:13:36
para guardar string 00:13:38
o sea, este objeto miArrayList 00:13:39
está encapsulando dentro del array 00:13:41
Lo está ocultando dentro, ¿vale? 00:13:43
Lo que hay dentro de esta cajita en realidad es un array 00:13:44
¿Vale? Eso es lo que habría ahí 00:13:47
Un array de cosas, ¿vale? 00:13:49
Pero para que este objeto me sirva para algo 00:13:51
Este objeto que yo he creado 00:13:53
El objeto new myArrayList 00:13:54
Cuando yo le instancie mi programa 00:13:55
Que lo llamaré como sea 00:13:57
Pues yo que sea, como sea 00:13:59
Pues tiene que ofrecerme 00:14:00
Un comportamiento, es decir, me tiene que ofrecer 00:14:02
La posibilidad de meter dentro 00:14:05
Sacar, etcétera 00:14:07
Bueno, pues, declaremos esos métodos 00:14:09
por ejemplo, 00:14:12
¿qué método básico querremos hacer? 00:14:14
Querremos hacer un método 00:14:17
que si yo le paso un elemento nuevo, 00:14:18
como string, 00:14:24
pues lo metan en el array. 00:14:29
Eso es lo que yo querré hacer en esa cajita 00:14:32
de mi ArrayList. 00:14:34
Un método que si yo le paso un elemento nuevo 00:14:35
lo metan en el array. 00:14:38
¿Vale? 00:14:39
Pues aquí es donde programaríamos 00:14:39
Toda esa cosa que ya hemos hecho mil veces de memoria 00:14:42
Sí 00:14:45
Lo que tienen los lunes y la lluvia 00:14:46
Pero claro 00:14:58
¿A qué habéis quedado? 00:15:00
¿A coger el coche? 00:15:02
¿A qué habéis quedado a coger el coche? 00:15:03
Todos nos habíamos separado 00:15:04
Venimos separados 00:15:05
Bueno 00:15:07
Vale, pues aquí es donde habría que hacer 00:15:10
toda esa complejidad y de envolverla 00:15:12
ahí, que aquí, pues, ¿qué haríamos? 00:15:15
Lo de siempre. Pues una 00:15:17
array aux 00:15:19
igual a new 00:15:20
stream 00:15:23
de len de datos 00:15:25
más uno. 00:15:27
Lo pongo así abreviado. Ahora, 00:15:31
copiar 00:15:33
datos en aux. 00:15:34
Añadir 00:15:40
el elemento e 00:15:41
Añadirlo al aux 00:15:44
En la posición libre 00:15:47
Ahora sustituir 00:15:48
Datos para que sea 00:15:51
Aux, es decir 00:15:53
Este código es el que meteríamos aquí 00:15:55
¿Vale? Este código es el que meteríamos aquí 00:15:56
¿Vale? Entonces una vez metido 00:15:58
Ahí ya ese código 00:16:01
Ahora yo ya en cualquier programa 00:16:02
Que a mí me dé la gana, cada vez que yo quiera 00:16:04
Trabajar con un montón de cadenas 00:16:07
Me hago un objeto new mi array list 00:16:08
Y ahora ya que quiero 00:16:11
meter una cadena nueva? Pues a 00:16:13
punto a 00:16:15
la cadena nueva que sea. 00:16:16
Y ya está. 00:16:20
Entonces, en 00:16:22
esa caja, mi ArrayList, estaré metiendo 00:16:23
la cadena nueva hola. 00:16:25
Entonces, 00:16:27
a través de un método a, 00:16:29
pues, me estoy 00:16:32
ahorrando todo lo que hemos estado haciendo a mano 00:16:33
todo el rato. 00:16:35
Claro, esta cajita 00:16:41
para ser más funcional 00:16:42
me tiene que permitir 00:16:43
recuperar el objeto en una posición 00:16:45
concreta, dame el objeto 00:16:48
que tienes en la posición 7 00:16:50
vale, también tendría 00:16:52
que tener ese método 00:16:54
vale 00:16:55
bueno, pues no pasa nada, podríamos hacerle 00:16:57
a este miArrayList 00:17:00
le podríamos hacer un método 00:17:01
que fuera 00:17:05
pues 00:17:08
delete y le pasamos 00:17:09
una posición 00:17:18
y ahora haríamos aquí todo el código 00:17:19
que ya sabemos hacer, todo el que ya sabemos 00:17:24
hacer que es, me creo 00:17:26
una array aux con una 00:17:28
posición menos 00:17:30
que la que tiene datos 00:17:31
copio todo lo de 00:17:34
datos en aux, saltándome 00:17:36
la posición esta 00:17:38
esta me la salto, una vez 00:17:40
que ya lo he hecho, sustituyo datos 00:17:42
por aux, lo que hemos hecho siempre 00:17:44
me estoy saltando todas las validaciones 00:17:46
claro, para que esto fuera más potente 00:17:48
pues me estoy saltando 00:17:50
las validaciones de 00:17:52
verificar que la posición 00:17:53
esté comprendida entre 00:17:56
cero y datos.led 00:17:58
menos uno, ¿vale? 00:18:00
Porque si no, pues este no te puede devolver 00:18:02
nada, ¿vale? Pero bueno, estoy 00:18:04
hablando en general más que 00:18:05
del código en particular 00:18:08
de la filosofía de las colecciones, 00:18:09
de qué son, eso es lo que me importa, 00:18:12
¿vale? Luego este código 00:18:14
pues habría que hacerlo más en detalle, claro, 00:18:15
¿vale? Bueno, pues una vez que yo 00:18:18
he metido ahí ese código, 00:18:20
que sabemos hacerlo perfectamente, lo hemos hecho mil veces 00:18:21
y se basa en lo de toda la vida 00:18:24
los if, los for y los arrays 00:18:25
pues que ahora yo en mi objeto 00:18:27
mi array list que me he creado para guardar cadenas 00:18:29
quiero eliminar la cadera 00:18:32
de posición 7 00:18:33
pues a punto delete 00:18:34
y ya está 00:18:38
y así podría hacer 00:18:40
incorporar aquí todos los métodos 00:18:43
para hacer lo que a mi me parezca 00:18:45
que es útil con una 00:18:47
colección de datos, con una caja de datos 00:18:49
que viene a ser añadir, eliminar, que te devuelva elemento en una posición, que sería el get, por ejemplo, aquí tendría sentido hacer otro método, que sea este método, sería muy fácil de hacer, porque te devuelve directamente, este método sería return datos de post, vale, me estoy saltando validaciones, 00:18:51
el método, habría que hacerlo más 00:19:38
correcto, diciendo, a ver, pos 00:19:39
está comprendido entre 0 00:19:42
y datos.let menos 1, porque 00:19:44
si no lo está, pues no puedes 00:19:46
hacer esto directamente, porque te daría 00:19:48
un ArrayIndexAuronException, 00:19:50
pero bueno, son detalles de implementación 00:19:52
que sabréis hacer perfectamente. 00:19:54
¿Vale? Lo que me 00:19:57
importa ahora es que veáis lo que es 00:19:58
una colección. Una colección 00:20:00
es una clase que se declara 00:20:02
pensada para contener datos 00:20:04
y ofrecerme 00:20:06
formas de manipular con ellos 00:20:09
entonces cuando yo quiera un montón de datos 00:20:11
me instancio una de esas colecciones 00:20:13
que hay muchos tipos 00:20:16
que ahora veremos cuáles 00:20:17
dependiendo de lo que yo quiera hacer con los datos 00:20:19
hay muchos tipos 00:20:20
me instancio una de esas 00:20:21
y ya tengo mi cajita 00:20:22
y una vez instanciada 00:20:24
pues ya meto cosas en la caja 00:20:27
elimino de la caja 00:20:30
recupero 00:20:31
lo que sea que yo quiera ofrecer 00:20:33
hacer con esos datos 00:20:35
que siempre, pues es eso 00:20:38
insertar nuevo en la caja 00:20:39
borrar, recuperar 00:20:42
y poco más 00:20:44
decirme el tamaño 00:20:46
que tiene, cosas de esas 00:20:48
¿vale? pues esto es una colección 00:20:49
una clase que ya está hecha 00:20:52
para ahorrarnos, hacer lo que ya 00:20:54
sabemos hacer 00:20:56
¿vale? y estas clases, su objetivo es 00:20:57
ofrecerme a mí la posibilidad 00:21:00
de trabajar con un montón de datos 00:21:02
escondiendo la complejidad 00:21:04
de la RAI, que en realidad el RAI 00:21:06
es lo único que hay nativo 00:21:08
entre comillas en Java para guardar muchos datos 00:21:10
es lo único, ¿vale? 00:21:12
todo lo demás está hecho por clases que esconden 00:21:14
esa complejidad, yo las instancio, las llamo 00:21:16
y ya está, esta es la idea de una colección 00:21:18
esto es lo que es una colección 00:21:21
¿vale? ¿qué ibas a preguntar? 00:21:22
no, que estaba pensando en por qué no le hacemos 00:21:24
static esto, pero 00:21:26
yo no sé si esto, o sea, la idea 00:21:28
¿static el qué? 00:21:30
Sí, las clases y los métodos 00:21:31
No, las clases no pueden ser estáticas 00:21:33
O sea, perdón, el método, los métodos 00:21:35
Hombre, para que los métodos sean estáticos 00:21:36
Esto tendría que ser estático 00:21:39
Pero si esto es estático, no, o sea 00:21:40
Cada objeto miArrayList 00:21:43
Que tú instancies, es una caja distinta 00:21:45
O sea, tú quieres 00:21:47
Por ejemplo, uno puede ser nombres, aquí tienes los nombres 00:21:48
Otro puede ser apellidos 00:21:51
Pues otra nueva de apellidos 00:21:53
Cada cajita miArrayList tiene su propia array 00:21:54
O sea, tú quieres esto, me voy a usar ahora 00:21:56
Arrays normales, quiero usar solo Arrays 00:21:59
list, o sea, para aplicar 00:22:01
todas estas cosas. 00:22:03
O sea, si yo hago yo una nueva array, entonces 00:22:04
mejor lo instancio como 00:22:07
array list y ya está. Hombre, más cómodo 00:22:08
que hagas una colección. 00:22:10
Más cómodo que instancies 00:22:13
un objeto array list porque te vas 00:22:15
a dar a escribir tu código. 00:22:17
No porque sea mejor a nivel 00:22:19
de código. Siempre va a ser mejor 00:22:21
todo lo que tú programes 00:22:22
porque tienes un absoluto control 00:22:24
de lo que realmente se va a ejecutar. Desde el momento 00:22:26
que te vienes a llamar a métodos y a delegar 00:22:28
acciones en esos métodos ya pierdes 00:22:31
el control de cómo lo hacen 00:22:33
pero desde luego es mucho más cómodo 00:22:34
a nivel de escritura de código es mucho más cómodo 00:22:37
en lugar de hacerte tú 00:22:39
tu array de nombres, tu array de 00:22:40
apellidos, tu array de notas 00:22:43
puestos de instancias 00:22:45
un objeto array list para tus nombres 00:22:47
que tendrá dentro su propio array 00:22:48
un objeto array list para los apellidos 00:22:50
que tendrá dentro su propio array 00:22:52
un objeto array list para las notas 00:22:54
que tendrá dentro su propio array 00:22:56
y luego ya 00:22:58
cada cosa que quieras hacer 00:22:59
con cada cajita, pues llamas a los 00:23:02
métodos de ese objeto 00:23:04
¿vale? en la cajita A 00:23:05
quiero añadir un nombre nuevo 00:23:07
en la cajita B, que era la de apellidos 00:23:09
quiero borrar un apellido 00:23:12
entonces el código queda muchísimo más fácil 00:23:13
de hacer, aunque luego se esté ejecutando 00:23:16
lo mismo, porque 00:23:18
cada vez que tú llamas a Adelete 00:23:19
te estás metiendo en un método 00:23:22
que hace lo que hemos hecho nosotros todo el rato 00:23:24
¿vale? 00:23:26
Pero Java esto te lo da 00:23:28
Java de por sí ya tiene una arraylist 00:23:30
Una clase de arraylist de por sí 00:23:32
Claro, claro, es lo que decía 00:23:33
Pero te la podrías haber hecho tú 00:23:37
Las colecciones son 00:23:39
Clases que nos dan ya hechas 00:23:41
Como otras millones de miles de clases 00:23:43
Como local que nos dan hechas 00:23:45
Para apretarnos la vida 00:23:46
Pero lo que tienen dentro son cosas que podríamos haber hecho nosotros 00:23:47
Lógicamente 00:23:51
Entonces yo por esto este le he llamado 00:23:52
Mi arraylist, si lo hubiéramos tenido que hacer nosotros 00:23:54
Lo habríamos hecho así 00:23:56
Vale, vamos a hacer 00:23:57
Una versión sencilla 00:24:11
Para que lo veamos más claro 00:24:12
De nuestro 00:24:14
ArrayList particular y como lo usaríamos 00:24:17
Y luego ya explicamos 00:24:19
Porque luego ya 00:24:20
Las colecciones que trae Java 00:24:22
Pues no son solo ArrayList, son muchas otras 00:24:24
están clasificadas en función del tipo, patatín, patatán 00:24:26
y eso ya pues sí que tenemos que ver 00:24:29
solamente para acabar de entender 00:24:31
por qué existen las colecciones 00:24:34
y cuál es su filosofía de uso 00:24:36
vamos a 00:24:38
si nos programáramos la nuestra propia 00:24:39
¿cómo lo haríamos? 00:24:42
vale 00:24:50
pues venga 00:24:51
En japonés. 00:24:59
Vale. 00:25:22
vale, pues vamos a utilizar 00:25:23
este primer proyecto 00:25:30
que he subido a la virtual para 00:25:31
programar nuestras propias colecciones 00:25:35
que el linked list también 00:25:37
lo vais a programar, porque ese sí que es chulo y divertido 00:25:38
el linked list 00:25:41
la lista enlazada 00:25:43
linked 00:25:45
no es linkedin 00:25:47
del linked list 00:25:48
vale, me hago un paquetillo 00:25:51
Por aquí un paquetillo 00:25:53
Para ArrayList 00:25:54
Venga, pues me voy a hacer 00:25:56
Un main para motivar 00:26:06
Lo interesante que puede ser esto 00:26:08
Pues resulta que yo tengo aquí un programa 00:26:10
Que me pide trabajar 00:26:22
Con un montón de nombres 00:26:24
Y un montón de notas, por ejemplo 00:26:26
O lo que sea, vale 00:26:29
Entonces, joder, tengo que trabajar con un montón de nombres 00:26:30
Haciendo cosas 00:26:33
Pues nada 00:26:34
Tengo que trabajar con un montón de nombres 00:26:35
Pues nos haríamos esto 00:26:39
Y ya tendríamos el primer problemilla 00:26:42
Que es 00:26:45
Jolines 00:26:46
Que rollo 00:26:48
Tener que decidir desde ya el tamaño 00:26:49
Que rollo 00:26:52
Vale, pues esta es la primera 00:26:54
Complejidad que vamos a envolver 00:26:56
Con nuestra clase 00:26:59
Mi ArrayList 00:27:01
Esta es la primera cosa 00:27:02
que vamos a ocultar ya 00:27:03
para que no moleste 00:27:07
porque ahora uno sueña despierto 00:27:08
y dice, jolín, ojalá 00:27:10
yo tuviera una clase 00:27:12
ojalá yo tuviera una clase 00:27:14
así de largo 00:27:24
los hay, y más 00:27:31
y más 00:27:32
ya veréis como seis fringos 00:27:33
Vale, pues ojalá yo tuviera una clase 00:27:37
Que en lugar de lo de arriba 00:27:40
Me permitiera hacer esto 00:27:42
Yo la instancio 00:27:45
Sin más 00:27:48
Y el tamaño que se adapte 00:27:48
Yo creo la caja 00:27:52
Y según meto en la caja 00:27:54
Que se vaya agrandando 00:27:56
Eso es un problema suyo 00:27:57
Y según saco de la caja que vaya encogiendo 00:27:58
Es un problema suyo 00:28:01
Yo aquí en mi main no quiero problemas 00:28:01
No quiero nada de tener que tomar decisiones sobre el tamaño 00:28:04
No quiero, no me interesa 00:28:07
Yo creo la caja 00:28:09
Y que esa caja ya tenga la posibilidad 00:28:10
De hacerse grande, pequeña 00:28:13
Según yo le dé cosas o se las quite 00:28:14
Ese es el primer problema 00:28:16
Que quiero eludir 00:28:18
Vale, pues vamos a crearnos esa caja 00:28:19
Que nos permite olvidarnos 00:28:24
De esas problemáticas 00:28:26
Vamos a crearnos esta clase 00:28:27
Venga 00:28:29
Ahí me la he creado en el mismo paquete 00:28:31
Vale, esta 00:28:39
Ahí me la creo 00:28:40
Esa clase que yo quiero instanciar desde aquí 00:28:48
Vale 00:28:50
Esta clase 00:28:53
¿Para qué quería que me sirviera? 00:28:54
Para guardar muchos stream 00:28:56
Pues venga 00:28:57
Inicialmente 00:28:59
Cuando la caja se cree por primera vez 00:29:05
¿Qué tamaño queremos que tenga? 00:29:08
Cero pelotero 00:29:12
Vale 00:29:13
Yo aquí después de hacer el new 00:29:16
Mi cajita 00:29:18
Cero 00:29:21
Ya sea la grande cuando le metamos cosas 00:29:22
Ahora mismo cero 00:29:24
Vale 00:29:25
Y esta propiedad 00:29:27
Puede ser un private magnífico 00:29:29
Ahí estupendo 00:29:32
Porque nadie tiene que acceder a ese array 00:29:33
En absoluto 00:29:36
Solamente la propia cajita 00:29:38
Para meter cosas si yo se la doy y sacarlas 00:29:40
Nadie más tiene que acceder a ese array 00:29:42
Entonces hay un private estupendo 00:29:44
Vale 00:29:46
Ahora 00:29:49
Ahora yo quiero meter un nombre nuevo que me han dado 00:29:50
Quiero meter el primer nombre 00:29:54
Jolines, pues yo quiero, ya que he creado una caja 00:29:55
Que quiero que me 00:29:58
Exima de todos 00:30:00
Los problemas 00:30:02
Pues yo quiero esto, esto es lo que yo quiero 00:30:03
Yo quiero poder 00:30:06
Hacer esto, añade un nombre 00:30:08
Y olvidarme de todo 00:30:10
Eso es lo que yo quiero hacer, desde este main 00:30:12
O desde este otro main, o desde donde me dé la gana 00:30:14
Esto es lo que yo quiero 00:30:16
Esto es mi sueño 00:30:17
Añade Luis, y ya está 00:30:21
Y saber que ese nombre Luis está en la caja 00:30:24
Esto es lo que yo querría 00:30:26
Olvidarme de todo lo demás 00:30:27
Bueno, pues para eso 00:30:30
La clase miArrayListChulo, etcétera, etcétera 00:30:33
Necesita tener este método 00:30:36
Claro, necesita tenerlo 00:30:38
No hay otra 00:30:40
Bueno, cómo ver qué importará 00:30:40
Hay que hacerlo 00:30:44
Es una clase nueva, ¿qué estamos haciendo? 00:30:44
Pues nada 00:30:48
Vamos a hacer 00:30:48
Este método 00:30:51
Vale, pues este método 00:30:52
que queremos que haga 00:30:57
queremos que coja este dato 00:30:59
agrande 00:31:02
en una posición 00:31:04
este array, lo agrande 00:31:05
en una, lo meta 00:31:08
y lo sustituya, bueno pues lo que hemos 00:31:10
hecho mil veces 00:31:12
aux igual 00:31:13
new string 00:31:16
dato.length 00:31:25
más uno 00:31:28
agrandamos, hacemos una cajita 00:31:29
Auxiliar con una posición más 00:31:32
Datos 00:31:34
Sí, vale 00:31:37
Y len sin paréntesis 00:31:39
Vale 00:31:42
Ahora copiamos una en el otra 00:31:43
Menor que 00:31:46
Datos.lens 00:31:52
Incrementando 00:31:55
Pues que hacemos 00:31:57
En aux de y queremos que vaya 00:31:59
Datos de y 00:32:02
Vale 00:32:03
Ya hemos copiado todas las posiciones 00:32:05
Salvo la adicional de AUX 00:32:08
Que está vacía 00:32:10
Pero claro, en la adicional de AUX 00:32:11
Queremos que vaya dato 00:32:13
AUX, en la adicional de AUX 00:32:15
Que es AUX.len 00:32:19
Dígame 00:32:22
Vale 00:32:22
Pues en la adicional de AUX 00:32:27
Queremos que vaya dato 00:32:31
Y ahora AUX es nuestra nueva caja 00:32:32
AUX ya es la caja buena 00:32:35
Es nuestra nueva caja 00:32:37
Con lo cual la caja vieja 00:32:38
Fuera 00:32:39
La caja vieja fuera 00:32:41
Queremos la nueva caja 00:32:43
Pues ya está 00:32:44
Ya tenemos el método aux 00:32:50
Perdón, el método add 00:32:54
El método de siempre, ya está hecho 00:32:55
Entonces yo ahora desde cualquier otro sitio 00:32:58
Desde mi main que está aquí 00:33:02
O desde otro main que esté en otro lado 00:33:04
O desde donde sea 00:33:06
Yo puedo meter nombres en esa caja 00:33:07
Mira, voy a meter Luis 00:33:10
En la caja está Luis 00:33:11
Mira, ahora voy a meter otro nombre 00:33:12
Pues Ala 00:33:15
Y genial, súper práctico esta clase 00:33:16
Me permite guardar cosas con el add 00:33:22
Y yo olvidada de 00:33:24
Todos los rollos de Array, es que aquí ni veo Array 00:33:28
No lo veo por ningún sitio 00:33:30
¿Dónde está el Array? No sabemos 00:33:31
Vale, lo que pasa es que una caja 00:33:33
Que me vale solo para meter 00:33:38
Pues que oculta es, ¿no? 00:33:40
Que oscurantista 00:33:42
O sea, hombre, también querré 00:33:44
Ver lo que hay dentro 00:33:46
o eliminarlo 00:33:47
con un array yo puedo recorrerlo 00:33:50
para ver lo que hay, o sea, si en un almacén 00:33:51
de datos no puedo 00:33:54
acceder a lo que hay dentro del almacén de datos 00:33:55
tal cual los meto perdidos 00:33:57
para siempre, pues no tiene mucho sentido 00:33:59
¿no? vale, pues a mí me encantaría 00:34:01
poder recorrer, por ejemplo 00:34:04
esta colección, ¿vale? 00:34:05
vale, la posibilidad de recorrer 00:34:32
la colección queremos tenerla 00:34:34
o sea, nosotros podíamos recorrer un array 00:34:35
con un for, ¿verdad? podíamos recorrer 00:34:37
para ver lo que hay en cada posición 00:34:39
y así veíamos lo que había, si nos interesaba 00:34:41
es lo que hacíamos con un array, recorrerlo y acceder a posiciones sueltas 00:34:43
bueno, pues también querríamos poder con mi caja 00:34:47
es decir, yo querría 00:34:50
voy a poner primero acceder 00:34:53
acceder a elementos de la colección 00:34:57
yo querría la posibilidad de acceder 00:35:00
igual que podía un array, yo mi array, si fuera mi array nombres 00:35:05
yo podría poner nombres de 3, nombres de 1 00:35:08
pues aquí querría poder acceder también 00:35:11
Entonces, ¿cómo me gustaría a mí tener un método que con esta cajita me permitiera recuperar el elemento en una posición cualquiera? 00:35:14
En la cero, por ejemplo. 00:35:30
Ojalá, ojalá tuviera un método que me permitiera recuperar, que me devolviera el elemento en esa posición, 00:35:32
que me lo devolviera para que yo lo consultara y viera cuál es. 00:35:40
Igual que tengo el array, si esto fuera un array, ya sabemos que tenemos esto. 00:35:43
Pero es que esto no es un array 00:35:50
Pero yo tengo que poder hacer a la posición 00:35:52
De la caja igualmente 00:35:54
Pues ojalá tuviera yo un método 00:35:55
Que me hiciera esto 00:35:58
Ojalá lo tuviera 00:36:00
Pues hombre, ¿por qué no? 00:36:01
Es muy fácil, ¿por qué no? Vamos a hacérselo 00:36:04
Pues venga, en mi super clase 00:36:06
En mi ArrayList 00:36:10
Yo le puedo hacer 00:36:11
Un método 00:36:13
Que me devuelva un string 00:36:15
Hacemos este método y paramos 00:36:18
Que yo le paso una posición 00:36:22
¿Vale? 00:36:25
Y me devuelvo lo que hay en esa posición 00:36:27
Vale, vamos a validar 00:36:31
Que la posición sea correcta 00:36:35
Porque si no 00:36:36
Si posición 00:36:37
Es mayor 00:36:40
Que datos.length 00:36:42
Menos uno 00:36:46
Posición 00:36:51
Es menor que cero 00:36:56
Problemas, la posición me la han pasado mal 00:36:58
Problemas 00:37:00
Pues entonces aquí pongo un null y ya está, por ejemplo 00:37:01
¿Vale? Es la versión que estoy haciendo 00:37:04
Return null 00:37:06
Devuélveme un objeto null 00:37:07
Si la posición es incorrecta 00:37:10
Y si no 00:37:12
Y si no 00:37:14
Pues return el qué 00:37:18
Pues return datos 00:37:19
De posición 00:37:21
Y tan ricamente 00:37:23
Y tan ricamente 00:37:26
¿Vale? 00:37:28
Pues ala, un método estupendo 00:37:39
Que me permite a mí 00:37:40
Dada una posición, ver que hay 00:37:42
Pues yo ya desde mi main 00:37:44
Sin problemas 00:37:47
Aquí puedo mostrar lo que hay en la posición 0 00:37:49
Y lo que es más 00:37:52
Podría recorrer 00:37:54
El array 00:37:56
La caja 00:37:58
Ahora después lo hacemos 00:37:59
Vamos a probar esto sin más 00:38:00
Entonces yo ejecuto esto 00:38:02
Y ala, estupendo 00:38:04
Que quiero ver lo que hay en la posición 1 00:38:12
Pues en la posición 1 me mostrará 00:38:15
Que quiero ver lo que hay en la posición 7 00:38:17
Me va a dar un null 00:38:21
Pues null 00:38:24
En la posición 7 00:38:25
No hay posición 7 00:38:26
¿Veis? Entonces desde mi main 00:38:28
Yo ahí en mi main 00:38:31
Ni tengo a raíz 00:38:33
Ni tengo cosas extrañas 00:38:35
Desde mi main tengo una caja que instancio 00:38:37
Para guardar stream 00:38:39
Solamente vale para stream, eso sí 00:38:41
Añado 00:38:42
recupero por posición 00:38:44
y podríamos añadir más métodos 00:38:46
¿vale? 00:38:49
pues esto es una colección 00:38:51
una clase que me permite 00:38:52
almacenar un montón de datos 00:38:54
y me ofrece unos métodos para manipularlos 00:38:56
y esos métodos 00:38:59
pues son métodos normales y corrientes 00:39:00
que podemos hacer nosotros 00:39:03
pero claro, luego me es a mi más cómodo 00:39:04
usar directamente esa colección 00:39:07
en cualquier otro sitio, la uso 00:39:08
y ya está, es mucho más fácil 00:39:11
Pues el ArrayList 00:39:13
El ArrayList es esto 00:39:15
Con más métodos 00:39:17
Lógicamente y más depuraditos 00:39:20
Y saltado a genérico 00:39:22
Que es lo que sí que no sabemos hacer todavía 00:39:24
Para que yo pueda guardarme 00:39:26
Da igual que sea string, que sea int, que sea lo que sea 00:39:27
Pues esto es un ArrayList 00:39:29
Vale, vamos a parar aquí un momentico 00:39:31
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:
7
Fecha:
2 de febrero de 2026 - 10:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 36″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.35

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid