1
00:00:00,000 --> 00:00:06,000
Vale, pues vamos a entender un poquito por dentro esto de los Arrays, ¿vale?

2
00:00:06,000 --> 00:00:10,000
Entonces, venced la pérdida mental, porfa, e intentad escuchar.

3
00:00:10,000 --> 00:00:16,000
Porque uno podría hacer ejercicios de Arrays, por lo que hemos visto hasta ahora,

4
00:00:16,000 --> 00:00:21,000
y podría llegar hasta aprobar algún examen, pero vamos, duraría dos, tres diarios.

5
00:00:21,000 --> 00:00:26,000
Las cosas hay que entenderlas, hay que entenderlas para no caerse

6
00:00:26,000 --> 00:00:31,000
en cuanto uno da un paso fuera de lo básico.

7
00:00:31,000 --> 00:00:36,000
Bueno, pues entonces, ¿qué estamos haciendo en realidad cuando declaramos,

8
00:00:36,000 --> 00:00:38,000
qué es lo que está pasando, quiero decir,

9
00:00:38,000 --> 00:00:41,000
qué es lo que está pasando en realidad cuando declaramos un Array?

10
00:00:41,000 --> 00:00:44,000
Pongo siempre el ejemplo de enteros porque es el más sencillo,

11
00:00:44,000 --> 00:00:46,000
el que estamos más acostumbrados a los números,

12
00:00:46,000 --> 00:00:50,000
pero me da igual que el Array sea de enteros que de números decimales, me da lo mismo.

13
00:00:50,000 --> 00:00:55,000
Bueno, vamos a suponer que hemos declarado aquí un Array de números,

14
00:00:55,000 --> 00:01:02,000
y además hemos dicho que para usarlo tenemos que definir un tamaño en memoria,

15
00:01:02,000 --> 00:01:05,000
que eso no hay otra, antes de yo poder usarlo.

16
00:01:05,000 --> 00:01:11,000
Y eso lo hacemos de esta manera, new, espacio, el tipo de dato, y ahora aquí el tamaño.

17
00:01:13,000 --> 00:01:16,000
Vamos a suponer que es 20, bueno, pues 20.

18
00:01:16,000 --> 00:01:19,000
Vale, ¿qué está pasando físicamente en memoria principal?

19
00:01:19,000 --> 00:01:25,000
Pues en la memoria RAM, automáticamente la máquina virtual reserva un espacio,

20
00:01:28,000 --> 00:01:36,000
reserva un espacio para tantas posiciones, tantas como hayamos dicho aquí.

21
00:01:37,000 --> 00:01:38,000
¿Vale?

22
00:01:39,000 --> 00:01:45,000
Sí, Daniel, para tantas como hayamos dicho aquí, si hemos dicho 20, para 20.

23
00:01:50,000 --> 00:01:58,000
Y además sabemos que esta puedo acceder a ella mediante el nombre número 0,

24
00:01:58,000 --> 00:02:05,000
a esta podré acceder mediante el nombre número 1, y así a todas,

25
00:02:05,000 --> 00:02:12,000
hasta esta final, a la que podré acceder con el nombre números, ¿qué?

26
00:02:14,000 --> 00:02:15,000
19.

27
00:02:17,000 --> 00:02:18,000
¿Vale?

28
00:02:19,000 --> 00:02:23,000
Vale, entonces números 0, números 1, números 2, ya sabemos lo que es,

29
00:02:23,000 --> 00:02:24,000
pero ¿y números?

30
00:02:24,000 --> 00:02:25,000
¿Números qué es?

31
00:02:25,000 --> 00:02:29,000
Números es algo, para la máquina virtual es algo, porque de hecho aquí

32
00:02:29,000 --> 00:02:33,000
lo hemos usado para hacer esta asignación, lo hemos usado.

33
00:02:34,000 --> 00:02:39,000
Es decir, no nos estamos limitando a usar, ah bueno, que no estáis viendo ahí nada.

34
00:02:40,000 --> 00:02:41,000
Vale.

35
00:02:41,000 --> 00:02:44,000
Es decir, la variable número suelta ya es algo.

36
00:02:44,000 --> 00:02:46,000
Números 0 tenemos claro lo que es.

37
00:02:46,000 --> 00:02:53,000
Cuando yo escribo números 0, tenemos claro lo que es, es este espacio, este espacio.

38
00:02:54,000 --> 00:02:57,000
Y si yo le asigno 7, ya sabemos que asignamos 7 a este espacio.

39
00:02:58,000 --> 00:03:04,000
Si yo escribo números 3, también tengo claro lo que es.

40
00:03:04,000 --> 00:03:09,000
Números 3 es este espacio, 0, 1, 2, 3, este, este es números 3.

41
00:03:10,000 --> 00:03:17,000
Y si yo le asigno aquí cualquier cosa, pues por ejemplo, números 0 por 3,

42
00:03:17,000 --> 00:03:22,000
por ejemplo, pues sé que a números 3, que es este, le estoy asignando lo que tenga este,

43
00:03:22,000 --> 00:03:24,000
que es números 0 multiplicado por 3.

44
00:03:24,000 --> 00:03:26,000
Vale, hasta ahí es lo que hemos estado usando.

45
00:03:27,000 --> 00:03:32,000
Una vez declarado un array y reservado su espacio, hemos usado sus posiciones individuales.

46
00:03:33,000 --> 00:03:37,000
¿Vale? Eso es lo que nosotros ya, hasta ahora, hemos estado usando

47
00:03:37,000 --> 00:03:42,000
y se supone que tenemos ya entendido y clarísimo cómo funciona.

48
00:03:42,000 --> 00:03:44,000
Vale, pero siguiente salto.

49
00:03:45,000 --> 00:03:48,000
¿Y la variable números ella sola quién es?

50
00:03:50,000 --> 00:03:52,000
¿Esta variable números quién es?

51
00:03:52,000 --> 00:03:56,000
Porque ya la hemos usado en el ejemplo que hemos puesto antes, porque yo tenía dos arrays

52
00:03:56,000 --> 00:03:59,000
y a números 1 le he asignado números 2.

53
00:04:01,000 --> 00:04:03,000
Esto lo he hecho.

54
00:04:03,000 --> 00:04:05,000
Y el compilador lo ha parecido muy bien.

55
00:04:05,000 --> 00:04:07,000
Ha dado un error, pero habrá que ver porque lo ha dado,

56
00:04:07,000 --> 00:04:10,000
pero números 1 es una variable igual.

57
00:04:11,000 --> 00:04:13,000
En este caso, números.

58
00:04:13,000 --> 00:04:15,000
Entonces, la pregunta que nos hacemos es

59
00:04:17,000 --> 00:04:23,000
¿y este término, números solo, sin el 0, sin el 1, sin el 2, a qué se refiere?

60
00:04:23,000 --> 00:04:27,000
Porque con el 0, con el 1, con el 2, ya sabemos a qué se refiere a estas posiciones,

61
00:04:27,000 --> 00:04:29,000
a estas posiciones, ya lo sabemos.

62
00:04:29,000 --> 00:04:33,000
Pero números ella solita, ¿números a qué se refieren?

63
00:04:34,000 --> 00:04:39,000
Pues números ella sola, sin índice, sin índice, números, es también una variable,

64
00:04:39,000 --> 00:04:43,000
un espacio en memoria, también lo es, también lo es, es un espacio en memoria.

65
00:04:44,000 --> 00:04:46,000
¿Y este espacio en memoria qué tiene?

66
00:04:47,000 --> 00:04:51,000
Pues tiene una dirección de memoria, tiene una dirección,

67
00:04:52,000 --> 00:04:57,000
y la dirección que tiene es la dirección donde está colocado el array.

68
00:04:58,000 --> 00:05:02,000
Luego, en realidad, lo que físicamente está apareciendo en la memoria RAM

69
00:05:02,000 --> 00:05:04,000
cuando hacemos esto es

70
00:05:06,000 --> 00:05:08,000
un espacio para guardar una dirección de memoria.

71
00:05:09,000 --> 00:05:13,000
Este espacio se llama números, este espacio se llama números.

72
00:05:14,000 --> 00:05:16,000
Y luego está apareciendo, después de hacer esto,

73
00:05:17,000 --> 00:05:20,000
está apareciendo un espacio con 20 posiciones, las que sean,

74
00:05:20,000 --> 00:05:24,000
y la dirección de memoria, la dirección donde está este espacio,

75
00:05:25,000 --> 00:05:27,000
colgando a partir de él, está contenida aquí.

76
00:05:28,000 --> 00:05:30,000
Esto es lo que físicamente ha aparecido.

77
00:05:31,000 --> 00:05:33,000
Lo que pasa es que a nosotros lo que nos interesa son estas posiciones

78
00:05:33,000 --> 00:05:35,000
que es donde están nuestros datos.

79
00:05:35,000 --> 00:05:37,000
Es esto lo que nos interesa.

80
00:05:37,000 --> 00:05:39,000
Por eso nosotros usamos números 0, números 1, números 2,

81
00:05:39,000 --> 00:05:41,000
porque nos interesan estas posiciones.

82
00:05:41,000 --> 00:05:42,000
¿Vale?

83
00:05:42,000 --> 00:05:44,000
Esta variable números por sí misma,

84
00:05:44,000 --> 00:05:47,000
ella, lo que tiene es la dirección de memoria,

85
00:05:47,000 --> 00:05:49,000
entonces esa variable en sí, esta dirección me da igual.

86
00:05:49,000 --> 00:05:51,000
Esta dirección me da igual.

87
00:05:51,000 --> 00:05:53,000
Lo que pasa es que la máquina virtual

88
00:05:53,000 --> 00:05:55,000
necesita que esto esté montado así.

89
00:05:56,000 --> 00:05:59,000
Porque cuando yo le digo a la máquina virtual, le digo

90
00:06:02,000 --> 00:06:04,000
números 0 igual a 1,

91
00:06:04,000 --> 00:06:06,000
cuando yo le digo esto,

92
00:06:06,000 --> 00:06:08,000
ella físicamente lo que hace es

93
00:06:09,000 --> 00:06:11,000
coge números,

94
00:06:11,000 --> 00:06:13,000
coge números,

95
00:06:13,000 --> 00:06:15,000
coge números,

96
00:06:15,000 --> 00:06:17,000
coge números,

97
00:06:17,000 --> 00:06:19,000
se va a esta dirección de memoria,

98
00:06:19,000 --> 00:06:21,000
a través de esta dirección de memoria,

99
00:06:21,000 --> 00:06:23,000
viaja hasta aquí.

100
00:06:23,000 --> 00:06:25,000
Ahora suma tanto como el índice,

101
00:06:25,000 --> 00:06:27,000
que es 0, se queda aquí,

102
00:06:27,000 --> 00:06:29,000
que es 3, baja hasta 3.

103
00:06:29,000 --> 00:06:31,000
O sea, cuando yo digo esto,

104
00:06:31,000 --> 00:06:33,000
en realidad se desencadena toda esa acción.

105
00:06:33,000 --> 00:06:35,000
La máquina virtual viaja a esta dirección

106
00:06:35,000 --> 00:06:37,000
que está recogida aquí,

107
00:06:37,000 --> 00:06:39,000
viaja a esta dirección,

108
00:06:39,000 --> 00:06:41,000
a través de esta dirección viaja hasta aquí,

109
00:06:41,000 --> 00:06:43,000
y a través del índice ya viaja hasta donde toca.

110
00:06:43,000 --> 00:06:45,000
Todo eso es lo que hace.

111
00:06:45,000 --> 00:06:47,000
Para nosotros es muy sencillo,

112
00:06:47,000 --> 00:06:49,000
para nosotros es números 3 igual a 1,

113
00:06:49,000 --> 00:06:51,000
ya sabemos que el efecto final es este.

114
00:06:51,000 --> 00:06:53,000
Pero lo que está ocurriendo físicamente es esto que digo,

115
00:06:53,000 --> 00:06:55,000
y la estructura que hay en memoria montada

116
00:06:55,000 --> 00:06:57,000
es esta,

117
00:06:57,000 --> 00:06:59,000
es esta,

118
00:06:59,000 --> 00:07:01,000
es esta, ¿vale?

119
00:07:03,000 --> 00:07:05,000
Bueno, pues entonces,

120
00:07:05,000 --> 00:07:07,000
el saber que esto es así,

121
00:07:07,000 --> 00:07:09,000
que esto está así montado,

122
00:07:09,000 --> 00:07:11,000
nos permite ya entender muchas cosas

123
00:07:11,000 --> 00:07:13,000
que pasan con array y trabajar con cosas.

124
00:07:13,000 --> 00:07:15,000
Por ejemplo,

125
00:07:15,000 --> 00:07:17,000
vamos a ver el caso de antes.

126
00:07:17,000 --> 00:07:19,000
Yo tenía números 1

127
00:07:19,000 --> 00:07:21,000
que era un array

128
00:07:21,000 --> 00:07:23,000
de 10 posiciones.

129
00:07:23,000 --> 00:07:25,000
Vale, pues ya está,

130
00:07:25,000 --> 00:07:27,000
el ejercicio que hemos hecho antes.

131
00:07:31,000 --> 00:07:33,000
Pues en el ejercicio que hemos hecho antes,

132
00:07:33,000 --> 00:07:35,000
esta sería la estructura que se queda montada.

133
00:07:35,000 --> 00:07:37,000
Aparece una variable en memoria,

134
00:07:37,000 --> 00:07:39,000
números 1,

135
00:07:39,000 --> 00:07:41,000
que tiene una dirección de memoria.

136
00:07:41,000 --> 00:07:43,000
La dirección que se va a suponer,

137
00:07:43,000 --> 00:07:45,000
donde está todo esto es la dirección de memoria,

138
00:07:45,000 --> 00:07:47,000
pues yo qué sé,

139
00:07:47,000 --> 00:07:49,000
dirección de memoria 37,

140
00:07:49,000 --> 00:07:51,000
por poner cualquier chorrado.

141
00:07:51,000 --> 00:07:53,000
Pues entonces, esta variable

142
00:07:53,000 --> 00:07:55,000
tendrá la dirección de memoria

143
00:07:55,000 --> 00:07:57,000
y guardadita, una dirección de memoria,

144
00:07:57,000 --> 00:07:59,000
ahí guardada la tiene.

145
00:07:59,000 --> 00:08:01,000
Entonces la dirección de memoria,

146
00:08:01,000 --> 00:08:03,000
la máquina virtual,

147
00:08:03,000 --> 00:08:05,000
la selecciona automáticamente la que le da la gana

148
00:08:05,000 --> 00:08:07,000
en función de donde vea

149
00:08:07,000 --> 00:08:09,000
a ella que hay espacio.

150
00:08:09,000 --> 00:08:11,000
No le decimos nosotros donde tiene que colocar

151
00:08:11,000 --> 00:08:13,000
este array, a partir de qué dirección,

152
00:08:13,000 --> 00:08:15,000
lo selecciona ella automáticamente.

153
00:08:15,000 --> 00:08:17,000
Aquí tengo espacio, lo coloco aquí el array

154
00:08:17,000 --> 00:08:19,000
y ahora la dirección a partir

155
00:08:19,000 --> 00:08:21,000
de la cual lo he colocado la pongo aquí,

156
00:08:21,000 --> 00:08:23,000
en ese espacio.

157
00:08:23,000 --> 00:08:25,000
Bueno, pues con esta declaración

158
00:08:25,000 --> 00:08:27,000
hemos montado esta estructura.

159
00:08:27,000 --> 00:08:29,000
Vamos a hacer ahora la otra

160
00:08:29,000 --> 00:08:31,000
que teníamos.

161
00:08:31,000 --> 00:08:33,000
La otra que teníamos

162
00:08:33,000 --> 00:08:35,000
era esta.

163
00:08:37,000 --> 00:08:39,000
Números2

164
00:08:39,000 --> 00:08:41,000
igual a

165
00:08:41,000 --> 00:08:43,000
newIn de 5.

166
00:08:43,000 --> 00:08:45,000
Este segundo array tenía sólo

167
00:08:45,000 --> 00:08:47,000
5 posiciones, 5.

168
00:08:47,000 --> 00:08:49,000
Entonces al tener sólo 5

169
00:08:49,000 --> 00:08:51,000
la estructura que se queda en memoria

170
00:08:51,000 --> 00:08:53,000
es esta.

171
00:08:53,000 --> 00:08:55,000
Números

172
00:08:55,000 --> 00:08:57,000
2

173
00:08:57,000 --> 00:08:59,000
Se le asigna

174
00:08:59,000 --> 00:09:01,000
la dirección de memoria, la dirección que sea,

175
00:09:01,000 --> 00:09:03,000
la que la máquina virtual encuentre que le interesa.

176
00:09:03,000 --> 00:09:05,000
Yo qué sé, imaginaos que es esta.

177
00:09:05,000 --> 00:09:07,000
Y esta dirección de memoria

178
00:09:07,000 --> 00:09:09,000
le lleva a un espacio

179
00:09:09,000 --> 00:09:11,000
en memoria RAM, en este caso

180
00:09:11,000 --> 00:09:13,000
con 5 posiciones sólo.

181
00:09:15,000 --> 00:09:17,000
¿Vale? Y este espacio

182
00:09:17,000 --> 00:09:19,000
estará a partir de la dirección 72.

183
00:09:19,000 --> 00:09:21,000
Bueno, pues esta es la estructura

184
00:09:21,000 --> 00:09:23,000
que se ha montado como

185
00:09:23,000 --> 00:09:25,000
consecuencia de hacer esta sentencia de aquí.

186
00:09:25,000 --> 00:09:27,000
¿Vale? Está la variable

187
00:09:27,000 --> 00:09:29,000
números2 con una dirección

188
00:09:29,000 --> 00:09:31,000
y esta dirección lleva a donde están

189
00:09:31,000 --> 00:09:33,000
ya las posiciones. Entonces cuando hagamos

190
00:09:33,000 --> 00:09:35,000
números2 de 0

191
00:09:35,000 --> 00:09:37,000
sabemos que es esta, porque la máquina virtual

192
00:09:37,000 --> 00:09:39,000
cogerá números2, viajará hasta aquí

193
00:09:39,000 --> 00:09:41,000
y sería la 0. Cuando hagamos números2 de 1

194
00:09:41,000 --> 00:09:43,000
pues sabemos que es esta. ¿Vale?

195
00:09:43,000 --> 00:09:45,000
Pero lo que está en memoria es todo esto de aquí.

196
00:09:45,000 --> 00:09:47,000
Bueno, pues ahora vamos a

197
00:09:47,000 --> 00:09:49,000
hacer esa sentencia

198
00:09:49,000 --> 00:09:51,000
que hemos hecho ahí probando.

199
00:09:51,000 --> 00:09:53,000
La sentencia que hemos hecho

200
00:09:53,000 --> 00:09:55,000
era esta. Bueno, vamos a suponer que

201
00:09:55,000 --> 00:09:57,000
hemos rellenado los estos, los hemos rellenado

202
00:09:57,000 --> 00:09:59,000
este tiene 7, 3, 4

203
00:09:59,000 --> 00:10:01,000
menos 1, 2, 5

204
00:10:01,000 --> 00:10:03,000
yo que sé, cualquier cosa.

205
00:10:03,000 --> 00:10:05,000
Y este tiene 7, 3, 4

206
00:10:05,000 --> 00:10:07,000
menos 1, 5.

207
00:10:07,000 --> 00:10:09,000
Vale.

208
00:10:09,000 --> 00:10:11,000
Eh...

209
00:10:11,000 --> 00:10:13,000
Ahora vamos a hacer esa sentencia que hemos probado.

210
00:10:15,000 --> 00:10:17,000
A números2

211
00:10:17,000 --> 00:10:19,000
a números1

212
00:10:19,000 --> 00:10:21,000
creo que era

213
00:10:21,000 --> 00:10:23,000
sí, a números1

214
00:10:23,000 --> 00:10:25,000
asígnale

215
00:10:27,000 --> 00:10:29,000
números2

216
00:10:29,000 --> 00:10:31,000
¿Vale? Esta es la sentencia que hemos probado.

217
00:10:31,000 --> 00:10:33,000
¿Qué hemos dicho?

218
00:10:33,000 --> 00:10:35,000
La sentencia para el compilador maravillosa

219
00:10:35,000 --> 00:10:37,000
porque son dos variables del mismo

220
00:10:37,000 --> 00:10:39,000
tipo. Las dos son de tipo

221
00:10:39,000 --> 00:10:41,000
a raíz de enteros. Números1 es a raíz de

222
00:10:41,000 --> 00:10:43,000
enteros y números2 es a raíz de enteros.

223
00:10:43,000 --> 00:10:45,000
Luego el compilador asigna una variable a otra

224
00:10:45,000 --> 00:10:47,000
que son del mismo tipo, fenomenal.

225
00:10:47,000 --> 00:10:49,000
Vale, luego esa sentencia es estupenda. Y ahora la pregunta

226
00:10:49,000 --> 00:10:51,000
es, ¿pero qué está pasando físicamente

227
00:10:51,000 --> 00:10:53,000
cuando hacemos la sentencia?

228
00:10:53,000 --> 00:10:55,000
Bueno, ahora ya sabemos que

229
00:10:55,000 --> 00:10:57,000
números1 es una variable que tiene esta dirección de memoria

230
00:10:57,000 --> 00:10:59,000
y números2 es esta

231
00:10:59,000 --> 00:11:01,000
otra que tiene esta dirección de memoria.

232
00:11:01,000 --> 00:11:03,000
Entonces, si yo hago, oye,

233
00:11:03,000 --> 00:11:05,000
a números1 asígnale números2

234
00:11:05,000 --> 00:11:07,000
¿qué estoy haciendo? Pues

235
00:11:07,000 --> 00:11:09,000
a números1 le piso

236
00:11:09,000 --> 00:11:11,000
esta dirección que tenía, fuera, la basura

237
00:11:11,000 --> 00:11:13,000
y le asigno la que

238
00:11:13,000 --> 00:11:15,000
tiene números2, que

239
00:11:15,000 --> 00:11:17,000
es esta.

240
00:11:17,000 --> 00:11:19,000
Esto es lo que estoy haciendo si hago esto.

241
00:11:19,000 --> 00:11:21,000
¿Verdad? A esto

242
00:11:21,000 --> 00:11:23,000
le piso lo que

243
00:11:23,000 --> 00:11:25,000
tenía y le asigno esta.

244
00:11:25,000 --> 00:11:27,000
Con lo cual este enlace se rompió.

245
00:11:27,000 --> 00:11:29,000
Esto desapareció.

246
00:11:29,000 --> 00:11:31,000
Y automáticamente números1

247
00:11:31,000 --> 00:11:33,000
empieza a apuntar

248
00:11:33,000 --> 00:11:35,000
al mismo sitio

249
00:11:35,000 --> 00:11:37,000
que el otro.

250
00:11:37,000 --> 00:11:39,000
¿Vale? Esto es lo que estamos

251
00:11:39,000 --> 00:11:41,000
haciendo. No es que estemos copiando el

252
00:11:41,000 --> 00:11:43,000
contenido de este array en este array.

253
00:11:43,000 --> 00:11:45,000
No estamos haciendo eso

254
00:11:45,000 --> 00:11:47,000
cuando hacemos esta sentencia.

255
00:11:47,000 --> 00:11:49,000
Lo que hacemos es, oye, ojo,

256
00:11:49,000 --> 00:11:51,000
a la dirección de memoria que tenía

257
00:11:51,000 --> 00:11:53,000
números1, písala

258
00:11:53,000 --> 00:11:55,000
llevaba un array, llevaba un array

259
00:11:55,000 --> 00:11:57,000
pues písala y asígnala la dirección

260
00:11:57,000 --> 00:11:59,000
que tenía números2, que es esta.

261
00:11:59,000 --> 00:12:01,000
Entonces ahora las dos tienen la misma dirección, esta y esta

262
00:12:01,000 --> 00:12:03,000
las dos. Luego los dos arrays

263
00:12:03,000 --> 00:12:05,000
llevan al mismo sitio.

264
00:12:05,000 --> 00:12:07,000
Luego ahora son físicamente el mismo.

265
00:12:07,000 --> 00:12:09,000
Los he convertido en físicamente

266
00:12:09,000 --> 00:12:11,000
el mismo, que es este. ¿Y este

267
00:12:11,000 --> 00:12:13,000
qué le ha pasado?

268
00:12:13,000 --> 00:12:15,000
Se ha quedado sin nadie

269
00:12:15,000 --> 00:12:17,000
que le apunte. Ahí sigue.

270
00:12:17,000 --> 00:12:19,000
En memoria reservado.

271
00:12:19,000 --> 00:12:21,000
Pero no hay absolutamente ninguna

272
00:12:21,000 --> 00:12:23,000
variable que le apunte. Conclusión, este array

273
00:12:23,000 --> 00:12:25,000
es inaccesible.

274
00:12:25,000 --> 00:12:27,000
Nunca jamás, desde el programa, nunca

275
00:12:27,000 --> 00:12:29,000
jamás se va a poder acceder aquí.

276
00:12:29,000 --> 00:12:31,000
Se queda absolutamente inaccesible.

277
00:12:31,000 --> 00:12:33,000
Entonces,

278
00:12:33,000 --> 00:12:35,000
precisamente para que las cosas inaccesibles

279
00:12:35,000 --> 00:12:37,000
no estén ahí

280
00:12:37,000 --> 00:12:39,000
engrosando la memoria, ocupando memoria

281
00:12:39,000 --> 00:12:41,000
porque tiene una memoria ocupada, la máquina virtual

282
00:12:41,000 --> 00:12:43,000
no puede disponer de ella.

283
00:12:43,000 --> 00:12:45,000
Pues como se ha quedado inaccesible, esto ya es un agujero

284
00:12:45,000 --> 00:12:47,000
negro. Es imposible

285
00:12:47,000 --> 00:12:49,000
llegar aquí. No hay ninguna variable

286
00:12:49,000 --> 00:12:51,000
que tenga una dirección de memoria que lleve aquí.

287
00:12:51,000 --> 00:12:53,000
Pues como esto se ha quedado en agujero negro,

288
00:12:55,000 --> 00:12:57,000
existe en Java,

289
00:12:57,000 --> 00:12:59,000
la máquina virtual de Java tiene un pequeño proceso

290
00:12:59,000 --> 00:13:01,000
que es el que se llama

291
00:13:01,000 --> 00:13:03,000
el recolector de basura

292
00:13:03,000 --> 00:13:05,000
o el garbage collector.

293
00:13:05,000 --> 00:13:07,000
Y el recolector de basura es un proceso que está

294
00:13:07,000 --> 00:13:09,000
cada pocos milisegundos

295
00:13:09,000 --> 00:13:11,000
tirando a la basura

296
00:13:11,000 --> 00:13:13,000
todo lo que se ha quedado colgando

297
00:13:13,000 --> 00:13:15,000
de la nada, sin nadie que le apunte.

298
00:13:15,000 --> 00:13:17,000
Pues después de haber hecho esta

299
00:13:17,000 --> 00:13:19,000
sentencia, este

300
00:13:19,000 --> 00:13:21,000
se ha quedado colgando de la nada.

301
00:13:21,000 --> 00:13:23,000
Inaccesible, se acabó. Esto no se va a poder

302
00:13:23,000 --> 00:13:25,000
usar nunca. Entonces el recolector

303
00:13:25,000 --> 00:13:27,000
de basura, el solito, va detectando

304
00:13:27,000 --> 00:13:29,000
estas situaciones

305
00:13:29,000 --> 00:13:31,000
y dice, ah, fuera, este inaccesible

306
00:13:31,000 --> 00:13:33,000
a la basura, lo tira

307
00:13:33,000 --> 00:13:35,000
y ya hace disponible esa memoria

308
00:13:35,000 --> 00:13:37,000
para los futuros

309
00:13:37,000 --> 00:13:39,000
usos de la máquina virtual.

310
00:13:41,000 --> 00:13:43,000
El recolector de basura lo tiró.

311
00:13:43,000 --> 00:13:45,000
Y ahora ya, números

312
00:13:45,000 --> 00:13:47,000
1 y números 2 son físicamente

313
00:13:47,000 --> 00:13:49,000
lo mismo. Tengo dos variables

314
00:13:49,000 --> 00:13:51,000
distintas, pero

315
00:13:51,000 --> 00:13:53,000
las dos tienen la misma dirección de memoria

316
00:13:53,000 --> 00:13:55,000
y las dos llevan al mismo sitio.

317
00:13:55,000 --> 00:13:57,000
Claro, por eso cuando

318
00:13:57,000 --> 00:13:59,000
en nuestro código hemos recorrido ahora

319
00:13:59,000 --> 00:14:01,000
números 1, lo hemos recorrido

320
00:14:01,000 --> 00:14:03,000
hasta 10, creyendo que recorríamos esto.

321
00:14:03,000 --> 00:14:05,000
Pues no.

322
00:14:05,000 --> 00:14:07,000
Cuando nos hemos pasado del 5,

323
00:14:07,000 --> 00:14:09,000
no se ha salido una raíz y no se ha salido un exception,

324
00:14:09,000 --> 00:14:11,000
porque números 1, después de haber hecho esta asignación,

325
00:14:11,000 --> 00:14:13,000
ahora es este.

326
00:14:13,000 --> 00:14:15,000
Ahora es este.

327
00:14:15,000 --> 00:14:17,000
Entonces ya no podemos pasarnos de ahí,

328
00:14:17,000 --> 00:14:19,000
porque ahora es este físicamente.

329
00:14:19,000 --> 00:14:21,000
Por eso nos ha salido la raíz e índice

330
00:14:21,000 --> 00:14:23,000
va a un excepción.

331
00:14:23,000 --> 00:14:25,000
¿Vale?

332
00:14:25,000 --> 00:14:27,000
Entonces,

333
00:14:27,000 --> 00:14:29,000
importantísimo entender

334
00:14:29,000 --> 00:14:31,000
que esto por sí mismo, eso solo,

335
00:14:31,000 --> 00:14:33,000
sin un índice puesto asociado,

336
00:14:33,000 --> 00:14:35,000
sin un índice puesto

337
00:14:35,000 --> 00:14:37,000
como este, 0, 1, 2, eso,

338
00:14:37,000 --> 00:14:39,000
es una variable también,

339
00:14:39,000 --> 00:14:41,000
pero es una variable que lo que tiene es una dirección.

340
00:14:41,000 --> 00:14:43,000
Y a través de esa dirección,

341
00:14:43,000 --> 00:14:45,000
poniendo yo ya aquí el índice que sea,

342
00:14:45,000 --> 00:14:47,000
ya puedo acceder

343
00:14:47,000 --> 00:14:49,000
a una posición.

344
00:14:49,000 --> 00:14:51,000
¿Vale?

345
00:14:51,000 --> 00:14:53,000
Entonces, acostumbrémonos a este concepto

346
00:14:53,000 --> 00:14:55,000
de dirección de memoria.

347
00:14:55,000 --> 00:14:57,000
¿Por qué?

348
00:14:57,000 --> 00:14:59,000
Ahora ya, cuando empecemos a ver las clases

349
00:14:59,000 --> 00:15:01,000
y objetos, ya todo lo que vamos a manejar son objetos.

350
00:15:01,000 --> 00:15:03,000
Y los objetos son direcciones

351
00:15:03,000 --> 00:15:05,000
de memoria.

352
00:15:05,000 --> 00:15:07,000
Y de entender bien toda la complejidad que va por debajo,

353
00:15:07,000 --> 00:15:09,000
se deriva

354
00:15:09,000 --> 00:15:11,000
que nuestros programas

355
00:15:11,000 --> 00:15:13,000
que compilarán perfectamente

356
00:15:13,000 --> 00:15:15,000
y estarán todos estupendos, valgan para algo

357
00:15:15,000 --> 00:15:17,000
o no valgan para nada.

358
00:15:17,000 --> 00:15:19,000
De que entendamos bien esa complejidad.

359
00:15:19,000 --> 00:15:21,000
Bueno, pues,

360
00:15:21,000 --> 00:15:23,000
¿esto está entendido?

361
00:15:23,000 --> 00:15:25,000
Sí, seguro.

362
00:15:27,000 --> 00:15:29,000
Bueno, pues en esta situación,

363
00:15:29,000 --> 00:15:31,000
este se fue a la basura porque el conductor de basura

364
00:15:31,000 --> 00:15:33,000
ha dicho, oye, te has quedado

365
00:15:33,000 --> 00:15:35,000
sin nadie

366
00:15:35,000 --> 00:15:37,000
que te referencie.

367
00:15:37,000 --> 00:15:39,000
Sin nadie, pues tú fuera, no vales para nada.

368
00:15:39,000 --> 00:15:41,000
¿Vale?

369
00:15:41,000 --> 00:15:43,000
Entonces, ahora ya,

370
00:15:43,000 --> 00:15:45,000
después de esa situación, se nos ha quedado

371
00:15:45,000 --> 00:15:47,000
esta y esta.

372
00:15:47,000 --> 00:15:49,000
¿Vale?

373
00:15:49,000 --> 00:15:51,000
Imaginaos que ahora digo yo, oye, pues

374
00:15:51,000 --> 00:15:53,000
ahora quiero que números 2

375
00:15:53,000 --> 00:15:55,000
me apunten,

376
00:15:55,000 --> 00:15:57,000
no quiero yo que apunten los dos al mismo.

377
00:15:57,000 --> 00:15:59,000
Vaya desperdicio de memoria.

378
00:15:59,000 --> 00:16:01,000
Pues, por ejemplo,

379
00:16:01,000 --> 00:16:03,000
si quiero que números 2 ahora

380
00:16:03,000 --> 00:16:05,000
me apunte a otro array distinto que me voy a crear.

381
00:16:05,000 --> 00:16:07,000
Puedo hacerlo sin ningún problema.

382
00:16:07,000 --> 00:16:09,000
Imaginaos que ahora hacemos esto.

383
00:16:11,000 --> 00:16:13,000
Cada vez que yo haga

384
00:16:13,000 --> 00:16:15,000
esto,

385
00:16:15,000 --> 00:16:17,000
por ejemplo,

386
00:16:17,000 --> 00:16:19,000
es decir,

387
00:16:19,000 --> 00:16:21,000
imaginaos que a una variable array

388
00:16:21,000 --> 00:16:23,000
que yo tengo declarada, le vuelvo a hacer

389
00:16:23,000 --> 00:16:25,000
otro new int, porque me da la gana, le vuelvo a hacer

390
00:16:25,000 --> 00:16:27,000
otro new int. ¿Vale? Pues le vuelvo a hacer otro new int.

391
00:16:27,000 --> 00:16:29,000
Pues, ¿qué pasa cada vez que

392
00:16:29,000 --> 00:16:31,000
hacemos un new int?

393
00:16:31,000 --> 00:16:33,000
Cada vez que hacemos un new int,

394
00:16:33,000 --> 00:16:35,000
se crea un espacio en memoria.

395
00:16:35,000 --> 00:16:37,000
En este caso, de dos posiciones,

396
00:16:37,000 --> 00:16:39,000
la 0 y la 1.

397
00:16:39,000 --> 00:16:41,000
Y este espacio en memoria se queda apuntado

398
00:16:41,000 --> 00:16:43,000
por números 2.

399
00:16:43,000 --> 00:16:45,000
Imaginaos que este espacio en memoria, pues,

400
00:16:45,000 --> 00:16:47,000
se ha creado ahí, con la posición 0 y la 1.

401
00:16:47,000 --> 00:16:49,000
¿Vale? El new int

402
00:16:49,000 --> 00:16:51,000
lo que hace es crear espacio en memoria.

403
00:16:51,000 --> 00:16:53,000
Y ahora,

404
00:16:53,000 --> 00:16:55,000
el espacio en memoria, la dirección,

405
00:16:55,000 --> 00:16:57,000
se guarda

406
00:16:57,000 --> 00:16:59,000
en la variable que esté aquí, números 2.

407
00:16:59,000 --> 00:17:01,000
Con lo cual, números 2, ahora ya

408
00:17:01,000 --> 00:17:03,000
dejaría de tener la dirección

409
00:17:03,000 --> 00:17:05,000
del otro, empezaría a tener

410
00:17:05,000 --> 00:17:07,000
la de este que acabo de crear.

411
00:17:09,000 --> 00:17:11,000
Con lo cual, este enlace se rompe.

412
00:17:11,000 --> 00:17:13,000
Y ahora, números 2,

413
00:17:13,000 --> 00:17:15,000
empieza a apuntar a este.

414
00:17:17,000 --> 00:17:19,000
¿Vale? Empieza a apuntar aquí.

415
00:17:19,000 --> 00:17:21,000
Porque yo he

416
00:17:21,000 --> 00:17:23,000
creado un espacio, ese espacio está en una

417
00:17:23,000 --> 00:17:25,000
dirección, y esa dirección se guarda en la variable

418
00:17:25,000 --> 00:17:27,000
que yo ponga aquí.

419
00:17:27,000 --> 00:17:29,000
Y ahora ya tendría números 1 apuntando a este.

420
00:17:29,000 --> 00:17:31,000
Y números 2

421
00:17:31,000 --> 00:17:33,000
apuntando a este otro.

422
00:17:39,000 --> 00:17:41,000
¿Vale? Más o menos.

423
00:17:41,000 --> 00:17:43,000
Es decir,

424
00:17:43,000 --> 00:17:45,000
vamos a recopilar un poco.

425
00:17:45,000 --> 00:17:47,000
Vamos a revisar entonces

426
00:17:47,000 --> 00:17:49,000
qué estamos haciendo realmente cuando hacemos

427
00:17:49,000 --> 00:17:51,000
esta sentencia.

428
00:17:51,000 --> 00:17:53,000
Ahora ya vamos a analizarla un poco mejor.

429
00:17:57,000 --> 00:17:59,000
Esta de aquí.

430
00:17:59,000 --> 00:18:01,000
Esta, que es la que hemos

431
00:18:01,000 --> 00:18:03,000
plantado siempre a Capón, cuando queríamos

432
00:18:03,000 --> 00:18:05,000
usar un array de números

433
00:18:05,000 --> 00:18:07,000
2, 3, 4, 5, 6, 7,

434
00:18:07,000 --> 00:18:09,000
8, 9, 10, 11,

435
00:18:09,000 --> 00:18:11,000
12, 13, 14, 15,

436
00:18:11,000 --> 00:18:13,000
16, 17, 18, 19,

437
00:18:13,000 --> 00:18:15,000
cuando queríamos usar un array

438
00:18:15,000 --> 00:18:17,000
de emperos o lo que fuera de x posiciones.

439
00:18:17,000 --> 00:18:19,000
¿Pues qué estamos haciendo?

440
00:18:19,000 --> 00:18:21,000
Bueno, pues la primera parte,

441
00:18:21,000 --> 00:18:23,000
esta,

442
00:18:23,000 --> 00:18:25,000
uno la podría poner suelta, así.

443
00:18:27,000 --> 00:18:29,000
Es decir, en realidad podríamos hacer

444
00:18:29,000 --> 00:18:31,000
primero la declaración del array.

445
00:18:31,000 --> 00:18:33,000
Imaginaos que yo hago esta

446
00:18:33,000 --> 00:18:35,000
primera parte sin más.

447
00:18:35,000 --> 00:18:37,000
Bueno, pues con esta primera parte

448
00:18:37,000 --> 00:18:39,000
que estamos declarando,

449
00:18:39,000 --> 00:18:41,000
una variable números,

450
00:18:41,000 --> 00:18:43,000
una variable números,

451
00:18:43,000 --> 00:18:45,000
pensada

452
00:18:45,000 --> 00:18:47,000
para contener una dirección

453
00:18:47,000 --> 00:18:49,000
de memoria.

454
00:18:57,000 --> 00:18:59,000
Y esta dirección de memoria,

455
00:18:59,000 --> 00:19:01,000
¿ahora mismo a dónde estaría apuntando?

456
00:19:01,000 --> 00:19:03,000
A nada, porque mientras yo no

457
00:19:03,000 --> 00:19:05,000
creo un espacio,

458
00:19:05,000 --> 00:19:07,000
esta variable números

459
00:19:07,000 --> 00:19:09,000
se ha creado, ha aparecido,

460
00:19:09,000 --> 00:19:11,000
pensada para contener la dirección de memoria,

461
00:19:11,000 --> 00:19:13,000
pero ahora mismo, mientras yo no le haga el newInt,

462
00:19:13,000 --> 00:19:15,000
no apunta a nada.

463
00:19:15,000 --> 00:19:17,000
Esto se le llama

464
00:19:17,000 --> 00:19:19,000
apuntar a null.

465
00:19:19,000 --> 00:19:21,000
¿Vale?

466
00:19:21,000 --> 00:19:23,000
De hecho, si hiciérais ahora, solamente

467
00:19:23,000 --> 00:19:25,000
con esta sentencia, luego un system out

468
00:19:25,000 --> 00:19:27,000
de números, se pondría null.

469
00:19:27,000 --> 00:19:29,000
Se diría, oye, ¿qué tiene esta variable

470
00:19:29,000 --> 00:19:31,000
de números? Tiene null, una dirección de memoria

471
00:19:31,000 --> 00:19:33,000
que es null, no apunta a nada.

472
00:19:33,000 --> 00:19:35,000
Vale, entonces con este array

473
00:19:35,000 --> 00:19:37,000
no podemos hacer nada, obviamente,

474
00:19:37,000 --> 00:19:39,000
porque es una dirección de memoria que apunta a nada.

475
00:19:39,000 --> 00:19:41,000
Aquí no hay espacio ni nada.

476
00:19:41,000 --> 00:19:43,000
Ahora queremos crear el espacio.

477
00:19:43,000 --> 00:19:45,000
Pues para crear el espacio,

478
00:19:45,000 --> 00:19:47,000
ahora ya sí que hay que hacer el newEste.

479
00:19:55,000 --> 00:19:57,000
Números

480
00:19:59,000 --> 00:20:01,000
igual

481
00:20:01,000 --> 00:20:03,000
a newInt

482
00:20:03,000 --> 00:20:05,000
de 3, por ejemplo.

483
00:20:05,000 --> 00:20:07,000
Vale.

484
00:20:07,000 --> 00:20:09,000
Ahora ya, con newInt,

485
00:20:09,000 --> 00:20:11,000
ya se crea el espacio.

486
00:20:11,000 --> 00:20:13,000
Vale, con esto se crea.

487
00:20:13,000 --> 00:20:15,000
Ala, muy bien, ya tenemos el espacio, en este caso,

488
00:20:15,000 --> 00:20:17,000
para 3.

489
00:20:17,000 --> 00:20:19,000
Este espacio la máquina virtual decide crearlo

490
00:20:19,000 --> 00:20:21,000
donde le pete.

491
00:20:21,000 --> 00:20:23,000
Imaginaos que lo crea en esta dirección.

492
00:20:23,000 --> 00:20:25,000
Ahí lo crea.

493
00:20:25,000 --> 00:20:27,000
Y ahora la dirección de memoria donde está ese

494
00:20:27,000 --> 00:20:29,000
espacio creado, la guarda

495
00:20:29,000 --> 00:20:31,000
en la variable que hay aquí.

496
00:20:31,000 --> 00:20:33,000
Vale, pues como resultado de esta sentencia,

497
00:20:33,000 --> 00:20:35,000
no solo se crea el espacio,

498
00:20:35,000 --> 00:20:37,000
sino que esta dirección, ahora ya,

499
00:20:37,000 --> 00:20:39,000
se guarda ahí.

500
00:20:41,000 --> 00:20:43,000
Eso significa

501
00:20:43,000 --> 00:20:45,000
que este array ha dejado ya de apuntar

502
00:20:45,000 --> 00:20:47,000
a null, y este array empieza

503
00:20:47,000 --> 00:20:49,000
a apuntar aquí.

504
00:20:49,000 --> 00:20:51,000
Y ya podemos empezar a trabajar.

505
00:20:51,000 --> 00:20:53,000
Ahora ya, números 0 es alguien,

506
00:20:53,000 --> 00:20:55,000
números 1 es alguien, números 2 es alguien.

507
00:20:57,000 --> 00:20:59,000
Antes de hacer esto, números 0 es nada.

508
00:20:59,000 --> 00:21:01,000
Ahora veremos lo que es. Error, nada.

509
00:21:01,000 --> 00:21:03,000
Pero una vez hecho esto,

510
00:21:03,000 --> 00:21:05,000
ahora ya sí, porque ya hay espacio en memoria.

511
00:21:05,000 --> 00:21:07,000
Entonces,

512
00:21:07,000 --> 00:21:09,000
¿que lo hago en dos líneas separadas o en una?

513
00:21:09,000 --> 00:21:11,000
Me da igual.

514
00:21:11,000 --> 00:21:13,000
Más cómodo en una, ¿no? Más cómodo.

515
00:21:13,000 --> 00:21:15,000
Pero entended que son dos ideas.

516
00:21:15,000 --> 00:21:17,000
Dos ideas.

517
00:21:17,000 --> 00:21:19,000
Esto declara la variable

518
00:21:19,000 --> 00:21:21,000
con la dirección de memoria de donde va a estar

519
00:21:21,000 --> 00:21:23,000
el array, pero mientras el array no esté creado,

520
00:21:23,000 --> 00:21:25,000
esto apunta a null.

521
00:21:25,000 --> 00:21:27,000
Y ahora esto ya sí que

522
00:21:27,000 --> 00:21:29,000
crea el espacio. Esto ya sí.

523
00:21:31,000 --> 00:21:33,000
¿Vale?

524
00:21:33,000 --> 00:21:35,000
Entonces, con esta variable se puede trabajar

525
00:21:35,000 --> 00:21:37,000
por separado, pero se puede trabajar sabiendo que es una

526
00:21:37,000 --> 00:21:39,000
dirección de memoria. Que ahora me dicen,

527
00:21:39,000 --> 00:21:41,000
oye, hazte una copia de este array.

528
00:21:41,000 --> 00:21:43,000
O sea, yo podría hacer esto, por ejemplo,

529
00:21:43,000 --> 00:21:45,000
int

530
00:21:49,000 --> 00:21:51,000
números 2

531
00:21:51,000 --> 00:21:53,000
y a números 2, oye, asígnale

532
00:21:53,000 --> 00:21:55,000
números.

533
00:21:55,000 --> 00:21:57,000
Pues esto es una sentencia

534
00:21:57,000 --> 00:21:59,000
perfectamente normal. ¿Qué estoy haciendo

535
00:21:59,000 --> 00:22:01,000
aquí? Declarar una

536
00:22:01,000 --> 00:22:03,000
variable números 2

537
00:22:07,000 --> 00:22:09,000
así, pensada

538
00:22:09,000 --> 00:22:11,000
para contener un array. Luego esto es una dirección

539
00:22:11,000 --> 00:22:13,000
de memoria. Está pensada

540
00:22:13,000 --> 00:22:15,000
para una dirección de memoria. Vale.

541
00:22:15,000 --> 00:22:17,000
Y ahora, a esta variable números 2

542
00:22:17,000 --> 00:22:19,000
que tiene una dirección de memoria, ¿qué le

543
00:22:19,000 --> 00:22:21,000
asignamos? La dirección

544
00:22:21,000 --> 00:22:23,000
que está en números. ¿Vale? Muy

545
00:22:23,000 --> 00:22:25,000
bien. Le asignamos lo que tiene números.

546
00:22:25,000 --> 00:22:27,000
Que tiene 23. Muy bien.

547
00:22:27,000 --> 00:22:29,000
Le asignamos el 23.

548
00:22:29,000 --> 00:22:31,000
¿Eso qué significa? Que números 2

549
00:22:31,000 --> 00:22:33,000
automáticamente se queda

550
00:22:33,000 --> 00:22:35,000
apuntando aquí. Luego

551
00:22:35,000 --> 00:22:37,000
con esta sentencia estoy

552
00:22:37,000 --> 00:22:39,000
creando dos direcciones de memoria

553
00:22:39,000 --> 00:22:41,000
que me llevan al mismo array.

554
00:22:43,000 --> 00:22:45,000
¿Vale?

555
00:22:45,000 --> 00:22:47,000
¿Qué implicaciones tiene esto?

556
00:22:47,000 --> 00:22:49,000
Que si yo hago

557
00:22:49,000 --> 00:22:51,000
números de 0

558
00:22:51,000 --> 00:22:53,000
igual a 3.

559
00:22:53,000 --> 00:22:55,000
Pues está claro.

560
00:22:55,000 --> 00:22:57,000
Números de 0 se apunta un 3.

561
00:22:57,000 --> 00:22:59,000
Y ahora muestro

562
00:23:03,000 --> 00:23:05,000
números 2

563
00:23:05,000 --> 00:23:07,000
de 0

564
00:23:07,000 --> 00:23:09,000
Uno podría pensar, oye, que

565
00:23:09,000 --> 00:23:11,000
números 2, yo no le he dado ningún valor.

566
00:23:11,000 --> 00:23:13,000
A ver, es que números 2 tiene una dirección

567
00:23:13,000 --> 00:23:15,000
de números. Luego te apunta al mismo sitio. Luego

568
00:23:15,000 --> 00:23:17,000
si muestras esto, números 2 de 0 te va

569
00:23:17,000 --> 00:23:19,000
a dar el 3 también. Porque es el mismo

570
00:23:19,000 --> 00:23:21,000
físicamente. Es el mismo.

571
00:23:21,000 --> 00:23:23,000
¿Vale? Entonces

572
00:23:23,000 --> 00:23:25,000
como números 2

573
00:23:25,000 --> 00:23:27,000
tiene la copia de esta dirección

574
00:23:27,000 --> 00:23:29,000
todos los cambios que yo haga a través

575
00:23:29,000 --> 00:23:31,000
de números

576
00:23:31,000 --> 00:23:33,000
los voy a poder acceder a través de números 2

577
00:23:33,000 --> 00:23:35,000
también. Porque los dos apuntan

578
00:23:35,000 --> 00:23:37,000
al mismo lado. Los dos apuntan al mismo sitio.

579
00:23:39,000 --> 00:23:41,000
¿Vale?

580
00:23:41,000 --> 00:23:43,000
Bueno, pues es muy importante entender esto

581
00:23:43,000 --> 00:23:45,000
y que lo reviséis y que lo

582
00:23:45,000 --> 00:23:47,000
tengáis muy muy claro y entendido. Es la

583
00:23:47,000 --> 00:23:49,000
base, en realidad, de la programación

584
00:23:49,000 --> 00:23:51,000
frente a objetos. Esta idea

585
00:23:51,000 --> 00:23:53,000
entender que una cosa es la dirección de memoria

586
00:23:53,000 --> 00:23:55,000
donde están los datos y otra cosa

587
00:23:55,000 --> 00:23:57,000
son los datos.

588
00:23:57,000 --> 00:23:59,000
¿Vale? Y que a unos datos se puede

589
00:23:59,000 --> 00:24:01,000
acceder desde un montón

590
00:24:01,000 --> 00:24:03,000
de variables siempre y cuando

591
00:24:03,000 --> 00:24:05,000
esa tengan la misma dirección.

592
00:24:07,000 --> 00:24:09,000
¿Vale?

593
00:24:11,000 --> 00:24:13,000
Vale, pues...

594
00:24:17,000 --> 00:24:19,000
Si...

595
00:24:21,000 --> 00:24:23,000
A ver...

596
00:24:33,000 --> 00:24:35,000
Ahora...

597
00:24:51,000 --> 00:24:53,000
...

598
00:25:03,000 --> 00:25:05,000
Vale, pues entonces, el ejercicio en el que estábamos.

599
00:25:15,000 --> 00:25:17,000
En el que estábamos.

600
00:25:17,000 --> 00:25:19,000
Ahora ya entendemos

601
00:25:19,000 --> 00:25:21,000
lo que ha pasado, ¿verdad?

602
00:25:21,000 --> 00:25:23,000
Después de haber copiado

603
00:25:23,000 --> 00:25:25,000
en números 1 y números 2

604
00:25:25,000 --> 00:25:27,000
la dirección números

605
00:25:27,000 --> 00:25:29,000
1 me apunta al mismo sitio que números

606
00:25:29,000 --> 00:25:31,000
2. Con lo cual, números 1 y números

607
00:25:31,000 --> 00:25:33,000
2 ahora son lo mismo.

608
00:25:33,000 --> 00:25:35,000
Luego este 10 era el problema.

609
00:25:35,000 --> 00:25:37,000
Ahora, números 1

610
00:25:37,000 --> 00:25:39,000
solo me llega hasta 5. Solo me

611
00:25:39,000 --> 00:25:41,000
llega hasta 5. Si yo intento

612
00:25:41,000 --> 00:25:43,000
recorrerlo hasta 10, me pasa lo que me ha pasado.

613
00:25:43,000 --> 00:25:45,000
Que cuando me rebaso

614
00:25:45,000 --> 00:25:47,000
de la posición 4...

615
00:25:47,000 --> 00:25:49,000
¿Vale?

616
00:25:49,000 --> 00:25:51,000
Ese ha sido el problema.

617
00:25:51,000 --> 00:25:53,000
Vamos a ponerlo aquí.

618
00:25:55,000 --> 00:25:57,000
Ahora, números

619
00:25:57,000 --> 00:25:59,000
1 y

620
00:26:01,000 --> 00:26:03,000
números 2 apuntan

621
00:26:05,000 --> 00:26:07,000
al mismo sitio.

622
00:26:11,000 --> 00:26:13,000
Luego, números

623
00:26:13,000 --> 00:26:15,000
1 solo tiene

624
00:26:15,000 --> 00:26:17,000
5 posiciones.

625
00:26:19,000 --> 00:26:21,000
¿Vale? Entonces, si yo quiero recorrer

626
00:26:21,000 --> 00:26:23,000
números 1

627
00:26:23,000 --> 00:26:25,000
tiene que tener 5.

628
00:26:27,000 --> 00:26:29,000
Ahora ya esto no me da error

629
00:26:29,000 --> 00:26:31,000
de ejecución.

630
00:26:31,000 --> 00:26:33,000
Ese es el primer array que hemos hecho, con posiciones aleatorias.

631
00:26:33,000 --> 00:26:35,000
Ese es el segundo que hemos

632
00:26:35,000 --> 00:26:37,000
hecho, con posiciones aleatorias.

633
00:26:37,000 --> 00:26:39,000
Luego, hemos ido

634
00:26:39,000 --> 00:26:41,000
posición por posición copiando

635
00:26:41,000 --> 00:26:43,000
uno en otro. Aquí no hemos

636
00:26:43,000 --> 00:26:45,000
alterado las direcciones de memoria y nada.

637
00:26:45,000 --> 00:26:47,000
Números 2 sigue apuntando a este array

638
00:26:47,000 --> 00:26:49,000
y números 1 a este.

639
00:26:49,000 --> 00:26:51,000
Lo que hemos hecho ha sido ir copiando las posiciones.

640
00:26:51,000 --> 00:26:53,000
Pero es distinto ir copiando posiciones una tras otra

641
00:26:53,000 --> 00:26:55,000
que ¡paf! de golpe mueve la dirección

642
00:26:55,000 --> 00:26:57,000
entera. Ahora,

643
00:26:57,000 --> 00:26:59,000
hemos asignado directamente números 1 y números 2.

644
00:26:59,000 --> 00:27:01,000
Pues ahora ya, números

645
00:27:01,000 --> 00:27:03,000
1 y números 2 son lo mismo.

646
00:27:03,000 --> 00:27:05,000
Van al mismo sitio.

647
00:27:05,000 --> 00:27:07,000
Y hemos mostrado el mismo array

648
00:27:07,000 --> 00:27:09,000
dos veces.

649
00:27:13,000 --> 00:27:15,000
Vamos a poner aquí otro ejemplo.

650
00:27:25,000 --> 00:27:27,000
Ejemplo 4.

651
00:27:27,000 --> 00:27:29,000
Ejemplo 5.

652
00:27:41,000 --> 00:27:43,000
Solo tiene 5 posiciones.

653
00:27:57,000 --> 00:27:59,000
Vamos a hacer rápidamente

654
00:27:59,000 --> 00:28:01,000
eso que hemos visto en

655
00:28:01,000 --> 00:28:03,000
la pizarra. Yo tengo mis dos

656
00:28:03,000 --> 00:28:05,000
arrays. Ahora mismo solo son

657
00:28:05,000 --> 00:28:07,000
direcciones de memoria que no apuntan a nada.

658
00:28:07,000 --> 00:28:09,000
Vamos a mostrar a ver

659
00:28:09,000 --> 00:28:11,000
qué me sale que tienen.

660
00:28:11,000 --> 00:28:13,000
Números 1.

661
00:28:13,000 --> 00:28:15,000
¿Vale?

662
00:28:15,000 --> 00:28:17,000
¿Qué me dice?

663
00:28:17,000 --> 00:28:19,000
Números 1 no está

664
00:28:19,000 --> 00:28:21,000
inicializada.

665
00:28:21,000 --> 00:28:23,000
Es una dirección de memoria pero que

666
00:28:23,000 --> 00:28:25,000
apunta a null. No está inicializada.

667
00:28:25,000 --> 00:28:27,000
Entonces,

668
00:28:27,000 --> 00:28:29,000
vamos a inicializarla.

669
00:28:29,000 --> 00:28:31,000
Pues venga, números 1 igual.

670
00:28:31,000 --> 00:28:33,000
Le vamos a asignar

671
00:28:33,000 --> 00:28:35,000
un array de

672
00:28:35,000 --> 00:28:37,000
10 posiciones, por ejemplo.

673
00:28:37,000 --> 00:28:39,000
Ahora ya,

674
00:28:39,000 --> 00:28:41,000
números 1 ya apunta a un

675
00:28:41,000 --> 00:28:43,000
espacio de 10 posiciones

676
00:28:43,000 --> 00:28:45,000
consecutivas a las que pueda acceder

677
00:28:45,000 --> 00:28:47,000
con 0, 1, 2.

678
00:28:47,000 --> 00:28:49,000
¿Y ahora qué vamos a hacer con números 2?

679
00:28:49,000 --> 00:28:51,000
A números 2 le vamos a asignar

680
00:28:51,000 --> 00:28:53,000
números 1.

681
00:28:55,000 --> 00:28:57,000
Luego, números 2 y números 1

682
00:28:57,000 --> 00:28:59,000
apuntan al mismo sitio.

683
00:29:01,000 --> 00:29:03,000
Números 1 y números

684
00:29:03,000 --> 00:29:05,000
2

685
00:29:05,000 --> 00:29:07,000
se han

686
00:29:07,000 --> 00:29:09,000
quedado apuntando

687
00:29:11,000 --> 00:29:13,000
al mismo sitio.

688
00:29:15,000 --> 00:29:17,000
Vamos a comprobarlo.

689
00:29:17,000 --> 00:29:19,000
Vamos a asignar valores a números 1

690
00:29:19,000 --> 00:29:21,000
y luego vamos a recorrer números 2.

691
00:29:21,000 --> 00:29:23,000
Vamos a rellenar

692
00:29:23,000 --> 00:29:25,000
números 1.

693
00:29:25,000 --> 00:29:27,000
Pues venga,

694
00:29:31,000 --> 00:29:33,000
tras i sea menor que

695
00:29:33,000 --> 00:29:35,000
10, era.

696
00:29:35,000 --> 00:29:37,000
En lugar de por teclado

697
00:29:37,000 --> 00:29:39,000
vamos a rellenarlo con números aleatorios.

698
00:29:41,000 --> 00:29:43,000
Números 1

699
00:29:43,000 --> 00:29:45,000
de i

700
00:29:45,000 --> 00:29:47,000
le vamos a asignar

701
00:29:47,000 --> 00:29:49,000
y le vamos a

702
00:29:49,000 --> 00:29:51,000
asignar

703
00:29:53,000 --> 00:29:55,000
punto random

704
00:29:55,000 --> 00:29:57,000
por 50, números aleatorios

705
00:29:57,000 --> 00:29:59,000
entre 0 y 50.

706
00:30:01,000 --> 00:30:03,000
Hacemos el casting entero

707
00:30:03,000 --> 00:30:05,000
para que...

708
00:30:07,000 --> 00:30:09,000
Vale, el array

709
00:30:09,000 --> 00:30:11,000
números 1 de 10 posiciones está relleno.

710
00:30:11,000 --> 00:30:13,000
Es el único que hemos

711
00:30:13,000 --> 00:30:15,000
rellenado. Ahora

712
00:30:15,000 --> 00:30:17,000
vamos a recorrer el segundo.

713
00:30:17,000 --> 00:30:19,000
Vamos a mostrar lo que tiene

714
00:30:21,000 --> 00:30:23,000
para ver lo que tiene.

715
00:30:27,000 --> 00:30:29,000
En otro bucle

716
00:30:29,000 --> 00:30:31,000
fuera aparte para que el programa quede más claro.

717
00:30:41,000 --> 00:30:43,000
La arrastraron.

718
00:30:45,000 --> 00:30:47,000
Números de i

719
00:30:47,000 --> 00:30:49,000
seguido de

720
00:30:49,000 --> 00:30:51,000
un espacio.

721
00:30:59,000 --> 00:31:01,000
Vale, y pongo

722
00:31:01,000 --> 00:31:03,000
los asteriscos.

723
00:31:03,000 --> 00:31:05,000
Vale, pues a ver.

724
00:31:05,000 --> 00:31:07,000
He rellenado el primero.

725
00:31:07,000 --> 00:31:09,000
Y lo he mostrado.

726
00:31:11,000 --> 00:31:13,000
Vale, pues voy a mostrar el segundo

727
00:31:13,000 --> 00:31:15,000
también. Vamos a mostrarle al segundo.

728
00:31:15,000 --> 00:31:17,000
Que no le hemos rellenado, ni hemos hecho nada

729
00:31:17,000 --> 00:31:19,000
al segundo.

730
00:31:19,000 --> 00:31:21,000
Solo hemos rellenado con esto el primero.

731
00:31:21,000 --> 00:31:23,000
Vamos a mostrar el segundo.

732
00:31:27,000 --> 00:31:29,000
Vale, pues lo hemos mostrado.

733
00:31:29,000 --> 00:31:31,000
Ahora, lo hemos rellenado con

734
00:31:31,000 --> 00:31:33,000
esto el primero. Vamos a mostrar el segundo.

735
00:31:37,000 --> 00:31:39,000
Hago este mismo bucle.

736
00:31:45,000 --> 00:31:47,000
Mostramos el segundo.

737
00:31:55,000 --> 00:31:57,000
Vale, a ver que pasa.

738
00:31:57,000 --> 00:31:59,000
Vale, veis lo que hemos hecho.

739
00:31:59,000 --> 00:32:01,000
No hemos rellenado el primero.

740
00:32:01,000 --> 00:32:03,000
Y sin haber hecho nada

741
00:32:03,000 --> 00:32:05,000
con el segundo, salvo esta asignación,

742
00:32:05,000 --> 00:32:07,000
salvo esta.

743
00:32:07,000 --> 00:32:09,000
Lo mostramos ahora.

744
00:32:13,000 --> 00:32:15,000
Y veis, efectivamente,

745
00:32:17,000 --> 00:32:19,000
a través de números 2, llegamos

746
00:32:19,000 --> 00:32:21,000
al mismo sitio. Llegamos al mismo

747
00:32:21,000 --> 00:32:23,000
array.

748
00:32:23,000 --> 00:32:25,000
Llegamos al mismo.

749
00:32:25,000 --> 00:32:27,000
Este es número 2.

750
00:32:27,000 --> 00:32:29,000
Este es número 1.

751
00:32:29,000 --> 00:32:31,000
Son exactamente el mismo, porque

752
00:32:31,000 --> 00:32:33,000
después de haber hecho esta asignación,

753
00:32:33,000 --> 00:32:35,000
las dos direcciones de memoria

754
00:32:35,000 --> 00:32:37,000
son la misma.

755
00:32:37,000 --> 00:32:39,000
Las dos direcciones van al mismo lado.

756
00:32:39,000 --> 00:32:41,000
Me da igual acceder al array

757
00:32:41,000 --> 00:32:43,000
desde números 1 que desde números 2.

758
00:32:43,000 --> 00:32:45,000
Me da igual. Estoy accediendo a la misma

759
00:32:45,000 --> 00:32:47,000
zona de memoria.

760
00:32:47,000 --> 00:32:49,000
Desde el momento en que he asignado una a la otra.

761
00:32:51,000 --> 00:32:53,000
Estoy accediendo a la misma zona de memoria.

762
00:32:57,000 --> 00:32:59,000
¿Vale?

763
00:33:01,000 --> 00:33:03,000
¿Entendido esto?

764
00:33:05,000 --> 00:33:07,000
Bueno, antes de que os pongáis

765
00:33:07,000 --> 00:33:09,000
a hacer ejercicios,

766
00:33:09,000 --> 00:33:11,000
solo una cosita más

767
00:33:11,000 --> 00:33:13,000
para que sea más cómodo.

768
00:33:13,000 --> 00:33:15,000
Es una tontería.

769
00:33:15,000 --> 00:33:17,000
Aunque nos quedan unas cuantas cosas de array.

770
00:33:17,000 --> 00:33:19,000
Vale, cuando recorremos

771
00:33:19,000 --> 00:33:21,000
un array, ya hemos dicho

772
00:33:21,000 --> 00:33:23,000
que la forma más

773
00:33:23,000 --> 00:33:25,000
práctica y rápida de hacerlos con un

774
00:33:25,000 --> 00:33:27,000
for, porque el for ya me permite

775
00:33:27,000 --> 00:33:29,000
aquí declarar de forma rápida una variable

776
00:33:29,000 --> 00:33:31,000
que empieza variando cero, la voy incrementando

777
00:33:31,000 --> 00:33:33,000
y llego hasta donde yo quiera.

778
00:33:33,000 --> 00:33:35,000
Bueno, pues ya esa variable, ya esa

779
00:33:35,000 --> 00:33:37,000
me vale como índice.

780
00:33:37,000 --> 00:33:39,000
Entonces el for es la forma más práctica

781
00:33:39,000 --> 00:33:41,000
de recorrer un array.

782
00:33:41,000 --> 00:33:43,000
Porque ya esa variable me vale como índice.

783
00:33:43,000 --> 00:33:45,000
Pero el problema es que yo me tengo que

784
00:33:45,000 --> 00:33:47,000
acordar, cuando pongo aquel numerito,

785
00:33:47,000 --> 00:33:49,000
me tengo que acordar

786
00:33:49,000 --> 00:33:51,000
del tamaño que tenía el array.

787
00:33:51,000 --> 00:33:53,000
Para acordarme me tengo que ir arriba

788
00:33:53,000 --> 00:33:55,000
y declarar. Tengo que acordar.

789
00:33:55,000 --> 00:33:57,000
Bueno, eso a veces

790
00:33:57,000 --> 00:33:59,000
vale. Pues el mayor

791
00:33:59,000 --> 00:34:01,000
problema que tiene es que me tengo que ir a ver

792
00:34:01,000 --> 00:34:03,000
uy, ¿cuántos tenía? Diez.

793
00:34:03,000 --> 00:34:05,000
Pero es que hay veces que si el programa consta de varias

794
00:34:05,000 --> 00:34:07,000
partes, como ya veremos, son

795
00:34:07,000 --> 00:34:09,000
funciones aparte, es que es imposible.

796
00:34:09,000 --> 00:34:11,000
Yo físicamente, mirando

797
00:34:11,000 --> 00:34:13,000
mi código, no voy a poder saber

798
00:34:13,000 --> 00:34:15,000
de qué tamaño se declaró

799
00:34:15,000 --> 00:34:17,000
ese array. Hay veces que no voy a poder saberlo.

800
00:34:17,000 --> 00:34:19,000
Porque la parte del código a la que tengo

801
00:34:19,000 --> 00:34:21,000
acceso, es distinta a la

802
00:34:21,000 --> 00:34:23,000
parte del código en la que se declaró.

803
00:34:23,000 --> 00:34:25,000
Eso nos va a ocurrir enseguida, cuando ya tengamos

804
00:34:25,000 --> 00:34:27,000
varias clases. Luego, una situación

805
00:34:27,000 --> 00:34:29,000
así, que ponemos aquí,

806
00:34:31,000 --> 00:34:33,000
es decir, sería

807
00:34:33,000 --> 00:34:35,000
interesante que hubiera una manera

808
00:34:35,000 --> 00:34:37,000
de, dado una variable array,

809
00:34:37,000 --> 00:34:39,000
una dirección de memoria, saber

810
00:34:39,000 --> 00:34:41,000
yo qué tamaño

811
00:34:41,000 --> 00:34:43,000
tiene el array al que apunta.

812
00:34:43,000 --> 00:34:45,000
Sería ideal si eso existiera.

813
00:34:45,000 --> 00:34:47,000
Pues existe.

814
00:34:47,000 --> 00:34:49,000
Si yo tengo una variable array como números

815
00:34:49,000 --> 00:34:51,000
1,

816
00:34:51,000 --> 00:34:53,000
pues tengo una posibilidad

817
00:34:53,000 --> 00:34:55,000
que es esta,

818
00:34:55,000 --> 00:34:57,000
que es

819
00:34:57,000 --> 00:34:59,000
sacar el tamaño

820
00:34:59,000 --> 00:35:01,000
que hay reservado

821
00:35:01,000 --> 00:35:03,000
para ese array números 1.

822
00:35:03,000 --> 00:35:05,000
Entonces, desde el momento que yo

823
00:35:05,000 --> 00:35:07,000
pongo nombre de un array,

824
00:35:07,000 --> 00:35:09,000
.length,

825
00:35:09,000 --> 00:35:11,000
esto es el tamaño

826
00:35:11,000 --> 00:35:13,000
que se reservó cuando se le declaró.

827
00:35:13,000 --> 00:35:15,000
El tamaño que se reservó.

828
00:35:15,000 --> 00:35:17,000
¿Que se reservó 100? Es 100.

829
00:35:17,000 --> 00:35:19,000
Si se reservó 30, será 30.

830
00:35:19,000 --> 00:35:21,000
No tengo que irme aquí a buscar esto.

831
00:35:21,000 --> 00:35:23,000
No tengo que irme a buscarlo.

832
00:35:23,000 --> 00:35:25,000
Es fundamental, porque habrá veces que ni siquiera

833
00:35:25,000 --> 00:35:27,000
tengamos acceso a esa sentencia.

834
00:35:27,000 --> 00:35:29,000
Pero nos da igual.

835
00:35:29,000 --> 00:35:31,000
Entonces, esto es muy cómodo

836
00:35:31,000 --> 00:35:33,000
para hacer recorridos de

837
00:35:33,000 --> 00:35:35,000
for, porque no tengo que andar yo aquí arrastrando

838
00:35:35,000 --> 00:35:37,000
el número. Pongo números 1.length

839
00:35:37,000 --> 00:35:39,000
y ya está, o aquí igual.

840
00:35:39,000 --> 00:35:41,000
Aquí pongo números 2.length

841
00:35:47,000 --> 00:35:49,000
y ya está, ya lo tengo.

842
00:35:49,000 --> 00:35:51,000
De hecho, si ejecutamos

843
00:35:51,000 --> 00:35:53,000
este código, nos va a dar lo mismo.

844
00:35:53,000 --> 00:35:55,000
¿Vale? Porque números

845
00:35:55,000 --> 00:35:57,000
length, números 2.length

846
00:35:57,000 --> 00:35:59,000
¿Vale? Entonces aquí

847
00:35:59,000 --> 00:36:01,000
de nuevo nos liéis.

848
00:36:01,000 --> 00:36:03,000
Uno podría decir, oye, pero números 2.

849
00:36:03,000 --> 00:36:05,000
Yo a números 2 no le hice ningún new.

850
00:36:05,000 --> 00:36:07,000
No le hice ningún ya.

851
00:36:07,000 --> 00:36:09,000
Pero es que a números 2 le hemos asignado números 1.

852
00:36:09,000 --> 00:36:11,000
Con lo cual, números 2 y números 1

853
00:36:11,000 --> 00:36:13,000
es que son lo mismo.

854
00:36:13,000 --> 00:36:15,000
Como son lo mismo, números 2.length

855
00:36:15,000 --> 00:36:17,000
será lo mismo que números 1.length

856
00:36:17,000 --> 00:36:19,000
porque son lo mismo, gracias a esta

857
00:36:19,000 --> 00:36:21,000
asignación que le hemos hecho.

858
00:36:25,000 --> 00:36:27,000
¿Vale?

859
00:36:27,000 --> 00:36:29,000
Pues vamos a subir una primera hoja

860
00:36:29,000 --> 00:36:31,000
de ejercicios.