1
00:00:00,300 --> 00:00:05,519
Voy a grabar esta parte de la clase, por lo tanto, si habláis, me autorizáis a grabar vuestro.

2
00:00:06,419 --> 00:00:12,220
Entonces, nosotros hemos entendido más o menos qué es un array, cómo funciona, grosso modo,

3
00:00:12,339 --> 00:00:15,220
y hemos hecho algunos ejemplos de uso de array.

4
00:00:16,219 --> 00:00:22,879
Entonces, hemos dicho también que el array, en realidad, por debajo, está construido como un objeto.

5
00:00:22,879 --> 00:00:25,679
entonces las variables

6
00:00:25,679 --> 00:00:27,820
que tienen como tipo array

7
00:00:27,820 --> 00:00:29,519
no son

8
00:00:29,519 --> 00:00:31,960
variables que tienen dentro un valor

9
00:00:31,960 --> 00:00:34,119
directamente, mas tienen una referencia

10
00:00:34,119 --> 00:00:35,840
a una zona de memoria donde

11
00:00:35,840 --> 00:00:37,079
está construido el objeto

12
00:00:37,079 --> 00:00:39,679
el array es una variable

13
00:00:39,679 --> 00:00:42,000
es un trozo

14
00:00:42,000 --> 00:00:43,920
de memoria que tiene varios compartimentos

15
00:00:43,920 --> 00:00:45,939
varias celdas

16
00:00:45,939 --> 00:00:48,100
en cada celda tenemos un valor

17
00:00:48,100 --> 00:00:49,219
de un determinado tipo

18
00:00:49,219 --> 00:00:51,479
int, string o lo que sea

19
00:00:51,479 --> 00:01:00,219
Nosotros utilizamos una referencia, una variable que se refiere a este trozo de memoria

20
00:01:00,219 --> 00:01:05,519
Llegamos allí y luego decimos de estas 10 celdas que tengo, pues quiero la celda 5, quiero la celda 7

21
00:01:05,519 --> 00:01:08,959
Y accedemos a esos valores que queremos ver

22
00:01:08,959 --> 00:01:12,840
¿Qué implica esto de la referencia y cosas por el resto?

23
00:01:13,840 --> 00:01:15,480
Imaginaos este trocito de código

24
00:01:15,480 --> 00:01:19,340
O sea, tengo string x que es igual a 1, 2, 3, 4, 5

25
00:01:19,340 --> 00:01:21,819
este es un array, se crea un array

26
00:01:21,819 --> 00:01:24,219
por algún lado, y x se referencia

27
00:01:24,219 --> 00:01:25,359
a este array, y ahora hago

28
00:01:25,359 --> 00:01:28,040
string y es igual a x

29
00:01:28,040 --> 00:01:30,120
entonces

30
00:01:30,120 --> 00:01:31,939
esta cosa de aquí

31
00:01:31,939 --> 00:01:33,260
en realidad

32
00:01:33,260 --> 00:01:35,900
no me está creando una copia

33
00:01:35,900 --> 00:01:37,799
del array, me está

34
00:01:37,799 --> 00:01:39,980
creando dos referencias

35
00:01:39,980 --> 00:01:41,319
al mismo array

36
00:01:41,319 --> 00:01:44,000
entonces si yo ahora hago

37
00:01:44,000 --> 00:01:45,480
x de 3

38
00:01:45,480 --> 00:01:47,219
es igual a 7

39
00:01:47,219 --> 00:01:56,159
o sea 0, 1, 2 y 3, este 4 lo cambio por 7, también y de 3 valdrá 7.

40
00:01:58,260 --> 00:02:00,379
No he hecho una copia del array.

41
00:02:00,560 --> 00:02:08,680
Gráficamente, cuando hago string x1 de 4, 5, tengo una referencia x a este objeto de aquí.

42
00:02:09,460 --> 00:02:15,860
Cuando hago string corchetes y es igual a x, no creo una copia de la estructura.

43
00:02:15,860 --> 00:02:23,139
Lo que estoy haciendo es copiar, es crear una nueva referencia a esta misma estructura.

44
00:02:24,340 --> 00:02:24,979
¿Se entiende?

45
00:02:25,800 --> 00:02:31,139
Entonces, cuando ahora x de 3 es 7, o sea, sustituyo esta parte de aquí,

46
00:02:31,939 --> 00:02:36,379
también y que apunta a la misma estructura verá el cambio.

47
00:02:39,680 --> 00:02:39,800
¿Sí?

48
00:02:40,139 --> 00:02:46,939
O sea, que esta, la parte de aquí, no hace una copia de la rey.

49
00:02:48,319 --> 00:02:49,699
Es importante esto.

50
00:02:50,759 --> 00:02:55,620
Yo digo, ah, me copio la red así, así luego lo puedo cambiar y sigo teniendo los valores originales.

51
00:02:55,719 --> 00:02:57,080
No, no se hace así.

52
00:02:58,900 --> 00:02:59,400
¿Se entiende?

53
00:03:00,759 --> 00:03:01,819
¿Dudas sobre esto?

54
00:03:03,979 --> 00:03:11,199
Así, por conocimiento vuestro futuro, es como se portan absolutamente todos los objetos.

55
00:03:11,939 --> 00:03:13,759
Los objetos son por referencia.

56
00:03:13,759 --> 00:03:17,460
solo los valores, los tipos primitivos

57
00:03:17,460 --> 00:03:18,840
son por valores

58
00:03:18,840 --> 00:03:21,240
o sea, si yo hago lo mismo

59
00:03:21,240 --> 00:03:23,379
con una variable int x

60
00:03:23,379 --> 00:03:25,860
que hago int x es igual a 7

61
00:03:25,860 --> 00:03:28,580
luego hago int y es igual a x

62
00:03:28,580 --> 00:03:30,500
y luego cambio x

63
00:03:30,500 --> 00:03:32,879
y no se ve

64
00:03:32,879 --> 00:03:34,080
¿entendéis?

65
00:03:36,770 --> 00:03:37,689
si yo creo

66
00:03:37,689 --> 00:03:43,569
int x es igual a 7

67
00:03:43,569 --> 00:03:48,490
he creado una variable int con dentro 7

68
00:03:48,490 --> 00:03:52,169
que se llama x. Cuando hago int

69
00:03:52,169 --> 00:03:55,210
y es igual a x

70
00:03:55,210 --> 00:03:59,349
no estoy creando una referencia a esta,

71
00:03:59,889 --> 00:04:02,889
estoy creando una nueva variable que se llama y

72
00:04:02,889 --> 00:04:07,030
que tiene dentro int y se copia este valor.

73
00:04:08,389 --> 00:04:12,650
Si ahora yo hago x es igual a 5

74
00:04:12,650 --> 00:04:15,789
esto se destruye

75
00:04:15,789 --> 00:04:17,089
el de 5

76
00:04:17,089 --> 00:04:19,550
pero Y sigue teniendo 7

77
00:04:19,550 --> 00:04:20,569
¿vale?

78
00:04:20,910 --> 00:04:23,009
esto es porque los tipos primitivos

79
00:04:23,009 --> 00:04:24,329
trabajan por valor

80
00:04:24,329 --> 00:04:25,790
no por referencia

81
00:04:25,790 --> 00:04:27,649
¿ok?

82
00:04:27,889 --> 00:04:28,790
sin embargo

83
00:04:28,790 --> 00:04:31,829
cuando uso un objeto

84
00:04:31,829 --> 00:04:32,970
cuando uso un array

85
00:04:32,970 --> 00:04:35,509
cuando yo copio

86
00:04:35,509 --> 00:04:36,670
el array

87
00:04:36,670 --> 00:04:37,529
¿veis que es de guía?

88
00:04:37,629 --> 00:04:38,649
como antes que ponía

89
00:04:38,649 --> 00:04:40,250
int Y es igual a X

90
00:04:40,250 --> 00:04:41,269
es lo mismo que

91
00:04:41,269 --> 00:04:41,910
¿dónde está?

92
00:04:41,910 --> 00:04:51,610
Es lo mismo que esta cosa de aquí, solo que aquí lo estoy haciendo entre tipos primitivos, mientras aquí lo estoy haciendo entre rays.

93
00:04:52,189 --> 00:04:58,089
Pues esta asignación de aquí no me copia, no me crea una copia de los valores,

94
00:04:58,730 --> 00:05:02,189
sino que me crea una copia de lo que está dentro de la referencia.

95
00:05:02,389 --> 00:05:07,730
Y por lo tanto, estoy apuntando a los mismos valores, al mismo objeto, a la misma estructura.

96
00:05:07,730 --> 00:05:12,509
Si cambio una de estas dos, el cambio se verá reflejado en la otra.

97
00:05:13,829 --> 00:05:14,610
¿Por qué sirve?

98
00:05:15,709 --> 00:05:16,949
Por mil y media cosas.

99
00:05:17,990 --> 00:05:21,449
No es que sirva, es que es como funciona una cosa y la otra.

100
00:05:21,850 --> 00:05:25,110
Luego tú sabes cómo funciona y lo haces funcionar como te da la carta.

101
00:05:31,000 --> 00:05:39,339
Ahora, ¿y qué pasa si yo en vez de quiero que X e Y tengan dos copias que sean distintas

102
00:05:39,339 --> 00:05:43,420
y que si cambio algo en x no se vea en y, ¿vale?

103
00:05:43,579 --> 00:05:46,720
Aquí la cuestión no es a uno sirve, a uno no sirve.

104
00:05:47,000 --> 00:05:49,279
Aquí la cuestión es lo que yo necesito.

105
00:05:49,899 --> 00:05:56,139
Yo pueda que necesite que x y sean dos variables en partes distintas de mi programa

106
00:05:56,139 --> 00:05:58,040
que accedan a la misma estructura.

107
00:05:59,019 --> 00:06:03,399
Lo entenderemos mejor cuando veremos los métodos en la función, ¿vale?

108
00:06:03,639 --> 00:06:06,839
Pero yo puedo necesitar las dos cosas.

109
00:06:06,839 --> 00:06:15,839
Puedo necesitar que x e y apunten a la misma estructura, entonces que cambios en x se reflejen también en y y cambios en y se reflejen también en x.

110
00:06:16,339 --> 00:06:18,899
O puedo necesitar que sean completamente separadas.

111
00:06:19,220 --> 00:06:21,399
Entonces necesito una copia del array.

112
00:06:23,620 --> 00:06:25,920
¿Cómo se hace la otra versión?

113
00:06:26,639 --> 00:06:29,980
Para hacer la otra versión tengo que copiar el array.

114
00:06:30,379 --> 00:06:31,480
¿Cómo se copia el array?

115
00:06:31,480 --> 00:06:33,259
Pues yo tengo mi array original.

116
00:06:33,259 --> 00:06:36,800
Fijaos que cuando creo Y no lo hago igual a X,

117
00:06:37,220 --> 00:06:40,899
mas creo un nuevo array distinto.

118
00:06:41,720 --> 00:06:45,420
Y a este punto con un for recorro todo X

119
00:06:45,420 --> 00:06:49,399
y copio lo que hay X en Y.

120
00:06:49,939 --> 00:06:52,040
Entonces lo que estaría haciendo es

121
00:06:52,040 --> 00:06:57,879
que cuando pillo X creo una estructura con dentro lo que sea.

122
00:06:57,879 --> 00:07:15,540
Ahora, cuando creo Y, me creo una estructura con los mismos números de celdas, pero sin nada dentro, porque aquí habría podido poner el new string de X.lend, por ejemplo, ¿vale? Para hacerlo del mismo tamaño de X.

123
00:07:15,540 --> 00:07:24,199
Y ahora me voy con un for por cada celda de X copiando el contenido de la celda en la misma celda de Y.

124
00:07:24,660 --> 00:07:29,740
Entonces ahora tengo una copia de las dos estructuras.

125
00:07:29,879 --> 00:07:33,579
X apunta a la estructura verde, Y apunta a la estructura azul.

126
00:07:33,879 --> 00:07:43,500
Si yo cambio algo en X y se cambia aquí con 7, pues este cambio no se ve reflejado en azul porque es una estructura distinta.

127
00:07:43,500 --> 00:07:48,500
No son referencias al mismo objeto, no son referencias separadas a objetos separados.

128
00:07:50,779 --> 00:07:51,100
¿Dudas?

129
00:07:56,449 --> 00:07:58,529
Empezaremos con las redes multidimensionales.

130
00:07:58,689 --> 00:08:01,209
Sé que queréis, pero bueno, venga, hoy no.

131
00:08:03,990 --> 00:08:09,949
El concepto de este de aquí es, ahora lo aplicamos, por ejemplo, al problema que decíamos antes.

132
00:08:10,310 --> 00:08:16,490
Es decir, ¿qué pasa si yo he acabado los espacios en una red y quiero un espacio más?

133
00:08:17,389 --> 00:08:19,949
Pues entonces tendré que hacer algo parecido a esto.

134
00:08:21,069 --> 00:08:24,329
O mejor, una combinación de estas dos cosas.

135
00:08:24,670 --> 00:08:24,870
¿Vale?

136
00:08:24,870 --> 00:08:28,709
Porque yo me creo una copia de X, Y.

137
00:08:29,449 --> 00:08:32,909
Que pero en vez de cinco posiciones tenga una más, seis.

138
00:08:33,769 --> 00:08:33,970
¿Vale?

139
00:08:34,149 --> 00:08:38,870
Luego copio todas las primeras cinco celdas en la nueva estructura.

140
00:08:39,769 --> 00:08:40,009
¿Vale?

141
00:08:40,250 --> 00:08:45,889
Me quedará una celda libre que será la que utilizo para añadir el nuevo elemento.

142
00:08:46,490 --> 00:08:54,690
Y a este punto, usando esta cosa de aquí, hago que x, en vez de apuntar a la verde, apunte a la azul.

143
00:08:57,580 --> 00:09:01,480
Y entonces ahora tengo que x apunta a la nueva estructura más grande.

144
00:09:02,200 --> 00:09:03,720
Ya está. Encantado de la vida.

145
00:09:05,519 --> 00:09:14,200
¿Qué pasa con esta estructura de aquí, que antes era referenciada por x y ahora no hay una variable que referencie esta estructura?

146
00:09:16,940 --> 00:09:17,960
¿Entendéis el problema?

147
00:09:20,779 --> 00:09:36,750
yo tengo yo tengo una variable x que tiene dentro una referencia a un objeto así vale lo que hago

148
00:09:36,750 --> 00:09:44,789
es crear una estructura y que apunte a una celda más grande ya una red más grande copio todo lo

149
00:09:44,789 --> 00:09:50,950
que estaba aquí en la parte de arriba lo copio aquí abajo sé que había 1 2 y 3 aquí copio 1 2

150
00:09:50,950 --> 00:10:00,250
y 3, me sobra un hueco. A este punto, haciendo que x es igual a y, lo que estoy haciendo es,

151
00:10:00,250 --> 00:10:06,370
borrando esta cosa de aquí y diciendo que x es igual a lo que apunta y, estoy precisamente

152
00:10:06,370 --> 00:10:17,750
copiando esto aquí dentro. ¿Vale? Y entonces, ahora, x es el nuevo objeto, tiene una celda

153
00:10:17,750 --> 00:10:19,830
libre, fenomenal, he logrado lo que quería yo,

154
00:10:20,149 --> 00:10:21,789
pero la pregunta es, ¿qué pasa

155
00:10:21,789 --> 00:10:25,639
con esto? Porque esto ocupa

156
00:10:25,639 --> 00:10:26,080
memoria.

157
00:10:27,899 --> 00:10:29,580
O sea, sí que lo ha guardado, pero ya no lo hace caso.

158
00:10:29,899 --> 00:10:31,860
Claro, pero ¿yo quiero

159
00:10:31,860 --> 00:10:33,379
que se quede ahí en memoria?

160
00:10:34,159 --> 00:10:35,799
Pues no. El hecho

161
00:10:35,799 --> 00:10:37,759
es que Java, que es

162
00:10:37,759 --> 00:10:39,480
muy amigable desde esta perspectiva,

163
00:10:39,879 --> 00:10:41,279
si tiene un objeto

164
00:10:41,279 --> 00:10:44,240
al que nadie hace referencia,

165
00:10:44,240 --> 00:10:45,820
o sea, que no hay un

166
00:10:45,820 --> 00:10:48,240
handler, no hay un manejador, no hay una

167
00:10:48,240 --> 00:10:54,659
variable que apunta a este objeto, lo marca como que, oye mira, nadie puede acceder a este objeto,

168
00:10:54,659 --> 00:11:14,539
y cada cierto tiempo pasa un señor que se llama el Garbage Collector, que es el recolector de

169
00:11:14,539 --> 00:11:22,179
basura. El Garbage Collector es un procedimiento que hace la Java Virtual Machine, que es ir a

170
00:11:22,179 --> 00:11:29,120
mirar su memoria, mirar el IP, ver si hay objetos al que no se puede acceder porque no tienen

171
00:11:29,120 --> 00:11:36,700
referencias a ello y eso de allí lo quita, diciendo que ahora está memoria libre. El garbage collector

172
00:11:36,700 --> 00:11:47,259
nosotros no tenemos ningún modo de activarlo. Hay una función, system.gc, que lo que te dice es

173
00:11:47,259 --> 00:11:55,259
oye mira si puedes pasa el garbage collector pero será siempre la java virtual machine que decide

174
00:11:55,259 --> 00:12:06,379
cuándo ejecutar normalmente no se ejecuta a menos que no se tienen dos casos o no tengo nada que

175
00:12:06,379 --> 00:12:10,879
hacer hay una parte del programa en que el programa se ha parado no tiene nada que hacer pues como

176
00:12:10,879 --> 00:12:15,259
tengo tiempo libre, procesador libre, pues lanzo el Garbage Collector y limpio un poco.

177
00:12:15,259 --> 00:12:22,220
O si necesito memoria. A mí se me había desequilibrado esta memoria, la he llenado con

178
00:12:22,220 --> 00:12:29,240
objetos, necesito más memoria, pasa un momento el Garbage Collector a ver si se vacía algo y tengo

179
00:12:29,240 --> 00:12:38,360
espacio para reposar. Pero es un proceso, es algo que hace la Llaverton Machine sola, sin que yo

180
00:12:38,360 --> 00:12:44,279
pueda interferir con él. Yo ni puedo solicitarlo, ni puedo garantizar que se ejecute, ni lo

181
00:12:44,279 --> 00:12:54,360
puedo ejecutar. En otros lenguajes de programación demoníacos e infernales, el garbage collector

182
00:12:54,360 --> 00:13:02,960
no existe. Y vosotros tenéis que gestionar la memoria. C++, típicamente los C, necesitan

183
00:13:02,960 --> 00:13:09,899
tanto alocar la memoria como desalojarla, o sea, tú cuando creas un objeto le dices

184
00:13:09,899 --> 00:13:15,820
oye mira necesito este espacio, él te da ese espacio y cuando ya no lo usas más dices

185
00:13:15,820 --> 00:13:24,019
este espacio libéralo, si tú se te olvida liberarlo, pues creas lo que se llama un memory

186
00:13:24,019 --> 00:13:29,820
leak, vale, o sea que tu programa mientras funciona crea objetos que luego no se destruyen

187
00:13:29,820 --> 00:13:35,259
Y por lo tanto, el tamaño en memoria crece y crece y crece hasta que llega el momento

188
00:13:35,259 --> 00:13:39,480
en que tienes demasiados objetos allí y tu programa colapsa.

189
00:13:41,580 --> 00:13:43,960
Java es bueno desde esta perspectiva.

190
00:13:44,500 --> 00:13:47,940
Nosotros ni pedimos memoria ni la quitamos.

191
00:13:49,080 --> 00:13:50,799
Lo hace toda la Java de Tomasch.

192
00:13:51,980 --> 00:13:55,419
Y es un infierno gestionar la memoria.

193
00:13:56,940 --> 00:13:57,220
¿Dudas?

194
00:13:57,220 --> 00:14:10,990
Entonces, vamos a verlo aquí. Imaginámonos que yo tenga un array de enteros, porque es

195
00:14:10,990 --> 00:14:23,720
el más fácil. Aquí. Que es esta cosa aquí. Uno, dos y tres. Y que ahora diga, oye, quiero

196
00:14:23,720 --> 00:14:30,080
insertar un nuevo valor. Tengo int nuevo, que es cuatro. Y lo tengo que insertar en

197
00:14:30,080 --> 00:14:38,360
este array? No puedo. Entonces lo que hago es, necesito que este objeto aquí, porque

198
00:14:38,360 --> 00:14:46,960
luego al final yo lo que quiero hacer es iso ar, perdón, esto sería a raíz de punto

199
00:14:46,960 --> 00:14:56,539
toString de ar, y lo que quiero es ver todos los valores que he metido, 1, 2, 3, y también

200
00:14:56,539 --> 00:15:14,159
este 4 entonces como lo hago pues para hacer esto necesito un nuevo array que será grande como el

201
00:15:14,159 --> 00:15:24,340
array viejo pero un poco más esto por ejemplo es una posición más grande si aquí pusiera por

202
00:15:24,340 --> 00:15:37,000
2 lo que haría es aumentar el tamaño de este array por 2. Ahora, yo tengo dos arrays. Este

203
00:15:37,000 --> 00:15:47,620
que tiene dentro 1, 2 y 3 y este que tiene cuatro posiciones pero está vacío. Lo escribimos. Arrays.tostring

204
00:15:47,620 --> 00:16:09,529
y también que estáis clicando me explica y que estoy clicando que estáis así nuevo

205
00:16:09,529 --> 00:16:15,350
art entonces aquí veremos que esto tiene una posibilidad tres posiciones con escrito

206
00:16:15,350 --> 00:16:17,909
1 2 3 y este de aquí tiene nada

207
00:16:17,909 --> 00:16:30,820
Esto tiene 1, 2 y 3. Esto tiene 4 posiciones con ceros dentro, porque int, si yo no le digo qué es, me pone un cero en automático.

208
00:16:32,539 --> 00:16:38,500
Ahora, lo que voy a hacer es copiar este señor aquí dentro.

209
00:16:38,500 --> 00:17:04,140
Entonces, for inti es igual a cero y menor que r.length y más más, dentro de nuevo array en la posición i, vas a copiar lo que estaba en array en la posición i.

210
00:17:06,500 --> 00:17:06,920
¿Entiende?

211
00:17:06,920 --> 00:17:10,940
después de todo este proceso

212
00:17:10,940 --> 00:17:13,480
si yo escribo

213
00:17:13,480 --> 00:17:13,960
al

214
00:17:13,960 --> 00:17:16,180
el nuevo rey

215
00:17:16,180 --> 00:17:18,420
vamos con un inciso

216
00:17:18,420 --> 00:17:21,960
una separación

217
00:17:21,960 --> 00:17:34,839
cada vez que los escribo

218
00:17:34,839 --> 00:17:37,000
pongo un número distinto para que se vea

219
00:17:37,000 --> 00:17:38,079
que estoy escribiendo

220
00:17:38,079 --> 00:17:41,220
y aquí esto será el final

221
00:17:41,220 --> 00:17:44,119
entonces

222
00:17:44,119 --> 00:17:46,619
si yo ahora miro y lanzo

223
00:17:46,619 --> 00:17:51,180
En la primera tenía esto con 1, 2, 3 y este de aquí con todo vacío.

224
00:17:52,380 --> 00:17:56,220
Ahora tengo 1, 2, 3 y he copiado 1, 2, 3.

225
00:17:57,099 --> 00:18:04,319
Pero fijaos que ar, esto, sigue siendo una referencia al viejo, al de 3.

226
00:18:06,539 --> 00:18:14,559
Ahora que he creado esto nueva rey, lo que puedo hacer es decir que ar

227
00:18:14,559 --> 00:18:17,000
es igual a nuevaRey.

228
00:18:22,849 --> 00:18:25,349
Esta cosa, lo que me hace es, vale,

229
00:18:25,430 --> 00:18:28,009
la referencia a este objeto de aquí, la pierdo,

230
00:18:28,569 --> 00:18:31,049
y la sustituyo con la referencia a este objeto de aquí,

231
00:18:31,150 --> 00:18:32,309
que ahora es este objeto de aquí.

232
00:18:33,329 --> 00:18:34,670
Por lo tanto, ahora ar,

233
00:18:35,670 --> 00:18:37,789
en la opción 3,

234
00:18:38,829 --> 00:18:40,690
cuando lo escribo, ¿qué me espero de ver?

235
00:18:43,259 --> 00:18:44,299
¿Qué veré aquí?

236
00:18:45,960 --> 00:18:49,000
Lo mismo, dos veces esta cosa de aquí.

237
00:18:49,000 --> 00:18:58,190
Es que en el 3 ya los dos están apuntando al mismo objeto.

238
00:18:58,609 --> 00:19:11,910
Fijaos que si yo ahora cambio 1, por ejemplo, a ar de 3 le pongo el nuevo valor, el que tenía que añadir, este de aquí, ¿os acordáis?

239
00:19:11,910 --> 00:19:17,369
Pues y ahora reescribo los dos

240
00:19:17,369 --> 00:19:27,490
Fijaos que he cambiado solo ar

241
00:19:27,490 --> 00:19:31,410
Nuevo ar no lo he tocado

242
00:19:31,410 --> 00:19:35,210
Pero si yo lo lanzo

243
00:19:35,210 --> 00:19:36,809
En el 4

244
00:19:36,809 --> 00:19:40,730
¿Veis que el 4 se ha añadido tanto en ar como en nuevo ar?

245
00:19:43,789 --> 00:19:44,109
¿Lo veis?

246
00:19:45,970 --> 00:19:46,849
¿Por qué?

247
00:19:46,849 --> 00:19:50,210
Porque ahora estas son dos referencias

248
00:19:50,210 --> 00:19:52,089
al mismo objeto

249
00:19:52,089 --> 00:19:53,730
los cambios que hago aquí

250
00:19:53,730 --> 00:19:55,349
se verán reflejados aquí

251
00:19:55,349 --> 00:19:58,589
y ahora yo

252
00:19:58,589 --> 00:19:59,809
el nuevo ar

253
00:19:59,809 --> 00:20:01,329
esta variable de aquí

254
00:20:01,329 --> 00:20:02,849
me puedo olvidar de ella

255
00:20:02,849 --> 00:20:05,670
y seguir adelante trabajando con ar

256
00:20:05,670 --> 00:20:09,390
¿entiendes?

257
00:20:11,329 --> 00:20:11,569
si

258
00:20:11,569 --> 00:20:14,009
lo que estoy entendiendo es que

259
00:20:14,009 --> 00:20:15,630
estás copiando

260
00:20:15,630 --> 00:20:18,029
la referencia

261
00:20:18,029 --> 00:20:18,910
en la otra

262
00:20:18,910 --> 00:20:22,029
no tiene la misma referencia

263
00:20:22,029 --> 00:20:31,829
Lo que estamos haciendo es prácticamente la misma cosa entre variables normales,

264
00:20:31,829 --> 00:20:38,829
solo que cuando tú tienes a y b, que son este 7 y este 5,

265
00:20:39,690 --> 00:20:45,650
tú lo que estás haciendo, si haces a es igual a b, lo que estás haciendo es copiar esto aquí dentro.

266
00:20:45,650 --> 00:20:49,210
cuando trabajas con objetos

267
00:20:49,210 --> 00:20:51,089
al hacer x es igual a y

268
00:20:51,089 --> 00:20:52,809
no estás copiando

269
00:20:52,809 --> 00:20:55,049
el objeto, estás copiando

270
00:20:55,049 --> 00:20:56,289
esta referencia

271
00:20:56,289 --> 00:20:58,910
la copias aquí y entonces

272
00:20:58,910 --> 00:21:01,069
ahora este tiene la misma referencia

273
00:21:01,069 --> 00:21:01,829
va aquí también

274
00:21:01,829 --> 00:21:13,710
entonces vamos a hacer

275
00:21:13,710 --> 00:21:14,670
un ejercicito

276
00:21:14,670 --> 00:21:16,289
10 minutos

277
00:21:16,289 --> 00:21:20,789
el que os había dicho antes

278
00:21:20,789 --> 00:21:24,579
esto será 6

279
00:21:24,579 --> 00:21:35,099
Entonces, este me dice

280
00:21:35,099 --> 00:21:37,259
voy a leer números infinitos

281
00:21:37,259 --> 00:21:39,299
desde teclado, ¿vale?

282
00:21:41,299 --> 00:21:43,400
Dame números

283
00:21:43,400 --> 00:21:46,960
Lo pondremos después

284
00:21:46,960 --> 00:21:49,180
Scanner

285
00:21:49,180 --> 00:21:51,339
scan es igual

286
00:21:51,339 --> 00:21:52,839
a new scanner

287
00:21:52,839 --> 00:21:58,670
de System.it

288
00:21:58,670 --> 00:22:03,170
Yo voy a leer números infinitos, números infinitos, números infinitos

289
00:22:03,170 --> 00:22:07,369
hasta que el usuario me ponga un cero. Si el usuario me pone un cero

290
00:22:07,369 --> 00:22:10,849
asumo que ha acabado y que quiere que haga lo que haga.

291
00:22:10,849 --> 00:22:12,569
Y lo que quiero hacer es

292
00:22:12,569 --> 00:22:18,910
lo dejo sencillo, escribir todos los números que me has puesto

293
00:22:18,910 --> 00:22:19,730
pero en pantalla.

294
00:22:19,730 --> 00:22:23,690
Me das números, me das números

295
00:22:23,690 --> 00:22:26,130
Cuando pones cero yo te escribo todos los números

296
00:22:26,130 --> 00:22:26,869
Que me has dado tú

297
00:22:26,869 --> 00:22:28,970
Pero no hay un límite

298
00:22:28,970 --> 00:22:30,829
Si tú sigues dándome números

299
00:22:30,829 --> 00:22:32,109
Yo sigo dándome números

300
00:22:32,109 --> 00:22:33,769
Entonces

301
00:22:33,769 --> 00:22:36,569
Empezamos con

302
00:22:36,569 --> 00:22:38,549
Int

303
00:22:38,549 --> 00:22:40,869
Números

304
00:22:40,869 --> 00:22:42,970
Es igual a

305
00:22:42,970 --> 00:22:43,269
Int

306
00:22:43,269 --> 00:22:47,069
De cero

307
00:22:47,069 --> 00:22:51,579
Esto es una array sin celdas

308
00:22:51,579 --> 00:22:54,200
¿De acuerdo?

309
00:22:55,220 --> 00:22:56,779
Entonces, mi idea es

310
00:22:56,779 --> 00:22:59,160
Cada vez que me ponen un nuevo número

311
00:22:59,160 --> 00:23:00,779
Yo lo que hago es

312
00:23:00,779 --> 00:23:01,960
Aumentar una celda

313
00:23:01,960 --> 00:23:03,880
Ponerlo dentro de este array

314
00:23:03,880 --> 00:23:07,039
Y asociar números a este nuevo array

315
00:23:07,039 --> 00:23:07,940
¿Vale?

316
00:23:08,000 --> 00:23:09,279
Cada vez que me dan un número

317
00:23:09,279 --> 00:23:12,559
Yo creo un nuevo array un poquito más grande

318
00:23:12,559 --> 00:23:13,259
¿Sí?

319
00:23:13,640 --> 00:23:16,559
Empiezo por cero porque no me han dado valores

320
00:23:16,559 --> 00:23:18,200
Mientras que no me han dado valores

321
00:23:18,200 --> 00:23:19,819
Pues, ya está

322
00:23:19,819 --> 00:23:22,559
Y yo sé, cada vez que cuando me dan

323
00:23:22,559 --> 00:23:29,279
un valor nuevo no cabe en el array anterior. Solo me dan un 1 y yo sé que hay 0 plazas. Por lo tanto

324
00:23:29,279 --> 00:23:33,720
lo tengo que extender. Cuando me darán 2 había una plaza sola. Entonces siempre lo extendo. Luego ya

325
00:23:33,720 --> 00:23:39,960
mañana, no, el viernes vemos si mejoramos esta cosa. Yo sé que esto lo tengo que hacer siempre.

326
00:23:39,960 --> 00:23:57,920
Entonces lo que hago es, CISO. Ya lo tengo. Dame un número y aquí tengo dos opciones. O es 0 o es

327
00:23:57,920 --> 00:24:10,039
es un número distinto a cero. Si es cero, he acabado. ¿Sí? Entonces, si, ah, lo leo aquí, int, nuevo, o valor,

328
00:24:10,039 --> 00:24:29,079
val, es igual a scan.nextInt. Leo el nuevo valor. Si val es distinto de cero, hago algo. Si no, he acabado.

329
00:24:29,079 --> 00:24:35,109
esta es más o menos la plana

330
00:24:35,109 --> 00:24:37,089
ahora, esta cosa de aquí

331
00:24:37,089 --> 00:24:38,690
pero no la hago una vez sola

332
00:24:38,690 --> 00:24:40,750
la hago mogollón de veces

333
00:24:40,750 --> 00:24:45,130
entonces, ¿cómo hago para que

334
00:24:45,130 --> 00:24:46,750
esto se haga muchas veces?

335
00:24:48,670 --> 00:24:49,069
huile

336
00:24:49,069 --> 00:24:50,289
ozor

337
00:24:50,289 --> 00:24:53,670
¿por qué huile?

338
00:24:53,670 --> 00:24:55,910
porque no tengo

339
00:24:55,910 --> 00:24:57,970
idea de cuántas veces lo voy a hacer

340
00:24:57,970 --> 00:24:58,950
¿vale?

341
00:24:59,349 --> 00:25:00,970
es, mientras

342
00:25:00,970 --> 00:25:02,710
val

343
00:25:02,710 --> 00:25:05,869
sea distinto

344
00:25:05,869 --> 00:25:08,589
de cero,

345
00:25:10,069 --> 00:25:11,390
trabaja, trabaja, trabaja,

346
00:25:11,450 --> 00:25:12,470
trabaja. ¿Vale?

347
00:25:16,519 --> 00:25:18,299
Entonces, cuidado, pero

348
00:25:18,299 --> 00:25:20,480
este valor yo lo estoy pidiendo aquí.

349
00:25:21,579 --> 00:25:22,460
¿Sí? Entonces

350
00:25:22,460 --> 00:25:24,579
necesitaré una primera

351
00:25:24,579 --> 00:25:26,319
vez pedirlo

352
00:25:26,319 --> 00:25:26,799
fuera.

353
00:25:29,259 --> 00:25:30,460
Yo empiezo.

354
00:25:30,920 --> 00:25:32,400
Te digo, oye, mira,

355
00:25:32,700 --> 00:25:34,319
porque esto sería más un Dubai, pero

356
00:25:34,319 --> 00:25:36,240
yo leo el primer número

357
00:25:36,240 --> 00:25:38,059
que este número es cero

358
00:25:38,059 --> 00:25:40,380
pues aquí dentro no entraré nunca

359
00:25:40,380 --> 00:25:42,200
y llego directamente aquí al final

360
00:25:42,200 --> 00:25:43,720
aquí en la parte final

361
00:25:43,720 --> 00:25:48,740
si tú el primer número que me das es un cero

362
00:25:48,740 --> 00:25:50,460
yo no entraré nunca

363
00:25:50,460 --> 00:25:52,500
en este while y se acabó

364
00:25:52,500 --> 00:25:53,319
ya he acabado

365
00:25:53,319 --> 00:25:55,640
si en vez

366
00:25:55,640 --> 00:25:58,339
no es cero

367
00:25:58,339 --> 00:26:00,039
sí que entraré aquí dentro

368
00:26:00,039 --> 00:26:01,519
pero en vez de pedir

369
00:26:01,519 --> 00:26:03,700
directamente un nuevo valor

370
00:26:03,700 --> 00:26:07,019
haré esta cosa de aquí

371
00:26:07,019 --> 00:26:08,160
ahora veremos que

372
00:26:08,160 --> 00:26:10,859
y luego pido un nuevo valor

373
00:26:10,859 --> 00:26:14,319
ahora este if

374
00:26:14,319 --> 00:26:16,200
ya no me hace falta

375
00:26:16,200 --> 00:26:18,559
¿por qué? porque me lo está haciendo esto

376
00:26:18,559 --> 00:26:20,819
mientras que esta cosa

377
00:26:20,819 --> 00:26:21,720
sea verdadera

378
00:26:21,720 --> 00:26:23,519
pues entonces entra aquí dentro

379
00:26:23,519 --> 00:26:25,880
entonces si yo entro aquí dentro

380
00:26:25,880 --> 00:26:28,519
lo que tengo que hacer es almacenar el nuevo valor

381
00:26:28,519 --> 00:26:30,259
tengo en valor un nuevo valor

382
00:26:30,259 --> 00:26:31,339
lo almaceno

383
00:26:31,339 --> 00:26:34,019
y luego pido el valor siguiente

384
00:26:34,019 --> 00:26:35,279
y vuelvo aquí.

385
00:26:36,059 --> 00:26:38,240
Esto es como un do while hecho un poquito raro.

386
00:26:39,460 --> 00:26:39,579
¿Sí?

387
00:26:40,460 --> 00:26:41,420
Vale. Entonces,

388
00:26:42,000 --> 00:26:44,240
me han dado un valor. Este valor no es

389
00:26:44,240 --> 00:26:44,500
cero.

390
00:26:45,559 --> 00:26:48,140
Lo almaceno. Para almacenar lo que tengo

391
00:26:48,140 --> 00:26:50,099
que hacer, tengo que crear

392
00:26:50,099 --> 00:26:51,859
un array más grande.

393
00:26:52,720 --> 00:26:53,700
¿Vale? Entonces,

394
00:26:53,980 --> 00:26:54,400
int

395
00:26:54,400 --> 00:26:56,279
array

396
00:26:56,279 --> 00:26:59,759
más grande

397
00:26:59,759 --> 00:27:02,599
es igual a

398
00:27:02,599 --> 00:27:04,960
new int

399
00:27:04,960 --> 00:27:06,740
de números

400
00:27:06,740 --> 00:27:08,980
punto length

401
00:27:08,980 --> 00:27:11,220
que sería 0

402
00:27:11,220 --> 00:27:12,339
en este caso al principio

403
00:27:12,339 --> 00:27:13,279
más 1

404
00:27:13,279 --> 00:27:16,079
luego lo copio

405
00:27:16,079 --> 00:27:19,359
por int y es igual a

406
00:27:19,359 --> 00:27:21,220
0 y menor que

407
00:27:21,220 --> 00:27:23,319
números

408
00:27:23,319 --> 00:27:24,619
punto length

409
00:27:24,619 --> 00:27:26,240
y más más

410
00:27:26,240 --> 00:27:28,779
por todas las casillas de

411
00:27:28,779 --> 00:27:31,039
números que podrían ser cero

412
00:27:31,039 --> 00:27:32,500
y por lo tanto esto no lo hago

413
00:27:32,500 --> 00:27:33,259
¿vale? pero

414
00:27:33,259 --> 00:27:37,160
lo que hago es copiar dentro de más grande

415
00:27:37,160 --> 00:27:38,240
de i

416
00:27:38,240 --> 00:27:40,680
lo que hay

417
00:27:40,680 --> 00:27:42,099
en números

418
00:27:42,099 --> 00:27:46,829
de i ¿de acuerdo?

419
00:27:47,849 --> 00:27:49,269
y cuando he acabado

420
00:27:49,269 --> 00:27:50,289
de copiarlo

421
00:27:50,289 --> 00:27:53,009
lo que hago es primero que

422
00:27:53,009 --> 00:27:55,250
números es igual a más grande

423
00:27:55,250 --> 00:27:57,069
y aquí he

424
00:27:57,069 --> 00:27:58,410
completado la copia

425
00:27:58,410 --> 00:28:01,009
he completado el agrandamiento de números

426
00:28:01,009 --> 00:28:02,990
he pillado lo que había

427
00:28:02,990 --> 00:28:04,369
le he añadido una casilla

428
00:28:04,369 --> 00:28:07,210
he metido la referencia a este nuevo objeto

429
00:28:07,210 --> 00:28:09,069
por lo tanto ahora ya números

430
00:28:09,069 --> 00:28:11,170
tiene una celda más

431
00:28:11,170 --> 00:28:13,210
y ahora en la última

432
00:28:13,210 --> 00:28:14,309
celda de números

433
00:28:14,309 --> 00:28:15,549
añado val

434
00:28:15,549 --> 00:28:19,410
¿cómo accedo a la última casilla de números?

435
00:28:24,250 --> 00:28:24,930
números

436
00:28:24,930 --> 00:28:26,609
punto length

437
00:28:26,609 --> 00:28:28,069
menos 1

438
00:28:28,069 --> 00:28:30,569
es igual a val

439
00:28:30,569 --> 00:28:33,859
entonces

440
00:28:33,859 --> 00:28:36,559
me han dicho que tengo un nuevo valor

441
00:28:36,559 --> 00:28:50,819
Vale, perfecto. Entonces me creo una cosa más grande, copio todo lo que tenía antes, asocio la referencia al nuevo objeto más grande, al nuevo array más grande y en su última posición le pongo el valor nuevo que me han puesto.

442
00:28:51,420 --> 00:28:53,380
Y ahora pido otro número.

443
00:28:54,680 --> 00:28:58,619
Si este número será distinto de cero, volveré a hacer esto.

444
00:29:00,819 --> 00:29:06,660
Si este número es igual a cero, llego aquí, salgo y llego a la parte final.

445
00:29:06,660 --> 00:29:08,740
Y en la parte final, ¿qué tengo que decir?

446
00:29:09,240 --> 00:29:09,799
Si eso

447
00:29:09,799 --> 00:29:12,900
Arraiza

448
00:29:12,900 --> 00:29:14,220
Punto toString

449
00:29:14,220 --> 00:29:15,779
De

450
00:29:15,779 --> 00:29:17,400
Número

451
00:29:17,400 --> 00:29:19,500
Fijaos

452
00:29:19,500 --> 00:29:21,279
Que este

453
00:29:21,279 --> 00:29:24,119
Esta variable de aquí

454
00:29:24,119 --> 00:29:26,839
Solo existe dentro del while

455
00:29:26,839 --> 00:29:27,779
¿Vale?

456
00:29:28,200 --> 00:29:29,599
Hasta que llega al final del while

457
00:29:29,599 --> 00:29:32,420
Cada ciclo, esta variable de aquí se destruye

458
00:29:32,420 --> 00:29:34,460
Porque no me interesa esta variable de aquí

459
00:29:34,460 --> 00:29:35,740
La que me interesa es esta

460
00:29:35,740 --> 00:29:38,019
es esta que me llevo delante

461
00:29:38,019 --> 00:29:39,960
cuando he pasado

462
00:29:39,960 --> 00:29:42,019
este while, más grande

463
00:29:42,019 --> 00:29:43,900
no existe, existe solo

464
00:29:43,900 --> 00:29:45,779
números, y en cada

465
00:29:45,779 --> 00:29:47,480
ciclo del while más grande

466
00:29:47,480 --> 00:29:49,940
apuntará a una nueva estructura

467
00:29:49,940 --> 00:29:51,200
más grande que la anterior

468
00:29:51,200 --> 00:29:54,119
y al final yo haré el cambio, que el número se apunte

469
00:29:54,119 --> 00:29:55,059
a esta nueva estructura

470
00:29:55,059 --> 00:29:57,019
y más grande ya no me interesa

471
00:30:05,740 --> 00:30:15,980
esta x en el de antes. Esta aquí sería x. Le cambio la referencia a este de aquí, que era la

472
00:30:15,980 --> 00:30:21,779
que tenía antes, ahora se lo cambio de nuevo. Mientras y es la que se crea dentro del while,

473
00:30:21,779 --> 00:30:27,039
pero luego no me sirve de nada. Esto lo puedo quitar y a mí lo que me interesa es mantenerme

474
00:30:27,039 --> 00:30:34,000
x, porque al final lo que voy a escribir es números, no más grandes. En este caso,

475
00:30:34,000 --> 00:30:36,619
seguir trabajando con la primera referencia

476
00:30:36,619 --> 00:30:38,160
por lo tanto, mejor en el caso de que

477
00:30:38,160 --> 00:30:40,559
digamos... O sea, que yo quiera copias

478
00:30:40,559 --> 00:30:42,059
y cosas por el estilo. Se puede, ¿no? O sea,

479
00:30:42,700 --> 00:30:44,640
depende del ejercicio. Depende de lo que

480
00:30:44,640 --> 00:30:46,519
quieres hacer. Entonces, ahora yo tengo

481
00:30:46,519 --> 00:30:48,380
el ejercicio, fijaos que

482
00:30:48,380 --> 00:30:50,700
no sé cuántos números voy a poner,

483
00:30:51,099 --> 00:30:52,559
puedo poner cuántos números me da

484
00:30:52,559 --> 00:30:54,440
la gana, esto no me limita,

485
00:30:55,140 --> 00:30:56,359
yo sigo dando números

486
00:30:56,359 --> 00:30:58,440
y él no me ha dicho, ah, no, te podías dar

487
00:30:58,440 --> 00:31:00,339
solo tres números, no. Cuando

488
00:31:00,339 --> 00:31:02,519
pongo un cero, se acaba

489
00:31:02,519 --> 00:31:04,640
y me escribe todos los números

490
00:31:04,640 --> 00:31:06,359
que yo le he puesto hasta ahora.

491
00:31:10,019 --> 00:31:11,140
Si yo lo lanzo

492
00:31:11,140 --> 00:31:13,160
y pongo cero al primero,

493
00:31:14,000 --> 00:31:14,880
es una red vacía.

494
00:31:14,880 --> 00:31:16,880
¡Uy!