1
00:00:00,000 --> 00:00:07,259
Vamos a grabar la clase, por lo tanto, si habláis o hacéis preguntas, pues me autorizáis a grabar vuestra voz, ¿vale?

2
00:00:07,940 --> 00:00:15,060
Entonces, hasta ahora estamos con las estructuras de control, ¿vale?

3
00:00:15,199 --> 00:00:19,940
Entonces, lo que permiten hacer es controlar el flujo de ejecución de un programa.

4
00:00:21,260 --> 00:00:27,399
Hemos visto que, en teoría, vemos tres familias, tres cosas distintas.

5
00:00:27,399 --> 00:00:35,899
Una es el condicional que sostancialmente me está diciendo que un bloque se ejecutará o no dependiendo de una condición

6
00:00:35,899 --> 00:00:38,859
El if como ejemplo básico

7
00:00:38,859 --> 00:00:45,939
Más hemos visto el if-else, más hemos visto el switch que son otras estructuras parecidas

8
00:00:45,939 --> 00:00:53,719
Ahora vamos a ver el segundo bloque de opciones que son las estructuras iterativas

9
00:00:53,719 --> 00:01:05,159
Son, sustancialmente, pillar un bloque, un conjunto de comandos, una serie de instrucciones y que estas instrucciones se repitan más de una vez.

10
00:01:05,519 --> 00:01:13,819
La idea es que mientras una condición sea verdadera o un cierto número de veces, quiero repetir un bloque de instrucciones.

11
00:01:14,640 --> 00:01:17,000
Veremos para qué sirve y haremos ejemplos.

12
00:01:17,000 --> 00:01:22,819
La tercera, tercer bloque será el de llamada de métodos

13
00:01:22,819 --> 00:01:25,799
Porque sustancialmente yo estoy ejecutando un código

14
00:01:25,799 --> 00:01:28,319
Interrumpo un código en un cierto momento

15
00:01:28,319 --> 00:01:30,400
Me voy a otro bloque de códigos

16
00:01:30,400 --> 00:01:33,599
Ejecuto eso y luego vuelvo a lo que estaba ejecutando

17
00:01:33,599 --> 00:01:34,879
Pero lo veremos más adelante

18
00:01:34,879 --> 00:01:38,040
Por ahora centrámonos en las estructuras iterativas

19
00:01:38,040 --> 00:01:42,859
Estructuras iterativas permiten repetir un determinado bloque más de una vez

20
00:01:42,859 --> 00:01:46,299
Podría ser cero, una o más veces

21
00:01:46,299 --> 00:01:50,560
La idea es que se pueda repetir un bloque

22
00:01:50,560 --> 00:01:59,040
Y existen dos grandes estructuras iterativas que podemos utilizar en este contexto

23
00:01:59,040 --> 00:02:01,579
Posiblemente en algunos lenguajes existen más

24
00:02:01,579 --> 00:02:04,659
En Java existe también otra que es parecida a estas

25
00:02:04,659 --> 00:02:08,020
Que son el while y el for

26
00:02:08,020 --> 00:02:13,800
El while es una estructura que te dice

27
00:02:13,800 --> 00:02:19,280
Vete repitiendo este bloque, esta serie de instrucciones

28
00:02:19,280 --> 00:02:22,460
Mientras que una condición sea verdadera

29
00:02:22,460 --> 00:02:24,860
Tú estableces una condición

30
00:02:24,860 --> 00:02:27,240
Esta condición será una expresión booleana

31
00:02:27,240 --> 00:02:31,539
Mientras que esta condición será verdadera

32
00:02:31,539 --> 00:02:38,460
Mi programa seguirá ejecutando una vez y otra y otra y otra el mismo bloque

33
00:02:38,460 --> 00:02:42,900
Cuando esta condición se volverá falsa

34
00:02:42,900 --> 00:02:45,439
Pues entonces saldré del bloque y seguiré adelante

35
00:02:45,439 --> 00:02:47,860
Con la instrucción que está debajo del while

36
00:02:47,860 --> 00:02:50,759
¿Cuántas veces lo voy a ejecutar?

37
00:02:51,099 --> 00:02:51,699
No lo sé

38
00:02:51,699 --> 00:02:58,379
El while, a priori, no sé cuántas veces voy a ejecutar ese bloque

39
00:02:58,379 --> 00:03:01,419
Mientras que la condición sea verdadera, sigo

40
00:03:01,419 --> 00:03:05,240
Cuando la condición se volverá falsa, pues a ese punto saldré

41
00:03:05,240 --> 00:03:09,080
Por otro lado está en vez el for

42
00:03:09,080 --> 00:03:13,340
El for es, a nivel lógico, lo mismo

43
00:03:13,340 --> 00:03:15,520
Es siempre una estructura iterativa

44
00:03:15,520 --> 00:03:19,719
De hecho, puedo cambiar un while para que haga como un for

45
00:03:19,719 --> 00:03:21,759
Y puedo cambiar un for para que haga como un while

46
00:03:21,759 --> 00:03:26,639
Pero el for se suele utilizar cuando yo ya sé

47
00:03:26,639 --> 00:03:30,159
Cuántas veces voy a ejecutar ese bloque

48
00:03:30,159 --> 00:03:33,620
Cuidado, que este cuántas veces puede que sea una variable

49
00:03:33,620 --> 00:03:34,659
Puede que sea n

50
00:03:34,659 --> 00:03:39,000
Entonces, hasta que el usuario no me dé ese número

51
00:03:39,000 --> 00:03:41,159
no lo sé, pero sé que una vez que

52
00:03:41,159 --> 00:03:43,280
se ha fijado ese número, que habré sacado ese número

53
00:03:43,280 --> 00:03:45,180
por donde sea, pues ese número

54
00:03:45,180 --> 00:03:47,199
n vale 10, pues sé que ejecutaré

55
00:03:47,199 --> 00:03:49,259
este bloque 10 veces, ese número vale 3

56
00:03:49,259 --> 00:03:51,219
pues sé que ejecutaré este bloque 3 veces

57
00:03:51,219 --> 00:03:52,219
¿vale?

58
00:03:52,780 --> 00:03:54,379
mientras en un while

59
00:03:54,379 --> 00:03:57,280
tú no sabes cuántas veces lo vas

60
00:03:57,280 --> 00:03:59,139
a hacer porque estás esperando que una condición

61
00:03:59,139 --> 00:04:01,379
se cumpla o no se cumpla en este caso

62
00:04:01,379 --> 00:04:03,020
entonces mientras que la condición

63
00:04:03,020 --> 00:04:05,020
está verdadera, sigues dando

64
00:04:05,020 --> 00:04:07,319
vueltas hasta que llega un momento en que

65
00:04:07,319 --> 00:04:10,080
Cambiará algo, tendrá que cambiar algo

66
00:04:10,080 --> 00:04:11,199
Para que tú salgas

67
00:04:11,199 --> 00:04:12,860
En el for

68
00:04:12,860 --> 00:04:14,500
Pues puede ser que

69
00:04:14,500 --> 00:04:15,800
A nivel de

70
00:04:15,800 --> 00:04:19,139
De programación

71
00:04:19,139 --> 00:04:20,040
Mientras estás programando

72
00:04:20,040 --> 00:04:23,019
No sabes cuantas veces harás este ciclo

73
00:04:23,019 --> 00:04:25,160
Pero está escrito en algún lado

74
00:04:25,160 --> 00:04:26,199
Está escrito en una variable

75
00:04:26,199 --> 00:04:28,399
Cuando esta variable estará instanciada

76
00:04:28,399 --> 00:04:30,100
Pues ese es el número de veces que lo hace

77
00:04:30,100 --> 00:04:33,759
Guay, vale

78
00:04:33,759 --> 00:04:36,939
Entonces, si yo tengo un cierto bloque de instrucciones

79
00:04:36,939 --> 00:04:38,779
Este de aquí, vale

80
00:04:38,779 --> 00:04:44,420
Y yo lo que quiero es que llego desde arriba, entro en una condición y evalúo esta condición

81
00:04:44,420 --> 00:04:46,160
Esta será una expresión booleana

82
00:04:46,160 --> 00:04:51,660
Podrá haber AND, OR y todas las cosas que hemos visto de los booleanos

83
00:04:51,660 --> 00:04:56,639
Pero al final, después de haber evaluado esta condición, tendré o TRUE o FALSE

84
00:04:56,639 --> 00:05:02,000
Si tengo FALSE, salto todo y sigo adelante

85
00:05:02,000 --> 00:05:09,519
Si tengo true, ejecuto una vez el bloque de instrucciones asociado con el while

86
00:05:09,519 --> 00:05:14,699
Y vuelvo arriba a evaluar nuevamente la condición

87
00:05:14,699 --> 00:05:25,300
Mientras que esta condición sea verdadera, yo seguiré dando vueltas en este bucle de aquí

88
00:05:25,300 --> 00:05:33,779
La idea es que por algún lado aquí en estas instrucciones haya un momento en que algo de esta condición cambie

89
00:05:33,779 --> 00:05:39,740
Para que llegue un momento en que esta condición se vuelva falsa, salgo del while y sigo adelante

90
00:05:39,740 --> 00:05:46,060
Cuidado, porque hasta ahora todos los programas que hemos hecho siempre acababan

91
00:05:46,060 --> 00:05:51,699
Tú lanzabas un programa, se quedaba a lo mejor ahí a la espera que tú escribías algo

92
00:05:51,699 --> 00:05:56,459
Pero en cuanto tú habías lanzado el programa y escrito los datos, pues ese programa acababa

93
00:05:56,459 --> 00:06:01,600
Ahora, con el while, nos exponemos a un problema nuevo

94
00:06:01,600 --> 00:06:04,839
Que es un bucle infinito

95
00:06:04,839 --> 00:06:07,819
Si yo pongo una condición aquí

96
00:06:07,819 --> 00:06:12,100
Y no cambio esta condición nunca en las instrucciones

97
00:06:12,100 --> 00:06:15,199
No saldré nunca de este bucle

98
00:06:15,199 --> 00:06:19,879
Y si esto es lo que quiero hacer, muy bien

99
00:06:19,879 --> 00:06:24,439
Pero si no es lo que quiero hacer, pues es un problema

100
00:06:24,439 --> 00:06:29,579
Porque puede que mi programa empiece a dar vuelta aquí un mogollón de veces

101
00:06:29,579 --> 00:06:39,000
Y me consume, me gaste mucho de procesador, de memoria, cosas por el estilo

102
00:06:39,000 --> 00:06:41,800
Porque está allí para siempre dando vueltas en ese bucle

103
00:06:41,800 --> 00:06:45,100
¿Existen programas que no acaban nunca?

104
00:06:45,519 --> 00:06:48,899
Sí, pensad al programa de un cajero automático

105
00:06:48,899 --> 00:06:52,079
Pues tú vas allí, metes la tarjeta, pillas el dinero

106
00:06:52,079 --> 00:06:54,839
Y luego el programa no acaba, vuelve al principio

107
00:06:54,839 --> 00:07:00,300
Entonces se puede hacer programas que estarán para siempre dando ciclos aquí

108
00:07:00,300 --> 00:07:03,560
Y que estarán parados de otra forma

109
00:07:03,560 --> 00:07:08,060
Que algo externo lo parará o cosas por el estilo

110
00:07:08,060 --> 00:07:09,259
Sí, se puede hacer

111
00:07:09,259 --> 00:07:15,279
Pero la cosa fundamental es que vosotros tenéis que saber qué estáis haciendo

112
00:07:15,279 --> 00:07:17,639
Tenéis que saber que si el programa tiene que acabar

113
00:07:17,639 --> 00:07:19,500
Pues aquí en las instrucciones

114
00:07:19,500 --> 00:07:21,360
En algún momento tendréis que poner algo

115
00:07:21,360 --> 00:07:22,420
Que cambie esta condición

116
00:07:22,420 --> 00:07:24,300
¿Sí?

117
00:07:24,959 --> 00:07:27,540
Cuando la condición se vuelve

118
00:07:27,540 --> 00:07:29,519
False, pues salimos y seguimos adelante

119
00:07:29,519 --> 00:07:31,639
Ejemplo de un while muy sencillo

120
00:07:32,220 --> 00:07:32,920
¿Qué hace

121
00:07:32,920 --> 00:07:34,259
Este while

122
00:07:34,259 --> 00:07:36,180
Según vosotros?

123
00:07:38,100 --> 00:07:39,660
Deja jugar

124
00:07:39,660 --> 00:07:40,740
También a los demás

125
00:07:40,740 --> 00:07:42,339
Deja un minuto

126
00:07:42,339 --> 00:07:43,959
Que la gente piense

127
00:07:43,959 --> 00:07:47,079
O 20 segundos

128
00:07:47,079 --> 00:07:54,060
Y me decís, según vosotros, que va a aparecer en pantalla

129
00:07:54,060 --> 00:08:00,360
Un momento, ahora os lo digo yo

130
00:08:00,360 --> 00:08:11,750
Pablo, venga, ¿qué hace esto?

131
00:08:23,189 --> 00:08:52,539
Vale, este de aquí pone, al principio i vale 0

132
00:08:52,539 --> 00:08:57,460
Entrará aquí y se preguntará, ¿i es menor o igual que 10?

133
00:08:57,600 --> 00:08:59,840
Pues sí, entrará aquí dentro y imprimirá 0

134
00:08:59,840 --> 00:09:04,659
y luego hace i es igual a i más 1, o sea que i será 1

135
00:09:04,659 --> 00:09:08,120
vuelve aquí arriba y dice 1 es menor o igual que 10

136
00:09:08,120 --> 00:09:11,840
si, entra aquí dentro y imprime 1 y i será 2

137
00:09:11,840 --> 00:09:15,399
vuelve aquí y dice 2 es menor que 10

138
00:09:15,399 --> 00:09:19,899
y así, así, así hasta que llega un momento en que aquí se ejecutará

139
00:09:19,899 --> 00:09:23,700
i más 1 y será 10, vuelve aquí y me pregunta

140
00:09:23,700 --> 00:09:27,320
i es menor o igual que 10, si, por lo tanto entra

141
00:09:27,320 --> 00:09:30,820
y escribe 10, entonces los números del 0 al 10

142
00:09:30,820 --> 00:09:33,940
a este punto, por favor un momento

143
00:09:33,940 --> 00:09:39,379
a este punto i suma 1, llega a 11

144
00:09:39,379 --> 00:09:43,799
va aquí, 11 no es menor o igual que 10

145
00:09:43,799 --> 00:09:47,460
y por lo tanto saldría de este bloque y seguiría

146
00:09:47,460 --> 00:09:51,080
aquí adelante, tened en cuenta que a partir de aquí abajo

147
00:09:51,080 --> 00:09:55,090
i valdría 11

148
00:09:55,090 --> 00:09:59,149
Porque la última vez que ha pasado por aquí

149
00:09:59,149 --> 00:10:01,230
Ha ejecutado esto, valía 10

150
00:10:01,230 --> 00:10:03,389
Entonces ha entrado, ha escrito 10

151
00:10:03,389 --> 00:10:05,090
Se ha actualizado a 11

152
00:10:05,090 --> 00:10:07,590
Ha llegado aquí, ha salido

153
00:10:07,590 --> 00:10:09,330
Dentro de ahí se ha quedado 11

154
00:10:09,330 --> 00:10:12,179
¿Sí?

155
00:10:13,019 --> 00:10:17,279
Pablo, no

156
00:10:17,279 --> 00:10:19,879
No porque he declarado int fuera

157
00:10:19,879 --> 00:10:26,049
La variable está declarada fuera de este bloque

158
00:10:26,049 --> 00:10:29,289
Por lo tanto el ámbito de esta variable es el bloque externo

159
00:10:29,289 --> 00:10:32,110
Por lo tanto aquí debajo sigue valiendo 11

160
00:10:32,110 --> 00:10:46,179
A ver, oficialmente sería 1, 2, 3, 4, 5, 6, 7, 8, 9

161
00:10:46,179 --> 00:10:48,980
Pero como es tan rápido, tú lo vas a ver como de bloque

162
00:10:48,980 --> 00:10:54,000
Si le pusieras aquí algo o una operación muy compleja

163
00:10:54,000 --> 00:10:56,179
Que él tarda 30 segundos en hacerla

164
00:10:56,179 --> 00:10:59,200
Pues entonces te escribiría un número cada 30 segundos

165
00:10:59,200 --> 00:11:01,159
Cuando lo va a ejecutar

166
00:11:01,159 --> 00:11:04,100
Solo que estas operaciones aquí son tan rápidas

167
00:11:04,100 --> 00:11:05,620
Que tú lo ves de bloque

168
00:11:05,620 --> 00:11:14,230
Podrías ponerle lo que se llama un thread.slip

169
00:11:14,230 --> 00:11:17,029
Que es sustancialmente párate un segundo, por ejemplo

170
00:11:17,029 --> 00:11:19,250
Entonces, un thread.sleep

171
00:11:19,250 --> 00:11:20,309
Lo veremos más adelante

172
00:11:20,309 --> 00:11:22,909
Entonces, entrarías aquí, harías una operación

173
00:11:22,909 --> 00:11:25,210
Luego estarías un segundo parado, sin hacer nada

174
00:11:25,210 --> 00:11:26,190
Luego lo harías otra vez

175
00:11:26,190 --> 00:11:29,730
Entonces verías lo que sale una vez a cada segundo

176
00:11:29,730 --> 00:11:30,169
Sí

177
00:11:30,169 --> 00:11:35,059
Repetir un bloque

178
00:11:35,059 --> 00:11:39,240
Ahora, ¿cuál es el sentido de esto?

179
00:11:39,700 --> 00:11:41,399
Escribir los números de 1 a 10

180
00:11:41,399 --> 00:11:42,919
O sea, de 0 a 10

181
00:11:42,919 --> 00:11:45,500
Sin tener que escribir 10 veces

182
00:11:45,500 --> 00:11:46,940
Si está en .ato.println

183
00:11:46,940 --> 00:11:48,139
¿Sí?

184
00:11:48,139 --> 00:11:56,000
O los números de 1, de 0 a 5000, sin tener que escribir 5000 veces system.auto.println.

185
00:11:58,299 --> 00:12:01,519
Ahora, ¿para qué sirve en la vida real? Por mogollón de cosas.

186
00:12:01,519 --> 00:12:06,539
O sea, hoy lo vamos a utilizar y no lo vais a dejar nunca jamás.

187
00:12:08,200 --> 00:12:15,779
Pensad a todos los ejercicios donde os he dado una palabra y decía que tiene que ser de 4 letras,

188
00:12:15,779 --> 00:12:18,440
O una palabra que tiene un número de tres dígitos

189
00:12:18,440 --> 00:12:19,259
Y cosas por el estilo

190
00:12:19,259 --> 00:12:21,360
Porque no teníamos la posibilidad de

191
00:12:21,360 --> 00:12:23,799
Un número N de dígitos

192
00:12:23,799 --> 00:12:26,000
Y hacer las cosas desde el primer dígito

193
00:12:26,000 --> 00:12:26,620
Hasta el final

194
00:12:26,620 --> 00:12:28,580
Porque tenía que hacerlo yo

195
00:12:28,580 --> 00:12:31,799
Con fuerza bruta

196
00:12:31,799 --> 00:12:33,600
Pues ahora mismo no

197
00:12:33,600 --> 00:12:36,279
Ahora mismo ya yo puedo pillar una cualquier palabra

198
00:12:36,279 --> 00:12:38,139
Y ver si es palíndroma o no

199
00:12:38,139 --> 00:12:39,299
O capicúa

200
00:12:39,299 --> 00:12:41,399
O sea, que serán los próximos ejercicios

201
00:12:41,399 --> 00:12:43,840
Los ejercicios que vamos a hacer ahora serán parecidos

202
00:12:43,840 --> 00:12:45,039
A los que hemos visto hasta ahora

203
00:12:45,039 --> 00:12:48,000
Pero con un poquito más de complejidad

204
00:12:48,000 --> 00:12:50,720
En vez de resolver solo problemas concretos

205
00:12:50,720 --> 00:12:53,820
De solo números con tres dígitos

206
00:12:53,820 --> 00:12:55,840
Pues ahora haremos, dame un número cualquiera

207
00:12:55,840 --> 00:12:59,500
Y ese número voy a hacer lo que tengo que hacer

208
00:12:59,500 --> 00:12:59,720
¿Sí?

209
00:13:00,320 --> 00:13:00,840
Veremos

210
00:13:00,840 --> 00:13:03,139
¿Qué aclaró el while?

211
00:13:03,299 --> 00:13:04,220
O sea, ¿qué hace?

212
00:13:04,360 --> 00:13:06,679
Como la estructura, la sintaxis, ¿vale?

213
00:13:06,740 --> 00:13:08,620
While, palabra reservada

214
00:13:08,620 --> 00:13:11,700
Una condición, no necesariamente tiene que utilizar y

215
00:13:11,700 --> 00:13:14,320
Pues aquí he utilizado y, pero ¿qué más da?

216
00:13:14,320 --> 00:13:16,019
Y aquí dentro escribe

217
00:13:16,019 --> 00:13:20,200
Fijaos que en este caso

218
00:13:20,200 --> 00:13:22,960
La condición depende de i

219
00:13:22,960 --> 00:13:25,159
Y que dentro del bloque

220
00:13:25,159 --> 00:13:27,600
En algún momento he toqueteado i

221
00:13:27,600 --> 00:13:29,899
Si quito este i

222
00:13:29,899 --> 00:13:32,240
Imaginaos que esta línea no esté

223
00:13:32,240 --> 00:13:33,799
¿Qué haría este programa?

224
00:13:34,340 --> 00:13:34,980
Sin esta línea

225
00:13:34,980 --> 00:13:40,259
Muy bien, ¿por qué levantar las manos?

226
00:13:42,600 --> 00:13:43,440
¿Qué haría esta cosa?

227
00:13:46,230 --> 00:13:46,789
Efectivamente

228
00:13:46,789 --> 00:13:48,509
Escribiría cero

229
00:13:48,509 --> 00:13:49,970
Nunca se actualiza cero

230
00:13:49,970 --> 00:13:52,870
Por lo tanto, cada vez que pasa por aquí, escribiría un cero

231
00:13:52,870 --> 00:13:55,509
Y cada vez cero sería menor o igual que diez

232
00:13:55,509 --> 00:13:59,509
Entonces se quedaría aquí al infinito poniendo cero, cero, cero, cero

233
00:13:59,509 --> 00:14:01,210
¿Vale?

234
00:14:01,710 --> 00:14:03,009
Y mi programa no acaba

235
00:14:03,009 --> 00:14:13,049
No, no explota

236
00:14:13,049 --> 00:14:15,809
Porque es lo que le has dicho que haga

237
00:14:15,809 --> 00:14:16,309
¿Vale?

238
00:14:17,090 --> 00:14:22,110
Si lo que estás haciendo es algo que gasta recursos

239
00:14:22,110 --> 00:14:23,529
Crea memoria

240
00:14:23,529 --> 00:14:25,509
No si creas una variable aquí dentro

241
00:14:25,509 --> 00:14:27,230
Porque cada ciclo se destruiría

242
00:14:27,230 --> 00:14:31,950
Si por ejemplo creas un proceso, cada vez que pasas por aquí creas otro programita.

243
00:14:32,830 --> 00:14:36,929
Y entonces vas creando proceso, vas creando proceso, como los recursos son limitados,

244
00:14:37,049 --> 00:14:40,710
llega un momento en que el sistema operativo no puede crear más procesos y explota.

245
00:14:41,389 --> 00:14:44,850
Pero esta cosa de aquí puede tirar para siempre.

246
00:14:45,129 --> 00:14:46,149
Luego lo hacemos.

247
00:14:49,629 --> 00:14:52,889
Así es como podría funcionar algún tipo de virus.

248
00:14:53,830 --> 00:14:57,789
Pero sería muy básico un virus que hace eso.

249
00:14:59,950 --> 00:15:11,590
dudas una versión un poquito distinta del while que pero es muy parecida es el do while vale si

250
00:15:11,590 --> 00:15:20,870
os fijáis en el while podría ser que estas instrucciones no se ejecuten nunca si yo llego

251
00:15:20,870 --> 00:15:28,110
a esta condición y esta condición es falsa salto esto y sigo adelante vale si este número de aquí

252
00:15:28,110 --> 00:15:30,330
en vez de ponerle 0 le digo al usuario

253
00:15:30,330 --> 00:15:31,149
dame un número

254
00:15:31,149 --> 00:15:33,350
y el usuario le pone 30

255
00:15:33,350 --> 00:15:35,769
30 es menor o igual que 10

256
00:15:35,769 --> 00:15:38,230
no, saltaría esto y seguiría adelante

257
00:15:38,230 --> 00:15:40,090
nunca haría nada

258
00:15:40,090 --> 00:15:40,850
dentro de este bloque

259
00:15:40,850 --> 00:15:43,929
si yo quiero

260
00:15:43,929 --> 00:15:46,049
estar seguro que al menos

261
00:15:46,049 --> 00:15:48,429
una vez este bloque se ejecute

262
00:15:48,429 --> 00:15:50,169
luego puede ser que no se repita

263
00:15:50,169 --> 00:15:52,250
pero que una vez se ejecuta

264
00:15:52,250 --> 00:15:53,750
y a partir de allí podría

265
00:15:53,750 --> 00:15:56,169
repetirse varias veces o podría

266
00:15:56,169 --> 00:15:58,129
no repetirse, pues puedo utilizar

267
00:15:58,129 --> 00:15:58,990
el do while

268
00:15:58,990 --> 00:16:02,549
el do while tiene las instrucciones

269
00:16:02,549 --> 00:16:03,289
antes

270
00:16:03,289 --> 00:16:06,110
y una vez siempre

271
00:16:06,110 --> 00:16:07,730
se ejecutará esta instrucción

272
00:16:07,730 --> 00:16:10,289
una vez ejecutada esta instrucción

273
00:16:10,289 --> 00:16:11,509
llego a la condición

274
00:16:11,509 --> 00:16:14,070
y si es verdadero, vuelvo

275
00:16:14,070 --> 00:16:16,049
a ejecutar las instrucciones

276
00:16:16,049 --> 00:16:17,850
si es falso, sigo adelante

277
00:16:17,850 --> 00:16:22,129
entonces la sintaxis sería así

278
00:16:22,129 --> 00:16:24,330
int contador es igual a 0

279
00:16:24,330 --> 00:16:24,789
do

280
00:16:24,789 --> 00:16:29,350
y luego el bloque, esta ejecución de aquí, esta cosa aquí

281
00:16:29,350 --> 00:16:32,090
se ejecutará al menos una vez siempre

282
00:16:32,090 --> 00:16:36,230
y luego después, mientras el contador es menor o igual que 10

283
00:16:36,230 --> 00:16:39,509
pues sigue haciendo cosas, fijaos

284
00:16:39,509 --> 00:16:44,929
no hay punto y coma por ningún lado, aquí en las instrucciones

285
00:16:44,929 --> 00:16:48,789
pero en el while no, si ponéis un punto y coma aquí, habéis hecho

286
00:16:48,789 --> 00:16:52,129
un while eterno que no hace nada

287
00:16:52,129 --> 00:16:56,350
Como el if que no haría nada

288
00:16:56,350 --> 00:16:58,429
Pero en este caso el problema es que el while

289
00:16:58,429 --> 00:17:00,350
Se quedaría aquí dentro para siempre

290
00:17:00,350 --> 00:17:01,730
Porque esto no se actualiza

291
00:17:01,730 --> 00:17:04,529
Y estaría haciendo un comando vacío para siempre

292
00:17:04,529 --> 00:17:06,549
Por tanto cuidado con esto

293
00:17:06,549 --> 00:17:09,650
Sin embargo en el do while

294
00:17:09,650 --> 00:17:11,529
La condición while

295
00:17:11,529 --> 00:17:13,190
Acaba con un punto en coma

296
00:17:13,190 --> 00:17:17,119
Entonces cuidado con la sintaxis

297
00:17:17,119 --> 00:17:28,779
Si aquí pusiera 11

298
00:17:28,779 --> 00:17:31,559
La primera vez escribiría 11

299
00:17:31,559 --> 00:17:34,119
Haría contador 12

300
00:17:34,119 --> 00:17:37,200
Aquí se daría cuenta que 12 es menor o igual que 10

301
00:17:37,200 --> 00:17:39,420
No, por lo tanto salgo y sigo adelante

302
00:17:39,420 --> 00:17:42,259
Y a partir de aquí abajo, mi contador valdría 12

303
00:17:42,259 --> 00:17:47,240
Si pongo 100, pues me imprimiría 100

304
00:17:47,240 --> 00:17:49,200
Valdría 101 y saldría

305
00:17:49,200 --> 00:17:52,119
Si pongo 0, como es este caso

306
00:17:52,119 --> 00:17:55,660
Pues entro aquí dentro, escribo el 0 y cambio a 1

307
00:17:55,660 --> 00:17:58,339
Escribo 1 y cambio a 2

308
00:17:58,339 --> 00:17:59,500
Escribo 2 y cambio a 3

309
00:17:59,500 --> 00:18:01,200
Hasta que valga 10

310
00:18:01,200 --> 00:18:03,099
Entonces escribo el 10

311
00:18:03,099 --> 00:18:07,440
esto me vale 11, y aquí 11 no es menor o igual que 10

312
00:18:07,440 --> 00:18:11,700
por lo tanto salgo, o sea que haría exactamente lo mismo que antes

313
00:18:11,700 --> 00:18:14,680
solo que la diferencia es que

314
00:18:14,680 --> 00:18:19,599
esto una vez se ejecutará siempre, mientras que aquí

315
00:18:19,599 --> 00:18:22,680
esto podría no ejecutarse nunca, dependiendo de la condición

316
00:18:22,680 --> 00:18:28,059
en cierto sentido, aquí antes evalúo la condición y luego empiezo a repetir

317
00:18:28,059 --> 00:18:32,059
mientras aquí empiezo a repetir y luego evalúo la condición

318
00:18:32,059 --> 00:18:35,500
o dicho de otra forma

319
00:18:35,500 --> 00:18:37,559
esto me permite repetir esto

320
00:18:37,559 --> 00:18:39,599
cero o más veces

321
00:18:39,599 --> 00:18:41,539
esto me permite

322
00:18:41,539 --> 00:18:44,119
repetir esto una o más veces

323
00:18:44,119 --> 00:18:47,849
dudas

324
00:18:47,849 --> 00:18:52,930
tanto el while

325
00:18:52,930 --> 00:18:53,869
como el do while

326
00:18:53,869 --> 00:18:56,750
se utilizan

327
00:18:56,750 --> 00:18:58,769
normalmente cuando no tengo

328
00:18:58,769 --> 00:19:01,069
claro cuantas veces

329
00:19:01,069 --> 00:19:03,009
tengo que ciclar

330
00:19:03,009 --> 00:19:04,450
cuantas veces tengo que

331
00:19:04,450 --> 00:19:06,990
volver a repetir este bloque aquí

332
00:19:06,990 --> 00:19:07,589
¿Vale?

333
00:19:08,269 --> 00:19:11,230
Si, por ejemplo, en este caso de aquí

334
00:19:11,230 --> 00:19:13,089
Que yo sé más o menos cuántos son

335
00:19:13,089 --> 00:19:15,089
Se repite unas 10 veces

336
00:19:15,089 --> 00:19:18,049
El while no sería el más indicado

337
00:19:18,049 --> 00:19:19,089
¿Vale?

338
00:19:19,089 --> 00:19:21,890
Se pone aquí como ejemplo porque es la cosa más fácil que se puede hacer

339
00:19:21,890 --> 00:19:23,230
Escribir un número 10 veces

340
00:19:23,230 --> 00:19:23,829
¿Sí?

341
00:19:24,109 --> 00:19:24,490
O 11

342
00:19:24,490 --> 00:19:25,690
Pero

343
00:19:25,690 --> 00:19:30,190
Cuando yo sé que voy a repetir esta cosa 10 veces

344
00:19:30,190 --> 00:19:31,289
O 11 veces

345
00:19:31,289 --> 00:19:32,569
O 20 veces seguro

346
00:19:32,569 --> 00:19:34,250
Lo que debería utilizar

347
00:19:34,250 --> 00:19:35,569
Es el for

348
00:19:35,569 --> 00:19:36,690
¿Vale?

349
00:19:36,990 --> 00:19:38,970
Son equivalentes

350
00:19:38,970 --> 00:19:40,829
Lo que puede hacer con el for

351
00:19:40,829 --> 00:19:42,470
Se puede hacer con el while

352
00:19:42,470 --> 00:19:44,150
Lo que puede hacer con el while

353
00:19:44,150 --> 00:19:45,450
Lo puede hacer con el for

354
00:19:45,450 --> 00:19:48,329
Pero es un poco como el if y el switch

355
00:19:48,329 --> 00:19:50,990
El if y el switch pueden hacer las mismas cosas

356
00:19:50,990 --> 00:19:52,369
Pero hay veces

357
00:19:52,369 --> 00:19:54,390
Que mejor un switch de un if

358
00:19:54,390 --> 00:19:56,049
Y hay veces que mejor un if de un switch

359
00:19:56,049 --> 00:19:57,549
Pues aquí lo mismo

360
00:19:57,549 --> 00:19:59,109
Cuando uso el while

361
00:19:59,109 --> 00:20:02,390
Cuando no sé cuantas veces voy a estar aquí dentro

362
00:20:02,390 --> 00:20:04,190
Imaginaos un ejercicio que os diga

363
00:20:04,190 --> 00:20:05,289
Dame un número

364
00:20:05,289 --> 00:20:07,029
Yo leo el número

365
00:20:07,029 --> 00:20:08,450
Y si el número es positivo

366
00:20:08,450 --> 00:20:10,109
Sigo pidiendo números

367
00:20:10,109 --> 00:20:13,029
Si el número es negativo, acabo

368
00:20:13,029 --> 00:20:16,109
¿Sé cuántas veces voy a pedir números?

369
00:20:17,269 --> 00:20:18,890
No, porque depende del usuario

370
00:20:18,890 --> 00:20:20,869
Si un día el usuario se despierta

371
00:20:20,869 --> 00:20:22,490
Y me da 100 números positivos

372
00:20:22,490 --> 00:20:24,210
Pues yo repetiré esto 100 veces

373
00:20:24,210 --> 00:20:26,490
Y cuando me dará el negativo, saldré

374
00:20:26,490 --> 00:20:29,190
Si mañana se despierta y me da 3 números positivos

375
00:20:29,190 --> 00:20:31,609
Y luego un negativo, pues solo tendré que repetir 3 veces

376
00:20:31,609 --> 00:20:32,809
Pero a tiempo aquí

377
00:20:32,809 --> 00:20:34,390
No sé cuántas veces serán

378
00:20:34,390 --> 00:20:56,309
Serán n veces, ¿sí? Sin embargo, si yo sé que quiero hacerlo 10 veces, por ejemplo, pues debería utilizar un for. ¿Cómo funciona un for? Es un poquito más complejo, pero hace lo mismo que antes, ¿vale? Hay una inicialización donde se inicializa un índice, una variable, un contador, ¿vale? A un cierto valor.

379
00:20:56,309 --> 00:21:04,970
Por ejemplo, i igual a 0, lo mismo que se hacía aquí, pero esto está incrustado en el mismo for, ahora veremos la cosa.

380
00:21:05,769 --> 00:21:13,609
Luego se empieza a mirar una condición, si la condición es verdadera, entro y hago las instrucciones,

381
00:21:14,269 --> 00:21:24,470
pero tengo un paso adicional que una vez acabadas las instrucciones, tengo una fase de actualización barra incremento de la variable que he inicializado aquí.

382
00:21:24,470 --> 00:21:27,000
esto

383
00:21:27,000 --> 00:21:31,319
for int i es igual a 0

384
00:21:31,319 --> 00:21:32,920
i menor que 10

385
00:21:32,920 --> 00:21:34,299
i más más

386
00:21:34,299 --> 00:21:37,400
fijaos que aquí estoy utilizando el menor estricto

387
00:21:37,400 --> 00:21:38,400
block

388
00:21:38,400 --> 00:21:41,119
entonces esta cosa de aquí

389
00:21:41,119 --> 00:21:43,400
se ejecutará

390
00:21:43,400 --> 00:21:46,059
mientras que i es menor que 10

391
00:21:46,059 --> 00:21:48,259
pero i valdrá 0

392
00:21:48,259 --> 00:21:49,720
la primera vez que empiezo

393
00:21:49,720 --> 00:21:51,299
esta es la fase de inicialización

394
00:21:51,299 --> 00:21:54,559
0 es menor que 10

395
00:21:54,559 --> 00:21:55,660
por lo tanto entraré

396
00:21:55,660 --> 00:22:04,019
Y antes de volver aquí, antes de volver a comprobar esta, voy a hacer la fase de actualización, que es esta de aquí.

397
00:22:05,059 --> 00:22:05,720
Y más más.

398
00:22:08,079 --> 00:22:12,880
Si ponéis un igual aquí, esto hace exactamente lo mismo que esto.

399
00:22:15,309 --> 00:22:15,710
Lo mismo.

400
00:22:16,410 --> 00:22:19,369
Inicializa, verifica, actualiza.

401
00:22:20,509 --> 00:22:27,069
Solo que como esto se hace muchas veces, Java proporciona, y muchos otros programas, lenguaje de programación,

402
00:22:27,069 --> 00:22:30,250
Proporciona una estructura propia

403
00:22:30,250 --> 00:22:32,769
Para cuando tienes que hacer este tipo de cosas

404
00:22:32,769 --> 00:22:35,150
Cuando tú sabes una variable que empieza en un valor

405
00:22:35,150 --> 00:22:37,430
Y que tiene que hacer una cosa varias veces

406
00:22:37,430 --> 00:22:39,609
Y este valor va incrementando cada vez

407
00:22:39,609 --> 00:22:51,160
37 y mayor que 94 y menos menos

408
00:22:51,160 --> 00:22:52,099
¿Qué te hago?

409
00:22:54,579 --> 00:22:56,160
Ah, aquí, scan, sí, sí

410
00:22:56,160 --> 00:22:57,259
¿Por qué no?

411
00:23:03,890 --> 00:23:04,410
Cuidado

412
00:23:04,410 --> 00:23:07,029
Esto se entiende más o menos

413
00:23:07,029 --> 00:23:09,390
¿Vale? Entonces es como un ciclo

414
00:23:09,390 --> 00:23:10,529
Pero en automático

415
00:23:10,529 --> 00:23:12,910
Por cada ciclo se ejecuta esto

416
00:23:12,910 --> 00:23:14,829
Entonces en este caso por ejemplo

417
00:23:14,829 --> 00:23:16,750
Y empezaría en 0 y por cada ciclo

418
00:23:16,750 --> 00:23:18,369
Cada vez que voy a comprobar esto

419
00:23:18,369 --> 00:23:19,490
Y me aumenta de 1

420
00:23:19,490 --> 00:23:22,950
La primera vez valdrá 0, la segunda vez 1, la tercera vez 2

421
00:23:22,950 --> 00:23:23,789
Etcétera, etcétera, etcétera

422
00:23:23,789 --> 00:23:26,890
Hasta que valdrá 10 y entonces saldrá

423
00:23:26,890 --> 00:23:29,289
Esto que me escribe en pantalla

424
00:23:29,289 --> 00:23:33,589
Los números

425
00:23:33,589 --> 00:23:38,299
De 0 al 9

426
00:23:38,299 --> 00:23:39,819
Cuidado, eh

427
00:23:39,819 --> 00:23:41,700
Menor estricto

428
00:23:41,700 --> 00:23:46,609
Entonces, ¿cuántas veces me repite esto?

429
00:23:49,829 --> 00:23:50,569
Diez veces.

430
00:23:51,230 --> 00:23:53,710
Del 0 al 9, lo está repitiendo diez veces.

431
00:23:54,490 --> 00:23:56,130
Lo está repitiendo este veces.

432
00:24:01,859 --> 00:24:03,259
Ejemplos de for también.

433
00:24:03,960 --> 00:24:05,359
inti.com

434
00:24:05,359 --> 00:24:09,819
for i igual a 0, i menor que 3, i más más.

435
00:24:10,380 --> 00:24:12,019
Existe el punto alto, el punto del n, i.

436
00:24:12,480 --> 00:24:13,640
i es igual a 10.

437
00:24:14,279 --> 00:24:16,480
Esta cosa de aquí es correcta.

438
00:24:16,740 --> 00:24:17,140
¿Por qué?

439
00:24:17,140 --> 00:24:34,099
¿Por qué? Porque int i se hace fuera de este bloque. Int i se ha declarado fuera del for. Por lo tanto, existe su ámbito, el ámbito de esta i, de esta variable, es todo esto. Aquí sigue existiendo.

440
00:24:34,099 --> 00:24:38,759
De hecho, si yo aquí imprimiera i, ¿me valdría cuánto?

441
00:24:39,180 --> 00:24:44,380
Si en esta línea aquí, en vez de hacer i igual a 10, imprimiera en pantalla i, ¿cuánto valdría?

442
00:24:47,500 --> 00:24:47,940
3.

443
00:24:49,400 --> 00:24:54,019
Entra aquí, vale 0, se pone a ciclar aquí imprimiendo todo lo que sea.

444
00:24:54,660 --> 00:25:04,539
Y cuando i, mientras i es menor que 3, sigue haciéndolo, cuando i se volverá 3, saldrá de aquí, y por lo tanto en este punto vale 3.

445
00:25:04,539 --> 00:25:08,099
Luego yo lo puedo cambiar a 10, es correcto

446
00:25:08,099 --> 00:25:11,200
En pantalla este código pondría 0, 1, 2

447
00:25:11,200 --> 00:25:15,079
La primera vale 0, escribe 0

448
00:25:15,079 --> 00:25:16,819
Luego vale 1, escribe 1

449
00:25:16,819 --> 00:25:18,619
Luego vale 2, escribe 2

450
00:25:18,619 --> 00:25:20,220
Luego vale 3, sale

451
00:25:20,220 --> 00:25:29,069
En este caso no es correcto

452
00:25:29,069 --> 00:25:30,130
Explotaría

453
00:25:30,130 --> 00:25:32,589
A tiempo de compilación

454
00:25:32,589 --> 00:25:34,390
O sea, no lo puedo ejecutar esto

455
00:25:34,390 --> 00:25:39,349
Porque estoy declarando la variable dentro del for

456
00:25:39,349 --> 00:25:42,329
Al declarar la variable dentro del for

457
00:25:42,329 --> 00:25:45,009
Esta variable solo existe en este bloque

458
00:25:45,009 --> 00:25:47,789
Cuando salgo de este bloque

459
00:25:47,789 --> 00:25:49,390
Y ya no existe

460
00:25:49,390 --> 00:25:51,329
Y si intento utilizarla

461
00:25:51,329 --> 00:25:52,329
Pues me da un error

462
00:25:52,329 --> 00:25:53,410
Me dice y no existe

463
00:25:53,410 --> 00:26:00,420
Me dice que no resuelve el símbolo

464
00:26:00,420 --> 00:26:00,859
¿Dudas?

465
00:26:04,970 --> 00:26:07,589
Claramente se pueden poner for dentro de for

466
00:26:07,589 --> 00:26:08,849
While dentro de while

467
00:26:08,849 --> 00:26:09,950
For dentro de while

468
00:26:09,950 --> 00:26:11,690
while dentro de for dentro de if

469
00:26:11,690 --> 00:26:13,210
if dentro de for de while

470
00:26:13,210 --> 00:26:14,910
podéis hacer lo que os da la gana

471
00:26:14,910 --> 00:26:18,130
y esto es lo que hace caos

472
00:26:18,130 --> 00:26:19,509
¿vale?

473
00:26:20,230 --> 00:26:22,269
utilizarlos así es relativamente sencillo

474
00:26:22,269 --> 00:26:23,789
cuando empezáis a meter

475
00:26:23,789 --> 00:26:26,470
for dentro de for y while dentro de while

476
00:26:26,470 --> 00:26:28,009
la cosa se complica

477
00:26:28,009 --> 00:26:29,329
se complica por dos cosas

478
00:26:29,329 --> 00:26:32,150
primero porque es más difícil entender que está pasando

479
00:26:32,150 --> 00:26:34,049
ahora intentamos analizar esto

480
00:26:34,049 --> 00:26:34,569
¿vale?

481
00:26:35,269 --> 00:26:36,849
pero la segunda cosa es que

482
00:26:36,849 --> 00:26:40,150
Normalmente cuando metemos un while dentro de un while

483
00:26:40,150 --> 00:26:41,250
O un for dentro de un for

484
00:26:41,250 --> 00:26:44,849
La complejidad computacional

485
00:26:44,849 --> 00:26:47,150
De los algoritmos

486
00:26:47,150 --> 00:26:50,109
Se vuelve peor

487
00:26:50,109 --> 00:26:50,890
¿Vale?

488
00:26:51,609 --> 00:26:53,589
¿Qué es la complejidad computacional?

489
00:26:53,849 --> 00:26:55,410
Es una medida de

490
00:26:55,410 --> 00:26:58,250
En base a los datos que me das

491
00:26:58,250 --> 00:27:01,130
Cuanto tarda mi programa

492
00:27:01,130 --> 00:27:02,410
Hacer lo que tiene que hacer

493
00:27:02,410 --> 00:27:03,509
¿Vale?

494
00:27:03,690 --> 00:27:06,289
Y eso se mide en términos de n

495
00:27:06,289 --> 00:27:13,529
Con n representa sustancialmente los datos que tú me das

496
00:27:13,529 --> 00:27:15,470
Si me das un dato, dos datos, mil datos

497
00:27:15,470 --> 00:27:27,910
Y por ejemplo la complejidad computacional puede ser del orden de n mismo

498
00:27:27,910 --> 00:27:28,910
Linear

499
00:27:28,910 --> 00:27:33,630
Eso quiere decir que si me das 10 datos tardaré 10 segundos

500
00:27:33,630 --> 00:27:37,130
Si me das mil datos, tardaré mil segundos

501
00:27:37,130 --> 00:27:41,430
Cuanto más datos me das, más tiempo tardaré

502
00:27:41,430 --> 00:27:42,809
Pero de una forma linear

503
00:27:42,809 --> 00:27:46,430
Luego hay programas buenos, algoritmos buenos

504
00:27:46,430 --> 00:27:49,390
Que pueden ser, por ejemplo, logarítmicos

505
00:27:49,390 --> 00:27:52,849
O sea, que el tiempo que tardan es logaritmo de n

506
00:27:52,849 --> 00:27:55,990
Eso quiere decir que cuanto más datos me das

507
00:27:55,990 --> 00:27:59,490
Si me das diez datos, tardaré un cierto tiempo

508
00:27:59,490 --> 00:28:02,509
Si me das mil datos, no tardo mil

509
00:28:02,509 --> 00:28:03,930
Tardo menos que 1000

510
00:28:03,930 --> 00:28:07,930
Más que 10

511
00:28:07,930 --> 00:28:10,289
Pero menos que 1000

512
00:28:10,289 --> 00:28:14,990
O sea que es mejor, es un algoritmo mejor con respecto al lineal

513
00:28:14,990 --> 00:28:18,789
El problema de poner for dentro de for y while dentro de while

514
00:28:18,789 --> 00:28:26,990
Es que podría llegar a tener un coste computacional de n elevado a la 2

515
00:28:26,990 --> 00:28:31,569
O sea que te doy un dato y me tardas un segundo

516
00:28:31,569 --> 00:28:37,589
te doy 10 y me tardas 100, te doy 1000 y me tardas 10.000 segundos.

517
00:28:39,309 --> 00:28:43,890
Estos son los problemas que cuando se complican, cuando intento hacerlo con más datos,

518
00:28:44,710 --> 00:28:48,109
pues llega un momento en que tarda demasiado el sistema y colapsa.

519
00:28:49,250 --> 00:28:54,410
Aún así, el estudio de la complejidad de un algoritmo no es una cosa que vemos aquí,

520
00:28:54,809 --> 00:29:00,609
alguna vez a lo mejor daré unas pinceladas cuando veremos algoritmos de búsqueda o cosas por el estilo,

521
00:29:00,609 --> 00:29:09,650
O de, no sé si habéis visto alguna vez en internet, en redes sociales o cosas por el estilo, TikTok o lo que sea

522
00:29:09,650 --> 00:29:17,890
Hay vídeos de ordenación de colecciones de datos

523
00:29:17,890 --> 00:29:27,430
Que salen una serie de columnitas desordenadas y os la ordena en un triangulito

524
00:29:27,430 --> 00:29:28,990
¿Esto nunca es una cosa así?

525
00:29:29,670 --> 00:29:31,109
No, lo buscaríais lo anterior

526
00:29:31,109 --> 00:29:38,509
Deberías intentar

527
00:29:38,509 --> 00:29:40,430
Evitarlo si no es necesario

528
00:29:40,430 --> 00:29:43,009
Hay problemas

529
00:29:43,009 --> 00:29:44,730
Que lo tienes que hacer

530
00:29:44,730 --> 00:29:46,289
Si o si, entonces lo vas a hacer

531
00:29:46,289 --> 00:29:48,769
Pero tienes que saber que cuando vas a hacer

532
00:29:48,769 --> 00:29:49,430
Una cosa así

533
00:29:49,430 --> 00:29:52,750
Tienes la posibilidad de crearte

534
00:29:52,750 --> 00:29:55,210
Un bloque de código

535
00:29:55,210 --> 00:29:56,970
Que luego va a ser

536
00:29:56,970 --> 00:29:58,349
Lento

537
00:29:58,349 --> 00:29:59,730
Cuando ejecutas

538
00:29:59,730 --> 00:30:01,789
Y si tienes un algoritmo que lo puede evitar

539
00:30:01,789 --> 00:30:07,250
pero eso siempre es en términos de optimización

540
00:30:07,250 --> 00:30:11,049
por ejemplo, ¿qué hace esta monstruosidad aquí?

541
00:30:11,690 --> 00:30:13,970
fijaos, tengo un for externo

542
00:30:13,970 --> 00:30:16,490
este for trabaja con i

543
00:30:16,490 --> 00:30:20,069
y va de 1 a 2

544
00:30:20,069 --> 00:30:23,470
o sea que lo que está aquí dentro

545
00:30:23,470 --> 00:30:25,730
se ejecutará dos veces, ¿lo veis?

546
00:30:26,130 --> 00:30:28,970
la primera vez valdrá 1, sumará 1, valdrá 2

547
00:30:28,970 --> 00:30:32,430
sigue entrando y cuando esto valdrá 3

548
00:30:32,430 --> 00:30:36,210
pues saldrá, por lo tanto la parte interna de este for

549
00:30:36,210 --> 00:30:37,549
se ejecutará dos veces

550
00:30:37,549 --> 00:30:44,109
dentro de este for hay otro for que va de 1

551
00:30:44,109 --> 00:30:47,789
a 2 también, ¿vale? y lo que hace

552
00:30:47,789 --> 00:30:51,680
es imprimir I

553
00:30:51,680 --> 00:30:56,480
luego un espacio, luego J

554
00:30:56,480 --> 00:31:01,579
luego un espacio y luego la multiplicación de I por J

555
00:31:03,779 --> 00:31:08,920
Entonces, la primera vez que entrará aquí, il vale 1 y j vale 1.

556
00:31:09,579 --> 00:31:11,720
Por lo tanto, esto será 1, 1, 1.

557
00:31:14,099 --> 00:31:14,220
¿Sí?

558
00:31:15,539 --> 00:31:19,720
Acaba este for y no vuelve el for exterior, vuelve el for interior.

559
00:31:21,619 --> 00:31:22,180
Justo.

560
00:31:24,319 --> 00:31:25,480
Y actualizará j.

561
00:31:26,400 --> 00:31:28,140
Por lo tanto, ahora j valdrá 2.

562
00:31:28,920 --> 00:31:32,519
Por lo tanto, entra aquí otra vez y sigue valiendo 1.

563
00:31:32,519 --> 00:31:34,819
J vale 2

564
00:31:34,819 --> 00:31:36,700
Y 2 por 1, 2

565
00:31:36,700 --> 00:31:39,180
Por lo tanto, 1, 2, 2

566
00:31:39,180 --> 00:31:44,109
Porque todavía no he pasado por aquí

567
00:31:44,109 --> 00:31:45,769
Porque he entrado en este bloque

568
00:31:45,769 --> 00:31:48,289
Y este for tiene que ciclar dos veces

569
00:31:48,289 --> 00:31:51,390
Antes de salir y llegar al final del for anterior

570
00:31:51,390 --> 00:31:53,940
¿Sí o no?

571
00:31:54,980 --> 00:31:57,720
Por lo tanto, ejecuto dos veces estas

572
00:31:57,720 --> 00:32:00,240
Antes de volver a actualizar este de arriba

573
00:32:00,240 --> 00:32:01,000
¿Vale?

574
00:32:01,579 --> 00:32:03,019
Lo he ejecutado dos veces

575
00:32:03,019 --> 00:32:05,259
Salgo fuera, vuelvo arriba

576
00:32:05,259 --> 00:32:08,059
Ahora i se actualiza, ahora i vale 2

577
00:32:08,059 --> 00:32:11,519
Y entra otra vez aquí dentro

578
00:32:11,519 --> 00:32:13,640
Y fijaos que cuando vuelve a entrar

579
00:32:13,640 --> 00:32:15,859
Esto antes había desaparecido

580
00:32:15,859 --> 00:32:17,680
Vuelve a ser un nuevo for

581
00:32:17,680 --> 00:32:20,660
E int j vuelve a empezar otra vez desde 1

582
00:32:20,660 --> 00:32:25,099
Entonces entra aquí dentro

583
00:32:25,099 --> 00:32:28,019
Esto vale 2, esto vale 1

584
00:32:28,019 --> 00:32:29,980
Y esto vale 2 por 1

585
00:32:29,980 --> 00:32:32,440
2, 1, 2

586
00:32:32,440 --> 00:32:37,960
Llego aquí y vuelvo a este for

587
00:32:37,960 --> 00:32:42,500
Actualizo j, ahora j vale 2

588
00:32:42,500 --> 00:32:46,880
Compruebo que j es menor o igual que 2, verdadero

589
00:32:46,880 --> 00:32:50,680
Vuelvo a entrar aquí, i sigue valiendo 2

590
00:32:50,680 --> 00:32:54,160
j vale 2, y 2 por 2 es 4

591
00:32:54,160 --> 00:32:55,960
2, 2, 4

592
00:32:57,839 --> 00:33:01,299
Llego aquí, actualizo j que diventa 3

593
00:33:01,299 --> 00:33:16,299
3 no es menor o igual que 2, por lo tanto salgo del for interno, llego aquí, voy aquí arriba, actualizo i, ahora i vale 3, 3 no es menor o igual que 2, por lo tanto salgo también del for externo.

594
00:33:19,549 --> 00:33:24,710
Poner for dentro de for empieza a ser un buen juego mental.

595
00:33:33,000 --> 00:33:34,259
No lo sé, este es un ejemplo.

596
00:33:34,259 --> 00:33:39,220
Pero imagínate que estas sean posiciones de una matriz.

597
00:33:39,220 --> 00:33:42,180
es que yo quiero recorrer esta matriz por líneas

598
00:33:42,180 --> 00:33:44,859
pues entonces estoy recorriendo la primera línea

599
00:33:44,859 --> 00:33:46,460
celda 1, celda 2

600
00:33:46,460 --> 00:33:49,279
luego cambio de línea, celda 1, celda 2

601
00:33:49,279 --> 00:33:54,819
¿para qué sirve? no lo sé

602
00:33:54,819 --> 00:33:56,359
¿se puede hacer? sí

603
00:33:56,359 --> 00:34:00,319
si mi problema me dice que tengo que hacer una cosa así

604
00:34:00,319 --> 00:34:03,619
pues veremos, hay situaciones en las que tengo que poner

605
00:34:03,619 --> 00:34:05,920
un while dentro de un while, un for dentro de un for

606
00:34:05,920 --> 00:34:07,740
un while dentro de un for o cosas por el estilo

607
00:34:07,740 --> 00:34:11,099
hay algoritmo que requieran

608
00:34:11,099 --> 00:34:13,679
hacer esa cosa

609
00:34:13,679 --> 00:34:17,639
fijar un valor y mirar todos los demás

610
00:34:17,639 --> 00:34:20,420
luego fijar otro valor y mirar todos los demás

611
00:34:20,420 --> 00:34:22,920
luego fijar otro valor y mirar todos los demás

612
00:34:22,920 --> 00:34:25,860
eso es un for

613
00:34:25,860 --> 00:34:27,739
dentro de un for

614
00:34:27,739 --> 00:34:39,250
ejemplos

615
00:34:39,250 --> 00:34:44,679
la idea es que ahora hagamos unos ejemplos

616
00:34:44,679 --> 00:34:48,400
luego a partir de mañana haremos más ejemplos todavía

617
00:34:48,400 --> 00:34:51,099
y luego empezaremos con ejercicios

618
00:34:51,099 --> 00:34:55,300
tened en cuenta que todo lo que hemos usado hasta ahora

619
00:34:55,300 --> 00:34:58,440
sigue funcionando

620
00:34:58,440 --> 00:35:03,860
sigue allí, sabemos los casting, crear variables

621
00:35:03,860 --> 00:35:08,219
operar con string, etc, etc, pues lo tenemos que saber

622
00:35:08,219 --> 00:35:12,519
pues vamos a ver ahora que pasa

623
00:35:12,519 --> 00:35:25,179
vale, entonces, vamos a hacer un ejercicio sencillo

624
00:35:25,179 --> 00:35:26,960
Vendrá seguramente más adelante

625
00:35:26,960 --> 00:35:30,579
Vamos a hacer el ejercicio que decíamos antes

626
00:35:30,579 --> 00:35:36,289
Quiero un programa

627
00:35:36,289 --> 00:35:39,889
Que lo que hace es pedir números al usuario

628
00:35:39,889 --> 00:35:43,349
Si los números son positivos

629
00:35:43,349 --> 00:35:45,409
Pedirá más y más

630
00:35:45,409 --> 00:35:50,829
En cuanto el usuario quiera acabar el programa

631
00:35:50,829 --> 00:35:52,650
Tiene que poner un número negativo

632
00:35:52,650 --> 00:35:54,889
Entonces

633
00:35:54,889 --> 00:35:57,750
ScannerScan es igual a

634
00:35:57,750 --> 00:35:58,889
NewScanner

635
00:35:58,889 --> 00:36:01,650
Existe en punto

636
00:36:01,650 --> 00:36:02,550
Sí

637
00:36:02,550 --> 00:36:04,409
Sí

638
00:36:04,409 --> 00:36:15,079
Eso se puede hacer muchos ejercicios

639
00:36:15,079 --> 00:36:15,460
Sí

640
00:36:15,460 --> 00:36:17,599
Por ejemplo

641
00:36:17,599 --> 00:36:19,880
Luego modificamos eso para hacer ese

642
00:36:19,880 --> 00:36:21,500
Int

643
00:36:21,500 --> 00:36:24,440
N es igual a

644
00:36:24,440 --> 00:36:26,539
Scanner.nextInt

645
00:36:26,539 --> 00:36:28,500
¿Vale?

646
00:36:28,500 --> 00:36:37,159
Ahora yo quiero un

647
00:36:37,159 --> 00:36:44,139
Bueno, dame un num

648
00:36:44,139 --> 00:36:48,619
Negativo para acabar

649
00:36:48,619 --> 00:36:53,349
Ahora, ¿cómo le digo

650
00:36:53,349 --> 00:36:57,469
Mientras que este n sea mayor que 0

651
00:36:57,469 --> 00:36:58,730
O mayor o igual que 0

652
00:36:58,730 --> 00:37:00,590
Sigue adelante

653
00:37:00,590 --> 00:37:03,989
Wille, why lo for?

654
00:37:05,570 --> 00:37:06,150
¿Por qué why?

655
00:37:06,590 --> 00:37:09,969
No sé cuántos números voy a pedir

656
00:37:09,969 --> 00:37:10,670
¿Vale?

657
00:37:11,030 --> 00:37:12,670
Pido todo lo que sea necesario

658
00:37:12,670 --> 00:37:13,769
Hasta que el usuario diga

659
00:37:13,769 --> 00:37:14,250
Ya está

660
00:37:14,250 --> 00:37:18,730
While n mayor o igual que 0

661
00:37:18,730 --> 00:37:21,030
Mientras esto sea verdadero

662
00:37:21,030 --> 00:37:22,269
¿Qué hago?

663
00:37:25,230 --> 00:37:25,949
Pido otro

664
00:37:25,949 --> 00:37:39,400
Cuando lo he acabado me preguntas cómo era el ejercicio

665
00:37:39,400 --> 00:37:45,980
Si hizo, ha acabado

666
00:37:45,980 --> 00:37:50,300
¿Qué hace esto de aquí?

667
00:37:50,699 --> 00:37:52,119
Me pide un primer número

668
00:37:52,119 --> 00:37:54,760
Fijaos que si esto es negativo

669
00:37:54,760 --> 00:37:56,420
Aquí dentro no entro

670
00:37:56,420 --> 00:37:58,780
Me voy aquí

671
00:37:58,780 --> 00:38:00,139
Y se ha acabado

672
00:38:00,139 --> 00:38:02,739
Si esto es positivo

673
00:38:02,739 --> 00:38:05,639
Como es positivo, entro dentro del while

674
00:38:05,639 --> 00:38:08,159
Y le digo, muy bien, dame otro número

675
00:38:08,159 --> 00:38:11,079
Y mientras que n

676
00:38:11,079 --> 00:38:13,199
Siga siendo positivo

677
00:38:13,199 --> 00:38:15,739
Siempre esta de aquí será positiva

678
00:38:15,739 --> 00:38:17,639
Y por lo tanto me quedaré aquí dando vueltas

679
00:38:17,639 --> 00:38:19,639
Y vueltas, y vueltas, y vueltas, y vueltas

680
00:38:19,639 --> 00:38:21,719
Hasta que me pongan

681
00:38:21,719 --> 00:38:22,800
Un número negativo

682
00:38:22,800 --> 00:38:25,519
Entonces será falso esto

683
00:38:25,519 --> 00:38:26,639
Y saldré aquí

684
00:38:26,639 --> 00:38:30,090
¿Cómo funciona esto?

685
00:38:36,789 --> 00:38:38,550
Dame un número para 3

686
00:38:38,550 --> 00:38:40,590
4, 5, 3

687
00:38:40,590 --> 00:38:42,730
36, 500, 700

688
00:38:42,730 --> 00:38:48,539
Hasta que le ponga

689
00:38:48,539 --> 00:38:49,920
Un número negativo

690
00:38:49,920 --> 00:38:58,949
¿Sí? Cualquier número

691
00:38:58,949 --> 00:39:01,760
¡Bum!

692
00:39:06,000 --> 00:39:07,320
Este aquí no es un entero

693
00:39:07,320 --> 00:39:10,199
No es un int

694
00:39:10,199 --> 00:39:12,800
¿Vale? Es un long

695
00:39:12,800 --> 00:39:14,500
Y quizás ni siquiera

696
00:39:14,500 --> 00:39:16,059
A lo mejor debería utilizar double

697
00:39:16,059 --> 00:39:18,400
¿Sí? Pero bueno

698
00:39:18,400 --> 00:39:22,280
Pero para nuestra cosa

699
00:39:22,280 --> 00:39:23,159
Nos vale

700
00:39:23,159 --> 00:39:26,599
¿Sí? Entonces, este es un ejemplo de while

701
00:39:26,599 --> 00:39:29,239
¿Para qué me puede servir while?

702
00:39:29,420 --> 00:39:30,219
¿Os acordáis?

703
00:39:30,900 --> 00:39:31,920
No, no os acordáis

704
00:39:31,920 --> 00:39:33,800
Por ejemplo, para hacer un menú

705
00:39:33,800 --> 00:39:35,159
¿Vale?

706
00:39:35,380 --> 00:39:38,219
Imaginaos un programa que puede hacer varias cosas

707
00:39:38,219 --> 00:39:40,800
Como eso de las sumas, las restas y las multiplicaciones

708
00:39:40,800 --> 00:39:43,780
Y que al final, después de haber hecho la suma, la resta

709
00:39:43,780 --> 00:39:45,519
Diga, ¿quieres hacer otra operación?

710
00:39:46,159 --> 00:39:48,739
Y si tú pones S, vuelve arriba

711
00:39:48,739 --> 00:39:52,079
Y me pide otra vez los números y la cosa

712
00:39:52,079 --> 00:39:54,300
Si tú pones N, pues sale abajo

713
00:39:54,300 --> 00:39:57,349
¿Sí?

714
00:39:58,869 --> 00:40:00,710
Ejemplo de for, mañana.