1
00:00:01,459 --> 00:00:07,339
Hola a todos, esta vez vídeo sin imágenes porque estoy muy cansada y no tengo buena cara.

2
00:00:08,099 --> 00:00:15,380
Creo que es la cuarta vez que empiezo el vídeo, así que lo voy a intentar hacer lo más rápido posible

3
00:00:15,380 --> 00:00:19,899
y de tirón porque no lo quiero editar. Así que si hablo rápido o me repito, lo siento.

4
00:00:20,600 --> 00:00:26,320
En este vídeo voy a explicar cómo han hecho diferentes alumnos el programa número 1,

5
00:00:26,320 --> 00:00:29,699
que es el que tenía que abrir un archivo

6
00:00:29,699 --> 00:00:32,700
que se llama, bueno, miento

7
00:00:32,700 --> 00:00:35,920
en tenerife.zip tenéis una carpeta comprimida

8
00:00:35,920 --> 00:00:37,399
con varios archivos

9
00:00:37,399 --> 00:00:40,439
os lo voy a enseñar

10
00:00:40,439 --> 00:00:43,579
estos son los archivos

11
00:00:43,579 --> 00:00:48,299
la carpeta tenerife tenía dos decenas de archivos

12
00:00:48,299 --> 00:00:51,679
cada uno de ellos tiene el número del año

13
00:00:51,679 --> 00:00:54,579
del 2000 al 2019 y .txt

14
00:00:55,240 --> 00:01:01,380
Si hago doble clic podéis ver que el archivo tiene el aspecto que se ve en el examen.

15
00:01:01,380 --> 00:01:16,379
Son como tres columnas, en la primera columna viene la fecha y luego un espacio, la temperatura máxima para esa fecha y luego otro espacio, este, y la temperatura mínima para esa fecha.

16
00:01:18,159 --> 00:01:24,260
Se pide que el programa, el usuario, le introduzca uno de los valores y devuelva ciertos datos.

17
00:01:24,260 --> 00:01:32,239
Queda dos. Pues tiene que devolver la temperatura máxima más alta y más baja, que es decir, de esta columna del centro.

18
00:01:32,859 --> 00:01:38,560
Luego tiene que devolver la temperatura mínima más alta y más baja para la columna de la derecha.

19
00:01:39,260 --> 00:01:46,599
Y luego tiene que devolver la media de las máximas, que es la del centro, y la media de las mínimas, que es la de la derecha.

20
00:01:47,140 --> 00:01:51,739
Y luego tiene que hacer la media de las dos que acaba de deciros, de estas dos superiores.

21
00:01:51,739 --> 00:01:55,859
Tiene que hacer la media, de la máxima media a la mínima media.

22
00:01:56,060 --> 00:02:01,579
Y por último, tiene que decir cuál es la mayor diferencia de temperatura que hay en un mismo día.

23
00:02:02,000 --> 00:02:10,979
Por ejemplo, en este primer día hay 6,70, diferencia de temperatura entre la máxima y la mínima.

24
00:02:11,419 --> 00:02:14,419
Pues hay que buscar la mayor diferencia en algún día.

25
00:02:15,759 --> 00:02:17,680
Vale, lo minimizo y os lo explico.

26
00:02:17,680 --> 00:02:29,099
Vamos a ver varios ejemplos. El más fácil de entender voy a utilizar el de Raquel.

27
00:02:43,349 --> 00:02:50,330
Raquel utiliza tres ArrayList que son de string, los tiene aquí, para guardar las fechas,

28
00:02:50,330 --> 00:02:52,810
los mínimos y los máximos

29
00:02:52,810 --> 00:02:54,550
y luego otras variables locales

30
00:02:54,550 --> 00:02:56,310
para ir guardando datos temporales

31
00:02:56,310 --> 00:02:58,530
fijaros que

32
00:02:58,530 --> 00:03:00,669
Raquel abre el escáner

33
00:03:00,669 --> 00:03:02,729
y le pregunta al usuario

34
00:03:02,729 --> 00:03:04,289
cuál va a ser el archivo

35
00:03:04,289 --> 00:03:05,110
y luego

36
00:03:05,110 --> 00:03:09,629
a ver dónde está

37
00:03:09,629 --> 00:03:12,509
simplemente pide

38
00:03:12,509 --> 00:03:13,689
la ruta del archivo

39
00:03:13,689 --> 00:03:16,349
en el caso de Raquel tengo que ponerle

40
00:03:16,349 --> 00:03:18,030
la ruta donde está mi

41
00:03:18,030 --> 00:03:19,009
archivo

42
00:03:19,009 --> 00:03:25,030
y luego lo abre y no comprueba en ningún momento si el archivo existe

43
00:03:25,030 --> 00:03:26,909
lo que podría dar un lugar a un error

44
00:03:26,909 --> 00:03:29,370
luego voy a comprobar para que lo veáis

45
00:03:29,370 --> 00:03:34,229
si yo le pongo aquí cualquier nombre

46
00:03:34,229 --> 00:03:37,250
2001.txt

47
00:03:37,250 --> 00:03:38,810
que no lo va a encontrar

48
00:03:38,810 --> 00:03:42,669
y da una excepción y el programa acaba de mala manera

49
00:03:42,669 --> 00:03:44,550
eso no es lo que tenía que hacer

50
00:03:44,550 --> 00:03:45,729
tenían que acabar bien

51
00:03:45,729 --> 00:03:47,930
se tenían que controlar las excepciones

52
00:03:47,930 --> 00:03:50,449
entonces Raquel no lo controla

53
00:03:50,449 --> 00:03:52,289
la solución en el programa

54
00:03:52,289 --> 00:03:54,030
es que yo ponga

55
00:03:54,030 --> 00:03:56,509
no puedo usar las teclas

56
00:03:56,509 --> 00:03:57,689
porque si no paro la grabación

57
00:03:57,689 --> 00:03:59,710
la solución es que yo ponga mi ruta

58
00:03:59,710 --> 00:04:02,449
en este caso está una carpeta hacia arriba

59
00:04:02,449 --> 00:04:04,150
o sea dos puntos

60
00:04:04,150 --> 00:04:05,750
luego tenerife

61
00:04:05,750 --> 00:04:08,449
la barra y por ejemplo

62
00:04:08,449 --> 00:04:11,710
2001.txt

63
00:04:11,710 --> 00:04:14,009
y me devuelve a temperatura

64
00:04:14,009 --> 00:04:16,730
todo lo que he pedido excepto lo último

65
00:04:16,730 --> 00:04:20,449
Tiene las máximas, las mínimas, las medias, la intermedia

66
00:04:20,449 --> 00:04:23,389
Pero falta el valor máximo de diferencia

67
00:04:23,389 --> 00:04:25,050
Entre máximo y mínimo diario

68
00:04:25,050 --> 00:04:27,850
Bien, ¿qué hace el de Raquel?

69
00:04:28,209 --> 00:04:32,930
Lee cada línea, la parte, la línea en una array de string

70
00:04:32,930 --> 00:04:33,430
Aquí

71
00:04:33,430 --> 00:04:36,370
Y la separa por los espacios

72
00:04:36,370 --> 00:04:39,889
Y esa parts, que podría llamarse de otra manera

73
00:04:39,889 --> 00:04:40,889
Que tiene las partes

74
00:04:40,889 --> 00:04:43,850
En la posición 0 tiene la fecha

75
00:04:43,850 --> 00:04:45,189
Que lo guarda en parte 1

76
00:04:45,189 --> 00:04:46,290
Se podría haber llamado fecha

77
00:04:46,290 --> 00:04:53,629
En Parts 1 tiene el máximo y en Parts 2, posición 2, tiene el mínimo.

78
00:04:53,850 --> 00:04:58,750
Y por eso lo guarda en la lista de fechas de máximos y mínimos con el ADD.

79
00:04:59,490 --> 00:05:01,250
Y luego directamente lo calcula.

80
00:05:05,750 --> 00:05:11,370
La parte interesante del ejercicio de Raquel es que tiene una función CalcularMedia

81
00:05:11,370 --> 00:05:15,170
que la utiliza tanto para calcular la media de la lista de los máximos

82
00:05:15,170 --> 00:05:17,470
como calcular la media de la lista de los mínimos.

83
00:05:18,170 --> 00:05:21,050
Y lo mismo ocurre con una función que se llama calcular máxima,

84
00:05:21,129 --> 00:05:24,670
que la usa para máximos y para mínimos.

85
00:05:25,290 --> 00:05:27,750
Y luego lo mismo una que tiene calcular mínimo.

86
00:05:28,069 --> 00:05:29,589
Entonces, ¿qué me gusta del ejercicio de Raquel?

87
00:05:29,750 --> 00:05:33,490
Que ha reutilizado la misma función para máximos y para mínimos.

88
00:05:33,649 --> 00:05:38,990
Y luego tiene aquí simplemente un cálculo en el que hace la suma de las dos medias,

89
00:05:38,990 --> 00:05:46,470
La divide entre 2 y lo último que hace es imprimirlo y cerrar el fichero.

90
00:05:47,110 --> 00:05:49,430
Vamos a ver cómo son las funciones.

91
00:05:49,949 --> 00:05:54,069
Fijaros, recibe un ArrayList de String, se llama CalcularMedia.

92
00:05:54,149 --> 00:05:57,430
No le importa si es el ArrayList de máximos o de mínimos.

93
00:05:58,329 --> 00:06:00,089
Y vamos, podría hacerlo hasta con las flechas.

94
00:06:00,689 --> 00:06:06,569
Entonces, empieza con los contadores a 0, el de la media está bien.

95
00:06:06,569 --> 00:06:17,350
Para cada uno de los is, que se supone que son los strings que hay en la lista, hace un doble parse doble y lo convierte a doble.

96
00:06:17,529 --> 00:06:22,089
Lo suma en el valor de la media y va contando las líneas.

97
00:06:22,569 --> 00:06:26,829
Cuando termina, devuelve la media más el partido por el contador.

98
00:06:26,829 --> 00:06:30,649
el problema es que tiene esto

99
00:06:30,649 --> 00:06:33,029
que si alguno de los archivos tuviera un valor

100
00:06:33,029 --> 00:06:34,870
que no pudiera pasarse a doble

101
00:06:34,870 --> 00:06:36,949
porque yo podía haber puesto

102
00:06:36,949 --> 00:06:39,230
archivos con errores en el examen

103
00:06:39,230 --> 00:06:40,769
daría error

104
00:06:40,769 --> 00:06:42,569
y el programa se quedaría colgado

105
00:06:42,569 --> 00:06:44,430
hay que controlar

106
00:06:44,430 --> 00:06:46,850
si se hace bien el parseo

107
00:06:46,850 --> 00:06:47,769
aquí

108
00:06:47,769 --> 00:06:50,089
calcular máxima

109
00:06:50,089 --> 00:06:52,589
que está bien, que explica lo que recibe

110
00:06:52,589 --> 00:06:54,189
que es una write list

111
00:06:54,189 --> 00:06:56,269
y devuelve la máxima

112
00:06:56,269 --> 00:06:59,029
bien, inconvenientes

113
00:06:59,029 --> 00:07:01,430
que pone el máximo inicialmente a cero

114
00:07:01,430 --> 00:07:03,569
no es buena idea del todo

115
00:07:03,569 --> 00:07:04,290
porque

116
00:07:04,290 --> 00:07:07,029
podrían ser temperaturas negativas

117
00:07:07,029 --> 00:07:09,110
y entonces el máximo estaría saliendo mal

118
00:07:09,110 --> 00:07:10,509
porque estaría guardando un cero

119
00:07:10,509 --> 00:07:11,269
¿de acuerdo?

120
00:07:12,269 --> 00:07:13,670
nada, funciona muy fácil

121
00:07:13,670 --> 00:07:17,009
para cada i, que es un string que está en la lista

122
00:07:17,009 --> 00:07:18,870
primero lo comparte

123
00:07:18,870 --> 00:07:21,110
lo convierte a doble

124
00:07:21,110 --> 00:07:23,110
lo guarda en la variable comprobar

125
00:07:23,110 --> 00:07:24,589
y comprueba

126
00:07:24,589 --> 00:07:26,689
si comprobar es mayor que el máximo

127
00:07:26,689 --> 00:07:29,750
si es mayor, lo guarda como el nuevo máximo

128
00:07:29,750 --> 00:07:30,910
asigna comprobar

129
00:07:30,910 --> 00:07:32,610
y por último devuelve máximo

130
00:07:32,610 --> 00:07:35,629
el calcular mínimo funciona exactamente igual

131
00:07:35,629 --> 00:07:37,089
solo que está haciendo

132
00:07:37,089 --> 00:07:38,509
comprobando si lo que lee

133
00:07:38,509 --> 00:07:40,410
lo que ha parseado a doble

134
00:07:40,410 --> 00:07:42,110
porque aquí lo parsea

135
00:07:42,110 --> 00:07:45,810
lo coge del array list y lo convierte en doble

136
00:07:45,810 --> 00:07:47,649
comprueba si es menor que el mínimo

137
00:07:47,649 --> 00:07:48,709
si es menor que el mínimo

138
00:07:48,709 --> 00:07:51,170
guarda esa variable comprobar

139
00:07:51,170 --> 00:07:53,350
en el mínimo y por último lo devuelve

140
00:07:53,350 --> 00:07:54,889
hasta aquí el de Raquel

141
00:07:54,889 --> 00:07:56,509
que funciona y hace lo que pide

142
00:07:56,509 --> 00:08:00,870
aunque no cubre ninguna excepción

143
00:08:00,870 --> 00:08:04,069
ahora cierro el de Raquel

144
00:08:04,069 --> 00:08:06,930
y vamos a ver el de María

145
00:08:06,930 --> 00:08:08,089
que es muy diferente

146
00:08:08,089 --> 00:08:14,819
el de María

147
00:08:14,819 --> 00:08:17,639
cuando yo lo ejecuto

148
00:08:17,639 --> 00:08:20,000
voy a ponerme donde está el programa principal

149
00:08:20,000 --> 00:08:21,439
aquí

150
00:08:21,439 --> 00:08:26,279
aquí tenéis como lo ponía inicialmente la ruta

151
00:08:26,279 --> 00:08:28,459
que poner resources, doble barra, tenerife

152
00:08:28,459 --> 00:08:30,540
doble barra y lo concatena

153
00:08:30,540 --> 00:08:32,759
con lo que diga el usuario

154
00:08:32,759 --> 00:08:34,320
que es el nombre del archivo

155
00:08:34,320 --> 00:08:35,879
o ruta donde está

156
00:08:35,879 --> 00:08:38,639
o sea, sería el nombre del archivo

157
00:08:38,639 --> 00:08:40,279
¿de acuerdo? y no funciona

158
00:08:40,279 --> 00:08:42,600
entonces lo he cambiado y he tenido que poner en Linux

159
00:08:42,600 --> 00:08:44,559
resources barra

160
00:08:44,559 --> 00:08:46,240
contraria, barra tenerife

161
00:08:46,240 --> 00:08:47,879
y lo compate, es el único cambio que

162
00:08:47,879 --> 00:08:50,820
he hecho, vale, lo voy a ejecutar

163
00:08:50,820 --> 00:08:52,519
para que veáis que funciona

164
00:08:52,519 --> 00:08:54,759
porque tiene una parte interesante

165
00:08:54,759 --> 00:08:55,600
el de María

166
00:08:55,600 --> 00:08:58,500
voy a ponerle un nombre de archivo

167
00:08:58,500 --> 00:09:00,720
como he hecho antes con Raquel

168
00:09:00,720 --> 00:09:01,919
que no exista

169
00:09:01,919 --> 00:09:04,840
por ejemplo 200.txt

170
00:09:04,840 --> 00:09:08,539
María me dice que el archivo no existe

171
00:09:08,539 --> 00:09:09,860
que prueba de nuevo, no falla

172
00:09:09,860 --> 00:09:12,779
me va pidiendo nombres de archivos hasta que existan

173
00:09:12,779 --> 00:09:15,779
si yo le pongo 2001.txt

174
00:09:15,779 --> 00:09:18,840
me devuelve los valores y termina

175
00:09:18,840 --> 00:09:20,559
y me lo devuelve todo

176
00:09:20,559 --> 00:09:22,299
lo que he pedido, máximos, mínimos

177
00:09:22,299 --> 00:09:24,919
incluso cuál es el día

178
00:09:24,919 --> 00:09:29,159
en el que hay mayor diferencia de temperaturas, que es este.

179
00:09:31,419 --> 00:09:37,519
Esta parte no recuerdo si la he modificado yo o no, ya no me acuerdo.

180
00:09:38,620 --> 00:09:40,779
Bien, el código, que no me quiero enrollar.

181
00:09:42,779 --> 00:09:50,159
Vale, María tiene una función, tiene una particularidad, y es fijaros lo que devuelven sus métodos.

182
00:09:50,159 --> 00:09:55,919
métodos. Devuelven a raíz de dobles, porque resulta que los métodos de María te devuelven

183
00:09:55,919 --> 00:10:01,100
todo de una vez. Te devuelven el máximo, el mínimo y la media. El nombre no es muy

184
00:10:01,100 --> 00:10:05,539
adecuado, que lo ha llamado GetMaximas. Yo le he cambiado el nombre haciendo unas pruebas.

185
00:10:05,679 --> 00:10:11,419
Yo lo hubiera llamado... Mira, le voy a cambiar el nombre para que quede más claro. Vale,

186
00:10:11,419 --> 00:10:13,000
ese refactor

187
00:10:13,000 --> 00:10:14,340
y me estoy enrollando

188
00:10:14,340 --> 00:10:16,820
yo lo llamaría getMax

189
00:10:16,820 --> 00:10:18,700
min

190
00:10:18,700 --> 00:10:20,919
average

191
00:10:20,919 --> 00:10:25,490
¿por qué?

192
00:10:25,610 --> 00:10:27,149
porque devuelve las tres cosas

193
00:10:27,149 --> 00:10:29,509
así como está haciendo yo pruebas y lo he puesto así

194
00:10:29,509 --> 00:10:31,690
entonces que devuelve el máximo

195
00:10:31,690 --> 00:10:33,929
y la mínima y la media

196
00:10:33,929 --> 00:10:35,570
¿vale? pero solo lo hace

197
00:10:35,570 --> 00:10:37,110
para las máximas, ojo

198
00:10:37,110 --> 00:10:39,470
entonces inicialmente se crea

199
00:10:39,470 --> 00:10:41,529
un array de tres en los que los valores por defecto

200
00:10:41,529 --> 00:10:43,110
son 0, 100 y 0

201
00:10:43,110 --> 00:10:48,230
donde la posición cero, como dice el comentario, sería la máxima.

202
00:10:50,909 --> 00:10:54,250
Esta es la posición baja, el mínimo, por eso lo ponen a 100

203
00:10:54,250 --> 00:10:57,009
porque supone que cualquier valor va a ser más pequeño que 100.

204
00:10:57,809 --> 00:10:58,929
Y la media.

205
00:11:00,509 --> 00:11:02,190
¿Cómo mejoraría yo esto?

206
00:11:02,470 --> 00:11:04,950
Cogiendo el primer elemento de los que hay en la lista

207
00:11:04,950 --> 00:11:09,090
y usándolo como máximo y mínimo temporal.

208
00:11:09,990 --> 00:11:11,309
Aún así le funciona.

209
00:11:11,309 --> 00:11:17,629
Porque como no hay valores extremos, no hay nada que esté a menos 50 o que esté a más 50.

210
00:11:17,929 --> 00:11:19,809
Bueno, está bien, me he enrollado.

211
00:11:20,830 --> 00:11:26,269
Va contando las líneas y para cada vector que tiene en la lista de entradas,

212
00:11:26,750 --> 00:11:32,750
porque María guarda las tres cosas en la lista, guarda la fecha, el máximo y el mínimo.

213
00:11:33,330 --> 00:11:36,129
Entonces el vector lo que tiene es las tres cosas.

214
00:11:36,570 --> 00:11:38,850
Entonces la posición donde está la máxima es la 1.

215
00:11:38,850 --> 00:11:45,929
así que lo parsea a un doble igual que ha hecho Raquel pero aquí solamente con la posición 1

216
00:11:45,929 --> 00:11:54,929
lo guarda en leído y ahora comprueba si el leído es mayor que la temperatura que tenía guardada como máxima en este array

217
00:11:54,929 --> 00:12:01,909
y luego comprueba si el leído es menor que la temperatura que tenía guardada como mínima

218
00:12:01,909 --> 00:12:04,850
porque en la posición 1 está la mínima que sería aquí

219
00:12:04,850 --> 00:12:10,970
y además lo suma en temperaturas máximas en el vector en la posición 2

220
00:12:10,970 --> 00:12:15,309
así que va comprobando si es mayor que la máxima que es esta

221
00:12:15,309 --> 00:12:17,350
mayor que la mínima que es esta

222
00:12:17,350 --> 00:12:19,169
y lo va sumando a las medias

223
00:12:19,169 --> 00:12:22,090
y cuando termina lo divide

224
00:12:22,090 --> 00:12:26,450
lo que ha ido guardando aquí en la segunda posición del vector

225
00:12:26,450 --> 00:12:27,470
en la segunda posición 2

226
00:12:27,470 --> 00:12:30,870
es que lo divide lo que ha sumado entre el contador

227
00:12:30,870 --> 00:12:31,669
y lo devuelve

228
00:12:31,669 --> 00:12:35,570
Así que obtiene las tres cosas, máximo, mínimo y media.

229
00:12:37,389 --> 00:12:48,769
¿Qué pasa? Que tiene una función muy similar, esta, que devuelve un array list, perdón, que recibe un array list con toda la lista de entradas y que devuelve un array de tres de dobles.

230
00:12:48,769 --> 00:13:01,509
Y funciona exactamente igual, solo que en vez de mirar la posición uno de los vectores, si os acordáis, voy a poner esto, ella guarda en un vector las tres cosas.

231
00:13:01,669 --> 00:13:04,990
entonces la posición 1 son los máximos

232
00:13:04,990 --> 00:13:06,769
la posición 2 son las fechas

233
00:13:06,769 --> 00:13:09,889
así que lo hace todo para la posición 2

234
00:13:09,889 --> 00:13:12,889
así que coge lo que hay en la posición 2 de la entrada

235
00:13:12,889 --> 00:13:14,210
para todas las entradas

236
00:13:14,210 --> 00:13:16,970
lo pasea a doble

237
00:13:16,970 --> 00:13:18,389
lo guarda en leído

238
00:13:18,389 --> 00:13:20,889
y va comprobando si leído es mayor

239
00:13:20,889 --> 00:13:22,269
que la posición 0

240
00:13:22,269 --> 00:13:24,929
que es donde está la máxima

241
00:13:24,929 --> 00:13:26,529
y si lo es lo guarda

242
00:13:26,529 --> 00:13:28,889
en las temperaturas mínimas

243
00:13:28,889 --> 00:13:32,529
yo llamaría valores mínimas

244
00:13:32,529 --> 00:13:34,210
o datos para mínimas, no lo sé

245
00:13:34,210 --> 00:13:36,049
y luego si leído es menor

246
00:13:36,049 --> 00:13:37,289
lo guarda como mínima

247
00:13:37,289 --> 00:13:38,809
y luego lo va sumando

248
00:13:38,809 --> 00:13:41,830
en la posición del vector

249
00:13:41,830 --> 00:13:44,250
donde guarda toda la suma

250
00:13:44,250 --> 00:13:45,909
y una vez acabado

251
00:13:45,909 --> 00:13:48,370
lo divide por las líneas que ha ido contando

252
00:13:48,370 --> 00:13:50,110
pues eso se podía hacer

253
00:13:50,110 --> 00:13:51,970
en una única función

254
00:13:51,970 --> 00:13:53,129
y luego lo mismo

255
00:13:53,129 --> 00:13:56,129
tiene esta otra función

256
00:13:56,129 --> 00:13:58,269
que es interesante, que es la getDiferencia

257
00:13:58,269 --> 00:14:06,070
que no lo había hecho raquel que hace coge la raíz y por ahora inicialmente la diferencia inicial

258
00:14:06,070 --> 00:14:12,450
es cero va a pensar que tenemos una máxima y una mínima iguales no sabemos de qué fecha es así

259
00:14:12,450 --> 00:14:19,330
esto entonces lo hizo no lo ha modificado es el original de maría entonces para cada vector con

260
00:14:19,330 --> 00:14:27,250
los tres valores fecha mayor máxima y mínima que hay en la lista coge el de la posición 1 que es la

261
00:14:27,250 --> 00:14:34,190
máxima, lo guarda en max, luego coge el de la posición 2, lo guarda en mínimo y comprueba

262
00:14:34,190 --> 00:14:40,009
si el restar esos dos es mayor que la diferencia que había inicialmente, que es esta que había

263
00:14:40,009 --> 00:14:45,210
guardado como cero. Si eso se cumple, entonces lo que va a hacer es que en diferencia mayor

264
00:14:45,210 --> 00:14:55,169
guarda máximo menos en mínimo. Y como sabe la fecha que está en la posición cero, pues

265
00:14:55,169 --> 00:15:00,269
la guarda. Guarda fecha diferencia igual a lo que hay en entrada 0. Así que va

266
00:15:00,269 --> 00:15:04,830
guardando la diferencia y la fecha. Y cuando termina lo devuelve todo en un

267
00:15:04,830 --> 00:15:11,850
string junto. Devuelve la diferencia, que es un doble con formato con dos decimales,

268
00:15:11,850 --> 00:15:18,409
y la fecha, que es un string. Entonces, ¿cómo funciona su código principal?

269
00:15:18,409 --> 00:15:23,129
Aquí tenemos el do while por el que puede estar leyendo archivos hasta que le das

270
00:15:23,129 --> 00:15:29,490
un archivo válido que está guay y luego comprueba si el archivo no existe si el

271
00:15:29,490 --> 00:15:36,610
archivo no existe saca un mensaje por la pantalla de error

272
00:15:36,610 --> 00:15:41,669
cuando llegamos aquí es que se supone que ya el archivo existe así que hace un

273
00:15:41,669 --> 00:15:47,590
try que es lo que no hacía raquel e intenta abrir un escáner con el nombre

274
00:15:47,590 --> 00:15:56,909
del archivo y aquí te una raíz donde va guardando todos los datos entonces mientras haya líneas

275
00:15:58,429 --> 00:16:04,929
coge la siguiente línea next line y con el método split lo separa por los espacios y eso lo guarda

276
00:16:04,929 --> 00:16:09,769
en un vector que se llama entrada que es un vector string que inicialmente va a tener tres

277
00:16:09,769 --> 00:16:14,049
inconvenientes que tiene esto

278
00:16:14,049 --> 00:16:16,490
que podrían venir en el archivo

279
00:16:16,490 --> 00:16:20,210
líneas incorrectas que no tuvieran

280
00:16:20,210 --> 00:16:22,350
las dos temperaturas y no lo sabríamos

281
00:16:22,350 --> 00:16:24,690
y eso no se está controlando

282
00:16:24,690 --> 00:16:26,649
tendría que controlarse

283
00:16:26,649 --> 00:16:28,269
cuando se calculan las máximas

284
00:16:28,269 --> 00:16:30,250
y la mínima, debería hacer un try

285
00:16:30,250 --> 00:16:32,669
para ver que no sale del vector

286
00:16:32,669 --> 00:16:34,529
vale, cuando ha leído

287
00:16:34,529 --> 00:16:36,610
la entrada, le añade a la raíz de entrada

288
00:16:36,610 --> 00:16:37,590
y luego lo cierra

289
00:16:37,590 --> 00:16:41,549
y aquí tiene sus variables donde va a guardar los valores

290
00:16:41,549 --> 00:16:44,370
las máximas, las mínimas y llama sus funciones

291
00:16:44,370 --> 00:16:48,789
al que obtiene máxima, mínima ya veréis para las máximas

292
00:16:48,789 --> 00:16:52,470
luego la misma función pero que lo hace para las mínimas

293
00:16:52,470 --> 00:16:54,909
y luego la media de temperaturas y demás

294
00:16:54,909 --> 00:16:55,690
y lo imprime todo

295
00:16:55,690 --> 00:16:58,330
y aquí tiene la excepción que solo tiene una

296
00:16:58,330 --> 00:17:00,169
que es algo ha salido mal

297
00:17:00,169 --> 00:17:05,549
y ahora voy a enseñar el que ha hecho Lucía

298
00:17:05,549 --> 00:17:12,440
el que ha hecho Lucía

299
00:17:12,440 --> 00:17:17,480
utiliza también dos ArrayList

300
00:17:17,480 --> 00:17:19,740
solo dos, no tres, no tienen de las fechas

301
00:17:19,740 --> 00:17:23,359
y guarda las temperaturas máximas y las mínimas

302
00:17:23,359 --> 00:17:25,000
y también cuenta las líneas

303
00:17:25,000 --> 00:17:28,779
y Lucía lo hace todo el rato con tres variables globales

304
00:17:28,779 --> 00:17:32,079
entonces todos sus métodos usan esas variables

305
00:17:32,079 --> 00:17:34,720
lo primero que hace es comprobar

306
00:17:34,720 --> 00:17:36,839
cuál es la opción del usuario

307
00:17:36,839 --> 00:17:43,960
introduce el año y si no está entre 2000 y 2019 te dice que el año está mal

308
00:17:43,960 --> 00:17:48,299
te obliga a que pongas un año de 2000 a 2019 porque sabe que no existe el

309
00:17:48,299 --> 00:17:57,440
archivo y leer archivo es un método que le llega el año y lo que hace es leerlo

310
00:17:57,440 --> 00:18:01,779
inicialmente lucia lo tenía así pero a mí no me funciona en linux he tenido que

311
00:18:01,779 --> 00:18:11,079
cambiar la ruta. Así que solo tengo que poner el año. Y lee el archivo y hace lo mismo.

312
00:18:11,240 --> 00:18:17,319
Mientras haya líneas, va añadiendo las líneas que lee. Pero no lee toda la línea. Lucia

313
00:18:17,319 --> 00:18:22,339
lee la fecha, que la tira, no la usa, como no la quiere para nada, simplemente la lee.

314
00:18:22,859 --> 00:18:27,660
La primera palabra separada por un espacio. Luego aquí lee la máxima y la guarda en

315
00:18:27,660 --> 00:18:32,619
máxima y aquí lee la mínima y la guarda en mínima pero las guarda como string y

316
00:18:32,619 --> 00:18:37,500
además cuenta las líneas y dice que ha quitado líneas vacías porque le daba

317
00:18:37,500 --> 00:18:40,339
error

318
00:18:40,420 --> 00:18:46,220
cierra el lector y gestiona dos excepciones una que no encuentra la

319
00:18:46,220 --> 00:18:50,900
excepción y luego cualquier otra por si cualquier otro tipo de problema hace una

320
00:18:50,900 --> 00:18:59,000
excepción genérica. Y aquí pasa algo parecido.

321
00:18:59,000 --> 00:19:04,400
Fijaros en este código de este método, que es un calcular temperatura máxima

322
00:19:04,400 --> 00:19:12,579
superior. Y luego hay aquí otra, a ver si la veo,

323
00:19:12,579 --> 00:19:19,579
calcular temperatura mínima superior, que son exactamente iguales. Recorre

324
00:19:19,579 --> 00:19:24,099
un ArrayList y calcula cuál es el máximo y el mínimo. Lo que pasa es que como uso

325
00:19:24,099 --> 00:19:28,480
variables globales, aquí lo hace para la lista de temperaturas máximas. Entonces para

326
00:19:28,480 --> 00:19:37,660
cada string que está en temperaturas, comprueba si pasándolo a doble es mayor que la temperatura

327
00:19:37,660 --> 00:19:43,099
máxima superior, que inicialmente la pone a cero, ¿vale? Y si es así, lo guarda y es

328
00:19:43,099 --> 00:19:48,799
su nuevo máximo. Da todas las vueltas y devuelve el que ha guardado como máximo. Lo mismo

329
00:19:48,799 --> 00:19:50,819
hace con los mínimos

330
00:19:50,819 --> 00:19:52,740
va recorriendo y va guardando

331
00:19:52,740 --> 00:19:54,599
el mínimo temporal

332
00:19:54,599 --> 00:19:56,579
hasta que lo devuelve, pero es que funciona

333
00:19:56,579 --> 00:19:58,440
igual el mínimo para los mínimos

334
00:19:58,440 --> 00:20:00,519
estas funciones podían haberse

335
00:20:00,519 --> 00:20:02,859
hecho reutilizado

336
00:20:02,859 --> 00:20:04,880
como ha hecho

337
00:20:04,880 --> 00:20:06,500
Raquel, reutilizar las funciones

338
00:20:06,500 --> 00:20:08,500
pero claro, tenían que recibir como argumento la

339
00:20:08,500 --> 00:20:08,740
raíz

340
00:20:08,740 --> 00:20:12,460
y luego calcula

341
00:20:12,460 --> 00:20:14,680
la media, que simplemente

342
00:20:14,680 --> 00:20:16,119
lo recorre, pero llama

343
00:20:16,119 --> 00:20:17,799
la variable global

344
00:20:17,799 --> 00:20:20,640
y la media de las mínimas

345
00:20:20,640 --> 00:20:25,319
y la intermedia

346
00:20:25,319 --> 00:20:27,299
hace la media

347
00:20:27,299 --> 00:20:30,359
y de las máximas ya hace la media de la mínima

348
00:20:30,359 --> 00:20:32,000
que podía haber reutilizado

349
00:20:32,000 --> 00:20:33,779
las funciones que ya tenía antes

350
00:20:33,779 --> 00:20:36,140
para calcular la media

351
00:20:36,140 --> 00:20:37,480
y no tener que volver a hacerlo

352
00:20:37,480 --> 00:20:38,960
el código

353
00:20:38,960 --> 00:20:42,180
y aquí lo mismo

354
00:20:42,180 --> 00:20:44,059
calcula la diferencia en mayor temperatura

355
00:20:44,059 --> 00:20:46,380
recorriendo las dos listas

356
00:20:46,380 --> 00:20:46,859
a la vez

357
00:20:46,859 --> 00:20:49,339
y va comparando cada uno de la lista

358
00:20:49,339 --> 00:20:52,240
con el siguiente del otro lado de la lista

359
00:20:52,240 --> 00:20:56,119
en el caso de Lucía

360
00:20:56,119 --> 00:20:57,680
se asegura siempre que se leen

361
00:20:57,680 --> 00:20:58,920
que siempre hay dos

362
00:20:58,920 --> 00:21:01,240
porque como está haciendo

363
00:21:01,240 --> 00:21:03,160
next y next al leer

364
00:21:03,160 --> 00:21:03,619
aquí

365
00:21:03,619 --> 00:21:08,559
aquí siempre lee el máximo

366
00:21:08,559 --> 00:21:09,720
y luego lee el mínimo

367
00:21:09,720 --> 00:21:12,799
si no pudiera hacer un leer

368
00:21:12,799 --> 00:21:14,720
pues daría una excepción

369
00:21:14,720 --> 00:21:19,380
así que aquí no va a llegar ese fallo, siempre va a tener dos.

370
00:21:19,980 --> 00:21:24,880
¿Y cómo funciona? Pues hace un try en la que llama a leer archivo

371
00:21:24,880 --> 00:21:32,140
y con el valor, el valor que recibe leer archivo es lo que sea leer opción usuario.

372
00:21:32,339 --> 00:21:36,799
Este método devuelve el nombre del archivo, 2009 o 2017.

373
00:21:38,339 --> 00:21:43,500
Hace un catch si ha habido un problema de number former exception y hace otro catch.

374
00:21:44,720 --> 00:21:47,799
esas excepciones

375
00:21:47,799 --> 00:21:49,299
si saltan el programa

376
00:21:49,299 --> 00:21:51,779
no debería continuar

377
00:21:51,779 --> 00:21:53,359
porque en el caso de Lucía

378
00:21:53,359 --> 00:21:54,160
cuando hay un error

379
00:21:54,160 --> 00:21:56,779
después de coger la excepción

380
00:21:56,779 --> 00:21:59,680
imprime cosas porque puede imprimirlas

381
00:21:59,680 --> 00:22:01,539
no sé si ahora voy a saber repetir el error

382
00:22:01,539 --> 00:22:02,460
no, no voy a saber

383
00:22:02,460 --> 00:22:05,759
no me acuerdo como lo conseguí

384
00:22:05,759 --> 00:22:11,930
vale, y mi variante

385
00:22:11,930 --> 00:22:14,369
que tiene un error

386
00:22:14,369 --> 00:22:15,670
yo todavía no lo he conseguido arreglar

387
00:22:15,670 --> 00:22:16,950
por eso lo del vídeo tardío

388
00:22:16,950 --> 00:22:18,269
este es mi variante

389
00:22:18,269 --> 00:22:22,069
vale

390
00:22:22,069 --> 00:22:24,130
¿qué he variado?

391
00:22:24,390 --> 00:22:26,869
pues primero que he añadido uno de lista fechas

392
00:22:26,869 --> 00:22:28,210
para saber en qué fecha

393
00:22:28,210 --> 00:22:30,390
es el día que

394
00:22:30,390 --> 00:22:32,829
hay la mayor diferencia de temperaturas

395
00:22:32,829 --> 00:22:34,609
he mantenido el leer

396
00:22:34,609 --> 00:22:36,450
opción usuario

397
00:22:36,450 --> 00:22:37,650
y

398
00:22:37,650 --> 00:22:40,950
el file, vale, y aquí está la diferencia

399
00:22:40,950 --> 00:22:42,750
yo he usado

400
00:22:42,750 --> 00:22:44,750
he mantenido su código en el que se calcula

401
00:22:45,349 --> 00:22:48,029
el cual es la máxima

402
00:22:48,029 --> 00:22:52,910
Pero, le he cambiado el nombre, le he llamado CalcularTemperaturaMáxima y recibe una ArrayList.

403
00:22:53,450 --> 00:22:57,650
Eso quiere decir que lo puedo hacer para la lista de máximas o para la lista de mínimas.

404
00:22:58,410 --> 00:23:03,750
Lo primero que hace es comprobar si la lista no está vacía, por si acaso venía el archivo vacío.

405
00:23:03,750 --> 00:23:08,549
Entonces, si la lista está vacía, va a lanzar una excepción de NullPointerExcepción,

406
00:23:08,690 --> 00:23:15,289
porque me he encontrado algo apuntando un Null que yo no me lo esperaba, porque no debía estar vacío.

407
00:23:15,289 --> 00:23:19,190
y por eso mi método puede lanzar un null pointer exception

408
00:23:19,190 --> 00:23:21,210
si todo va bien, si no está vacío

409
00:23:21,210 --> 00:23:24,849
tomo el primer elemento de la array list como máximo temporal

410
00:23:24,849 --> 00:23:28,809
entonces le pido a la lista que me coja el get0

411
00:23:28,809 --> 00:23:34,730
y eso lo guardo como mi lista se supone que es de dobles

412
00:23:34,730 --> 00:23:38,109
pero me está dando error, ahí es donde me falla y todavía no he podido arreglarlo

413
00:23:38,109 --> 00:23:40,910
entonces yo pongo la lista get0 que es un doble

414
00:23:40,910 --> 00:23:42,910
lo guardo como temperatura máxima

415
00:23:42,910 --> 00:23:50,849
Y ahora, para cada doble que está en mi lista, que se llama temperatura, compruebo si la temperatura es mayor que la máxima.

416
00:23:50,910 --> 00:23:54,069
Si es mayor, pues la nueva temperatura máxima es temperatura.

417
00:23:54,529 --> 00:23:56,809
Y lo devuelvo. Eso es el código de Lucía.

418
00:23:56,910 --> 00:24:04,690
Solo he cambiado el argumento que recibe y la gestión de el que esté vacío y de cómo cojo el primero.

419
00:24:06,049 --> 00:24:10,150
Ahora, tiene un calcular temperatura mínima que es exactamente igual.

420
00:24:10,150 --> 00:24:16,150
recibo un ArrayList y puede devolver un null pointer exception, compruebo que no está vacío y

421
00:24:16,150 --> 00:24:20,230
cojo el primer elemento de la lista como mínimo. Entonces tengo una variable que es temperatura

422
00:24:20,230 --> 00:24:26,230
mínima, es temporal mientras doy vuelta y ahí lo que guardo es el get cero. Entonces para todos los

423
00:24:26,230 --> 00:24:31,990
que hay en la lista, que eso incluye el cero, voy comprobando si la temperatura es menor que la

424
00:24:31,990 --> 00:24:39,150
mínima. Si es así, lo machaco. Esto es lo que he quitado del código de Lucía y lo mismo he hecho

425
00:24:39,150 --> 00:24:44,849
para la media que recibo una rey list entonces me va el mismo método para la media de las máximas

426
00:24:44,849 --> 00:24:53,369
y la media de las mínimas y es igual compruebo si está vacío y luego las voy sumando y las divido

427
00:24:53,369 --> 00:24:58,750
entre el tamaño de la lista porque le puedo preguntar a la lista cuántos elementos tiene

428
00:24:58,750 --> 00:25:00,430
no me hace falta contarlos

429
00:25:00,430 --> 00:25:04,990
y luego la temperatura intermedia

430
00:25:04,990 --> 00:25:07,130
nada

431
00:25:07,130 --> 00:25:09,349
como Lucía la tiene

432
00:25:09,349 --> 00:25:10,269
la he mantenido

433
00:25:10,269 --> 00:25:12,329
y solamente que en vez de hacer los cálculos

434
00:25:12,329 --> 00:25:14,490
llamo a calcular temperatura media

435
00:25:14,490 --> 00:25:15,569
de la lista 1

436
00:25:15,569 --> 00:25:18,809
a calcular temperatura media de la lista 2

437
00:25:18,809 --> 00:25:19,869
y lo divido entre 2

438
00:25:19,869 --> 00:25:22,670
recibe lista 1 y lista 2 por argumentos

439
00:25:22,670 --> 00:25:24,289
lo intento

440
00:25:24,289 --> 00:25:26,069
y si algo no va bien

441
00:25:26,069 --> 00:25:28,349
hago un catch de no poner excepción

442
00:25:28,349 --> 00:25:30,549
porque calcular temperatura media

443
00:25:30,549 --> 00:25:32,009
si lista está vacía

444
00:25:32,009 --> 00:25:34,349
va a devolver un null pointer excepción

445
00:25:34,349 --> 00:25:37,130
entonces al menos tengo una de las dos listas vacía

446
00:25:37,130 --> 00:25:38,630
lo que hago es lanzar la excepción

447
00:25:38,630 --> 00:25:40,750
al programa superior para que la gestione

448
00:25:40,750 --> 00:25:42,049
y si todo va bien

449
00:25:42,049 --> 00:25:43,049
pues devuelvo la media

450
00:25:43,049 --> 00:25:45,109
y

451
00:25:45,109 --> 00:25:48,029
vale

452
00:25:48,029 --> 00:25:49,650
y calcular la diferencia

453
00:25:49,650 --> 00:25:52,990
de mayor temperatura

454
00:25:52,990 --> 00:25:55,130
aquí tengo que tener un error

455
00:25:55,130 --> 00:25:56,230
y

456
00:25:56,230 --> 00:26:01,000
porque Lucía ha hecho

457
00:26:01,000 --> 00:26:03,839
un número de líneas

458
00:26:03,839 --> 00:26:04,799
aquí lo voy a hacer

459
00:26:04,799 --> 00:26:05,740
eso está mal hecho

460
00:26:05,740 --> 00:26:10,210
debería hacerlo

461
00:26:10,210 --> 00:26:11,730
con lista

462
00:26:11,730 --> 00:26:14,230
punto 6

463
00:26:14,230 --> 00:26:17,490
lista 1.6

464
00:26:17,490 --> 00:26:18,490
como en principio

465
00:26:18,490 --> 00:26:20,349
las dos tienen el mismo tamaño

466
00:26:20,349 --> 00:26:21,890
si no le robo el que ha llegado antes

467
00:26:21,890 --> 00:26:23,769
le pregunto a la lista 1

468
00:26:23,769 --> 00:26:24,750
cuál es su tamaño

469
00:26:24,750 --> 00:26:27,529
y mientras de I0

470
00:26:27,529 --> 00:26:28,950
hay menor que el tamaño

471
00:26:28,950 --> 00:26:35,869
calculo el valor de la lista 1 menos el valor de la lista 2

472
00:26:35,869 --> 00:26:40,089
y si esa diferencia que acabo de calcular, calculada

473
00:26:40,089 --> 00:26:43,369
es mayor que la diferencia temporal

474
00:26:43,369 --> 00:26:45,450
pues entonces lo guardo

475
00:26:45,450 --> 00:26:47,210
y me guardo en qué posición estoy

476
00:26:47,210 --> 00:26:49,410
que estoy en la posición Y de la raíz

477
00:26:49,410 --> 00:26:53,710
inicialmente pongo la diferencia a 0

478
00:26:53,710 --> 00:26:57,470
entonces cuando termino de dar vueltas

479
00:26:57,470 --> 00:27:00,390
devuelvo la diferencia mayor temporal

480
00:27:00,390 --> 00:27:03,809
y lo concateno con el string del día

481
00:27:03,809 --> 00:27:05,849
y obtengo la fecha

482
00:27:05,849 --> 00:27:09,670
hago fechas.get con la posición temporal

483
00:27:09,670 --> 00:27:11,609
hay algo que se me ha olvidado contar

484
00:27:11,609 --> 00:27:16,400
o no sé si lo he contado

485
00:27:16,400 --> 00:27:17,640
si se lo he contado

486
00:27:17,640 --> 00:27:19,299
que tanto el máximo como el mínimo

487
00:27:19,299 --> 00:27:20,940
cojo el primer elemento de la lista

488
00:27:20,940 --> 00:27:24,400
no supongáis que vuelva a ser el máximo o el mínimo

489
00:27:24,400 --> 00:27:25,539
excepto la media

490
00:27:25,539 --> 00:27:28,259
que por defecto puedo dejar un 0

491
00:27:28,259 --> 00:27:32,539
si se calcula y todas son cero, pues devolvería un cero o devolvería error.

492
00:27:34,539 --> 00:27:44,759
Entonces, ¿qué hace? Hago un try, pero dentro del try he metido la lógica de leer archivo. Si todo

493
00:27:44,759 --> 00:27:49,680
va bien, entonces me imprimirá el calcular temperatura máxima de las máximas, el de las

494
00:27:49,680 --> 00:27:55,819
mínimas, y aquí voy llamando a todas las funciones. Y si hubiera un error, saltaría el catch. Puede

495
00:27:55,819 --> 00:28:03,920
salta el catch en number format exception, cuando haya un problema con el formato o una excepción

496
00:28:03,920 --> 00:28:11,720
general. Y ya está. Muchas gracias por atender. Espero que haya quedado claro que hay varias

497
00:28:11,720 --> 00:28:18,259
maneras de hacerlo y que en todas habría que haber comprobado las excepciones, que no lo hemos comprobado casi.