1
00:00:00,000 --> 00:00:07,000
Voy a grabar esta clase, por lo tanto, todo lo que digáis estará grabado

2
00:00:07,000 --> 00:00:16,000
Estamos viendo los arrays, que son variables que pueden contener más de un valor

3
00:00:16,000 --> 00:00:23,000
Todos del mismo tipo, un cierto tamaño, un cierto número de valores del mismo tipo

4
00:00:23,000 --> 00:00:35,000
Lo que pasa es que al principio de la creación, cuando creo un array, lo que hago es decirle el tamaño de este array

5
00:00:35,000 --> 00:00:43,000
Cuantas posiciones puede contener, y luego el tamaño de este array se queda fijo, no se puede modificar

6
00:00:43,000 --> 00:00:50,000
Un array se define de un cierto tamaño, este tamaño eventualmente puede ser elegido a tiempo de ejecución

7
00:00:50,000 --> 00:00:58,000
Yo puedo pedir un número al usuario, el usuario me da 5 y yo creo un array de 5 posiciones

8
00:00:58,000 --> 00:01:09,000
Porque no, no tiene que ser creado a tiempo de programación, de cuando hago el código

9
00:01:09,000 --> 00:01:19,000
El tamaño del array puede ser inicializado después, pero una vez que lo he creado, ese es su tamaño y ese se queda

10
00:01:19,000 --> 00:01:25,000
No se puede extender o recortar un array, si no con un método que ahora vemos

11
00:01:25,000 --> 00:01:30,000
Que no es cambiar el tamaño del array, el array es fijo

12
00:01:30,000 --> 00:01:37,000
Aquí os acordáis como se declara, como se inicializa y como se asignan a las celdas

13
00:01:37,000 --> 00:01:42,000
Sostancialmente es una variable, donde después de la variable tiene estas dos corchetes

14
00:01:42,000 --> 00:01:46,000
Que me dicen que posición de esa variable voy a guardar el dato

15
00:01:46,000 --> 00:01:53,000
Entonces en vez de tener la int x es igual a 7 y yo sé que esa x solo puede contener un valor

16
00:01:53,000 --> 00:01:58,000
Entonces le pongo directamente el valor, aquí le tendré que decir a mi array una cierta posición

17
00:01:58,000 --> 00:02:04,000
Como en la posición 0 ponme 16, en la posición 1 ponme 37, etc.

18
00:02:07,000 --> 00:02:15,000
La cosa interesante es que el índice que utilizamos aquí para acceder a las varias celdas del array es un número

19
00:02:15,000 --> 00:02:20,000
Y como tal podemos hacer operaciones sobre él, podemos utilizar una variable

20
00:02:20,000 --> 00:02:30,000
Y sobre todo nosotros la utilizamos en for, con un for lo que puede hacer es recorrer el array

21
00:02:33,000 --> 00:02:42,000
Utilizando una variable y como índice, esta y que vaya desde 0 hasta el final, hasta la última posición del array

22
00:02:42,000 --> 00:02:48,000
Que os recuerdo que es array.length menos 1, la última posición

23
00:02:48,000 --> 00:02:53,000
Si yo tengo un array de 5 posiciones va de 0 a 4, las posiciones posibles

24
00:02:53,000 --> 00:03:04,000
También no es necesario recorrerlo entero, si por alguna razón yo quiero recorrer los primeros 10 celdas de un array

25
00:03:04,000 --> 00:03:09,000
Pues puedo poner que el límite sea 11, o sea menor que 11 o menor o igual que 10

26
00:03:10,000 --> 00:03:21,000
O si quiero empezar en vez de la 0 desde la 3, pues puedo poner aquí igual hasta 13 y seguir adelante

27
00:03:21,000 --> 00:03:26,000
O sea que no necesariamente tengo que recorrerlo siempre entero

28
00:03:26,000 --> 00:03:32,000
Hemos visto también que existe una estructura distinta, que es la estructura for each

29
00:03:33,000 --> 00:03:41,000
La estructura for each me permite, o sea se usa cuando quiero en vez de recorrer todo el array seguramente

30
00:03:41,000 --> 00:03:48,000
Quiero pillar todos los elementos de los arrays y hacer algo sobre estos elementos

31
00:03:48,000 --> 00:03:53,000
Entonces es esta cosa de aquí, esta es equivalente a poner for int i es igual a 1

32
00:03:54,000 --> 00:04:01,000
i es menor que nums.length i++ y luego poner que int i es igual a nums de i

33
00:04:01,000 --> 00:04:05,000
int y es igual a nums de i, sería lo mismo

34
00:04:05,000 --> 00:04:11,000
Pero como esto se hace mucho, el de entrar en todas las celdas de un array

35
00:04:11,000 --> 00:04:15,000
Pillar los valores que están allí dentro y hacer algo con esos valores

36
00:04:15,000 --> 00:04:21,000
Pues existe esta forma aquí para que sea más fácil, más rápido de hacer

37
00:04:21,000 --> 00:04:26,000
Esto sobre todo nos vendrá bien cuando haremos los objetos

38
00:04:26,000 --> 00:04:33,000
Porque aquí en vez de int pillaré un objeto y sobre el objeto haré las operaciones que tengo que hacer sobre el objeto

39
00:04:33,000 --> 00:04:35,000
Lo veremos

40
00:04:35,000 --> 00:04:42,000
Por ahora la única cosa es que tened en cuenta que si utilizáis esto, lo que estáis perdiendo es el índice

41
00:04:43,000 --> 00:04:47,000
Ahora estáis pillando todos los enteros de este array

42
00:04:47,000 --> 00:04:55,000
Pero no sabéis en qué posición del array está el número que habéis pillado en un cierto momento

43
00:04:55,000 --> 00:04:59,000
O os lo guardáis vosotros, creáis aquí un int posición igual a 0

44
00:04:59,000 --> 00:05:02,000
Y cada vez que entráis aquí dentro al final hacéis un pos++

45
00:05:02,000 --> 00:05:06,000
Pero entonces a ese punto ya os compensa el otro

46
00:05:06,000 --> 00:05:14,000
Lo único es que a veces hay programas en el que quiero saber la posición en la que estoy en el array

47
00:05:14,000 --> 00:05:18,000
Y otras veces no, simplemente quiero hacer algo sobre todos los arrays

48
00:05:18,000 --> 00:05:23,000
Todos los ejercicios que hemos hecho nosotros de calcular la media, de sumar todos los elementos

49
00:05:23,000 --> 00:05:26,000
Pues eso me da igual si está en la posición 0, 1 o 2

50
00:05:26,000 --> 00:05:29,000
Lo que tengo que hacer es hacer algo con todos los elementos

51
00:05:29,000 --> 00:05:31,000
Por lo tanto esto sí nos puede servir

52
00:05:31,000 --> 00:05:38,000
Si yo quiero hacer, por ejemplo, un programa que busca en qué posición está un cierto valor

53
00:05:38,000 --> 00:05:40,000
Que yo le introduzco de un array

54
00:05:40,000 --> 00:05:45,000
Pues entonces necesitaría mantenerme la posición

55
00:05:45,000 --> 00:05:47,000
Saber en qué posición estoy mirando para decir

56
00:05:47,000 --> 00:05:49,000
Mira, he encontrado, tú estabas buscando el valor 5

57
00:05:49,000 --> 00:05:51,000
Lo he encontrado en la posición 3

58
00:05:51,000 --> 00:05:53,000
Y te contesto, mira, estaba en la posición 3

59
00:05:53,000 --> 00:05:57,000
Entonces en este caso es mejor utilizar el otro for

60
00:05:57,000 --> 00:06:00,000
Porque tengo el índice i que va creciendo

61
00:06:00,000 --> 00:06:04,000
Y puedo usar ese índice i para decir cuando lo encuentro pues haz algo con ese índice

62
00:06:04,000 --> 00:06:06,000
¿Me explico?

63
00:06:06,000 --> 00:06:08,000
¿Dudas?

64
00:06:11,000 --> 00:06:13,000
Escribir el contenido de un array

65
00:06:13,000 --> 00:06:17,000
Vale, hemos visto esta cosa de aquí

66
00:06:19,000 --> 00:06:22,000
Este es un comodín, arrays.toString de un array

67
00:06:22,000 --> 00:06:26,000
Que lo que me hace es escribir el contenido de un array

68
00:06:26,000 --> 00:06:28,000
En un formato que es corchete

69
00:06:28,000 --> 00:06:31,000
Todos los contenidos separados por coma, otro corchete

70
00:06:31,000 --> 00:06:36,000
Esto técnicamente lo podéis usar para hacer pruebas

71
00:06:36,000 --> 00:06:38,000
Para, oye, mi programa no está funcionando

72
00:06:38,000 --> 00:06:44,000
Voy a mirar rápidamente que contiene este array en un determinado punto

73
00:06:44,000 --> 00:06:49,000
Y en vez de hacerme un for que vaya en todas las posiciones y haga no sé qué

74
00:06:49,000 --> 00:06:51,000
Pues uso esta cosa aquí

75
00:06:51,000 --> 00:06:55,000
Si el ejercicio os pide de escribir en pantalla el contenido de un array

76
00:06:55,000 --> 00:06:59,000
En teoría no es esto lo que se está pidiendo

77
00:06:59,000 --> 00:07:00,000
¿Vale?

78
00:07:00,000 --> 00:07:04,000
Porque todavía nosotros estamos trabajando con for, while y cosas por el estilo

79
00:07:04,000 --> 00:07:08,000
Entonces quiero ver que sabéis utilizar for, while y sabéis cómo utilizar

80
00:07:08,000 --> 00:07:10,000
¿Es claro?

81
00:07:11,000 --> 00:07:12,000
Vale

82
00:07:14,000 --> 00:07:16,000
Entonces

83
00:07:17,000 --> 00:07:20,000
Una cosa interesante de los arrays

84
00:07:20,000 --> 00:07:23,000
Es que los arrays no funcionan como los tipos primitivos

85
00:07:23,000 --> 00:07:31,000
¿Os acordáis que la última vez hicimos un ejemplo de copiar una variable y copiar un array?

86
00:07:31,000 --> 00:07:35,000
Y vimos que esto funcionaba de forma distinta

87
00:07:35,000 --> 00:07:37,000
A ver si lo tengo

88
00:07:40,000 --> 00:07:44,000
¿Os acordáis que cuando yo tengo una situación como esta?

89
00:07:44,000 --> 00:07:47,000
En la que creo la variable x que vale 8

90
00:07:47,000 --> 00:07:50,000
Luego int y es igual a x

91
00:07:50,000 --> 00:07:51,000
Y cambio x

92
00:07:51,000 --> 00:07:55,000
Y imprimo las dos cosas x e y

93
00:07:55,000 --> 00:07:58,000
X ha cambiado, x valdrá 20

94
00:07:58,000 --> 00:08:00,000
Pero y no

95
00:08:00,000 --> 00:08:02,000
Esto pasa porque

96
00:08:06,000 --> 00:08:08,000
Cuando yo creo x

97
00:08:08,000 --> 00:08:11,000
Estoy creando un espacio de memoria

98
00:08:11,000 --> 00:08:14,000
Dentro de esto pongo por ejemplo 8

99
00:08:14,000 --> 00:08:16,000
Según el ejemplo

100
00:08:16,000 --> 00:08:17,000
¿Vale?

101
00:08:17,000 --> 00:08:20,000
Luego cuando hago int y igual a x

102
00:08:20,000 --> 00:08:24,000
Lo que estoy creando es un nuevo espacio de memoria que se llama y

103
00:08:24,000 --> 00:08:28,000
Y copio lo que está dentro de x

104
00:08:28,000 --> 00:08:30,000
Es decir, esto

105
00:08:30,000 --> 00:08:34,000
Así que cuando luego hago x igual a 20

106
00:08:34,000 --> 00:08:37,000
Lo que estoy haciendo es modificar esta variable

107
00:08:37,000 --> 00:08:40,000
Sin tocar la variable y

108
00:08:40,000 --> 00:08:41,000
¿Si?

109
00:08:41,000 --> 00:08:44,000
Son dos espacios de memoria separados

110
00:08:44,000 --> 00:08:46,000
La copia se ha hecho por valor

111
00:08:46,000 --> 00:08:48,000
Es decir, que el valor que estaba en x

112
00:08:48,000 --> 00:08:50,000
Se ha puesto en el otro espacio de memoria

113
00:08:50,000 --> 00:08:53,000
Por lo tanto, después de esta

114
00:08:53,000 --> 00:08:56,000
De esta instrucción de aquí

115
00:08:56,000 --> 00:08:59,000
Yo tengo dos copias del valor 8

116
00:08:59,000 --> 00:09:01,000
Independientes

117
00:09:01,000 --> 00:09:04,000
Cuando sobre escribo la x

118
00:09:04,000 --> 00:09:06,000
La y no se ve sobre escrita

119
00:09:06,000 --> 00:09:08,000
Son dos cosas separadas

120
00:09:08,000 --> 00:09:10,000
¿Se entiende esto?

121
00:09:10,000 --> 00:09:13,000
En los arrays es distinto

122
00:09:13,000 --> 00:09:15,000
Cuando yo creo

123
00:09:15,000 --> 00:09:17,000
Entonces tengo aquí

124
00:09:17,000 --> 00:09:19,000
Esto por ejemplo

125
00:09:19,000 --> 00:09:22,000
Entonces

126
00:09:22,000 --> 00:09:25,000
Creo un array

127
00:09:25,000 --> 00:09:27,000
De una determinada forma

128
00:09:27,000 --> 00:09:29,000
Luego hago una copia de este array

129
00:09:29,000 --> 00:09:32,000
Y modifico el primero

130
00:09:32,000 --> 00:09:38,000
Si funcionara como las variables normales

131
00:09:38,000 --> 00:09:41,000
Este cambio no afectaría a dos

132
00:09:41,000 --> 00:09:42,000
¿Si?

133
00:09:42,000 --> 00:09:43,000
Serían dos copias

134
00:09:43,000 --> 00:09:46,000
Hay un array que es A1 que contiene 1, 2 y 3

135
00:09:46,000 --> 00:09:48,000
Y A2 que contiene 1, 2 y 3

136
00:09:48,000 --> 00:09:50,000
Cambio en el primero un 100

137
00:09:50,000 --> 00:09:51,000
Pongo un 100

138
00:09:51,000 --> 00:09:53,000
Pues el segundo no se vería afectado

139
00:09:53,000 --> 00:09:56,000
El problema es que los arrays no son tipos primitivos

140
00:09:56,000 --> 00:09:59,000
Son objetos por debajo

141
00:09:59,000 --> 00:10:02,000
Entonces funcionan un poco de forma distinta

142
00:10:02,000 --> 00:10:06,000
Cuando yo creo A1

143
00:10:06,000 --> 00:10:09,000
Estoy creando una variable

144
00:10:09,000 --> 00:10:12,000
Con tres espacios

145
00:10:12,000 --> 00:10:13,000
Un array

146
00:10:13,000 --> 00:10:17,000
Y le pongo 1, 2 y 3

147
00:10:17,000 --> 00:10:18,000
¿Vale?

148
00:10:18,000 --> 00:10:21,000
Cuando ejecuto esta

149
00:10:21,000 --> 00:10:24,000
Osea int A2 es igual a 1

150
00:10:24,000 --> 00:10:26,000
Estoy creando un nuevo array

151
00:10:26,000 --> 00:10:29,000
A2

152
00:10:29,000 --> 00:10:31,000
Pero no se copian estos valores

153
00:10:31,000 --> 00:10:34,000
Lo que se copia es la referencia

154
00:10:34,000 --> 00:10:37,000
En realidad dentro de A1

155
00:10:37,000 --> 00:10:44,000
Hay un puntero a esta estructura de aquí

156
00:10:44,000 --> 00:10:46,000
Y cuando hago esta operación de aquí

157
00:10:46,000 --> 00:10:48,000
De copiar A1 en A2

158
00:10:48,000 --> 00:10:51,000
No estoy copiando el contenido de la estructura

159
00:10:51,000 --> 00:10:59,000
Si no estoy copiando el mismo puntero

160
00:10:59,000 --> 00:11:01,000
Entonces ahora no tengo dos arrays

161
00:11:01,000 --> 00:11:06,000
Tengo un array solo con dos nombres

162
00:11:06,000 --> 00:11:11,000
Esta es como funciona cuando estoy utilizando las referencias

163
00:11:11,000 --> 00:11:14,000
O punteros, si por ejemplo trabajáis en C

164
00:11:14,000 --> 00:11:17,000
C se trabaja mucho con punteros

165
00:11:17,000 --> 00:11:21,000
¿Qué pasa cuando luego en A1 de 0 cambio a 100?

166
00:11:21,000 --> 00:11:24,000
Pues A1 de 0 va a esta estructura

167
00:11:24,000 --> 00:11:27,000
Va en la posición 0 que es esta de aquí

168
00:11:27,000 --> 00:11:30,000
Y sustituye el 1 con un 100

169
00:11:30,000 --> 00:11:34,000
Si ahora escribo A2 de 0

170
00:11:34,000 --> 00:11:44,000
Esto también contiene 100

171
00:11:44,000 --> 00:11:47,000
Antes las dos variables eran independientes

172
00:11:47,000 --> 00:11:49,000
Porque el paso era por valor

173
00:11:49,000 --> 00:11:51,000
Se ha copiado el valor

174
00:11:51,000 --> 00:11:53,000
Mientras ahora se ha pasado la referencia

175
00:11:53,000 --> 00:11:57,000
Por lo tanto estamos trabajando sobre el mismo objeto

176
00:11:57,000 --> 00:11:59,000
Sobre el mismo array

177
00:11:59,000 --> 00:12:09,000
Este es importante

178
00:12:09,000 --> 00:12:11,000
No obstante yo haya modificado solo A1

179
00:12:11,000 --> 00:12:17,000
A2 de 0 vale 100 también

180
00:12:17,000 --> 00:12:19,000
Porque no hay dos arrays

181
00:12:19,000 --> 00:12:22,000
Hay dos referencias al mismo array

182
00:12:22,000 --> 00:12:25,000
Hay un array solo

183
00:12:25,000 --> 00:12:28,000
Y entonces aquí viene la pregunta para vosotros

184
00:12:28,000 --> 00:12:37,000
¿Cómo copio un array?

185
00:12:37,000 --> 00:12:41,000
Entonces hemos llegado a esta conclusión

186
00:12:41,000 --> 00:12:44,000
Cuando yo tengo un array A1

187
00:12:44,000 --> 00:12:47,000
Que tiene 1, 2 y 3 dentro

188
00:12:47,000 --> 00:12:49,000
Si hago una cosa como esta

189
00:12:49,000 --> 00:12:51,000
No estoy copiando el array

190
00:12:51,000 --> 00:12:53,000
Estoy creando una nueva referencia

191
00:12:53,000 --> 00:12:56,000
O sea A2 al mismo array

192
00:12:56,000 --> 00:12:58,000
Los cambios que yo haga en A1

193
00:12:58,000 --> 00:13:01,000
Se verán también si acedo A2

194
00:13:01,000 --> 00:13:03,000
Y los cambios que hago en A2

195
00:13:03,000 --> 00:13:07,000
Se verán también si acedo con A1

196
00:13:07,000 --> 00:13:08,000
¿Por qué?

197
00:13:08,000 --> 00:13:09,000
Porque son el mismo array

198
00:13:09,000 --> 00:13:11,000
No es una copia de un array

199
00:13:11,000 --> 00:13:13,000
Si no es dos referencias

200
00:13:13,000 --> 00:13:16,000
Dos nombres al mismo array

201
00:13:16,000 --> 00:13:19,000
Si quiero copiar el array

202
00:13:19,000 --> 00:13:21,000
Lo que tengo que hacer

203
00:13:21,000 --> 00:13:23,000
Es crearme un nuevo array

204
00:13:23,000 --> 00:13:26,000
Del mismo tamaño que tiene el array original

205
00:13:26,000 --> 00:13:28,000
De esta forma ahora ya tengo dos arrays

206
00:13:28,000 --> 00:13:30,000
Uno es este

207
00:13:30,000 --> 00:13:32,000
Y uno es este otro

208
00:13:32,000 --> 00:13:34,000
Y luego hacer un FOR

209
00:13:34,000 --> 00:13:38,000
Que aceda a todas las posiciones de A1

210
00:13:38,000 --> 00:13:41,000
Y los copie explícitamente dentro de A3

211
00:13:41,000 --> 00:13:43,000
Entonces al final de esto

212
00:13:43,000 --> 00:13:45,000
Tengo una situación

213
00:13:45,000 --> 00:13:47,000
En la que tengo A1

214
00:13:47,000 --> 00:13:49,000
Que es el array original

215
00:13:49,000 --> 00:13:51,000
A2 que es otra referencia al mismo array

216
00:13:51,000 --> 00:13:53,000
Entonces los cambios de A1

217
00:13:53,000 --> 00:13:54,000
Lo verá también A2

218
00:13:54,000 --> 00:13:56,000
Y los cambios de A2 lo verá también A1

219
00:13:56,000 --> 00:14:00,000
Y A3 en vez se ha creado un nuevo array

220
00:14:00,000 --> 00:14:02,000
Por otro lado

221
00:14:02,000 --> 00:14:04,000
Y este nuevo array por otro lado

222
00:14:04,000 --> 00:14:06,000
Se han copiado de uno en uno

223
00:14:06,000 --> 00:14:08,000
Todos los valores que estaban en el A1

224
00:14:08,000 --> 00:14:10,000
Usando el FOR

225
00:14:10,000 --> 00:14:12,000
Por lo tanto ahora tengo dos copias

226
00:14:12,000 --> 00:14:15,000
Del mismo array

227
00:14:15,000 --> 00:14:18,000
A3 referencia esta copia

228
00:14:18,000 --> 00:14:21,000
Y A1 y A2 referencia esta otra copia

229
00:14:21,000 --> 00:14:23,000
Los cambios que se hacen en A1 y A2

230
00:14:23,000 --> 00:14:25,000
No se verán en A3

231
00:14:25,000 --> 00:14:27,000
Los cambios que se harán en A3

232
00:14:27,000 --> 00:14:29,000
No se verán ni en A1 ni en A2

233
00:14:39,000 --> 00:14:41,000
Entonces

234
00:14:41,000 --> 00:14:43,000
Esto es otra forma de verlo

235
00:14:44,000 --> 00:14:46,000
Cuando yo creo

236
00:14:46,000 --> 00:14:48,000
Aquí tengo un array de string

237
00:14:48,000 --> 00:14:50,000
Que se llama X

238
00:14:50,000 --> 00:14:52,000
Pues X apunta esta cosa aquí

239
00:14:52,000 --> 00:14:54,000
En la posición 0 está 1

240
00:14:54,000 --> 00:14:56,000
En la posición 1 está 2

241
00:14:56,000 --> 00:14:58,000
En la posición 2 está 3

242
00:14:58,000 --> 00:15:00,000
Son estos valores de aquí que he puesto

243
00:15:00,000 --> 00:15:02,000
Y estos son todos string

244
00:15:02,000 --> 00:15:04,000
Si yo hago

245
00:15:04,000 --> 00:15:08,000
String array de Y igual a X

246
00:15:08,000 --> 00:15:10,000
Lo que estoy haciendo es

247
00:15:10,000 --> 00:15:14,000
Duplicar las referencias a este array

248
00:15:14,000 --> 00:15:16,000
¿Cuántos arrays hay?

249
00:15:16,000 --> 00:15:18,000
Uno solo

250
00:15:18,000 --> 00:15:20,000
Pero tengo dos nombres para este array

251
00:15:20,000 --> 00:15:22,000
Entonces sería así

252
00:15:22,000 --> 00:15:24,000
Si ahora hago X de 3 igual a 7

253
00:15:24,000 --> 00:15:27,000
Y modifico este valor por 7

254
00:15:27,000 --> 00:15:31,000
Pues también Y de 3 valdrá 7

255
00:15:31,000 --> 00:15:34,000
Porque son referencias al mismo array

256
00:15:35,000 --> 00:15:37,000
¿Se entiende?

257
00:15:39,000 --> 00:15:41,000
¿Cómo copio un array entonces?

258
00:15:41,000 --> 00:15:43,000
Para copiar un array

259
00:15:43,000 --> 00:15:45,000
Yo tengo el array X

260
00:15:45,000 --> 00:15:47,000
Pues string de Y es igual a new

261
00:15:51,000 --> 00:15:53,000
String de 5

262
00:15:53,000 --> 00:15:55,000
¿Vale?

263
00:15:55,000 --> 00:15:57,000
Y esta cosa aquí es más compleja

264
00:15:57,000 --> 00:15:59,000
De lo que dijimos nosotros

265
00:15:59,000 --> 00:16:01,000
¿Vale?

266
00:16:05,000 --> 00:16:07,000
Lo dejamos

267
00:16:07,000 --> 00:16:09,000
Nosotros lo hemos hecho de la otra forma

268
00:16:09,000 --> 00:16:11,000
Esto aquí posiblemente funciona

269
00:16:11,000 --> 00:16:14,000
Pero si os fijáis aquí estoy haciendo un int Y

270
00:16:14,000 --> 00:16:16,000
Mientras deberían ser string

271
00:16:16,000 --> 00:16:18,000
Y entonces es distinto de cómo lo hemos utilizado

272
00:16:18,000 --> 00:16:20,000
Pues esto por ahora no lo miramos

273
00:16:20,000 --> 00:16:22,000
Lo que se ha hecho

274
00:16:22,000 --> 00:16:25,000
Pensándolo en el for que sabemos nosotros

275
00:16:25,000 --> 00:16:27,000
Int Y es igual a 0

276
00:16:27,000 --> 00:16:30,000
Y es menor que X.length

277
00:16:30,000 --> 00:16:32,000
Y más más

278
00:16:33,000 --> 00:16:36,000
Cuando hago esta cosa de aquí

279
00:16:36,000 --> 00:16:39,000
Lo que estoy haciendo es crear un nuevo array

280
00:16:39,000 --> 00:16:41,000
Ahora tengo dos arrays

281
00:16:41,000 --> 00:16:43,000
Y cuando hago el for

282
00:16:43,000 --> 00:16:46,000
Esta es una versión más complicada todavía

283
00:16:46,000 --> 00:16:48,000
Para nosotros que no la entendemos

284
00:16:48,000 --> 00:16:50,000
De este array

285
00:16:50,000 --> 00:16:52,000
Lo que estoy haciendo es copiar los valores

286
00:16:52,000 --> 00:16:55,000
Y cuando hago X de 3 es igual a 7

287
00:16:55,000 --> 00:16:57,000
Modificando este valor de aquí

288
00:16:57,000 --> 00:16:59,000
Este valor de aquí no se ve afectado

289
00:16:59,000 --> 00:17:01,000
Porque son dos arrays distintos

290
00:17:02,000 --> 00:17:04,000
¿Dudas?

291
00:17:07,000 --> 00:17:09,000
La última cosa

292
00:17:09,000 --> 00:17:12,000
Que nos queda para mirar

293
00:17:19,000 --> 00:17:21,000
Es lo siguiente

294
00:17:21,000 --> 00:17:23,000
Imaginaos

295
00:17:26,000 --> 00:17:29,000
Que yo tenga un array

296
00:17:33,000 --> 00:17:35,000
¿Sí?

297
00:17:36,000 --> 00:17:39,000
Normalmente nosotros dentro de este array

298
00:17:39,000 --> 00:17:41,000
¿Qué ponemos?

299
00:17:41,000 --> 00:17:43,000
Int, string, lo que sea

300
00:17:43,000 --> 00:17:45,000
Valores

301
00:17:45,000 --> 00:17:48,000
¿Qué pasa si yo dentro de esta celda

302
00:17:48,000 --> 00:17:51,000
Pongo un array?

303
00:17:51,000 --> 00:17:53,000
¿Sí?

304
00:17:59,000 --> 00:18:01,000
Y dentro de esta

305
00:18:01,000 --> 00:18:03,000
Otro array

306
00:18:03,000 --> 00:18:05,000
Y dentro de esta

307
00:18:05,000 --> 00:18:07,000
Otro array

308
00:18:07,000 --> 00:18:09,000
¿Lo puedo hacer?

309
00:18:13,000 --> 00:18:15,000
Nosotros hemos dicho que

310
00:18:15,000 --> 00:18:17,000
Dentro del array van variables

311
00:18:17,000 --> 00:18:19,000
¿Vale?

312
00:18:20,000 --> 00:18:21,000
Int

313
00:18:21,000 --> 00:18:22,000
¿Sí?

314
00:18:22,000 --> 00:18:23,000
Entonces pongo 3, 7, 5, etc

315
00:18:23,000 --> 00:18:25,000
Pero si en vez de poner un int aquí dentro

316
00:18:25,000 --> 00:18:27,000
Pongo un int array

317
00:18:27,000 --> 00:18:29,000
Int corchetas

318
00:18:29,000 --> 00:18:31,000
Pues entonces quiere decir que cuando hace de aquí

319
00:18:31,000 --> 00:18:33,000
No encuentro un valor concreto

320
00:18:33,000 --> 00:18:35,000
Sino encuentro un puntero

321
00:18:35,000 --> 00:18:37,000
Que me lleva a otro array

322
00:18:38,000 --> 00:18:41,000
Donde dentro están las cosas

323
00:18:42,000 --> 00:18:44,000
¿Esto cómo se llamará?

324
00:18:44,000 --> 00:18:46,000
Pues esto será un array A

325
00:18:46,000 --> 00:18:48,000
Que tiene un puntero

326
00:18:49,000 --> 00:18:51,000
Que llega a esta estructura de aquí

327
00:18:51,000 --> 00:18:53,000
Y luego yo puedo acceder a esta

328
00:18:53,000 --> 00:18:56,000
Con 0, 1, 2, 3, 4

329
00:18:56,000 --> 00:18:59,000
Si por ejemplo accedo a la 1

330
00:18:59,000 --> 00:19:02,000
Dentro no me encuentro ya un valor

331
00:19:02,000 --> 00:19:04,000
Si no me encuentro este array de aquí

332
00:19:04,000 --> 00:19:06,000
Que también serán

333
00:19:06,000 --> 00:19:09,000
0, 1, 2, 3, 4

334
00:19:12,000 --> 00:19:14,000
Y esto se puede hacer

335
00:19:14,000 --> 00:19:16,000
¿Cómo se declara una cosa de ese estilo?

336
00:19:16,000 --> 00:19:18,000
En vez de

337
00:19:18,000 --> 00:19:20,000
En vez de int

338
00:19:20,000 --> 00:19:22,000
Array

339
00:19:25,000 --> 00:19:27,000
Esto sería un array de int

340
00:19:27,000 --> 00:19:30,000
Pues hago un array de array

341
00:19:35,000 --> 00:19:37,000
Esta cosa aquí

342
00:19:37,000 --> 00:19:39,000
Me está diciendo que

343
00:19:39,000 --> 00:19:41,000
Como si fuera una cosa así

344
00:19:42,000 --> 00:19:44,000
Que yo tengo un array

345
00:19:44,000 --> 00:19:46,000
Que dentro no tiene int

346
00:19:46,000 --> 00:19:48,000
Dentro tiene int array

347
00:19:48,000 --> 00:19:50,000
Entonces tengo un array

348
00:19:50,000 --> 00:19:52,000
Que dentro tiene array de int

349
00:20:01,000 --> 00:20:03,000
Por ahora no lo hagamos

350
00:20:04,000 --> 00:20:06,000
Teniendo en cuenta que este de aquí

351
00:20:06,000 --> 00:20:08,000
No sé que son, son referencias

352
00:20:08,000 --> 00:20:10,000
Por lo tanto quien da el valor

353
00:20:10,000 --> 00:20:12,000
Es el valor final

354
00:20:12,000 --> 00:20:14,000
Yo puedo hacer un int array array

355
00:20:14,000 --> 00:20:16,000
Una cosa así

356
00:20:16,000 --> 00:20:18,000
Puedo hacer un string array array

357
00:20:18,000 --> 00:20:20,000
Entonces será un array de apuntadores

358
00:20:20,000 --> 00:20:22,000
Array de string

359
00:20:22,000 --> 00:20:24,000
Ahora hacer que esto sea un int

360
00:20:24,000 --> 00:20:26,000
Esto sea un string

361
00:20:26,000 --> 00:20:28,000
Esto sea una cosa

362
00:20:28,000 --> 00:20:30,000
Pues se puede hacer, sí

363
00:20:30,000 --> 00:20:32,000
Pero por ahora dejámoslo en otro lado

364
00:20:32,000 --> 00:20:34,000
Mejor que no

365
00:20:34,000 --> 00:20:36,000
Es más complejo que eso

366
00:20:36,000 --> 00:20:38,000
Con lo que sabemos hacer nosotros

367
00:20:38,000 --> 00:20:40,000
Con esta cosa aquí

368
00:20:40,000 --> 00:20:42,000
Esto decide los valores finales

369
00:20:42,000 --> 00:20:44,000
Yo estaré trabajando con enteros

370
00:20:44,000 --> 00:20:46,000
Pero no directamente en un array

371
00:20:46,000 --> 00:20:48,000
Sino que tengo antes un array

372
00:20:48,000 --> 00:20:50,000
De este array elijo una posición

373
00:20:50,000 --> 00:20:52,000
Y voy allí

374
00:20:52,000 --> 00:20:54,000
¿Para qué me sirven estas cosas, por ejemplo?

375
00:20:54,000 --> 00:20:56,000
Para hacer matrices

376
00:20:56,000 --> 00:20:58,000
¿Os acordáis de matrices?

377
00:20:58,000 --> 00:21:00,000
Para hacer tablas

378
00:21:00,000 --> 00:21:02,000
Para hacer, no lo sé

379
00:21:02,000 --> 00:21:04,000
Aquí esto represente un alumno

380
00:21:04,000 --> 00:21:06,000
Y en cada alumno tenga

381
00:21:06,000 --> 00:21:08,000
Una serie de notas

382
00:21:12,000 --> 00:21:14,000
No

383
00:21:14,000 --> 00:21:16,000
Sí

384
00:21:16,000 --> 00:21:18,000
No

385
00:21:18,000 --> 00:21:20,000
Sí, no

386
00:21:20,000 --> 00:21:22,000
Tiene un qué de parecido

387
00:21:22,000 --> 00:21:24,000
Pero la clave primaria

388
00:21:24,000 --> 00:21:26,000
Puede ser algo más complejo

389
00:21:26,000 --> 00:21:28,000
Mientras aquí es el numerito

390
00:21:28,000 --> 00:21:30,000
Es única, por lo tanto sí

391
00:21:30,000 --> 00:21:32,000
Es un identificador

392
00:21:32,000 --> 00:21:34,000
Es como si tú como clave primaria

393
00:21:34,000 --> 00:21:36,000
De una base de datos

394
00:21:36,000 --> 00:21:38,000
Utilizas una columna

395
00:21:38,000 --> 00:21:40,000
Que es identificador

396
00:21:40,000 --> 00:21:42,000
¿Cuánto tiene que ser?

397
00:21:42,000 --> 00:21:44,000
Pues sí, pero tiene sus diferencias

398
00:21:44,000 --> 00:21:46,000
Esta no es una base de datos

399
00:21:46,000 --> 00:21:48,000
No tiene un gestor sistema de bases de datos

400
00:21:48,000 --> 00:21:50,000
No tiene record infinitos

401
00:21:50,000 --> 00:21:52,000
Tiene los record que has puesto tú

402
00:21:54,000 --> 00:21:56,000
Ahora, esta cosa

403
00:21:56,000 --> 00:21:58,000
¿Quién me prohíbe de aquí dentro

404
00:21:58,000 --> 00:22:00,000
Poner un array?

405
00:22:02,000 --> 00:22:04,000
Nadie

406
00:22:04,000 --> 00:22:06,000
Entonces sería

407
00:22:06,000 --> 00:22:08,000
Array de Array de Array

408
00:22:08,000 --> 00:22:10,000
He hecho

409
00:22:10,000 --> 00:22:12,000
Una matriz tridimensional

410
00:22:12,000 --> 00:22:14,000
Pensando a un cubo

411
00:22:14,000 --> 00:22:16,000
Y yo me voy colocando

412
00:22:16,000 --> 00:22:18,000
En esta línea, esta columna

413
00:22:18,000 --> 00:22:20,000
Esta profundidad

414
00:22:22,000 --> 00:22:24,000
¿Quién me prohíbe de poner

415
00:22:24,000 --> 00:22:26,000
Dentro de este punto

416
00:22:26,000 --> 00:22:28,000
Otro array?

417
00:22:30,000 --> 00:22:32,000
Mientras tenga RAM

418
00:22:32,000 --> 00:22:34,000
No

419
00:22:34,000 --> 00:22:36,000
Pero para explotarlo con RAM

420
00:22:36,000 --> 00:22:38,000
Lo que pasa es que

421
00:22:38,000 --> 00:22:40,000
Llega un momento en que empieza a hablar

422
00:22:40,000 --> 00:22:42,000
De arrays

423
00:22:42,000 --> 00:22:44,000
N-dimensionales

424
00:22:44,000 --> 00:22:46,000
Multidimensionales

425
00:22:46,000 --> 00:22:48,000
Y empieza a ser un poco complejo de entender

426
00:22:48,000 --> 00:22:50,000
Hasta 3 dimensiones

427
00:22:50,000 --> 00:22:52,000
Nosotros nos lo figuramos como estoy moviéndome en un cubo

428
00:22:52,000 --> 00:22:54,000
Y tengo la X, la Y

429
00:22:54,000 --> 00:22:56,000
Y la Z

430
00:22:56,000 --> 00:22:58,000
Y más o menos

431
00:22:58,000 --> 00:23:00,000
Cuando ya empezamos con 4 dimensiones, 5 dimensiones, 6 dimensiones

432
00:23:00,000 --> 00:23:02,000
Nuestra mente ya empieza a decir

433
00:23:02,000 --> 00:23:04,000
A lo mejor soy un matemático

434
00:23:04,000 --> 00:23:06,000
Que está trabajando con vectores n-dimensionales

435
00:23:06,000 --> 00:23:08,000
Y entonces esto me viene fenomenal

436
00:23:08,000 --> 00:23:10,000
¿Vale?

437
00:23:10,000 --> 00:23:12,000
Pero nosotros

438
00:23:12,000 --> 00:23:14,000
Sufrimos mucho

439
00:23:14,000 --> 00:23:16,000
Es esto

440
00:23:20,000 --> 00:23:22,000
Declaración

441
00:23:22,000 --> 00:23:24,000
Esto es un array bidimensional

442
00:23:24,000 --> 00:23:26,000
Es decir que dentro de una posición

443
00:23:26,000 --> 00:23:28,000
Me encontraré

444
00:23:28,000 --> 00:23:30,000
Otro array

445
00:23:30,000 --> 00:23:32,000
Esto es tridimensional

446
00:23:32,000 --> 00:23:34,000
Esto es

447
00:23:34,000 --> 00:23:36,000
Cuanto quieras dimensional

448
00:23:36,000 --> 00:23:38,000
Puedo hacer lo que me da la gana

449
00:23:38,000 --> 00:23:40,000
¿Cómo inicializo una cosa de ese estilo?

450
00:23:40,000 --> 00:23:42,000
¿Qué hará esta

451
00:23:42,000 --> 00:23:44,000
Inicialización de aquí?

452
00:23:54,000 --> 00:23:56,000
Tendré un array con 4 posiciones

453
00:23:56,000 --> 00:23:58,000
Y en cada una de estas

454
00:23:58,000 --> 00:24:00,000
Posiciones dentro estará un array

455
00:24:00,000 --> 00:24:02,000
Con 2 posiciones

456
00:24:06,000 --> 00:24:08,000
Se puede, pero lo tienes que hacer

457
00:24:08,000 --> 00:24:10,000
Explícitamente

458
00:24:10,000 --> 00:24:12,000
Tú accederás a la posición 2

459
00:24:12,000 --> 00:24:14,000
De este array y decirle

460
00:24:14,000 --> 00:24:16,000
Este es este array de aquí

461
00:24:20,000 --> 00:24:22,000
Asignación

462
00:24:22,000 --> 00:24:24,000
Para acceder y poner un

463
00:24:24,000 --> 00:24:26,000
Número o un string

464
00:24:26,000 --> 00:24:28,000
Ahora tengo dos coordinadas

465
00:24:28,000 --> 00:24:30,000
Tengo que acceder a M1 de 0

466
00:24:30,000 --> 00:24:32,000
Es igual a 3

467
00:24:32,000 --> 00:24:34,000
Porque en M1 de 0 no va 3, va un array

468
00:24:36,000 --> 00:24:38,000
Para poder acceder a un valor concreto

469
00:24:38,000 --> 00:24:40,000
Tengo que acceder a M1

470
00:24:40,000 --> 00:24:42,000
De 0 y estaré

471
00:24:42,000 --> 00:24:44,000
Elegiendo en el primer array

472
00:24:44,000 --> 00:24:46,000
En este array que he pillado

473
00:24:46,000 --> 00:24:48,000
Que es el que está en posición 0

474
00:24:48,000 --> 00:24:50,000
Encontraré otro array

475
00:24:50,000 --> 00:24:52,000
Me voy a la posición 1

476
00:24:52,000 --> 00:24:54,000
Y allí pongo el 100

477
00:24:54,000 --> 00:24:56,000
Cuando hago

478
00:24:56,000 --> 00:24:58,000
A

479
00:24:58,000 --> 00:25:00,000
De

480
00:25:00,000 --> 00:25:02,000
Que se yo

481
00:25:02,000 --> 00:25:04,000
1

482
00:25:04,000 --> 00:25:06,000
3

483
00:25:06,000 --> 00:25:08,000
Lo que estoy haciendo es

484
00:25:08,000 --> 00:25:10,000
Vete a esta array

485
00:25:10,000 --> 00:25:12,000
Vete a la posición 1

486
00:25:12,000 --> 00:25:14,000
Y aquí estoy encontrando

487
00:25:14,000 --> 00:25:16,000
Este array

488
00:25:16,000 --> 00:25:18,000
Y de este array te vas a la posición 3

489
00:25:18,000 --> 00:25:20,000
0, 1, 2 y 3

490
00:25:20,000 --> 00:25:22,000
Y aquí le pones

491
00:25:22,000 --> 00:25:24,000
7

492
00:25:24,000 --> 00:25:26,000
7 tendrá aquí

493
00:25:38,000 --> 00:25:40,000
Se puede hacer

494
00:25:40,000 --> 00:25:42,000
Array de array

495
00:25:42,000 --> 00:25:44,000
De esta forma

496
00:25:44,000 --> 00:25:46,000
Esto contesta también a tu pregunta

497
00:25:46,000 --> 00:25:48,000
En la posición 0 de este

498
00:25:48,000 --> 00:25:50,000
De este array externo

499
00:25:50,000 --> 00:25:52,000
Tengo un array de 2 posiciones

500
00:25:52,000 --> 00:25:54,000
Solas

501
00:25:54,000 --> 00:25:56,000
En la segunda posición, en la posición 1

502
00:25:56,000 --> 00:25:58,000
Tengo un array de 3 posiciones

503
00:25:58,000 --> 00:26:00,000
Y en la tercera una posición sola

504
00:26:00,000 --> 00:26:02,000
Entonces estoy haciendo una situación

505
00:26:02,000 --> 00:26:04,000
Donde no todos los

506
00:26:04,000 --> 00:26:06,000
Arrays internos aquí tienen

507
00:26:06,000 --> 00:26:08,000
El mismo tamaño, sino que este aquí

508
00:26:08,000 --> 00:26:10,000
Por ejemplo tiene solo 2 posiciones

509
00:26:10,000 --> 00:26:12,000
Y este tiene 5

510
00:26:16,000 --> 00:26:18,000
Por eso es muy importante luego utilizar

511
00:26:18,000 --> 00:26:20,000
Length

512
00:26:20,000 --> 00:26:22,000
Si yo tengo situación como esta y no se cual es el tamaño de esto

513
00:26:22,000 --> 00:26:24,000
Pues cada vez que entro en una de estas posiciones

514
00:26:24,000 --> 00:26:26,000
Tendré que preguntar

515
00:26:26,000 --> 00:26:28,000
Cuanta es grande el array con el que voy a preguntar

516
00:26:28,000 --> 00:26:30,000
Como se por ejemplo

517
00:26:30,000 --> 00:26:32,000
El tamaño de este array de aquí

518
00:26:42,000 --> 00:26:44,000
A

519
00:26:44,000 --> 00:26:46,000
De 1

520
00:26:46,000 --> 00:26:48,000
A de 0

521
00:26:48,000 --> 00:26:50,000
Punto length

522
00:26:56,000 --> 00:26:58,000
Porque A de 0

523
00:26:58,000 --> 00:27:00,000
Siendo un array de array es un array

524
00:27:00,000 --> 00:27:02,000
Esta cosa de aquí es un array

525
00:27:02,000 --> 00:27:04,000
Un array entero

526
00:27:04,000 --> 00:27:06,000
Es este array entero

527
00:27:06,000 --> 00:27:08,000
Y si aquí le pregunto

528
00:27:08,000 --> 00:27:10,000
La longitud me dará

529
00:27:10,000 --> 00:27:12,000
1, 2, 3, 4, 5

530
00:27:12,000 --> 00:27:14,000
Si hago

531
00:27:14,000 --> 00:27:16,000
A de 3

532
00:27:18,000 --> 00:27:20,000
Punto length

533
00:27:22,000 --> 00:27:24,000
Me dará 2

534
00:27:26,000 --> 00:27:28,000
Si

535
00:27:28,000 --> 00:27:30,000
Si hago

536
00:27:30,000 --> 00:27:32,000
A de 1, 3 punto length

537
00:27:36,000 --> 00:27:38,000
Que me da

538
00:27:42,000 --> 00:27:44,000
Hola

539
00:27:54,000 --> 00:27:56,000
Explota

540
00:27:56,000 --> 00:27:58,000
Porque este señor no es un array

541
00:27:58,000 --> 00:28:00,000
Y sobre los arrays no se puede llamar length

542
00:28:00,000 --> 00:28:02,000
Sobre lo que no son arrays

543
00:28:02,000 --> 00:28:04,000
Sobre una variable int

544
00:28:04,000 --> 00:28:06,000
No puedo llamar length

545
00:28:06,000 --> 00:28:08,000
No

546
00:28:08,000 --> 00:28:10,000
Porque no he puesto la paréntesis

547
00:28:10,000 --> 00:28:12,000
Si fuera un string

548
00:28:12,000 --> 00:28:14,000
Y le pusiera length entre paréntesis

549
00:28:14,000 --> 00:28:16,000
Me diría el tamaño de esta string

550
00:28:16,000 --> 00:28:18,000
Pero cuando yo ya he entrado aquí

551
00:28:18,000 --> 00:28:20,000
En este array que es bidimensional

552
00:28:20,000 --> 00:28:22,000
Cuando ya he entrado aquí dentro

553
00:28:22,000 --> 00:28:24,000
No tengo un array

554
00:28:24,000 --> 00:28:26,000
Tengo un valor

555
00:28:26,000 --> 00:28:28,000
Que será int, que será string, que será boolean

556
00:28:28,000 --> 00:28:30,000
Que será lo que yo haya creado

557
00:28:30,000 --> 00:28:32,000
Y con este valor puede hacer lo que se hace sobre ese valor

558
00:28:32,000 --> 00:28:34,000
Si fuera un objeto

559
00:28:34,000 --> 00:28:36,000
Puede hacer todo lo que se puede hacer en un objeto

560
00:28:36,000 --> 00:28:38,000
Si es string que es un objeto

561
00:28:38,000 --> 00:28:40,000
Puedo llamar su método length

562
00:28:40,000 --> 00:28:42,000
Puedo llamar su método substring

563
00:28:42,000 --> 00:28:44,000
Puedo llamar todos los métodos que se pueden llamar substring

564
00:28:44,000 --> 00:28:46,000
Que no conocemos todavía

565
00:28:46,000 --> 00:28:48,000
Porque no hemos visto los objetos

566
00:28:50,000 --> 00:28:52,000
¿Se entiende?

567
00:28:54,000 --> 00:28:56,000
Esto es, lo estoy diciendo ahora

568
00:28:56,000 --> 00:28:58,000
Es más avanzado

569
00:28:58,000 --> 00:29:00,000
Para que se quede grabado

570
00:29:00,000 --> 00:29:02,000
Para que luego en un futuro lo podáis volver a ver

571
00:29:02,000 --> 00:29:04,000
¿Vale?

572
00:29:04,000 --> 00:29:06,000
Pero técnicamente

573
00:29:06,000 --> 00:29:08,000
Esto es un uso más avanzado

574
00:29:08,000 --> 00:29:10,000
De los arrays

575
00:29:10,000 --> 00:29:12,000
Nosotros a lo mejor

576
00:29:12,000 --> 00:29:14,000
En algún momento veremos arrays bidimensionales

577
00:29:14,000 --> 00:29:16,000
Muy probablemente

578
00:29:16,000 --> 00:29:18,000
Improbablemente

579
00:29:18,000 --> 00:29:20,000
Arrays tridimensionales

580
00:29:20,000 --> 00:29:22,000
No mucho más

581
00:29:22,000 --> 00:29:24,000
Pero la idea no es tanto de utilizar

582
00:29:24,000 --> 00:29:26,000
Arrays, arrays bidimensionales y cosas por el estilo

583
00:29:26,000 --> 00:29:28,000
Cuanto entender que es un array

584
00:29:28,000 --> 00:29:30,000
Entender como se usa

585
00:29:30,000 --> 00:29:32,000
Entender que es una estructura de datos

586
00:29:32,000 --> 00:29:34,000
Que puede contenerse en otras celdas

587
00:29:34,000 --> 00:29:36,000
De otros arrays

588
00:29:36,000 --> 00:29:38,000
Y saber cuando una cosa es un array

589
00:29:38,000 --> 00:29:40,000
Y cuando no es un array

590
00:29:40,000 --> 00:29:42,000
Para que yo pueda utilizar sobre los arrays

591
00:29:42,000 --> 00:29:44,000
Lo que puedo usar sobre los arrays

592
00:29:44,000 --> 00:29:46,000
Y que no pueda usar lo que se puede usar sobre los arrays

593
00:29:46,000 --> 00:29:48,000
Si lo que estoy utilizando no es un array

594
00:29:48,000 --> 00:29:50,000
Eso tiene que estar más o menos claro

595
00:29:50,000 --> 00:29:52,000
Antes o después

596
00:29:52,000 --> 00:29:54,000
El discurso que hemos hecho ahora

597
00:29:54,000 --> 00:29:56,000
Si yo tengo A de cero

598
00:29:56,000 --> 00:29:58,000
Esto es un array y por lo tanto puede hacer

599
00:29:58,000 --> 00:30:00,000
Un array

600
00:30:00,000 --> 00:30:02,000
Si yo tengo una cosa así

601
00:30:02,000 --> 00:30:04,000
Esto no es un array y por lo tanto no le puedo llamar

602
00:30:04,000 --> 00:30:06,000
A encima

603
00:30:08,000 --> 00:30:10,000
Así como si fuera un array tridimensional

604
00:30:10,000 --> 00:30:12,000
Cuando yo hago A de cero

605
00:30:12,000 --> 00:30:14,000
Lo que tengo dentro sería un array bidimensional

606
00:30:18,000 --> 00:30:20,000
Si yo tengo esto

607
00:30:20,000 --> 00:30:22,000
M2

608
00:30:22,000 --> 00:30:24,000
¿Vale?

609
00:30:24,000 --> 00:30:26,000
Que es un array tridimensional

610
00:30:26,000 --> 00:30:28,000
En cada una de estas celdas

611
00:30:28,000 --> 00:30:30,000
Hay cinco celdas

612
00:30:30,000 --> 00:30:32,000
Y en cada una de estas cinco celdas

613
00:30:32,000 --> 00:30:34,000
Hay tres celdas en profundidad

614
00:30:34,000 --> 00:30:36,000
Entonces si yo ahora busco

615
00:30:36,000 --> 00:30:38,000
M2 de cero

616
00:30:38,000 --> 00:30:40,000
Lo que obtengo es un array bidimensional

617
00:30:40,000 --> 00:30:42,000
He quitado

618
00:30:42,000 --> 00:30:44,000
La primera de las coordinadas

619
00:30:44,000 --> 00:30:46,000
Y ahora me quedan dos coordinadas

620
00:30:46,000 --> 00:30:48,000
Más para dar

621
00:30:48,000 --> 00:30:50,000
Pero bueno

622
00:30:50,000 --> 00:30:52,000
Por ahora

623
00:30:52,000 --> 00:30:54,000
Fijaos que

624
00:30:54,000 --> 00:30:56,000
Aquí un poquito lo dice

625
00:30:56,000 --> 00:30:58,000
Si yo hago M1 punto length

626
00:30:58,000 --> 00:31:00,000
Pues me está dando el tamaño

627
00:31:00,000 --> 00:31:02,000
De la primera coordinada

628
00:31:02,000 --> 00:31:04,000
Si yo hago M2

629
00:31:04,000 --> 00:31:06,000
De cero punto length

630
00:31:06,000 --> 00:31:08,000
Estaría en M2

631
00:31:08,000 --> 00:31:10,000
He entrado ya aquí y por lo tanto me da esta

632
00:31:10,000 --> 00:31:12,000
longitud de aquí

633
00:31:12,000 --> 00:31:14,000
Si yo hago M2 de cero cero punto length

634
00:31:14,000 --> 00:31:16,000
Habría entrado aquí

635
00:31:16,000 --> 00:31:18,000
Luego ha entrado aquí y me da esta

636
00:31:18,000 --> 00:31:20,000
longitud

637
00:31:20,000 --> 00:31:22,000
Pero bueno

638
00:31:24,000 --> 00:31:26,000
Porque M2 de cero

639
00:31:28,000 --> 00:31:30,000
Y la primera es esta

640
00:31:30,000 --> 00:31:32,000
Entonces si he entrado ya en uno de estos

641
00:31:32,000 --> 00:31:34,000
Entonces

642
00:31:34,000 --> 00:31:36,000
Allí dentro encuentro arrays bidimensionales

643
00:31:36,000 --> 00:31:38,000
De cinco

644
00:31:38,000 --> 00:31:40,000
Cinco por tres

645
00:31:40,000 --> 00:31:42,000
Este array

646
00:31:42,000 --> 00:31:44,000
Son seis

647
00:31:44,000 --> 00:31:46,000
Tablas cinco por tres

648
00:31:50,000 --> 00:31:52,000
Ok

649
00:31:52,000 --> 00:31:54,000
Matriz bidimensional

650
00:31:54,000 --> 00:31:56,000
Para tener varias filas

651
00:31:56,000 --> 00:31:58,000
Bla bla bla

652
00:31:58,000 --> 00:32:00,000
Estas cosas de aquí

653
00:32:00,000 --> 00:32:02,000
Os lo explico un poquito

654
00:32:02,000 --> 00:32:04,000
Ya lo hemos dicho antes

655
00:32:04,000 --> 00:32:06,000
Y aquí hay un pequeño ejemplo

656
00:32:06,000 --> 00:32:08,000
Del uso de dos

657
00:32:08,000 --> 00:32:10,000
Arrays multidimensionales

658
00:32:10,000 --> 00:32:12,000
Y cosas por el estilo

659
00:32:12,000 --> 00:32:14,000
Que podéis mirar con calma

660
00:32:14,000 --> 00:32:16,000
Para ver si entendéis algo de eso

661
00:32:16,000 --> 00:32:18,000
Teniendo en cuenta que

662
00:32:18,000 --> 00:32:20,000
Hasta esta transparencia