1
00:00:00,000 --> 00:00:11,000
Estoy grabando, por lo tanto, todo lo que digáis se grabará y me dais la autorización a que esto se grabe.

2
00:00:11,000 --> 00:00:17,000
Entonces, hoy vamos a ver rápidamente los Arrays. El concepto de Array no es difícil.

3
00:00:17,000 --> 00:00:26,000
Nos abre un mundo, porque gracias a los Arrays podemos hacer cosas mucho más complejas y mucho más impotentes,

4
00:00:27,000 --> 00:00:35,000
pero como concepto no es difícil. Luego hay que aprender a utilizarlos, ver cómo es la sintaxis, etc.

5
00:00:35,000 --> 00:00:40,000
Pero no es la cosa más difícil que haremos este año.

6
00:00:40,000 --> 00:00:48,000
Un Array Java es una estructura de datos que nos permite almacenar un conjunto de datos de un mismo tipo.

7
00:00:49,000 --> 00:00:54,000
Es una multivariable. ¿Os acordáis las variables que eran?

8
00:00:54,000 --> 00:01:02,000
Eran un cajón, un trozo de memoria, donde vosotros podíais poner dentro un valor.

9
00:01:02,000 --> 00:01:08,000
Ahora, la idea es que en vez de tener una variable, os recuerdo,

10
00:01:09,000 --> 00:01:18,000
esta era la variable, ¿no? Decíamos que la variable era un espacio de memoria, tenía un nombre, tenía un tipo, int.

11
00:01:20,000 --> 00:01:30,000
Ahora, en vez de hacer una cosa de ese estilo, lo que podemos hacer es una colección de variables del mismo tipo.

12
00:01:30,000 --> 00:01:37,000
Y decir que esto se llamará ArNombre.

13
00:01:37,000 --> 00:01:43,000
El nombre no es un intero, pero tendrá un nombre.

14
00:01:43,000 --> 00:01:46,000
Pero no que cada uno de estos valores tenga un nombre suyo.

15
00:01:46,000 --> 00:01:51,000
El nombre es uno solo. Serán todos interos.

16
00:01:51,000 --> 00:01:54,000
Por lo tanto, aquí dentro pueden ir solo interos.

17
00:01:55,000 --> 00:02:03,000
Y además, si yo puedo acceder a esta cosa de aquí, de la posición 0, yo tendré el valor que está aquí.

18
00:02:03,000 --> 00:02:08,000
O a esta cosa de aquí, de la posición 1, y tendré el valor que está aquí.

19
00:02:08,000 --> 00:02:18,000
O a esta cosa de aquí, de la posición 2, y accederé a este valor de aquí.

20
00:02:19,000 --> 00:02:24,000
¿Sí? Es decir, que es igual a una variable.

21
00:02:24,000 --> 00:02:27,000
Antes en una variable podía almacenar un solo valor.

22
00:02:27,000 --> 00:02:31,000
Ahora, en vez de tener un cajón, tengo una cajonera.

23
00:02:31,000 --> 00:02:37,000
Y dentro de esta cajonera puedo acceder al cajón 1, al cajón 2, al cajón 3, al cajón 4,

24
00:02:37,000 --> 00:02:41,000
siendo desde 0 el primero hasta el último, ¿vale?

25
00:02:41,000 --> 00:02:47,000
Todas se llamarán del mismo tipo, con el mismo nombre, pero en una cierta posición.

26
00:02:47,000 --> 00:02:49,000
De esa cajonera.

27
00:02:49,000 --> 00:02:58,000
Es la cajonera, número, edad, o ingresos, pero tendré ingresos de 0, y aquí dentro habrá un valor.

28
00:02:58,000 --> 00:03:01,000
Ingresos de 1, que allí dentro tendremos otro valor.

29
00:03:01,000 --> 00:03:04,000
Ingresos de 2, etcétera, etcétera, etcétera.

30
00:03:04,000 --> 00:03:06,000
¿Se entiende más o menos el concepto?

31
00:03:06,000 --> 00:03:09,000
¿Por qué esto es importante y potente? Lo veremos en los ejercicios.

32
00:03:09,000 --> 00:03:12,000
¿Vale? Por ahora, simplemente, la idea de un array es esto.

33
00:03:12,000 --> 00:03:16,000
Antes, una variable tenía un nombre, un int, y un valor solo.

34
00:03:16,000 --> 00:03:22,000
Ahora yo tengo un nombre, un tipo, y una serie de valores.

35
00:03:22,000 --> 00:03:24,000
En un cierto sentido.

36
00:03:24,000 --> 00:03:30,000
¿Sí? Vale. Siga.

37
00:03:30,000 --> 00:03:37,000
El tamaño de los arrays se declara en un primer momento, y no se puede cambiar en tiempo de ejecución.

38
00:03:37,000 --> 00:03:38,000
¿Vale?

39
00:03:38,000 --> 00:03:43,000
Es decir, cuando yo creo un array, y le digo, este array es de 10 posiciones.

40
00:03:43,000 --> 00:03:47,000
Si el array es de 10 posiciones, es de 10 posiciones.

41
00:03:47,000 --> 00:03:55,000
Si al tiempo de ejecución llega un momento en que necesito poner 11 valores,

42
00:03:55,000 --> 00:03:59,000
porque solo tengo 10 posiciones, pues tendré que hacer algo.

43
00:03:59,000 --> 00:04:02,000
Pero no puedo usar ese array.

44
00:04:02,000 --> 00:04:08,000
Ese array tiene 10 posiciones, no puede almacenar 11 valores.

45
00:04:08,000 --> 00:04:09,000
¿Qué hago?

46
00:04:09,000 --> 00:04:14,000
Pues me creo un nuevo array, que sea grande 20, lo copio, hago algo.

47
00:04:14,000 --> 00:04:15,000
¿Vale? Veremos.

48
00:04:15,000 --> 00:04:22,000
Pero el concepto es que, a tiempo de programación, yo elijo que voy a hacer este array

49
00:04:22,000 --> 00:04:25,000
donde voy a almacenar los ingresos de esta cuenta bancaria.

50
00:04:25,000 --> 00:04:27,000
¿Vale? ¿Cuántos ingresos hay? 100 ingresos.

51
00:04:27,000 --> 00:04:29,000
¿Vale? Puede haber máximo 100 ingresos.

52
00:04:29,000 --> 00:04:34,000
Y una vez que yo he puesto estos 100 ingresos, estos 100 ingresos no se pueden modificar.

53
00:04:34,000 --> 00:04:38,000
Este array es de 100 posiciones.

54
00:04:38,000 --> 00:04:43,000
Entonces, aplicándolo a los ejercicios anteriores, por ejemplo el COUNTA2,

55
00:04:43,000 --> 00:04:45,000
¿lo podría hacer con un array?

56
00:04:45,000 --> 00:04:49,000
Sí. Por ejemplo, si yo en los ejercicios anteriores cuando decíamos,

57
00:04:49,000 --> 00:04:56,000
dame 5 números, en vez de tener 5 variables, lo que voy a hacer es una variable sola,

58
00:04:56,000 --> 00:05:03,000
un array de 5 posiciones, y luego empezar con un FOR a rellenarlo diciendo

59
00:05:03,000 --> 00:05:07,000
que en la posición 0 me pones este valor de aquí, lo lees de teclado,

60
00:05:07,000 --> 00:05:12,000
en la posición 1 me pones este valor, y como el FOR tiene un índice que va de 0, 1, 2, 3, 4,

61
00:05:12,000 --> 00:05:15,000
pues me viene perfecto.

62
00:05:15,000 --> 00:05:21,000
De hecho, para rellenar array, para leer array, para trabajar con array,

63
00:05:21,000 --> 00:05:24,000
usaremos muchísimo el FOR.

64
00:05:28,000 --> 00:05:35,000
Sintaxis. ¿Cómo se declara un array? Así.

65
00:05:37,000 --> 00:05:44,000
Es igual que una variable, solo que tiene estos símbolos mágicos.

66
00:05:44,000 --> 00:05:50,000
La variable era tipo y el nombre. Int, edad.

67
00:05:50,000 --> 00:05:59,000
Ahora en vez es int, corchetes, corchetes y el nombre de este array.

68
00:05:59,000 --> 00:06:03,000
¿Lo hemos visto esto por algún lado?

69
00:06:03,000 --> 00:06:08,000
String, corchetes, arcs. ¿Qué es arcs?

70
00:06:12,000 --> 00:06:21,000
Public, static, void, main, string, corchetes, arcs. ¿Os acordáis?

71
00:06:21,000 --> 00:06:25,000
Si yo os pregunto, ¿y qué es este arcs?

72
00:06:25,000 --> 00:06:29,000
¿Nombre de qué? ¿De una variable?

73
00:06:29,000 --> 00:06:34,000
¿De un array? ¿De qué? De string.

74
00:06:34,000 --> 00:06:39,000
Arcs es un array de string.

75
00:06:39,000 --> 00:06:45,000
Es decir, que me espero allí, que si accedo a arcs de 0, habrá un string,

76
00:06:45,000 --> 00:06:50,000
si accedo a arcs de 1, habrá un string, si accedo a arcs de 2, habrá un string.

77
00:06:50,000 --> 00:06:52,000
Veremos cómo se usa arcs.

78
00:06:52,000 --> 00:06:56,000
Por ahora, simplemente quiero crear un array de enteros.

79
00:06:56,000 --> 00:07:01,000
Int, corchetes, mi array de int.

80
00:07:01,000 --> 00:07:05,000
String, corchetes, mi array de string.

81
00:07:05,000 --> 00:07:10,000
Con esto, ¿os acordáis cuando yo declaraba int, edad, punto y coma?

82
00:07:10,000 --> 00:07:16,000
Que todavía no lo había inicializado. Pues, misma cosa.

83
00:07:16,000 --> 00:07:25,000
Sé que mi array de int será un array de int, pero no sé su tamaño, no sé nada todavía.

84
00:07:25,000 --> 00:07:28,000
Todavía no vale nada. ¿Sí?

85
00:07:28,000 --> 00:07:32,000
¿Cómo lo inicializo?

86
00:07:32,000 --> 00:07:42,000
Por ejemplo, mi array de int es un nuevo array de int de 20 posiciones.

87
00:07:42,000 --> 00:07:52,000
Esto me crea una multivariable con 20 celdas allí dentro que puedan hospedar ints,

88
00:07:52,000 --> 00:07:59,000
que irán desde la posición 0 hasta la posición 19.

89
00:07:59,000 --> 00:08:02,000
La primera posición será la 0, la última será la 19.

90
00:08:02,000 --> 00:08:05,000
La posición 20 no existe.

91
00:08:05,000 --> 00:08:07,000
¿Lo veis?

92
00:08:07,000 --> 00:08:14,000
Si quisiera hacer un int de 5 posiciones, ¿cómo lo haría?

93
00:08:14,000 --> 00:08:16,000
¿Está de acuerdo? ¿Cómo lo haría?

94
00:08:16,000 --> 00:08:24,000
Crearme un array de 5 posiciones.

95
00:08:24,000 --> 00:08:26,000
Pues, de notas.

96
00:08:26,000 --> 00:08:30,000
Int, corchetes.

97
00:08:30,000 --> 00:08:33,000
¿Y qué queremos hacer?

98
00:08:33,000 --> 00:08:38,000
Números es igual a qué?

99
00:08:38,000 --> 00:08:46,000
new int

100
00:08:46,000 --> 00:08:53,000
Esto me ha creado un nuevo array de que se llama números, que contiene solo int en cada una de estas,

101
00:08:53,000 --> 00:08:58,000
que tiene 5 posiciones dentro, desde la posición 0 a la posición 4.

102
00:08:58,000 --> 00:09:21,000
Es decir, que esta cosa de aquí me crea un array que se llama números,

103
00:09:21,000 --> 00:09:32,000
que puede contener int, y que hay dentro 1, 2, 3, 4 y 5 celdas numeradas.

104
00:09:32,000 --> 00:09:38,000
Esta es la celda 0, 1, 2, 3 y 4.

105
00:09:38,000 --> 00:09:40,000
Con dentro el valor que sea.

106
00:09:40,000 --> 00:09:41,000
Ahora veremos.

107
00:09:41,000 --> 00:09:43,000
En este momento no hay nada allí dentro.

108
00:09:43,000 --> 00:09:48,000
Pero yo podría decir, oye mira, dentro números de 2 ponme 14.

109
00:09:48,000 --> 00:09:55,000
Pues entonces el número de 2 en esta posición pondré 14.

110
00:09:55,000 --> 00:09:58,000
¿Tienes que poner siempre new int?

111
00:09:58,000 --> 00:10:00,000
Cuando lo creas.

112
00:10:00,000 --> 00:10:04,000
Claro, pero si ya lo declaras al principio.

113
00:10:04,000 --> 00:10:11,000
Sí, pero cuando lo he declarado, no le he puesto qué es.

114
00:10:11,000 --> 00:10:16,000
Le he dicho, tú eres un array de int, pero como está hecho es cuántas posiciones, no te lo he dicho.

115
00:10:16,000 --> 00:10:22,000
¿Cuántas posiciones? Así.

116
00:10:22,000 --> 00:10:24,000
Esto, sí.

117
00:10:24,000 --> 00:10:33,000
Porque aquí estás creando un array de int y lo asocias a esta variable.

118
00:10:33,000 --> 00:10:34,000
No lo sé cuando lo creo aquí.

119
00:10:34,000 --> 00:10:38,000
Acuérdate que antes tengo que hacer la parte derecha del igual,

120
00:10:38,000 --> 00:10:40,000
y lo que sale de allí lo hago a la izquierda.

121
00:10:40,000 --> 00:10:45,000
Entonces en la parte izquierda ni la miro mientras estoy haciendo esto.

122
00:10:45,000 --> 00:10:48,000
¿Cómo hago un array de string de 15 posiciones?

123
00:10:48,000 --> 00:10:50,000
Pues new string de 15.

124
00:10:50,000 --> 00:10:58,000
¿Cómo hago un array de booleanos de 318 posiciones?

125
00:10:58,000 --> 00:11:05,000
new boolean corchete 318 corchete punto coma.

126
00:11:05,000 --> 00:11:08,000
¿Dudas? Vale.

127
00:11:08,000 --> 00:11:11,000
¿Cómo asigno valores a sus celdas?

128
00:11:11,000 --> 00:11:12,000
Pues así.

129
00:11:12,000 --> 00:11:20,000
Nombre del array, corchete, el número de la celda que acedo, corchete, es igual a un valor.

130
00:11:20,000 --> 00:11:22,000
Por ejemplo esto.

131
00:11:22,000 --> 00:11:29,000
Mi array de int en la posición 0 es igual a 16.

132
00:11:29,000 --> 00:11:38,000
La operación que hemos visto antes, que hemos dicho aquí.

133
00:11:38,000 --> 00:11:47,000
Para poner el 14 aquí dentro, ¿cómo lo hago?

134
00:11:47,000 --> 00:12:05,000
Números de 2, porque lo estoy insertando en la posición 2, es igual a 14.

135
00:12:05,000 --> 00:12:07,000
Quiero poner 3 aquí.

136
00:12:07,000 --> 00:12:10,000
¿Cómo lo hago?

137
00:12:10,000 --> 00:12:15,000
Aquí.

138
00:12:15,000 --> 00:12:20,000
Números.

139
00:12:20,000 --> 00:12:28,000
4 es igual.

140
00:12:28,000 --> 00:12:32,000
Ahora voy con la pregunta.

141
00:12:32,000 --> 00:12:47,000
System.out.println de números de 2 más números de 4.

142
00:12:47,000 --> 00:12:57,000
¿Qué me imprime por pantalla?

143
00:12:57,000 --> 00:13:01,000
¿Qué me imprime por pantalla?

144
00:13:01,000 --> 00:13:04,000
17.

145
00:13:04,000 --> 00:13:07,000
¿Acedo al número de 2 cuánto vale?

146
00:13:07,000 --> 00:13:10,000
14. Es un int.

147
00:13:10,000 --> 00:13:12,000
¿Acedo al número de 4 cuánto vale?

148
00:13:12,000 --> 00:13:14,000
3. Es un int.

149
00:13:14,000 --> 00:13:16,000
Int más int lo puede hacer.

150
00:13:16,000 --> 00:13:20,000
14 más 3, 17.

151
00:13:20,000 --> 00:13:23,000
¿Y ahora?

152
00:13:23,000 --> 00:13:28,000
¿Qué me imprime en pantalla?

153
00:13:28,000 --> 00:13:31,000
143.

154
00:13:31,000 --> 00:13:38,000
Acedo a una string, entonces estreno con catenación, con catena detrás 14,

155
00:13:38,000 --> 00:13:41,000
que pero se transforma en una string, por lo tanto 1, 4,

156
00:13:41,000 --> 00:13:47,000
y luego después le pego detrás 3, 1, 4, 3.

157
00:13:47,000 --> 00:13:50,000
¿Dudas?

158
00:13:50,000 --> 00:13:51,000
¿Sí?

159
00:13:51,000 --> 00:13:57,000
Pero como se usa el relativo, me interesa, ¿se entiende esta cosa de aquí?

160
00:13:57,000 --> 00:14:02,000
Números y entre corchete la posición a la que acedo.

161
00:14:02,000 --> 00:14:09,000
¿Sí o no?

162
00:14:09,000 --> 00:14:19,000
Entonces, por ejemplo, mi array de 19 espacios, ¿sí?

163
00:14:19,000 --> 00:14:21,000
Por ahora no lo hemos hecho.

164
00:14:21,000 --> 00:14:24,000
Ahora, la pregunta que tú me estás haciendo es otra.

165
00:14:24,000 --> 00:14:34,000
¿Qué es? ¿Qué pasa si yo hago aquí esto?

166
00:14:34,000 --> 00:14:37,000
En esta cosa aquí.

167
00:14:37,000 --> 00:14:41,000
¿Qué pasa si yo acedo a una posición que no he escrito nada ahí dentro?

168
00:14:41,000 --> 00:14:49,000
¿Qué pasaba si yo antes acedía a una variable que no había inicializado antes?

169
00:14:50,000 --> 00:14:53,000
Mejor que no lo hagas.

170
00:14:53,000 --> 00:15:01,000
¿Sí?

171
00:15:01,000 --> 00:15:02,000
Vale.

172
00:15:02,000 --> 00:15:07,000
Entonces, claramente si en vez de int es un array de string,

173
00:15:07,000 --> 00:15:11,000
pues acedo a la posición 0 y le pongo dentro una string.

174
00:15:11,000 --> 00:15:15,000
Acedo a la posición 14 y le pongo dentro una string.

175
00:15:15,000 --> 00:15:21,000
Recordad siempre que si son 20 posiciones, es de la 0 a la 19.

176
00:15:21,000 --> 00:15:24,000
Si son 50 posiciones, es de la 0 a la 49.

177
00:15:24,000 --> 00:15:29,000
Pero eso me viene bien en el for, porque yo empiezo for int es igual a 0

178
00:15:29,000 --> 00:15:34,000
y menor de la longitud del tamaño, ¿vale?

179
00:15:34,000 --> 00:15:36,000
Y por lo tanto me viene bien.

180
00:15:36,000 --> 00:15:39,000
Me va desde 0 al tamaño menos 1.

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

182
00:15:41,000 --> 00:15:46,000
Puedo hacer todas estas operaciones de golpe así.

183
00:15:46,000 --> 00:15:50,000
Esto me crea un array donde en la posición 0 tengo 1,

184
00:15:50,000 --> 00:15:52,000
en la posición 1 tengo menos 2,

185
00:15:52,000 --> 00:15:54,000
en la posición 2 tengo 3.

186
00:15:54,000 --> 00:16:00,000
Y es un array de 3 posiciones.

187
00:16:00,000 --> 00:16:03,000
O sea, lo pilla el sol.

188
00:16:03,000 --> 00:16:04,000
¿Sí?

189
00:16:04,000 --> 00:16:06,000
Si lo hago con estos pasos de aquí,

190
00:16:06,000 --> 00:16:09,000
luego lo que debería hacer es entrar en cada celda,

191
00:16:09,000 --> 00:16:12,000
hacer un for para inicializar cada celda un valor.

192
00:16:12,000 --> 00:16:16,000
Por ejemplo, todo a 0.

193
00:16:16,000 --> 00:16:17,000
¿Vale?

194
00:16:17,000 --> 00:16:19,000
Ahora lo hacemos, ¿eh?

195
00:16:19,000 --> 00:16:21,000
Vale.

196
00:16:21,000 --> 00:16:23,000
Variables índices.

197
00:16:23,000 --> 00:16:26,000
Una de las ventajas de los arrays es que puede acceder a cada compartimento,

198
00:16:26,000 --> 00:16:29,000
a cada celda, a cada bloque, a cada subvalor,

199
00:16:29,000 --> 00:16:31,000
llamadlo como os da la gana,

200
00:16:31,000 --> 00:16:33,000
utilizando un número entero, o sea, un índice.

201
00:16:33,000 --> 00:16:36,000
Eso de la posición 3, la posición 5.

202
00:16:36,000 --> 00:16:39,000
Esta cosa de aquí se está haciendo referencia a estos numeritos de aquí.

203
00:16:39,000 --> 00:16:43,000
Yo puedo acceder al número 3, al número 7, al número 4.

204
00:16:43,000 --> 00:16:44,000
¿Sí?

205
00:16:44,000 --> 00:16:47,000
Y voy a mirar qué hay ahí dentro de esa celda.

206
00:16:47,000 --> 00:16:50,000
Es como si fuera un pasillo con puertas,

207
00:16:50,000 --> 00:16:52,000
cada puerta tiene su número,

208
00:16:52,000 --> 00:16:55,000
y por lo tanto yo puedo acceder a la puerta 3,

209
00:16:55,000 --> 00:16:57,000
a la puerta 0, a la puerta 19,

210
00:16:57,000 --> 00:16:59,000
y cuando abro la puerta dentro está el valor

211
00:16:59,000 --> 00:17:04,000
del tipo que depende del tipo del array.

212
00:17:04,000 --> 00:17:05,000
¿Sí o no?

213
00:17:06,000 --> 00:17:07,000
¿Dudas?

214
00:17:11,000 --> 00:17:16,000
Si este número no es literal, sino variable,

215
00:17:17,000 --> 00:17:19,000
¿Veis la diferencia?

216
00:17:21,000 --> 00:17:24,000
podemos cambiar el valor de i según necesitemos

217
00:17:24,000 --> 00:17:28,000
creando potentes algoritmos de búsqueda, ordenación y recorrido del array.

218
00:17:28,000 --> 00:17:30,000
¿Dónde hemos visto este i?

219
00:17:30,000 --> 00:17:31,000
O sea, un for.

220
00:17:32,000 --> 00:17:33,000
¿Sí?

221
00:17:33,000 --> 00:17:35,000
A ver si hay un ejemplo ahora.

222
00:17:37,000 --> 00:17:38,000
Por ejemplo,

223
00:17:38,000 --> 00:17:41,000
vamos a hacer este array de aquí.

224
00:17:42,000 --> 00:17:44,000
Creo un array

225
00:17:45,000 --> 00:17:47,000
que se llama dias.

226
00:17:47,000 --> 00:17:48,000
¿Lo veis?

227
00:17:48,000 --> 00:17:50,000
Es un array de

228
00:17:51,000 --> 00:17:52,000
string.

229
00:17:53,000 --> 00:17:55,000
¿Grande cuántas posiciones?

230
00:17:56,000 --> 00:17:59,000
No lo sé, tengo que ver qué ha escrito aquí.

231
00:17:59,000 --> 00:18:00,000
¿Vale?

232
00:18:00,000 --> 00:18:04,000
Voy a contar 1, 2, 3, 4, 5, 6 y 7.

233
00:18:05,000 --> 00:18:07,000
Si ponía solo 5 días...

234
00:18:08,000 --> 00:18:10,000
Esto será grande 7.

235
00:18:10,000 --> 00:18:12,000
¿Este de aquí en qué posición está?

236
00:18:15,000 --> 00:18:16,000
¿Esto?

237
00:18:17,000 --> 00:18:18,000
6.

238
00:18:19,000 --> 00:18:23,000
Entonces, aquí si yo accedo a días de 0,

239
00:18:23,000 --> 00:18:24,000
¿qué me pondrá?

240
00:18:25,000 --> 00:18:26,000
¿Días de 6?

241
00:18:27,000 --> 00:18:28,000
Domingo.

242
00:18:28,000 --> 00:18:29,000
¿Días de 3?

243
00:18:33,000 --> 00:18:34,000
1, 2...

244
00:18:34,000 --> 00:18:37,000
Perdón, 0, 1, 2, 3, jueves.

245
00:18:39,000 --> 00:18:40,000
¿Dudas?

246
00:18:41,000 --> 00:18:42,000
¿Se entiende?

247
00:18:45,000 --> 00:18:46,000
Pregunta.

248
00:18:46,000 --> 00:18:47,000
Si yo pongo esto...

249
00:18:47,000 --> 00:18:48,000
Cuidado aquí, ¿eh?

250
00:18:49,000 --> 00:18:50,000
¿Lo veis?

251
00:18:52,000 --> 00:18:53,000
Vale.

252
00:18:53,000 --> 00:18:55,000
Y ahora pongo este programa aquí, ¿qué pasa?

253
00:18:57,000 --> 00:19:03,000
...

254
00:19:04,000 --> 00:19:06,000
Cuidado, aquí está el domingo, ¿eh?

255
00:19:07,000 --> 00:19:10,000
Cuando yo intento acceder a la posición 6,

256
00:19:10,000 --> 00:19:14,000
como ahora no es el domingo y la posición 6 no existe,

257
00:19:14,000 --> 00:19:21,000
vuestro mejor amigo, el Array Index Out of Bounds Exception.

258
00:19:22,000 --> 00:19:25,000
Esto lo veréis así en las próximas semanas.

259
00:19:27,000 --> 00:19:28,000
¿Sí?

260
00:19:29,000 --> 00:19:33,000
Índice del Array fuera de los límites.

261
00:19:33,000 --> 00:19:34,000
Error.

262
00:19:37,000 --> 00:19:40,000
Error del índice del Array fuera de los límites.

263
00:19:41,000 --> 00:19:43,000
Yo tengo un Array que va de 0 a 5

264
00:19:43,000 --> 00:19:45,000
y tú me estás pidiendo la posición 6.

265
00:19:45,000 --> 00:19:46,000
Explosion.

266
00:19:47,000 --> 00:19:48,000
¿Sí?

267
00:19:48,000 --> 00:19:49,000
Y te lo dice.

268
00:19:49,000 --> 00:19:51,000
Has pedido 6 y yo no lo tengo, el sexto.

269
00:19:52,000 --> 00:19:53,000
¿Sí?

270
00:19:54,000 --> 00:19:58,000
Entonces, cuidado con los índices, sobre todo los 4.

271
00:19:58,000 --> 00:20:01,000
Si vosotros os pasáis por un lado o por el otro,

272
00:20:01,000 --> 00:20:04,000
tanto en negativo si vais por debajo del 0

273
00:20:04,000 --> 00:20:07,000
como si vais por encima del número máximo que podéis hacer,

274
00:20:07,000 --> 00:20:08,000
os explota.

275
00:20:08,000 --> 00:20:12,000
Esto pasa normalmente cuando en vez de poner menor del número máximo

276
00:20:12,000 --> 00:20:13,000
ponéis menor o igual.

277
00:20:13,000 --> 00:20:17,000
Entonces intenta acceder también a la última posición y explota.

278
00:20:17,000 --> 00:20:19,000
Explosión y explota.

279
00:20:21,000 --> 00:20:26,000
¿Cómo sé cuántas posiciones tiene un Array con esta cosa aquí?

280
00:20:28,000 --> 00:20:30,000
¿Esto a qué se parece?

281
00:20:37,000 --> 00:20:38,000
String.

282
00:20:38,000 --> 00:20:39,000
Pero cuidado.

283
00:20:39,000 --> 00:20:41,000
En String es un método.

284
00:20:41,000 --> 00:20:44,000
En String tiene aquí dos paréntesis.

285
00:20:44,000 --> 00:20:46,000
Aquí no es un método.

286
00:20:46,000 --> 00:20:48,000
Es lo que se llama un atributo.

287
00:20:48,000 --> 00:20:49,000
¿Qué es?

288
00:20:49,000 --> 00:20:50,000
Lo veremos.

289
00:20:50,000 --> 00:20:51,000
Es una variable.

290
00:20:51,000 --> 00:20:53,000
Es una propiedad del Array.

291
00:20:53,000 --> 00:20:55,000
No es un método del Array.

292
00:20:55,000 --> 00:20:56,000
Es una propiedad.

293
00:20:56,000 --> 00:20:58,000
Es un valor asociado con el Array.

294
00:20:59,000 --> 00:21:02,000
Entonces, cuando lo llamáis sobre los Arrays es Length.

295
00:21:02,000 --> 00:21:05,000
Cuando lo llamáis sobre String es Length paréntesis.

296
00:21:07,000 --> 00:21:09,000
Tanto si os equivocáis os lo marca.

297
00:21:09,000 --> 00:21:10,000
Dice esto no existe.

298
00:21:11,000 --> 00:21:12,000
Mirad esto por ejemplo.

299
00:21:12,000 --> 00:21:14,000
¿Qué hará este programita?

300
00:21:16,000 --> 00:21:17,000
¿Qué hará?

301
00:21:29,000 --> 00:21:31,000
Crea un Array de char.

302
00:21:31,000 --> 00:21:32,000
¿Vale?

303
00:21:32,000 --> 00:21:34,000
Que dice que tiene diez posiciones.

304
00:21:34,000 --> 00:21:36,000
Y luego pilla una variable i.

305
00:21:36,000 --> 00:21:41,000
Que va de cero hasta un número que es menor de este diez.

306
00:21:42,000 --> 00:21:43,000
¿Sí?

307
00:21:43,000 --> 00:21:45,000
Por lo tanto irá de cero a nueve.

308
00:21:45,000 --> 00:21:48,000
Lo que hace es leer qué hay en el Array en cada posición.

309
00:21:49,000 --> 00:21:51,000
¿Para qué hace este código en concreto?

310
00:21:51,000 --> 00:21:52,000
No lo sé.

311
00:21:52,000 --> 00:21:53,000
Caos.

312
00:21:53,000 --> 00:21:55,000
Porque no ha inicializado nada.

313
00:21:56,000 --> 00:21:58,000
Entonces se puede probar y ver qué pasa.

314
00:21:58,000 --> 00:22:02,000
Muchos tipos primitivos como char, int y cosas por el estilo.

315
00:22:02,000 --> 00:22:05,000
Si no lo inicializo se inicializa a cero.

316
00:22:06,000 --> 00:22:07,000
¿Vale?

317
00:22:07,000 --> 00:22:11,000
Entonces es posible que no me explote pero me dará cosas raras.

318
00:22:13,000 --> 00:22:14,000
¿Sí?

319
00:22:14,000 --> 00:22:15,000
¿Oy?

320
00:22:19,000 --> 00:22:20,000
Está ahí.

321
00:22:21,000 --> 00:22:23,000
¿La sabes usar de un For?

322
00:22:23,000 --> 00:22:25,000
Pues si ahora está ahí la uso aquí dentro.

323
00:22:25,000 --> 00:22:28,000
En el primer ciclo del For valdrá cero.

324
00:22:28,000 --> 00:22:29,000
En el segundo valdrá uno.

325
00:22:29,000 --> 00:22:30,000
En el tercero...

326
00:22:30,000 --> 00:22:32,000
Entonces estoy recorriendo el Array.

327
00:22:33,000 --> 00:22:34,000
Por ejemplo.

328
00:22:41,000 --> 00:22:43,000
Veamos este código de aquí.

329
00:22:44,000 --> 00:22:45,000
¿Vale?

330
00:22:54,000 --> 00:22:56,000
Quiero recorrer este Array de aquí.

331
00:22:56,000 --> 00:22:57,000
¿Vale?

332
00:22:57,000 --> 00:22:59,000
Y imprimir todo el contenido de este Array.

333
00:22:59,000 --> 00:23:00,000
¿Cómo lo hago?

334
00:23:03,000 --> 00:23:06,000
Quiero que el resultado sea diez, veinte, treinta, cuarenta.

335
00:23:08,000 --> 00:23:09,000
For.

336
00:23:11,000 --> 00:23:13,000
Int y es igual a cero.

337
00:23:15,000 --> 00:23:16,000
¿Y?

338
00:23:18,000 --> 00:23:19,000
¿Menor?

339
00:23:21,000 --> 00:23:22,000
¿Números?

340
00:23:23,000 --> 00:23:24,000
Punto Length.

341
00:23:24,000 --> 00:23:25,000
¿Así?

342
00:23:26,000 --> 00:23:27,000
No.

343
00:23:28,000 --> 00:23:29,000
¿Y más más?

344
00:23:33,000 --> 00:23:36,000
System.out.println ¿De qué?

345
00:23:41,000 --> 00:23:42,000
¿Números?

346
00:23:45,000 --> 00:23:46,000
Ahí.

347
00:23:52,000 --> 00:23:57,000
Cuando i valdrá cero me imprimirá números de cero.

348
00:23:57,000 --> 00:23:58,000
O sea diez.

349
00:23:59,000 --> 00:24:00,000
Vuelve aquí.

350
00:24:00,000 --> 00:24:01,000
Aumenta uno.

351
00:24:01,000 --> 00:24:02,000
i vale uno.

352
00:24:02,000 --> 00:24:04,000
Me imprime número de uno.

353
00:24:05,000 --> 00:24:07,000
Aumenta uno i.

354
00:24:07,000 --> 00:24:08,000
Vale dos.

355
00:24:08,000 --> 00:24:09,000
Vuelve aquí.

356
00:24:09,000 --> 00:24:10,000
Imprime números de dos.

357
00:24:10,000 --> 00:24:11,000
Listo.

358
00:24:12,000 --> 00:24:13,000
Vuelve aquí.

359
00:24:13,000 --> 00:24:14,000
Números de tres.

360
00:24:14,000 --> 00:24:15,000
Listo.

361
00:24:16,000 --> 00:24:17,000
Vuelve aquí.

362
00:24:17,000 --> 00:24:18,000
i ahora vale cuatro.

363
00:24:19,000 --> 00:24:21,000
No es menor que cuatro.

364
00:24:21,000 --> 00:24:22,000
Y por lo tanto cero.

365
00:24:22,000 --> 00:24:24,000
He recorrido todo el Array.

366
00:24:27,000 --> 00:24:29,000
¿Cómo hago para recorrerlo al revés?

367
00:24:29,000 --> 00:24:31,000
Quiero leer de aquí a aquí.

368
00:24:40,000 --> 00:24:41,000
For.

369
00:24:42,000 --> 00:24:44,000
Interjota es igual a qué?

370
00:24:47,000 --> 00:24:48,000
Números.length.

371
00:24:49,000 --> 00:24:50,000
Punto y coma.

372
00:24:52,000 --> 00:24:53,000
Jota.

373
00:24:56,000 --> 00:24:58,000
Mayor que cero.

374
00:25:00,000 --> 00:25:01,000
Jota más más.

375
00:25:04,000 --> 00:25:06,000
Y lo mismo que antes.

376
00:25:12,000 --> 00:25:13,000
Pum.

377
00:25:13,000 --> 00:25:14,000
Index.

378
00:25:15,000 --> 00:25:17,000
Array index out of bound exception.

379
00:25:23,000 --> 00:25:25,000
Levantar la mano porque no sé de quién está hablando.

380
00:25:37,000 --> 00:25:38,000
Sí.

381
00:25:38,000 --> 00:25:39,000
¿Pero por qué?

382
00:25:39,000 --> 00:25:40,000
¿Puedo hacer esto?

383
00:25:40,000 --> 00:25:41,000
Sí.

384
00:25:42,000 --> 00:25:44,000
Pero donde quiero empezar es esto.

385
00:25:45,000 --> 00:25:47,000
Porque no existe la última posición.

386
00:25:48,000 --> 00:25:50,000
Si son cuatro posiciones,

387
00:25:51,000 --> 00:25:53,000
la última es la tres.

388
00:25:55,000 --> 00:25:56,000
¿Sí?

389
00:25:57,000 --> 00:25:59,000
Si son cinco posiciones,

390
00:25:59,000 --> 00:26:01,000
la última es la cuatro.

391
00:26:02,000 --> 00:26:06,000
Entonces empiezo desde su tamaño menos uno

392
00:26:06,000 --> 00:26:08,000
y llego hasta cero.

393
00:26:09,000 --> 00:26:10,000
¿Sí?

394
00:26:13,000 --> 00:26:14,000
¿Sí?

395
00:26:15,000 --> 00:26:18,000
Entonces ahora me saldría 40, 30, 20 y 10.

396
00:26:25,000 --> 00:26:28,000
Tranquilo, o sea, ahora no me interesa que sepáis utilizarlo.

397
00:26:28,000 --> 00:26:32,000
Me interesa que entendáis el concepto que está detrás.

398
00:26:33,000 --> 00:26:34,000
Recorrer un Array.

399
00:26:34,000 --> 00:26:36,000
Lo que acabamos de hacer.

400
00:26:40,000 --> 00:26:41,000
¿Vale?

401
00:26:43,000 --> 00:26:46,000
Aquí estoy leyendo estos de aquí, ¿no?

402
00:26:46,000 --> 00:26:48,000
Que son de lunes a viernes.

403
00:26:49,000 --> 00:26:51,000
Y entonces el día,

404
00:26:52,000 --> 00:26:54,000
es, y leo el contenido de esto.

405
00:26:55,000 --> 00:26:57,000
Entonces cuidado con esta cosa de aquí,

406
00:26:57,000 --> 00:26:59,000
como esto va de cero a,

407
00:27:00,000 --> 00:27:01,000
en este caso,

408
00:27:01,000 --> 00:27:03,000
cero, uno, dos, tres y cuatro,

409
00:27:03,000 --> 00:27:04,000
¿vale?

410
00:27:04,000 --> 00:27:05,000
Solo hasta viernes.

411
00:27:05,000 --> 00:27:06,000
Pues yo no quiero decir,

412
00:27:06,000 --> 00:27:08,000
el día cero es lunes.

413
00:27:08,000 --> 00:27:11,000
Porque no es como lo decimos nosotros los seres humanos.

414
00:27:11,000 --> 00:27:12,000
Nosotros decimos el primer día,

415
00:27:12,000 --> 00:27:13,000
el día uno es lunes.

416
00:27:14,000 --> 00:27:17,000
Entonces lo que estoy haciendo es usar esta X como apoyo

417
00:27:17,000 --> 00:27:19,000
que vale I más uno.

418
00:27:19,000 --> 00:27:21,000
En la posición cero, esto valdrá uno.

419
00:27:21,000 --> 00:27:23,000
En la posición dos, esto valdrá tres.

420
00:27:23,000 --> 00:27:24,000
Y así puedo decir,

421
00:27:24,000 --> 00:27:25,000
el día uno es,

422
00:27:25,000 --> 00:27:28,000
y voy a la celda cero de días que es lunes.

423
00:27:30,000 --> 00:27:31,000
¿Sí?

424
00:27:32,000 --> 00:27:33,000
Podría simplemente haber escrito,

425
00:27:33,000 --> 00:27:36,000
día, entre paréntesis, I más uno,

426
00:27:37,000 --> 00:27:39,000
es días de I.

427
00:27:40,000 --> 00:27:42,000
Pero esto ya lo veremos.

428
00:27:49,000 --> 00:27:52,000
Yo creo que nos paramos aquí.

429
00:27:52,000 --> 00:27:53,000
¿Vale?

430
00:27:56,000 --> 00:27:58,000
¿Existe esta cosa aquí?

431
00:28:02,000 --> 00:28:04,000
Que es un foro especial.

432
00:28:05,000 --> 00:28:06,000
Lo veremos.

433
00:28:07,000 --> 00:28:10,000
¿Existen problemas sobre copiar un array?

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

435
00:28:12,000 --> 00:28:13,000
Más lo veremos.

436
00:28:15,000 --> 00:28:18,000
¿Existen arrays multidimensionales?

437
00:28:30,000 --> 00:28:31,000
Da miedo.

438
00:28:32,000 --> 00:28:33,000
Da más miedo esto,

439
00:28:33,000 --> 00:28:36,000
o yo disfrazado de vampiro por Halloween.

440
00:28:38,000 --> 00:28:39,000
Y ya está.

441
00:28:39,000 --> 00:28:40,000
¿Vale?

442
00:28:40,000 --> 00:28:42,000
Y esto es más o menos lo que nos queda para saber.

443
00:28:42,000 --> 00:28:43,000
Se acabó.

444
00:28:43,000 --> 00:28:45,000
Por hoy nos paramos aquí.