Saltar navegación

20261112 Arrays - 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 15 de noviembre de 2026 por Raquel G.

1 visualizaciones

Descargar la transcripción

Venga. Vale, vamos a incorporar un nuevo tipo de dato porque los tipos de datos que tenemos hasta ahora realmente se nos quedan cortos. 00:00:00
Nosotros, los programas, lógicamente, trabajan con datos. Eso ya lo sabemos. 00:00:18
Entonces, nosotros hemos trabajado con numeritos sueltos, es decir, variables numéricas, int o float, si queríamos que fueran decimales o double. 00:00:23
entonces en algún caso 00:00:33
en lo que menos 00:00:37
para no perder demasiado tiempo 00:00:39
hemos trabajado con char sueltos 00:00:41
hemos visto que pueden ser 00:00:43
tratados como números enteros 00:00:46
también pueden ser sumados 00:00:47
porque cada número 00:00:49
cada char 00:00:52
se almacena internamente 00:00:53
como un número entero 00:00:55
tal y como indica la tabla ASTI 00:00:57
también conocemos el tipo Boolean 00:00:59
que bueno 00:01:03
es rarito porque solo puede almacenar 00:01:05
dos posibles valores, true o false 00:01:08
que es justo 00:01:10
lo que son las condiciones 00:01:12
las condiciones son true o son false 00:01:14
luego la variable boolean nos guarda condiciones 00:01:15
y también 00:01:18
hemos incorporado la posibilidad 00:01:20
de guardar 00:01:22
toda una cadena de caracteres 00:01:24
toda entera 00:01:26
porque los nombres 00:01:29
los textos 00:01:30
Son muchos caracteres y son datos básicos 00:01:33
No un texto, un nombre 00:01:35
Bueno, hemos incorporado esto 00:01:36
Que nos permite guardar toda una cadena de caracteres 00:01:38
Pero claro 00:01:40
Solamente esta posibilidad 00:01:43
De almacenamiento de datos 00:01:46
Se nos queda muy corta 00:01:48
Porque si mi aplicación 00:01:49
Trabaja por ejemplo 00:01:52
Con 20.000 00:01:53
Alumnos de un instituto 00:01:56
Necesito yo tener 00:01:58
20.000 variables stream 00:02:00
Pues es un poco rollo 00:02:01
20.000 variables stream 00:02:03
si yo, mi aplicación 00:02:04
trabaja con 10.000 00:02:07
precios de productos 00:02:08
10.000 variables num 00:02:10
precio 1, precio 2, precio 3 00:02:12
es una locura manejar tantas 00:02:14
variables 00:02:17
entonces cuando manejamos 00:02:17
muchos datos 00:02:21
variables sueltas como estas 00:02:22
se nos hacen poco 00:02:25
operativas, se nos quedan cortas 00:02:26
entonces 00:02:28
hay un montón de posibilidades 00:02:31
Pero todas están apoyadas, bueno, no todas, pero bueno, la gran mayoría de ellas están apoyadas en una estructura básica de programación que existe en cualquier lenguaje, en cualquiera, que es el array. 00:02:32
Entonces, eso es lo que vamos a incorporar ahora. 00:02:49
La estructura básica que existe en cualquier lenguaje de programación, la más eficiente, computacionalmente hablando. 00:02:52
sobre la que se apoyan, luego ya estructuras un poco más complejas, como ya iremos viendo. 00:03:02
Bueno, pues a ver, ¿qué es un array? 00:03:12
Un array es una estructura de datos, una capacidad de almacenamiento 00:03:15
que nos permite almacenar en memoria muchos datos del mismo tipo. 00:03:20
Luego, situación de antes, mi aplicación trabaja con las notas de mis 30 lucros. 00:03:50
Pues hombre, tener 30 variables string, alumno 1, alumno 2, alumno 3, es un rollo. 00:03:56
Anda, pues parece que la raíz se adapta a lo que quiero. 00:04:02
Porque me va a permitir tener muchos datos de tipo string. 00:04:06
En particular, 30 datos de tipo string, los 30 nombres de mis alumnos. 00:04:10
Parece que la raíz se adapta. 00:04:14
¿Vale? 00:04:16
Entonces, cuando queremos almacenar muchos datos del mismo tipo, 00:04:17
muchos números, muchos string, muchos ya veremos. 00:04:22
El array es la estructura, el tipo de variable que más se adapta, ¿vale? 00:04:26
Entonces, ¿cómo la usamos? ¿Cómo la creamos? ¿Cómo hacemos aparecer toda esa caja que me permite a mí guardar muchos? 00:04:36
Porque hacer aparecer una caja para un solo dato ya lo sabemos. 00:04:44
cuando nosotros hacemos int n 00:04:47
ya sabemos que automáticamente 00:04:51
con esto hacemos aparecer una cajita 00:04:53
para un número entero 00:04:55
¿vale? así es como se hace 00:04:57
aparecer la cajita para un único número 00:04:59
entero, pues como hacemos 00:05:01
aparecer la cajita 00:05:03
para un montón 00:05:04
un montón del mismo tipo 00:05:06
una única caja 00:05:08
para un montón del mismo tipo, que eso es lo que consigue 00:05:11
la array, una única caja 00:05:13
con un montón de datos del mismo 00:05:15
tipo, que es más fácil de manejar que un montón de cajas iguales, ¿verdad? Esa es 00:05:17
la ventaja, ¿no? Siempre nos va a ser más fácil tener una caja con compartimentos y 00:05:24
tener en la celdilla las 30 botellas de vino, yo llevo mi caja con las 30 botellas de vino, 00:05:34
que me den las 30 botellas de vino separadas cada una en una caja, es una locura, ¿vale? 00:05:40
Si me las dan todas juntas en una cajita, pues ya está, las tengo en las 30 y ya decido, 00:05:45
pues si quiero la que está en esta posición, si quiero la que está en esta, si quiero la que está en esta, ya lo decido. 00:05:51
Por eso es lo que me da el array. 00:05:55
Me da una caja única para guardar un montón de datos del mismo tipo. 00:05:57
Y así no tengo cajitas por separado, por lo que es lo mismo variables por separado. 00:06:04
Es más pesado de manejar. 00:06:08
vale, pues como hago 00:06:10
aparecer yo esta caja 00:06:12
para ya poder usarla para meter todos esos datos 00:06:13
pues declarando 00:06:16
el array, igual que 00:06:18
declarábamos una variable int 00:06:19
pues podemos declarar un array 00:06:21
y como declaramos un array 00:06:22
pues por ejemplo en el caso de que 00:06:27
queramos que ese array 00:06:30
sea de números enteros 00:06:32
pues ponemos 00:06:34
el int como siempre 00:06:36
pues ponemos el int 00:06:37
como siempre 00:06:58
y ahora 00:06:59
esta por ejemplo serían mis números 00:07:01
y ahora 00:07:03
para indicar que números no es un 00:07:06
único, joder, el rojo no está muy bien elegido 00:07:08
vale 00:07:11
para indicar que números 00:07:17
no es una única cajita con un int 00:07:19
sino muchas, muchos int 00:07:21
una caja de muchos 00:07:23
ponemos aquí dos corchetes que se abren 00:07:24
y se cierran, y ya está 00:07:27
poniendo ahí dos corchetes que se abren 00:07:29
y se cierran 00:07:32
automáticamente números 00:07:33
ya es una variable 00:07:36
que está pensada 00:07:38
para contener 00:07:39
un montón 00:07:41
de variables de ese tipo 00:07:43
int 00:07:46
sin los corchetes 00:07:46
números sería una única cajita 00:07:49
para un único número 00:07:51
y con los corchetes abriendo y cerrando 00:07:53
números es ahora 00:07:56
una caja con un montón de posiciones 00:07:58
en eso se convierte en números 00:08:00
poniendo los corchetes en una caja con un montón de posiciones. 00:08:03
Ahora, la siguiente pregunta sería, ¿cómo indico yo cuántas posiciones tiene esa caja? 00:08:09
Porque eso lo tengo que indicar al momento de crearlo. 00:08:16
No podemos decirle a la máquina virtual de Java, crea una caja para enteros y no decirle 00:08:19
de cuántos, hay que decirle de 27, de 12, de 15, para que la máquina virtual habilite 00:08:23
ese espacio en memoria. 00:08:30
Pues, ¿cómo se lo decimos? 00:08:32
Pues completando la declaración de esta manera, new int, int porque es el tipo de dato, si fuera dable sería dable, si fuera string sería string, y ahora ya de nuevo los corchetes, pero ahora ya sí poniendo el tamaño que queremos. 00:08:33
luego ahora ya esto sí que sí 00:08:54
de forma completa 00:08:57
crea una caja 00:08:58
para números enteros 00:09:00
de cuántas posiciones 00:09:02
de 10 00:09:04
y esto 00:09:05
hay que ponerlo siempre 00:09:11
sí o sí 00:09:14
no se puede crear un array 00:09:15
sin decir de partida 00:09:17
cuántas posiciones tiene que tener 00:09:19
y las posiciones que hemos puesto ahí 00:09:21
son inamovibles 00:09:25
eso ya no cambia 00:09:26
¿vale? 00:09:27
¿por qué se pone el mío? ¿por qué se pone no sé qué? 00:09:34
ya lo iremos entendiendo cuando veamos 00:09:37
cuando se le ha dado a objetos 00:09:38
ahora estamos entrando 00:09:39
menos en profundidad 00:09:42
que en las cosas 00:09:44
que otros años 00:09:46
porque ahora la idea es que cuanto antes 00:09:47
ahora ya no necesitáis 00:09:50
para bien o para mal 00:09:52
para ambas cosas 00:09:54
ya no necesitáis conocer las cosas en profundidad 00:09:56
porque ya no os vais a pelear vosotros 00:09:58
se va a pelear la IA 00:10:00
entonces ya para bien o para mal 00:10:02
No necesitáis conocerlas en profundidad 00:10:03
Necesitáis conocer cómo funciona 00:10:06
Entonces 00:10:08
Nos vamos a meter 00:10:10
Mucho menos en profundidades este año 00:10:12
Para poder ir un poquito más rápido 00:10:14
Y poder ver más cosas 00:10:15
Entonces, esto venía a cuento 00:10:18
Del new porque se pone 00:10:20
Ya lo entenderéis, ya lo veremos 00:10:21
Por ahora nos vale con que os quedéis 00:10:24
Que esta es la manera de 00:10:26
Crear en memoria 00:10:28
Una cajita 00:10:30
con 10 posiciones o las que sean 00:10:32
que se hayan puesto aquí 00:10:34
que quiero que la cajita 00:10:34
no sea para int sino para números 00:10:38
dabel, pues cambio dabel 00:10:40
dabel, que quiero que la 00:10:41
cajita no sea para números dabel 00:10:44
sino para string, pues cambio aquí 00:10:46
string, string 00:10:48
eso ya es lo de menos, vale, te ibas a preguntar algo 00:10:49
Guillermo 00:10:52
pues no puedes 00:10:52
te tienes que hacer una caja más grande 00:10:58
mover todo de la caja pequeña 00:11:00
a la caja grande 00:11:03
y ya con el espacio que te sobra 00:11:04
meter lo que sea, no puedes 00:11:06
¿y se podría hacer un array 00:11:08
que tenga tantos strings como dentro? 00:11:10
solamente se pueden 00:11:14
mezclar datos en un array 00:11:17
son datos 00:11:21
que tienen un ancestro común 00:11:22
¿qué es un ancestro común? 00:11:25
no podemos entenderlo hasta que entendamos 00:11:27
lo que es la herencia 00:11:29
y para ello damos objetos 00:11:29
pero, id y sprint, ya te digo yo 00:11:31
no tiene un ancestro común 00:11:34
bueno, tiene uno, pero es demasiado 00:11:35
pero es el primate de hace millones de años 00:11:37
entonces hacer una caja con primates 00:11:39
se complica, ya entenderás lo que te digo 00:11:41
¿dónde hay el id? 00:11:43
¿dónde hay el id? no, todos esos tipos primitivos 00:11:45
solo tienen un ancestro común 00:11:48
que es de hace millones de años 00:11:49
que es la clase object 00:11:52
pero es tan amplia 00:11:53
que hacer una caja de object es poco operativo 00:11:55
todo esto ya lo iremos a entender 00:11:57
Ahora mismo quédate con que los arrays solamente pueden contener datos del mismo tipo, pero sí que dejamos abierto para que no aparezca lo suelto de trolas, dejamos abierto del mismo tipo o con antecesores, con antepasados comunes y no todos los datos tienen antepasados comunes, pero eso ya lo trabajaremos. 00:11:59
Bueno, pues entonces, una vez que están metidos en la caja, ¿están metidos en la caja y todos son mogollón mezclados? 00:12:25
No, cada uno tiene su posición. 00:12:36
Entonces yo puedo decidir trabajar con este en un momento dado, o trabajar con este en un momento dado, o trabajar con este. 00:12:39
Claro que puedo, lógicamente, porque se distinguen por su posición. 00:12:48
No es tanto si hay mogollón, se distinguen cada uno por la posición en la que están. 00:12:52
Luego, cada posición tiene un nombre para poder decir yo al programa, oye, dame el que está en la posición tal, dame el que está en la posición tal, que ahora tiene su posición. 00:12:57
¿Y cómo se llaman las posiciones? Pues las posiciones se identifican con un numerito que empieza valiendo cero. 00:13:08
Esta sería la posición cero, la posición uno, la dos, la tres, ¿vale? 00:13:14
luego las posiciones 00:13:20
tienen asociado un número entero 00:13:22
que empiezan en 0 00:13:24
la primera posición de la caja 00:13:26
es la posición 0, la segunda es la 1 00:13:29
la siguiente es la 2 00:13:31
luego este array 00:13:32
de 10 00:13:35
posiciones 00:13:36
esas posiciones 00:13:39
oscilan entre la 0 y la 9 00:13:41
¿vale? 00:13:43
si el array 00:13:46
tuviera 20 posiciones 00:13:47
yo lo hubiera declarado aquí de 20 00:13:49
oscilarían entre la 0 y la 19 00:13:51
vale, la primera siempre es la 0 00:13:56
eso no es elegible 00:13:59
bueno, pues vamos a ver un ejemplo rápido 00:14:00
suerte, ahora se me ha ido el ratón 00:14:08
justo cuando tengo la cámara 00:14:16
ah, está aquí, vale 00:14:18
vale, pues 00:14:25
ejemplito 00:14:36
bueno, lo voy a poner aquí en cualquier programa rápido 00:14:39
para no perder tiempo 00:14:49
vale, pues por ejemplo 00:14:50
quiero yo guardar 00:15:26
20 números enteros 00:15:28
como hemos dicho antes 00:15:31
la opción esta, n1, n2, n3 00:15:33
y así a escribir hasta 20 00:15:38
es un poco absurda 00:15:40
no tiene sentido 00:15:41
y si luego me dicen en el programa 00:15:43
oye, haz el mismo programa pero en lugar de para 20 00:15:45
para 50 00:15:48
me tengo que ir aquí y añadir 00:15:49
n21, n22, o sea, no tiene sentido 00:15:52
si yo quiero trabajar con muchos números enteros 00:15:54
estar aquí escribiendo hasta el infinito 00:15:56
no tiene sentido 00:15:58
vale, pues entonces 00:16:00
como voy a trabajar con muchos números enteros 00:16:02
me voy a declarar 00:16:04
una caja común 00:16:06
o lo que es lo mismo, un array 00:16:07
una cajita común, que es esto, así lo declaro 00:16:09
a la que voy a llamar 00:16:12
pues como a mí me dé la gana llamar 00:16:14
vale, esta es mi caja común 00:16:16
con un montón de números 00:16:18
¿de cuántos? 00:16:20
pues lo que yo decida aquí 00:16:22
que quiero que sean 20 00:16:24
pues 20 00:16:26
ya tengo mi cajita común que se llama números 00:16:27
que ahora 00:16:30
me dicen, oye, cambia el programa 00:16:32
no vas a trabajar con 20, vas a trabajar con 200 00:16:34
pues cambias esto 00:16:36
y ya está 00:16:39
sin embargo, lógicamente si lo hubiéramos hecho 00:16:40
como N1, N2, N3 00:16:42
y me dicen, ya no vas a trabajar con 20, sino con 200 00:16:44
¿qué haces? añades 00:16:46
180 por debajo 00:16:48
n21, n22, es absurdo 00:16:49
sin embargo aquí 00:16:52
que no son 20, son 200 00:16:53
pues hala, ya está 00:16:55
¿vale? 00:16:57
y ahora esta cajita ya está 00:16:59
¿cómo accedo? esta caja no está vacía 00:17:01
no tiene nada, pero tiene el espacio 00:17:04
el espacio para los 20 números 00:17:05
pues por ejemplo 00:17:08
¿cómo accedo yo al espacio 00:17:09
que está en la posición 0 00:17:11
para asignarle un número cualquiera? 00:17:13
pues para acceder a un espacio 00:17:16
concreto, a una casilla concreta 00:17:17
pues accedemos 00:17:20
con el número, el nombre de la caja 00:17:22
números y entre corchetes 00:17:24
la posición a la que 00:17:26
yo quiero acceder 00:17:28
bueno, pues esto ya si es sólo 00:17:28
una 00:17:32
de las posiciones de la caja 00:17:33
ya es sólo una, la de la posición 0 00:17:35
vale, pues por ejemplo 00:17:37
con esto a la posición 0 le he dado el 00:17:40
que a la posición 1 00:17:42
le quiero dar el 45 también 00:17:45
pues ya está 00:17:48
a la posición 1 le doy el 45 00:17:51
que a la posición 00:17:54
19 le quiero dar el 45 00:17:58
pues a la 00:18:01
posición 19 00:18:02
le doy el 45 00:18:04
vale 00:18:06
entonces ya puedo trabajar 00:18:08
con cada espacio 00:18:10
de memoria en cada posición de esta manera 00:18:12
vale 00:18:14
esto ahora ya es una única variable 00:18:15
la que está en la posición 0 00:18:18
esta es la que está en la posición 1 00:18:19
esta es la que está en la posición 19 00:18:22
posiciones de la misma caja 00:18:24
de la caja números 00:18:26
vale 00:18:27
si yo intentar hacer esto 00:18:29
números de la posición 00:18:32
por ejemplo 00:18:36
igual a 45 00:18:37
el compilador no le molesta 00:18:39
porque esto 00:18:42
sintácticamente está bien 00:18:44
el problema es la ejecución 00:18:46
el contenido 00:18:48
cuando él vaya en memoria 00:18:49
a buscar la posición 23 00:18:51
va a decir, uy 00:18:53
aquí en memoria no hay nada 00:18:55
yo solamente tengo memoria para la posición 0, 1, 2 00:18:57
19, ya está 00:19:00
como le doy una posición de 20 00:19:02
en adelante, incluso la 20 00:19:04
el compilador no le importa 00:19:06
porque sintácticamente lo hemos hecho bien 00:19:08
nombre de caja que es array 00:19:10
con corchetes 00:19:11
con un número entero para indicar la posición 00:19:13
con un número entero 00:19:16
porque sintácticamente está perfecto 00:19:18
pero a la hora de darle contenido 00:19:20
y a la hora de ejecutar 00:19:22
hay memoria ahí, al compilador le da igual 00:19:23
si hay memoria o no hay memoria 00:19:25
a la hora de ejecutar esto 00:19:26
pues nos dice 00:19:29
uy, te has salido 00:19:31
de los índices del array 00:19:33
entonces este es el error típico 00:19:35
cuando tratas de acceder 00:19:38
a una posición de un array 00:19:40
que no existe 00:19:42
te has salido de las fronteras 00:19:43
¿vale? 00:19:45
Te dice, el índice 20, lo siento, pero está fuera de las fronteras, de la longitud 20. 00:19:48
Claro, porque la longitud 20 es de la 0 a la 19. 00:19:53
Entonces, este problema nos ha salido aquí. 00:19:58
¿Vale? 00:20:01
Entonces, eso por un lado. 00:20:03
Siempre, quedaos bien en la cabeza, que si el array tiene n posiciones, 00:20:05
en espacios posibles, las posiciones van entre la 0 y la n-1, sí o sí. 00:20:10
Si yo me salgo, el compilador no me va a decir nada, pero cuando lo ejecute no hay memoria ahí, no hay memoria, pues salta, ¿vale? 00:20:18
Vale, pues, ¿para qué me es útil haber declarado esto como caja en lugar de como variables sueltas? 00:20:27
Pues que ahora puedo recorrer esto con bucles y esto irlo cambiando. 00:20:33
Por ejemplo, si yo quisiera inicializar todos a 45, pues, hombre, podría hacer esto, ¿verdad? 00:20:37
números 3 00:20:43
igual a 45 00:20:46
y así estarme hasta el infinito 00:20:49
y así estarme 00:20:51
hasta 00:20:55
hasta números 19 00:20:56
igual a 45 00:21:03
podría estar así 00:21:05
números 0, números 19 00:21:07
que es lo que tendría que hacer si las variables 00:21:08
fueran sueltas, num1, num2 00:21:11
tendría que hacerlo así 00:21:13
pero al ser en un array 00:21:14
yo aquí veo que lo único que me cambia es lo que va aquí dentro 00:21:16
Pues hombre, vamos a meterlo en un for 00:21:19
Donde la variable del for 00:21:22
Sea precisamente esta 00:21:24
Pues ese es el uso 00:21:26
Típico de los for 00:21:28
Hombre, vamos a aprovecharlo para recorrer una array 00:21:30
Entonces en lugar de hacerlo así 00:21:32
Pues yo podría inicializar 00:21:34
Todas las posiciones de la array 00:21:36
De esta manera 00:21:38
Desde igual a 0, que es la primera posición 00:21:39
Mientras si sea menor que 20 00:21:42
Para quedarme en la 19 00:21:44
Incrementando i 00:21:46
para ir pasando por todas, 0, 1, 2, 3 00:21:48
hasta las 19 00:21:50
pues números de i 00:21:51
igual a lo que a mi me dé la gana 00:21:53
por ejemplo 00:21:56
entonces de esta manera 00:21:57
le estoy dando valor a todas 00:21:59
las posiciones del array en este bucle 00:22:02
que ahora me dicen 00:22:04
uy, cambia el programa 00:22:06
no son 20, son 200 00:22:08
no pasa nada, ya está 00:22:10
esto ha cambiado 00:22:11
nada más, pues no son 200 00:22:13
ahora, sino que son 150 00:22:16
cuenta, pues no pasa nada, lo cambio aquí y lo cambio aquí, luego el hacerlo con Arrays 00:22:17
hace el programa muy fácilmente modificable, si lo hubiera hecho con variables sueltas 00:22:26
pues estoy ahí todo el rato añadiendo y quitando, es absurdo, o sea esto no tendría 00:22:32
sentido hacerlo así, vale, entonces que ahora quiero recorrer el Array para mostrar lo que 00:22:35
tiene, pues venga vamos a ver que tiene esta Array, desde i igual a cero mientras i sea 00:22:44
menor que 150 00:22:49
incrementando y, venga, vamos a mostrar 00:22:53
que tiene el array, números de y 00:22:57
lo estamos inicializando a 45, porque me da a mi la gana 00:23:02
todos ellos, y ahora vamos a recorrerlo para mostrar 00:23:09
todas y cada una de las posiciones, la número es 0, cuando y es igual a 0 00:23:13
la número es 1, cuando y es igual a 1, me tendrán que aparecer 00:23:17
150.45 00:23:21
¿Vale? 00:23:24
Que ahí están los 150.45 00:23:27
Bueno, ¿alguna pregunta? 00:23:29
No, pues venga 00:23:39
Vamos a dejarlo aquí 00:23:40
Que lo estáis deseando 00:23:41
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
15 de noviembre de 2026 - 17:38
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
23′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
800.18 MBytes

Del mismo autor…

Ver más del mismo autor


EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid