Saltar navegación

20251111 Arrays_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 11 de noviembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues para introducir a Raíz. 00:00:00
Vamos a situarnos, por ejemplo, en el 20. 00:00:01
Que seguramente habéis hecho y estáis muy happy con él. 00:00:05
A ver, un momento, que esto no es... 00:00:12
Venga, nosotros no lo tenemos hecho, ¿verdad que no? 00:00:18
Vamos rápidamente a hacerlo. 00:00:21
Esto no era lo que yo quería. 00:00:25
¡Hala! 00:00:39
Venga, pues a ver, este era programa, que lea un número entero y muestre todas sus cifras, vale, pues nada, hacemos un super escáner y leemos el dato, un super escáner, un super escáner, introduzca número, 00:00:45
este es el 20 00:01:10
que lo vamos a usar pues ya que estamos 00:01:14
para empezar a necesitar 00:01:16
a necesitar a raíz 00:01:18
vale 00:01:20
pues a ver, vamos a sacar las cifras 00:01:20
bueno 00:01:24
uno lo podría hacer, lo convierte a string 00:01:26
y luego va mostrando 00:01:28
carácter por carácter 00:01:29
pero no vamos a hacerlo así porque entonces no 00:01:32
no motiva lo que a mi me interesa 00:01:35
que motive, vamos a hacerlo 00:01:38
operando sobre el número 00:01:40
bueno, pues ¿cómo sacamos las cifras de un número? 00:01:42
ya en su momento 00:01:46
en los ejercicios del primer tema 00:01:47
cuando necesitábamos unidades, decenas 00:01:49
centenas, hacíamos restos 00:01:51
de 10, divisiones entre 10 00:01:53
y lo conseguíamos 00:01:55
¿verdad? 00:01:57
aquí lo único es que lo tenemos que extender 00:01:58
en su momento lo hicimos, yo sabía exactamente 00:02:00
que eran 3 cifras 00:02:03
pues hacía las 3 operaciones y listo 00:02:04
aquí puede haber cualquier número de cifras 00:02:07
Entonces, no sé cuántos restos entre 10 tengo que hacer, pues voy a tener que hacer un bucle, entonces aquí ya tenemos que hacer un bucle. Bueno, pero no pasa nada porque podemos hacerlo así y ya está, que es lo que habréis hecho o pensado más o menos. 00:02:09
Pues tenéis un numerito, cualquiera. ¿Cómo podemos ir sacando las cifras decimales? Pues ir sacando los restos entre 10, ¿verdad? Si yo hago el primer resto entre 10, ya me da el 4, que son las unidades. 00:02:34
¿cómo saco la siguiente? 00:02:51
pues el cociente que me ha quedado 00:02:54
el cociente 00:02:56
que es 321 00:02:58
entonces 00:02:59
me interesará no solo hacer el resto 00:03:02
entre 10 para sacar la cifra 00:03:04
sino hacer también la división entre 10 00:03:05
para sacar el siguiente 00:03:08
cociente con el que operar 00:03:10
bueno, pues 00:03:11
este cociente que me ha quedado 00:03:14
vuelvo a hacer el resto entre 10 00:03:16
y ya saco la siguiente cifra 00:03:20
que es 1 00:03:22
pero divido también entre 10 00:03:23
para quedarme con el siguiente cociente 00:03:26
que ahora es 32 00:03:28
¡Hala! ya tengo 32 00:03:29
me hago el resto entre 10 00:03:31
y me da 2 00:03:35
que es 00:03:37
la siguiente cifra decimal 00:03:38
4, 1, 2 00:03:41
y ahora me hago mi cociente 00:03:42
para tener el siguiente dato 00:03:44
con el que operar 00:03:47
el 3, vale 00:03:48
Ahora, la cuarta operación que hago, 3, 3, resto de dividirlo entre 10, me da 3, que es mi siguiente cifra decimal, cociente de dividirlo entre 10, me da 0, lo cual me marca fin, ya se ha acabado, ¿vale? 00:03:49
pues entonces, esta operación que hemos hecho 00:04:07
es meter en un bucle 00:04:10
todo esto 00:04:12
meto en un bucle 00:04:13
cociente entre 10, saco cifra 00:04:15
divido entre 10 para siguiente cociente 00:04:18
meto eso en un bucle 00:04:21
cada operación 00:04:22
de resto me da 00:04:25
la cifra que tengo que mostrar 00:04:26
y cuando terminaré 00:04:28
cuando 00:04:31
el cociente obtenido sea 0 00:04:32
cuando el cociente obtenido sea 0 00:04:34
ya no tengo que seguir sacando más cifras 00:04:37
ya he terminado 00:04:38
bueno, pues podemos programar esto 00:04:39
y nos queda algo como esto 00:04:43
vale, pues a ver 00:04:46
esto es un bucle, ¿qué era? 00:04:53
mientras mi numerito 00:04:56
estoy segura que hay una forma óptima de hacerlo 00:04:58
pero bueno, vale 00:05:10
mientras mi numerito sea 00:05:12
mayor que cero 00:05:14
¿qué voy a hacer mientras mi numerito 00:05:16
sea mayor que cero? 00:05:19
Primero voy a sacar la cifra. 00:05:21
Num por ciento diez. 00:05:25
Y ahora voy a dividir el número entre diez. 00:05:29
Num entre igual diez. 00:05:33
¡Hala! Y ya está, ya he terminado mi programa. 00:05:40
Ya he programado lo que hemos hecho antes. 00:05:43
Estoy todo el rato. 00:05:46
Haz resto y muestra. 00:05:48
Y divide entre diez. 00:05:50
Divide entre diez y vuelve a guardar en num. 00:05:52
para actualizar el valor de ese cociente. 00:05:54
Y así mientras seas mayor que cero. 00:05:57
Cuando hayas llegado a cero, 00:05:59
es que ya has mostrado la última cifra. 00:06:01
Cuando ya hayas llegado a cero, 00:06:04
no quieres seguir haciendo... 00:06:05
Pues ya está, ya tenemos el programa así. 00:06:08
Bueno, ¿veis más o menos 00:06:14
que esta es la operación que hemos hecho antes en la pizarra? 00:06:15
Que está todo el rato, 00:06:18
saca resto, 00:06:20
y hace el cociente pisando el cociente anterior, 00:06:22
pisándolo, 00:06:25
Para volver arriba otra vez 00:06:25
A volver a sacar el siguiente resto 00:06:28
Y todo eso 00:06:29
Mientras ese cociente que vas actualizando 00:06:30
Lo vas actualizando 00:06:33
Sea mayor que cero 00:06:34
Bueno, vamos a probarlo 00:06:35
No vaya a ser que hayamos escrito mal 00:06:37
O algo no hayamos tenido en cuenta 00:06:42
Venga, pues a ver 00:06:43
Uh, con la R no le va a gustar 00:06:50
Joder 00:06:53
Ala 00:06:53
4, 5, 7, 8, 6 y 7 00:06:55
Vale 00:06:59
Parece que funciona 00:07:00
bueno, hasta ahí bien 00:07:02
pero claro me dicen 00:07:03
que feo, porque me estás sacando 00:07:07
primero las unidades 00:07:09
luego las decenas 00:07:11
como me gustaría que me las sacaras 00:07:13
al revés 00:07:15
es decir, que en lugar de 00:07:17
mostrármelas así, por este orden 00:07:19
me sacaras primero el 7 00:07:21
luego el 6, luego el 8 00:07:23
es como más visual 00:07:25
normalmente uno parece que 00:07:26
presta antes atención visualmente a este número 00:07:28
luego a este, pues me gustaría que a mí me sacaras 00:07:31
el 7, luego el 6 00:07:33
vale 00:07:34
me podrían decir, pedir esa modificación 00:07:39
tendría sentido 00:07:41
para que quedara más bonito, que me pidan esa modificación 00:07:43
pues la hemos liado 00:07:45
con la versión que tengo 00:07:47
aquí, la hemos liado pero bien 00:07:49
porque es que 00:07:51
yo las tengo que 00:07:53
sacar en este orden, es que yo voy sacando 00:07:55
los restos y me van viniendo 00:07:57
en el orden de las decenas, es que no 00:07:59
y tu tía, perdón, me van viniendo 00:08:01
desde la cifra más pequeñita hasta la mayor 00:08:03
y cada vez 00:08:05
que hago yo 00:08:07
para tenerlas ahí todas 00:08:10
tendría que pensar algo 00:08:12
para irlas guardando todas 00:08:14
y no perderlas 00:08:16
y luego ya cuando las tengo guardadas mostrarlas 00:08:17
a ver si me explico 00:08:20
el problema es 00:08:21
dígame 00:08:23
¿cómo se le diría el qué? 00:08:24
a ver, esta sentencia es la misma que 00:08:36
espérate y quite esa cosa 00:08:38
esta sentencia es lo mismo 00:08:39
que si tú haces esto 00:08:44
num 00:08:45
ahí 00:08:47
num igual 00:08:52
a num entre 10 00:08:54
¿vale? entonces 00:08:57
hago el cociente y piso el número 00:08:59
para luego seguir sacándole el resto 00:09:02
¿vale? es la versión abreviada 00:09:04
de eso 00:09:06
pues entonces 00:09:07
Aquí me encuentro con el problema de que yo desearía conservar estos valores, en lugar de mostrarlos tal cual los voy generando, 00:09:09
querría guardarlos en algún sitio 00:09:38
para luego poder 00:09:41
mostrarlos pero en orden inverso 00:09:43
porque si yo los muestro tal cual 00:09:45
los voy generando, pues no hay tu día 00:09:47
primero mostraré las unidades, luego las decenas 00:09:49
porque los voy mostrando tal cual los voy generando 00:09:51
pero me han dicho, no, no, no 00:09:53
muestra primero el último que generaste 00:09:55
y luego el antepenúltimo 00:09:57
luego el otro 00:09:59
entonces no me va a quedar más remedio que ver 00:10:00
y qué hago para en lugar de mostrarlos 00:10:03
tal cual los voy generando 00:10:05
que hago para guardarlos en algún sitio 00:10:07
pues en lugar de la sentencia 00:10:10
esta de system 00:10:12
lo que querríamos es 00:10:12
llevar cada uno de ellos a alguna variable 00:10:15
tenerlos ahí todos guardaditos 00:10:18
y una vez que los tengo 00:10:20
todos guardaditos 00:10:24
ahora ya empezar a mostrarlos 00:10:25
pero en el orden inverso 00:10:28
al que los fui rellenando 00:10:29
¿entendéis que esto sería una solución? 00:10:31
los voy guardando 00:10:35
y luego cuando los tenga todos 00:10:36
cuando ya haya terminado con el último 00:10:37
el bucle haya acabado 00:10:39
ahora ya me pongo a mostrarlos 00:10:41
pero en orden inverso a como los rellene 00:10:43
porque si no hago esto 00:10:44
y los voy mostrando tal cual 00:10:46
es que no hay tutía, los tengo que mostrar según me llenan 00:10:48
es que no hay otra 00:10:51
si quiero mostrarlos en otro orden o hacer otras cosas 00:10:51
los voy a tener que meter en una caja 00:10:54
y una vez que tengo la caja rellena 00:10:56
ahora empiezo a sacar desde el final 00:10:58
yo voy metiendo 00:11:00
me llega este número, me llega este número 00:11:01
ya los tengo todos 00:11:03
ahora te los voy a ir entregando pero al revés 00:11:05
primero el último que me llegó 00:11:07
vale, pues entonces 00:11:08
uno podría decir, ah bueno, muy fácil 00:11:12
no pasa nada 00:11:15
en lugar de hacer un system out 00:11:16
los voy metiendo en una variable 00:11:18
n igual a num 00:11:20
por ciento diez 00:11:22
claro, pero en la siguiente 00:11:25
iteración del bucle, ¿qué pasa con n? 00:11:27
estás pisando el anterior 00:11:30
lo has perdido 00:11:31
entonces ¿qué me hago? pongo aquí n1 00:11:32
pero en la siguiente vuelta del bucle 00:11:35
¿cómo hago para que este 1 sea N2? 00:11:37
no puedo 00:11:40
si yo pongo esta sentencia 00:11:40
va a ser siempre N1 00:11:42
aunque me haga aquí 20 variables 00:11:44
N1, N2, N3 00:11:46
¿cómo hago aquí para que 00:11:47
que pongo aquí 00:11:49
para que cada vez sea una distinta? 00:11:50
no puedo, tengo que poner un nombre de variable 00:11:52
¿cuál pongo? 00:11:54
entonces, ¿entendéis que es un problema 00:11:55
irresoluble 00:11:56
para el que me falta algo más? 00:11:59
para el que me falta algo más 00:12:01
bueno, pues 00:12:02
Pues aquí sería, Jolín, es que lo ideal sería que yo tuviera variables, una variable con el nombre que fuera, en el que pudiera guardar muchas cosas, muchas, porque esto me solucionaría, entre otros, este problema. 00:12:05
yo aquí tengo mi variable n 00:12:24
que en realidad es una caja 00:12:27
con muchas casillas 00:12:29
y le digo, guárdame este 00:12:30
en la primera casilla libre de la caja 00:12:33
y ya está 00:12:35
entonces cada iteración del bucle 00:12:36
guárdame en la primera casilla libre de la caja n 00:12:38
y esa va a ser siempre la misma sentencia 00:12:41
guárdame en la primera casilla libre 00:12:43
pues ya está, ojalá si existiera eso 00:12:45
pues lo tengo solucionado 00:12:47
¿vale? pues esos son los arrays 00:12:48
los arrays son una variable más 00:12:51
una variable más, es un array 00:12:53
pero es una variable 00:12:55
que tiene diferentes casillas 00:12:56
y yo en cada casilla 00:13:00
meto un dato distinto 00:13:03
pero esa variable array 00:13:05
tiene un único nombre 00:13:07
array de números, el nombre que yo quiera 00:13:09
tiene un único nombre y eso es lo que le da la fuerza 00:13:12
al tener un único nombre 00:13:14
yo aquí dentro de mi bucle digo 00:13:16
en el array n, mete eso 00:13:18
y ya está, y él ya lo meterá 00:13:20
donde toque 00:13:21
luego, cuando el bucle termina 00:13:23
todos 00:13:25
estarán guardaditos 00:13:26
todos estos restos 00:13:29
en sus diferentes casillas 00:13:30
y ahora ya sí me puedo plantear 00:13:32
entrar en la RAI-N y empezar ya 00:13:35
a mostrar, a hacer lo que quiera 00:13:37
con lo que hay en la casilla 00:13:38
bueno, pues es una herramienta 00:13:40
que necesitamos 00:13:43
es la siguiente 00:13:45
y última cosa 00:13:47
imprescindible para programar 00:13:48
no hay nada más imprescindible 00:13:50
que va a declaración de variables 00:13:52
y asignación de valores 00:13:54
operadores para hacer expresiones 00:13:56
decisiones, bucles y arrays 00:13:58
no hay absolutamente nada más necesario 00:14:01
para programar 00:14:03
todo lo demás son 00:14:03
formas de organizar esto 00:14:06
porque claro, solo con esto 00:14:09
cualquier programa se convierte 00:14:11
en una cosa infumable 00:14:13
pero con otras pautas de organización 00:14:14
como las clases, los objetos, no sé qué 00:14:17
pues lo puedes hacer un poco más 00:14:19
amigable 00:14:20
bueno pues entonces 00:14:23
¿cómo se declara un array? 00:14:26
¿qué es un array? etcétera 00:14:27
si nos 00:14:28
no, esto no quería yo 00:14:32
aquí 00:14:34
vale 00:14:38
¿arrays? 00:14:39
¿arrays? 00:14:58
arreglos 00:14:58
como dicen los libros raros 00:14:59
Hay libros raros por ahí que dicen arreglos 00:15:00
A veces, ¿vale? 00:15:02
Y no descarto yo que Chagpete alguna vez diga arreglo 00:15:06
En cualquier caso lo entendería 00:15:09
¿Vale? 00:15:11
Bueno, pues es 00:15:12
Un array es 00:15:14
Un tipo más 00:15:16
De dato 00:15:18
Ahora mismo los tipos de datos que conocemos son 00:15:19
Números 00:15:22
By, short, in, long 00:15:24
Decimales 00:15:25
flow of double 00:15:29
char 00:15:30
boolean y luego el stream 00:15:32
que guarda un montón de char juntos 00:15:35
de hecho el stream 00:15:37
por dentro es un array de char 00:15:39
aunque está tuneado 00:15:41
como entenderemos cuando veamos las clases 00:15:42
bueno pues un array que es 00:15:44
es una variable 00:15:47
es una única variable 00:15:48
un tipo de dato 00:15:50
que sirve 00:15:51
¿para qué sirve? 00:16:00
pues igual que el int sirve para guardar un número 00:16:01
el double sirve para guardar un decimal 00:16:03
pues ¿para qué sirve el array? 00:16:05
es un tipo de dato que sirve 00:16:08
para guardar 00:16:09
muchos 00:16:15
no uno 00:16:16
sino muchos datos 00:16:17
pero del mismo tipo 00:16:20
es decir 00:16:24
o todos int 00:16:27
o todos double 00:16:28
o todos char 00:16:29
pero un montón 00:16:32
esto del mismo tipo 00:16:34
lo escribo incluso 00:16:42
para que 00:16:43
nadie me acuse de mentir 00:16:45
pues lo escribo desde ya 00:16:48
con matices 00:16:50
porque bueno 00:16:52
si son objetos 00:16:54
que heredan de la misma jerarquía de herencia 00:16:56
los puedes mezclar también 00:16:58
pero eso cuando son objetos que heredan 00:17:00
de la misma jerarquía de herencia 00:17:02
y eso que tenemos ni puñetera idea de lo que significa 00:17:03
pues ahora mismo no aplica para nosotros 00:17:05
pero pongo el con matices con el mismo tipo 00:17:07
si son primitivos del mismo tipo 00:17:10
sí o sí 00:17:12
¿vale? 00:17:12
ahora mismo no nos aplica el con matices 00:17:15
pero luego ya entenderemos que sí, que tiene unos pequeños matices 00:17:17
¿vale? pues nos viene 00:17:20
genial 00:17:21
lo importante 00:17:25
es que 00:17:28
todos estos datos del mismo tipo 00:17:29
al estar guardados en una 00:17:32
única variable array 00:17:34
van a estar todos guardados 00:17:36
bajo un nombre único 00:17:39
ya no necesito número 1, número 2, número 3 00:17:40
número 4, ahora tendré 00:17:43
números y ahí dentro 00:17:45
irán 20, 30, 40 los que fueran 00:17:47
con el esquema que teníamos hasta ahora 00:17:49
si yo quería trabajar con 20 números 00:17:51
tenía que hacer número 1, número 2 00:17:53
número 3, eso era infumable 00:17:55
aparte de cómo me hago un bucle 00:17:57
cómo cambio dentro yo el nombre de la variable 00:17:59
imposible, pues 00:18:01
de esta manera puedo tener yo mis 30 números 00:18:02
pero todos 00:18:05
van a estar dentro del paraguas 00:18:06
números, ¿vale? 00:18:09
ahora vemos cómo 00:18:11
por definición no 00:18:11
que yo sepa 00:18:19
otra cosa es las restricciones que pueda haber 00:18:20
de la memoria del proceso 00:18:23
pero por definición como tal 00:18:24
que yo sepa no 00:18:26
pero es difícil que tú vayas a necesitar 00:18:27
un array que 00:18:30
pueda tener 00:18:31
más de 1000, 2000 posiciones 00:18:33
porque es que eso luego a la hora de manejarlo 00:18:35
le entretería tanto a la aplicación 00:18:37
que 00:18:38
bueno, pues vamos a ver 00:18:39
cómo 00:18:43
ahora ya que sabemos lo que es 00:18:44
cómo declaramos una variable array 00:18:48
pues por ejemplo 00:18:50
para declarar una variable que tenga números 00:18:52
que es la situación que nos hemos 00:18:55
visto ahora para las cifras 00:18:57
de un número 00:18:59
pues ponemos int 00:19:00
porque va a tener números int 00:19:02
y ahora para indicar que esto es 00:19:05
un array de int 00:19:07
no un único número, un array de int 00:19:09
es decir, una caja 00:19:11
pues pongo aquí esto, corchetes 00:19:12
que se abren y se cierran 00:19:15
con esto estoy indicando 00:19:16
ese tipo de dato es 00:19:19
una cajita de enteros 00:19:21
eso es lo que estoy indicando 00:19:22
no un único número 00:19:25
es decir, una caja de enteros 00:19:27
y ahora, ¿qué nombre doy a la variable? 00:19:28
como siempre, el que me dé la gana 00:19:31
Cuanto más explicativo sea mejor 00:19:32
Claro, pues yo que sé 00:19:34
Por ejemplo, números, lo que yo quiera 00:19:36
Ala 00:19:38
Ya está declarada 00:19:41
El array 00:19:44
¿Significa eso que la caja ya existe 00:19:45
Y la pueda usar? 00:19:51
No significa eso 00:19:53
¿Por qué? 00:19:56
Porque 00:19:59
Un array 00:20:00
En realidad 00:20:01
es un objeto 00:20:03
esta cuestión ya nos salió 00:20:05
cuando vimos los string 00:20:07
cuando vimos los string y declaramos una variable string 00:20:08
os dije 00:20:12
por ejemplo así 00:20:14
os dije 00:20:16
cuidado porque aunque la estamos usando 00:20:18
como cualquier variable primitiva 00:20:19
porque Java me lo permite por operatividad 00:20:21
nombre igual a no sé qué 00:20:23
pues realmente 00:20:25
esto es una variable objeto 00:20:26
¿Y qué significa que una variable sea objeto? 00:20:30
Pues significa que en realidad 00:20:34
Esa variable 00:20:36
Lo que realmente es 00:20:37
Es una dirección de memoria 00:20:39
Es lo que realmente es 00:20:41
Una variable objeto 00:20:44
Y esa dirección de memoria 00:20:45
Te lleva 00:20:47
Ahora ya sí 00:20:48
A la parte de la memoria RAM 00:20:51
Donde están los datos 00:20:54
En el caso de string 00:20:55
Pues a las letras 00:20:56
¿Vale? 00:20:57
es decir, cuando tenemos un string 00:21:00
realmente esto es lo que tenemos 00:21:02
aunque nosotros esta parte 00:21:04
no es transparente, ni la vemos 00:21:06
hacemos nombre igual a hlc 00:21:08
pues ya está, hlc va aquí 00:21:10
pero en realidad ha ido a través de la dirección 00:21:12
de memoria que es lo que está en nombre c 00:21:14
¿vale? esto lo recordáis 00:21:16
es un momento, ¿no? 00:21:17
bueno, pues a un array 00:21:20
le pasa lo mismo 00:21:22
a un array le pasa lo mismo 00:21:23
que es un objeto 00:21:26
luego, si 00:21:27
si yo declaro un array así sin más 00:21:35
lo único que tengo 00:21:40
lo único que tengo es esto 00:21:42
tengo una variable 00:21:47
que se llama números 00:21:49
que realmente es una dirección 00:21:51
de memoria 00:21:54
esto es lo que es 00:21:54
esto es lo que tengo 00:21:57
porque es un objeto, luego es la dirección de memoria 00:21:59
y esta dirección de memoria 00:22:02
ya sí que 00:22:04
me apunta a la caja 00:22:06
con todas sus posiciones 00:22:08
para guardar ahí 00:22:11
todas las cositas 00:22:13
ya me apunta a la caja 00:22:14
pero claro, la caja 00:22:16
cuando yo declaro esto 00:22:19
la caja no existe todavía 00:22:20
existe esto 00:22:22
una dirección de memoria que apunta 00:22:24
a algo que en algún momento 00:22:27
si yo lo creo 00:22:29
será una caja pero que ahora mismo no es nada 00:22:30
aquí no hay nada 00:22:33
es decir, apunta a qué 00:22:34
apunta al famoso null 00:22:35
que es la nada en java 00:22:39
el java null significa 00:22:40
memoria 00:22:43
inalcanzable 00:22:44
no hay nada, no hay alcanzable 00:22:46
luego 00:22:47
si yo hago 00:22:49
simplemente 00:22:53
esto 00:22:55
de aquí arriba 00:22:55
tengo esto 00:22:58
todavía no me vale para guardar nada 00:22:59
todavía no me vale para guardar nada 00:23:02
luego, ¿qué es lo que tengo que hacer? 00:23:04
imprescindible, tengo que hacer algo 00:23:06
para ahora ya sí 00:23:08
crear la caja 00:23:09
y que ya deje de apuntar a null 00:23:11
tengo que hacer algo para crear la caja 00:23:13
es lo primero que tengo que hacer, imprescindible 00:23:16
vale, ¿cómo creamos la caja? 00:23:18
pues así 00:23:21
a números le asigno 00:23:22
y pongo aquí 00:23:24
new 00:23:25
que os suena de new scanner, new no sé qué 00:23:26
que es lo que, pum, abre cosas 00:23:30
de repente en memoria, pum 00:23:32
pongo el tipo de dato 00:23:33
que sea 00:23:36
pongo el tipo de dato 00:23:37
que haya puesto aquí 00:23:46
y entre corchetes 00:23:49
el tamaño 00:23:50
que yo le quiero dar a la caja 00:23:52
si, el mismo tipo 00:23:54
que ya he puesto aquí 00:23:57
si he puesto double, pues double 00:23:57
lo que yo ya he puesto ahí 00:24:00
y ahí tengo que poner algo obligatorio 00:24:01
no lo puedo dejar en blanco 00:24:04
tengo que poner un valor 00:24:05
un valor, el que yo quiera 00:24:08
imaginaos que pongo 10 00:24:09
pues entonces 00:24:12
habré creado una cajita 00:24:14
1, 2, 3, 4, 5, 6, 7 00:24:16
voy a poner 7 00:24:19
y así 00:24:20
habré creado una caja con 7 casillas 00:24:21
¿vale? 00:24:25
entonces 00:24:29
con esto 00:24:29
hago la primera parte 00:24:31
declarar la variable que tiene la dirección de memoria 00:24:33
pero todavía no hay caja 00:24:36
y con esto hago la segunda parte 00:24:37
declarar 00:24:40
la cajita 00:24:42
¿vale? declararla 00:24:43
ahora ya existe, ya puedo meter cosas 00:24:51
en ella 00:24:53
recordad que aquí 00:24:53
lo que se pone es esto mismo 00:24:57
porque la caja puede ser de 00:25:00
dabble, de float, de stream 00:25:02
puede ser de stream, de cualquiera de los tipos 00:25:04
que conocemos 00:25:06
de cualquiera de ellos, yo pongo aquí 00:25:07
lo mismo 00:25:10
y, segunda parte 00:25:11
recordad que esta cantidad 00:25:14
es obligatoria 00:25:16
no puedo ponerlo en blanco y no 00:25:18
ahí hay que comprometerse ya 00:25:20
hay que decir, esa caja 00:25:22
va a tener 20 00:25:23
y una vez que me he comprometido y he dicho que va a tener 20 00:25:25
esa caja ya no se mueve 00:25:28
va a ser para 20, es imposible 00:25:30
hacerla más grande y es imposible encogerla 00:25:32
va a ser para 20 el resto de su vida 00:25:34
si deja de valerme, pues dejo de usarla 00:25:36
y me creo otra 00:25:40
20 números 00:25:42
20 posiciones, habría espacio para 20 números 00:25:43
aquí caben 7 números 00:25:45
dime 00:25:47
según me acuerdo, si no pones 20 números 00:25:49
lo rellenas con 19 00:25:51
¿conseguiría? 00:25:53
sí, lo que pasa es que en el último 00:25:55
tienes el valor por defecto 00:25:56
de los int que es 0 00:25:59
pero si tú pones 7 00:26:00
esta caja tiene automáticamente 00:26:03
7 espacios 00:26:06
vale 00:26:08
ahora tú ya vas a guardar 00:26:09
cosas ahí, pues para tenerlas 00:26:11
ahí guardadas, para luego consultarlas 00:26:13
para operar con ellas, lo que quieras 00:26:15
ahora mismo, como no le hemos metido 00:26:17
nada, pues la caja está 00:26:19
indefinida, si tratamos de 00:26:21
operar, la máquina virtual nos diría 00:26:23
eh, variable, podría no haber nada 00:26:25
ahí, claro que no hay nada 00:26:27
hombre, por defecto 00:26:28
sí que tiene algo, porque los bits no pueden 00:26:31
ser indefinidos, entonces tendrá ceros 00:26:33
porque un int 00:26:35
si no, no le da nada, lo que tiene en memoria 00:26:37
por defecto es un 0 00:26:39
vale 00:26:40
bueno, ya una vez que la caja ya está creada 00:26:41
ahora ya uno puede acceder a sus 00:26:45
posiciones según le da la gana 00:26:47
ahora quiero esta, ahora quiero esta 00:26:49
la que yo quiera 00:26:51
vale, a cada posición 00:26:52
cada casilla 00:26:55
tiene una posición asociada 00:26:57
la primera es la 0 00:26:59
siempre, la primera es la 0 00:27:01
2, así en este caso 00:27:05
hasta la 6 00:27:07
¿vale? luego cada casilla 00:27:08
de la array tiene una posición asociada 00:27:12
y la primera siempre es la 0 00:27:14
que yo quiero asignar 00:27:16
un 3, por ejemplo, en la posición 0 00:27:18
pues ¿cómo accedo 00:27:21
a cada posición? 00:27:22
números, corchetes 00:27:25
y la posición 00:27:26
luego números, corchetes 00:27:27
0, se refiere a esta casilla 00:27:30
solamente, se refiere a esa 00:27:32
luego si yo hago esto 00:27:34
estoy metiendo un 7 ahí 00:27:36
es como un char, ¿no? 00:27:38
sí, es la misma idea 00:27:41
porque de hecho un string 00:27:43
está construido por debajo con un array 00:27:44
lo que pasa es que está envuelto para que nos sea 00:27:46
más fácil de usar 00:27:48
¿vale? 00:27:50
que yo quiero acceder 00:27:52
a la última posición 00:27:54
pues números de 6 00:27:56
igual a 5, me metería un 5 ahí 00:27:58
puedo acceder 00:28:00
a cada posición por separado, hacer lo que yo quiera 00:28:02
automáticamente se me ha habilitado 00:28:04
una caja con posiciones 00:28:07
y ya está 00:28:08
a ver, lo que normalmente hacemos es recorrerlo 00:28:10
para verlas todas, rellenarlas todas 00:28:15
pues lo puedo hacer en un form 00:28:17
¿vale? 00:28:19
vamos a usar un array entonces 00:28:20
para completar ese ejercicio que hemos hecho 00:28:22
y ahora ya guardar las cifras 00:28:25
las posiciones 00:28:27
bueno, no, vamos a ver ejemplos 00:28:28
antes de hacer eso para que no nos olvidemos 00:28:31
vale, pues vamos a hacer 00:28:32
Ejemplos con Arrays para que entendamos bien 00:28:35
Cómo funciona 00:28:37
Vale, a ver 00:28:38
Necesitáis parar unos 00:28:57
Segundos, minutos 00:28:59
Sí, ahora lo vamos a 00:29:01
Ejemplos 00:29:05
47 minutos me quedan 00:29:06
De batería 00:29:11
Nada, no paramos 00:29:13
bueno, es más que nada 00:29:18
la grabación es larguísima 00:29:22
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:
4
Fecha:
11 de noviembre de 2025 - 20:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
29′ 24″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
941.25 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid