20261112 Arrays - Contenido educativo
Ajuste de pantallaEl ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:
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
no
00:11:14
solamente se pueden
00:11:14
mezclar datos en un array
00:11:17
si
00:11:19
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
20
00:15:30
como hemos dicho antes
00:15:31
la opción esta, n1, n2, n3
00:15:33
n4
00:15:36
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
45
00:17:42
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
23
00:18:35
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
- Ciclo formativo de grado básico
- 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