1
00:00:00,690 --> 00:00:06,690
Voy a grabar esta clase, por lo tanto, si habláis, me dais vuestro consentimiento a hablar, a grabar.

2
00:00:07,190 --> 00:00:11,330
Vale, entonces, ahora lo que vamos a ver es el concepto de copiar un array, ¿vale?

3
00:00:12,650 --> 00:00:19,929
Imaginámonos que yo tenga este array, string, corchetes x, es igual a un array, ¿vale?

4
00:00:19,929 --> 00:00:27,190
Y que ahora cree un nuevo array, string, corchetes y, es igual a x, ¿sí?

5
00:00:27,190 --> 00:00:37,509
Y ahora me voy a X en posición 3, 0, 1, 2, 3, y cambio este señor con 7.

6
00:00:38,609 --> 00:00:42,609
¿Qué pasa si ahora miro Y de 3?

7
00:00:44,130 --> 00:00:49,310
Pues lo que pasa es que también Y de 3 ha cambiado a 7.

8
00:00:50,289 --> 00:00:51,250
¿Por qué?

9
00:00:51,250 --> 00:01:08,750
Porque cuando yo creo un array, la X es como con los strings más o menos, no es un tipo primitivo, es un objeto, entonces aquí dentro no hay el valor directamente,

10
00:01:08,750 --> 00:01:20,409
Pero hay un puntero, el famoso que luego hace null pointer exception, un puntero, una zona de memoria en el que está este array.

11
00:01:20,769 --> 00:01:30,010
Aquí lo tenemos. Este x no es el array, es una flecha hacia una zona de memoria en la que está el array.

12
00:01:30,010 --> 00:01:39,030
¿Sí? Ahora, cuando hago esta operación de aquí, string y es igual a x, no estoy copiando la memoria

13
00:01:39,030 --> 00:01:46,849
No estoy copiando el array, pero estoy creando un nuevo y que apunta a la misma zona de memoria

14
00:01:46,849 --> 00:01:58,599
Entonces, estos no son dos arrays distintos, pero son el mismo array referenciado por dos variables distintas

15
00:01:58,599 --> 00:02:03,000
Tengo dos variables que apuntan al mismo objeto

16
00:02:03,000 --> 00:02:09,090
Es lo que estamos viendo

17
00:02:09,090 --> 00:02:13,969
Entonces, si ahora el puntero X en posición 3

18
00:02:13,969 --> 00:02:17,030
Cambia el interno a 7

19
00:02:17,030 --> 00:02:19,189
O sea, el puntero X llega a esto

20
00:02:19,189 --> 00:02:22,569
Vas a la zona 3 y modifica este 4

21
00:02:22,569 --> 00:02:23,909
Y escribe 7

22
00:02:23,909 --> 00:02:26,009
Lo está modificando en el array

23
00:02:26,009 --> 00:02:29,069
Lo que quiere decir que Y de 3

24
00:02:29,069 --> 00:02:32,569
También contendrá 7

25
00:02:32,569 --> 00:02:52,830
O sea que los arrays no se copian así, un int se copia así, int x es igual a 3, int y es igual a x, he creado dos zonas de memoria separadas, los tres valen 3, si cambio x, no cambio y.

26
00:02:52,830 --> 00:03:17,860
Ahora voy, ¿eh? Con enteros. Si yo hago int x es igual a 3, creo una zona de memoria que tiene solo int, que se llama x y que tiene dentro 3.

27
00:03:17,860 --> 00:03:22,840
ahora hago int, y es igual a x

28
00:03:22,840 --> 00:03:26,659
lo que estoy haciendo es crearme otra zona de memoria

29
00:03:26,659 --> 00:03:29,960
que se llama y, que contiene int

30
00:03:29,960 --> 00:03:33,639
y que tendrá aquí dentro el valor actual de x, o sea 3

31
00:03:33,639 --> 00:03:37,680
si ahora hago x es igual a 7

32
00:03:37,680 --> 00:03:42,099
esto se machaca y se pone un 7

33
00:03:42,099 --> 00:03:47,990
y si ahora digo imprime y

34
00:03:47,990 --> 00:03:50,750
me imprimirá 3

35
00:03:50,750 --> 00:03:55,189
porque son dos trozos

36
00:03:55,189 --> 00:03:56,990
de memorias distintos

37
00:03:56,990 --> 00:03:58,270
¿se entiende esto?

38
00:03:59,530 --> 00:04:01,530
todos los tipos primitivos

39
00:04:01,530 --> 00:04:02,750
funcionan así

40
00:04:02,750 --> 00:04:05,490
int, float

41
00:04:05,490 --> 00:04:07,389
float, double

42
00:04:07,389 --> 00:04:09,250
char

43
00:04:09,250 --> 00:04:10,409
boolean

44
00:04:10,409 --> 00:04:11,409
así

45
00:04:11,409 --> 00:04:16,170
ahora, con los arrays

46
00:04:16,170 --> 00:04:17,550
es distinto

47
00:04:17,550 --> 00:04:20,470
cuando yo hago

48
00:04:20,470 --> 00:04:22,790
int

49
00:04:22,790 --> 00:04:24,769
array

50
00:04:24,769 --> 00:04:26,709
x

51
00:04:26,709 --> 00:04:28,910
es igual a algo

52
00:04:28,910 --> 00:04:31,069
lo que estoy haciendo es crearme

53
00:04:31,069 --> 00:04:33,029
una variable que se llama x

54
00:04:33,029 --> 00:04:34,550
de tipo

55
00:04:34,550 --> 00:04:37,310
no lo sé, de tipo puntero

56
00:04:37,310 --> 00:04:39,209
¿vale? que en realidad

57
00:04:39,209 --> 00:04:41,209
lo que tiene es un puntero

58
00:04:41,209 --> 00:04:42,370
a una zona de memoria

59
00:04:42,370 --> 00:04:44,410
y en esta zona de memoria

60
00:04:44,410 --> 00:04:45,649
está mi array

61
00:04:45,649 --> 00:04:49,079
con sus posiciones

62
00:04:49,079 --> 00:04:51,720
0, 1, 2 y 3

63
00:04:51,720 --> 00:04:55,209
cuando hago int

64
00:04:55,209 --> 00:04:58,009
esta cosa aquí

65
00:04:58,009 --> 00:05:00,569
y es igual a x

66
00:05:00,569 --> 00:05:03,610
me creo también otro trozo de memoria

67
00:05:03,610 --> 00:05:05,189
de tipo que se yo

68
00:05:05,189 --> 00:05:07,689
que se llama y

69
00:05:07,689 --> 00:05:11,350
y lo que tiene es el mismo valor que esto

70
00:05:11,350 --> 00:05:13,850
y el mismo valor de esto es el mismo puntero

71
00:05:13,850 --> 00:05:14,990
de la misma zona de memoria

72
00:05:14,990 --> 00:05:17,470
¿se entiende?

73
00:05:18,209 --> 00:05:20,470
entonces cuando ahora hago x

74
00:05:20,470 --> 00:05:24,350
de 1 es igual a 9

75
00:05:24,350 --> 00:05:28,009
quiere decir que pongo 9 aquí dentro

76
00:05:28,009 --> 00:05:32,180
y cuando ahora hago siso

77
00:05:32,180 --> 00:05:36,779
de y de 1

78
00:05:36,779 --> 00:05:43,350
y apunta esta cosa aquí, voy a la 1

79
00:05:43,350 --> 00:05:48,629
y escribo 9, ¿se entiende?

80
00:05:48,629 --> 00:05:52,069
o sea que, repito

81
00:05:52,069 --> 00:05:56,310
los arrays no se copian así

82
00:05:56,310 --> 00:05:58,670
Esto no copia array

83
00:05:58,670 --> 00:06:01,990
Esto hace dos referencias al mismo array

84
00:06:01,990 --> 00:06:08,220
Por ejemplo, me puede servir para recorrer el array de dos formas distintas

85
00:06:08,220 --> 00:06:08,740
No lo sé

86
00:06:08,740 --> 00:06:12,699
Estoy dando dos nombres al mismo objeto

87
00:06:12,699 --> 00:06:15,279
Todos los objetos funcionan así

88
00:06:15,279 --> 00:06:17,720
Los objetos funcionan por referencia

89
00:06:17,720 --> 00:06:20,160
Los tipos primitivos funcionan por valor

90
00:06:20,160 --> 00:06:21,540
Por copia de valor

91
00:06:21,540 --> 00:06:25,750
¿Cómo duplicas un objeto?

92
00:06:25,750 --> 00:06:27,750
No tengo ni idea porque no sé qué es un objeto

93
00:06:27,750 --> 00:06:29,209
¿Qué es un objeto? Ni idea

94
00:06:29,209 --> 00:06:44,870
Pero sí que sé que existen los arrays. Entonces, ¿cómo copio un array? Fíjate tú. Es lo que estamos viendo. Copia de un array. Lo que no se hace es copiarlo así. Esto no copia el array.

95
00:06:44,870 --> 00:06:53,589
¿Queda claro a todos que esto no es una copia del array? ¿Que estas dos cosas se quedan vinculadas entre ellas y si modifico uno estoy modificando también la otra?

96
00:06:53,990 --> 00:07:00,230
¿Porque las dos cosas no son separadas, son el mismo objeto referenciado por dos variables distintas?

97
00:07:04,420 --> 00:07:09,279
Esto será particularmente útil cuando en un futuro veremos lo que se llama el paso por referencia.

98
00:07:09,279 --> 00:07:12,899
Paso un parámetro a un método

99
00:07:12,899 --> 00:07:16,579
Y lo que hace el método sobre este objeto que le he pasado

100
00:07:16,579 --> 00:07:18,839
Se verá también en el método que lo llama

101
00:07:18,839 --> 00:07:22,769
Entonces, ¿cómo se hace?

102
00:07:23,350 --> 00:07:25,730
Pues lo que se hace es lo siguiente

103
00:07:25,730 --> 00:07:30,209
Para copiar un array

104
00:07:30,209 --> 00:07:35,389
Lo que tengo que hacer es crearme otro array del mismo tamaño

105
00:07:35,389 --> 00:07:40,610
Tengo mi array, creo otro array vacío del mismo tamaño

106
00:07:40,610 --> 00:07:49,709
Y a este punto, celda por celda, voy a copiar lo que estaba en el viejo array en el nuevo

107
00:07:49,709 --> 00:07:51,790
¿Cómo se hace?

108
00:07:52,370 --> 00:07:53,370
Tengo mi array

109
00:07:53,370 --> 00:07:55,470
Se ve algo

110
00:07:55,470 --> 00:07:59,339
Tengo mi array

111
00:07:59,339 --> 00:08:05,240
He perdido mi array

112
00:08:05,240 --> 00:08:06,180
Lo tenía

113
00:08:06,180 --> 00:08:08,220
Tengo mi array otra vez, tercera vez

114
00:08:08,220 --> 00:08:09,220
La tercera vez la vencía

115
00:08:09,220 --> 00:08:11,740
Creo un nuevo array

116
00:08:11,740 --> 00:08:12,720
Nuevo

117
00:08:12,720 --> 00:08:14,899
Este es un objeto distinto

118
00:08:14,899 --> 00:08:18,000
no son el mismo, de hecho esto tiene 1, 2, 3, 4, 5

119
00:08:18,000 --> 00:08:19,439
y este no tiene nada

120
00:08:19,439 --> 00:08:21,620
tendrá todo null dentro

121
00:08:21,620 --> 00:08:24,100
y ahora con un for

122
00:08:24,100 --> 00:08:25,579
voy a mirar

123
00:08:25,579 --> 00:08:28,040
todas las posiciones de este de aquí

124
00:08:28,040 --> 00:08:29,720
y lo que voy a hacer

125
00:08:29,720 --> 00:08:30,680
es copiármelo

126
00:08:30,680 --> 00:08:36,629
de hecho

127
00:08:36,629 --> 00:08:38,970
este de aquí no debería ser 5

128
00:08:38,970 --> 00:08:41,129
debería ser x.length

129
00:08:41,129 --> 00:08:45,330
me hago un array con los mismos números

130
00:08:45,330 --> 00:08:46,710
posiciones de este de aquí

131
00:08:46,710 --> 00:08:52,549
Luego recorro este array de aquí y cada uno de los elementos los copio en este nuevo elemento

132
00:08:52,549 --> 00:08:57,289
Gráficamente, me creo un array con varias cosas

133
00:08:57,289 --> 00:08:58,289
Vale, fenomenal

134
00:08:58,289 --> 00:09:02,549
Me creo un nuevo array Y de 5 posiciones

135
00:09:02,549 --> 00:09:04,830
Es este de aquí, veis que está vacío

136
00:09:04,830 --> 00:09:10,309
Y ahora empiezo desde Y0 hasta YX.length

137
00:09:10,309 --> 00:09:12,929
Y pillo 1 y lo copio aquí

138
00:09:12,929 --> 00:09:14,809
Pillo 2 y lo copio aquí

139
00:09:14,809 --> 00:09:16,570
Pillo 3 y lo copio aquí

140
00:09:16,570 --> 00:09:19,570
pillo 4, lo copio aquí, pillo 5, lo copio aquí

141
00:09:19,570 --> 00:09:22,490
y ahora tengo dos arrays que son

142
00:09:22,490 --> 00:09:25,070
dos posiciones de memoria completamente separadas

143
00:09:25,070 --> 00:09:27,110
que si modifico uno

144
00:09:27,110 --> 00:09:31,789
este de aquí, no se está modificando

145
00:09:31,789 --> 00:09:34,210
el otro, porque son completamente separados

146
00:09:34,210 --> 00:09:41,269
se ve

147
00:09:41,269 --> 00:09:46,549
si modifico uno, el otro se queda igual

148
00:09:46,549 --> 00:09:50,250
porque ahora los dos punteros no apuntan

149
00:09:50,250 --> 00:09:53,690
a la misma zona de memoria, entonces los cambios de uno se ven en el otro,

150
00:09:54,070 --> 00:09:57,330
sino a zonas de memoria distintas, entonces los cambios que hago aquí

151
00:09:57,330 --> 00:10:02,269
no se reflejarán aquí. A menos que no lo haga yo

152
00:10:02,269 --> 00:10:06,750
explícitamente. Si ahora yo hago un i de 3 igual a 7,

153
00:10:06,889 --> 00:10:11,149
pues modificará el otro. ¿Dudas?

154
00:10:12,210 --> 00:10:27,029
¿A raíz multidimensionales os interesan? ¿For? ¿Por qué?

155
00:10:27,549 --> 00:10:32,419
¿Por qué estáis aprendiendo los for? Hacedlo vosotros.

156
00:10:32,419 --> 00:10:37,460
¿Hay algunos métodos perdidos en el multiverso que me permiten copiar un array?

157
00:10:38,059 --> 00:10:38,659
Probablemente.

158
00:10:39,779 --> 00:10:45,360
Probablemente, porque no es una cosa que hemos inventado hoy en clase, sino que es una cosa que se usa bastante comúnmente.

159
00:10:45,960 --> 00:10:46,860
Por lo tanto, sí.

160
00:10:47,580 --> 00:10:49,100
¿Y cuándo lo usaréis vosotros?

161
00:10:49,840 --> 00:11:00,179
Pues esto vosotros lo usaréis cuando tendréis un array de cinco posiciones y el usuario os pone seis palabras.

162
00:11:00,179 --> 00:11:07,879
Pero no quiero hacer spoiler con lo divertido que es eso cuando lo encontrare