1
00:00:00,000 --> 00:00:11,040
Venga, seguimos, que esto es muy relajadito, muy fácil de entender y mucho mejor que un

2
00:00:11,040 --> 00:00:16,640
descanso. Vale, pues hemos identificado que necesitamos eso. Vale, yo voy a trabajar con

3
00:00:16,640 --> 00:00:22,320
100 numerazos. Vale, vamos ahora mismo a acotar, vamos a quedarnos con esa situación. Una

4
00:00:22,320 --> 00:00:27,760
raíz de números. Puede ser de cadenas, de charts, de cualquier otro tipo de datos. Calla.

5
00:00:28,480 --> 00:00:39,480
Miguel, te duermes o hablas. A ver. Pues venga, vamos a suponer que queremos 100 números enteros.

6
00:00:39,480 --> 00:00:44,480
Pues una raíz de 100 números enteros. ¿Cómo me hago yo una raíz de 100 números enteros?

7
00:00:44,480 --> 00:00:50,440
Primero, como siempre, selecciono el nombre. Un nombre de variable lo más explicativo posible.

8
00:00:51,720 --> 00:00:56,840
En muchos ejercicios estamos usando para las variables n, x, y... Bueno, a ver, para ser

9
00:00:57,040 --> 00:01:01,320
rápidos y operativos está bien. Para una aplicación real, el nombre que sea lo más

10
00:01:01,320 --> 00:01:05,800
explicativo posible. Bueno, en este caso vamos a llamarlo números porque vamos a guardar números.

11
00:01:05,800 --> 00:01:10,360
Pero bueno, a lo que voy. Lo primero, uno elige el nombre que le va a dar esa variable. Venga,

12
00:01:10,360 --> 00:01:20,160
pues a mi variable array la voy a llamar números. Vale. Lo siguiente que decide es qué tipo de

13
00:01:20,160 --> 00:01:30,240
dato va a tener. Va a tener muchos números enteros. Vale, pues lo pone aquí. En este caso

14
00:01:30,240 --> 00:01:35,720
sí es int. Si no, sería double, chart, lo que fuera, lo pone aquí. Y para decir qué números

15
00:01:35,720 --> 00:01:42,720
son muchos, y no que es uno, sino que son muchos, lo indica añadiendo estos corchetes que se abren

16
00:01:42,720 --> 00:01:49,960
y se cierran. Ahí pegamos. Entonces, con esto indica qué números son muchos de int. Si no

17
00:01:49,960 --> 00:01:54,240
ponemos los corchetes, entonces sería un único int, como hemos hecho hasta ahora. ¿Verdad?

18
00:01:54,240 --> 00:02:03,360
Si no ponemos los estos, pues sería un único int. El nombre de la variable array es números.

19
00:02:03,840 --> 00:02:15,560
¿Vale? Pero claro, como en cualquier otra declaración de variable, efectivamente. Vale,

20
00:02:15,560 --> 00:02:39,480
pues entonces, esto ya significa el tipo de datos de números es muchos int. Los corchetes,

21
00:02:39,480 --> 00:02:46,480
muchos int. Vale. Y ya está, mi variable array ya se queda declarada. Ya está declarada. Ya existe

22
00:02:46,480 --> 00:02:51,360
esa variable. Claro, ahora ya nos viene el problema. Vale, ahora una variable ¿para qué

23
00:02:51,360 --> 00:02:56,360
sirve? Para meterle cosas, obviamente. Para meterle cosas. Cuando declaramos una variable

24
00:02:56,360 --> 00:03:03,320
entera normal, n1, nos sirve para meterle cositas. Por ejemplo, aquí le meto el 7, lo que yo quiera.

25
00:03:03,320 --> 00:03:08,320
Para eso le vale una variable. Pues a la variable números también le tengo que poder meter cositas.

26
00:03:08,320 --> 00:03:14,800
En este caso, un montón de números. Muchos. Vale, pues ahora nos viene la siguiente pregunta,

27
00:03:14,800 --> 00:03:20,600
que es, pero vamos a ver, ¿cuántos puedo meterle? ¿100, 20, 20.000? ¿Los que me den la gana en

28
00:03:20,600 --> 00:03:27,920
cada momento? Pues no. Desgraciadamente, la restricción de los arrays es que hay que decidir,

29
00:03:27,920 --> 00:03:35,560
a priori, antes de usarlo, antes de usarlo la primera vez, hay que decidir cuántos espacios,

30
00:03:35,600 --> 00:03:40,800
cuántas casillas queremos que tenga. Hay que decidirlo a priori. Y si yo decido que 20,

31
00:03:40,800 --> 00:03:47,920
ya se queda con 20 de por vida. Que luego resulta que en mi aplicación solo voy a usar 15, pues esos

32
00:03:47,920 --> 00:03:53,560
5 los he reservado para nada. Que luego resulta que en mi aplicación voy a usar 30, pues ese array

33
00:03:53,560 --> 00:04:00,240
no me vale, tendré que hacer otro. Entonces, yo tengo que decidir a priori el número de casillas

34
00:04:00,320 --> 00:04:06,480
de ese array. El número de enteros que van a caer. Lo tengo que decidir a priori. Y luego ya,

35
00:04:06,480 --> 00:04:12,080
el programa ya solamente puede contar con esas casillas. Si le quedan cortas o largas,

36
00:04:12,080 --> 00:04:16,320
si le quedan cortas, no pasa nada, tendrá de sobra. Perdón, si le quedan largas, no pasa nada,

37
00:04:16,320 --> 00:04:21,680
le sobrarán. Si le quedan cortas, no le vale. Tiene que hacer otro. Entonces, esa es la pega

38
00:04:21,680 --> 00:04:27,200
de los arrays, que son muy rígidos. Yo tengo que decidir a priori cuántas casillas. Si no,

39
00:04:28,000 --> 00:04:35,240
entonces no es muy flexible. Porque si esto luego depende de un bucle, y ese bucle,

40
00:04:35,240 --> 00:04:41,400
yo no sé cuántos números van a meter, pues a lo mejor yo decido 1000. Y luego el usuario va

41
00:04:41,400 --> 00:04:46,280
metiendo números en un bucle y llega a 1005. Pues la hemos liado, no vale. Esta es la pega.

42
00:04:46,280 --> 00:04:52,240
Y esa pega está ahí y existe y es insolventable. ¿Cómo se solventa? Pues con estructuras de datos

43
00:04:52,240 --> 00:04:56,680
dinámicas que ya son específicas de objetos que ya veremos más adelante. Pero el array de toda

44
00:04:56,680 --> 00:05:00,280
la vida es este. Bueno, pues entonces, hemos dicho que el... ¿Qué vas a decir?

45
00:05:00,280 --> 00:05:05,040
¿Hay algo parecido a un array de arrays? ¿O se puede hacer un array de dos dimensiones?

46
00:05:05,040 --> 00:05:11,200
Claro. Claro, a ver. ¿Y hay de más? ¿Eh? ¿Hay de más dimensiones?

47
00:05:11,200 --> 00:05:15,720
A ver, como si quieres poner corchetes aquí hasta el infinito. ¿Vale? Pero eso ya lo

48
00:05:15,720 --> 00:05:22,600
mencionaremos. Es decir, si tú quieres un array de arrays, ¿qué sería? Esto es un único array,

49
00:05:22,600 --> 00:05:28,440
pero ahora quieres muchos de este. Pues si quieres muchos de este, otros corchetes. Porque

50
00:05:28,440 --> 00:05:34,320
esto significa muchos de lo que hay delante. Eso significa. Entonces, si tú te pones esto aquí,

51
00:05:34,320 --> 00:05:39,560
significa muchos de esto. ¿Y esto qué es? A su vez un array. Pues esto sería muchos arrays.

52
00:05:40,840 --> 00:05:47,000
Que te pones otro más. Esto significa muchos de esto. Que a su vez hay muchos de esto. Pero a ver,

53
00:05:47,000 --> 00:05:51,640
que no se usen arrays como mucho de dos dimensiones porque reproducen un plano,

54
00:05:51,760 --> 00:05:57,040
pero no se usan de más porque para qué. No reproducen una situación real. No es computacionalmente

55
00:05:57,040 --> 00:06:03,240
eficiente. Pero bueno, a los de dos dimensiones ya iremos en su momento para... Ahora quedémonos

56
00:06:03,240 --> 00:06:13,280
con esto. ¿Vale? Vale, pues entonces. Repito, nuestro problema es que tenemos que decidir

57
00:06:13,280 --> 00:06:19,680
el número de casillas del array. ¿Cómo la decidimos? Escribiendo esto que yo pongo aquí.

58
00:06:19,680 --> 00:06:28,960
New. El tipo de dato. Este mismo. Este. Si yo aquí he puesto int, tengo que poner int. Si yo aquí he

59
00:06:28,960 --> 00:06:35,800
puesto dabble, tengo que poner dabble. Y aquí entre corchetes, el tamaño de ese array. El

60
00:06:35,800 --> 00:06:42,360
número de casillas que quiero que tenga. ¿Que quiero que tenga 100? Pues 100. Y así separado

61
00:06:42,360 --> 00:06:53,360
por punto y coma. Entonces con esto, ¿qué estoy haciendo? Estoy creando un espacio en

62
00:06:53,360 --> 00:07:02,360
memoria muy grandote, en el que caben 100 números. Enteros. Es decir, aquí habrá

63
00:07:02,360 --> 00:07:09,640
32 bits, aquí otros 32, 32, 32, porque es un array de int. Eso es lo que he creado

64
00:07:09,640 --> 00:07:19,920
haciendo new int. Un espacio para 100 de estos. 100 enteros. ¿Que yo hago un array de decimales?

65
00:07:19,920 --> 00:07:23,920
Bueno, pues hago un array de decimales.

66
00:07:37,920 --> 00:07:47,920
100, 50, 20, los que a mi me den la gana. Entonces, ¿que estaría haciendo con esto? Crear 100, 200, 30, 1000, 4, los que yo quiera,

67
00:07:47,920 --> 00:07:53,920
espacios en memoria, para cada uno de ellos un decimal. Pues aquí puede ir lo que yo quiera.

68
00:07:53,920 --> 00:08:03,920
Aquí puede ir lo que yo quiera. Siempre y cuando sean decimales. Entonces, las dos rigideces de los

69
00:08:03,920 --> 00:08:12,920
arrays, las dos rigideces son que todos los datos tienen que ser del mismo tipo y que el tamaño se

70
00:08:12,920 --> 00:08:20,920
declara a priori. Y luego, a lo mejor, según el programa se ejecute con unas entradas o con otras, a lo mejor este

71
00:08:20,920 --> 00:08:28,920
espacio que yo he estimado, pues no se adapta. Con un array, desde luego, no lo puedes hacer de otra manera.

72
00:08:28,920 --> 00:08:43,920
¿Vale? Pues con esto ya creamos el espacio en memoria. Y ahora ya lo que nos falta es cómo usar cada una de las casillas,

73
00:08:43,920 --> 00:08:49,920
cómo asignar valor. Bueno, pues esto ya es muy sencillo. Vamos a quedarnos con el ejemplo de los enteros.

74
00:08:50,920 --> 00:08:59,920
Cada casilla, por el hecho de ser un array, cada casilla o posición, ya vemos la posición para usar el lenguaje más habitual,

75
00:08:59,920 --> 00:09:07,920
cada posición tiene asociada un número de posición. La primera tendría, es la cero, la posición cero. La primera posición

76
00:09:07,920 --> 00:09:15,920
del array es la cero. La segunda es la uno. La siguiente es la dos. En este caso, si tengo 100, la última es la 91.

77
00:09:15,920 --> 00:09:25,920
¿Vale? Entonces, cada espacio del array o cada casilla tiene asociado un número de posición.

78
00:09:25,920 --> 00:09:33,920
Lo tiene asociado por pura definición del funcionamiento del array. Cero, uno, dos, empezando en la cero, sí.

79
00:09:33,920 --> 00:09:39,920
Y ahora yo puedo acceder a cada casilla por separado, porque no dejan de ser un montón de variables. Cada una de ellas

80
00:09:39,920 --> 00:09:46,920
es una variable entera, suelta. ¿Que yo quiero acceder a la posición cero para asignarle un valor? Pues, ¿cómo accedo?

81
00:09:46,920 --> 00:09:54,920
Nombre de la variable array, y entre corchetes, la posición a la que yo quiero acceder. ¿Que quiero a la cero

82
00:09:54,920 --> 00:10:01,920
porque me da gana la cero? Pues, a la cero. Y tendré la variable esta, que esta ya sí que es una variable suelta.

83
00:10:02,920 --> 00:10:12,920
O sea, números es todo. Números, corchetes, una posición, ya es una de ellas. Solo una. Y una de ellas ya es para un solo número.

84
00:10:12,920 --> 00:10:21,920
Pues, por ejemplo, esto, pues sería válido. A la posición cero del array le asigno el 7. Vale, pues le asigno el 7.

85
00:10:22,920 --> 00:10:33,920
¿Que ahora quiero, vete a saber por qué, a la posición 2 del array, asignarle el doble de lo que haya en la posición 1?

86
00:10:33,920 --> 00:10:46,920
Pues podría hacer, venga, a la posición 2, bueno, esta sería en realidad la tercera, si pongo números de 2 sería esta, ¿verdad?

87
00:10:46,920 --> 00:10:56,920
A la posición esta, a la 2, que es la tercera física, le voy a asignar el doble, ¿de qué? De lo que haya en la 1.

88
00:10:56,920 --> 00:11:00,920
Por ejemplo, lo que hay en la 1 ya sé lo que es, número cero.

89
00:11:05,920 --> 00:11:12,920
Es decir, luego aquí ya uno hace con cada posición lo que le dé la gana. Ya depende del problema que quiera resolver.

90
00:11:13,920 --> 00:11:25,920
Lo único que tenemos que saber es que para referirme yo a cada casilla, para referirme a cada posición, me referiré con el nombre de la variable y entre corchetes la posición que yo quiera.

91
00:11:25,920 --> 00:11:37,920
Y ahora ya cada uno de estos, cada número y la posición que yo quiera, la que sea, 0, 1, 2, cada uno de, ya es una variable suelta, ya se comporta como una variable suelta.

92
00:11:42,920 --> 00:11:52,920
¿Vale?

93
00:11:56,920 --> 00:11:59,920
Vale, pues vamos a parar aquí unos minutitos, dime.

94
00:11:59,920 --> 00:12:11,920
La posición 0 de las 100, la 1 de las 100, la 99 de las 100, eso no existe en tiempo.

95
00:12:14,920 --> 00:12:21,920
¿Cómo que el 2? No, en este caso el 2 tendrá 14 dentro, en este caso tendrá 14, claro.

96
00:12:21,920 --> 00:12:27,920
Si a números 0 le hubiéramos puesto 8, pues como resultado de esa expresión, la 2 tendría 16.

97
00:12:28,920 --> 00:12:35,920
¿Vale? Es decir, ya son como variables sueltas, pero accedo a ellas a través de su posición.

98
00:12:36,920 --> 00:12:44,920
¿Vale? Pues vamos a parar un momentito.