1
00:00:00,050 --> 00:00:06,110
Me da un poco de miedo quedarme sin sitio y tener problemas con la grabación.

2
00:00:07,549 --> 00:00:13,269
Bueno, vale, pues va bien.

3
00:00:14,529 --> 00:00:16,850
Venga, muy bien, pues vamos a empezar ya, ahora sí que vamos a empezar.

4
00:00:18,289 --> 00:00:20,070
Bueno, pues buenas tardes, noches.

5
00:00:21,530 --> 00:00:27,769
Hoy estrenamos una herramienta nueva de sesiones online, vamos a probar ya,

6
00:00:27,769 --> 00:00:29,989
ya le digo que la cuarta o la quinta creo que probamos,

7
00:00:29,989 --> 00:00:32,630
y vamos a hablar con

8
00:00:32,630 --> 00:00:34,329
con este Webex

9
00:00:34,329 --> 00:00:35,270
de Cisco

10
00:00:35,270 --> 00:00:38,289
la verdad es que tiene muy buena pinta

11
00:00:38,289 --> 00:00:40,490
y yo creo que tiene una cantidad de recursos

12
00:00:40,490 --> 00:00:41,869
interesantes, entonces vamos a

13
00:00:41,869 --> 00:00:44,509
vamos a ir cogiendo un poquito el tranquillo, con lo cual vamos a hacer una sesión

14
00:00:44,509 --> 00:00:45,229
un poco ligera

15
00:00:45,229 --> 00:00:50,350
vamos a ver algún ejercicio de los interesantes

16
00:00:50,350 --> 00:00:51,729
y

17
00:00:51,729 --> 00:00:53,909
en sesiones posteriores pues ya

18
00:00:53,909 --> 00:00:55,810
vamos a profundizar un poquito más cuando

19
00:00:55,810 --> 00:00:58,509
controlemos un poco más la herramienta

20
00:00:58,509 --> 00:01:00,570
sobre todo yo, claro, yo es la primera vez que la voy a usar

21
00:01:00,570 --> 00:01:01,630
a ver qué tal, a ver qué tal

22
00:01:01,630 --> 00:01:06,310
bueno, pues miren, tengo dos cositas que vamos a ver

23
00:01:06,310 --> 00:01:08,150
un poquito, ambas las tienen en

24
00:01:08,150 --> 00:01:09,510
el aula virtual, las dos

25
00:01:09,510 --> 00:01:12,230
¿vale? este cliente lo voy a ir un poquitín rápido

26
00:01:12,230 --> 00:01:14,230
con él, porque es un programita

27
00:01:14,230 --> 00:01:16,430
muy sencillo, lo que hace es básicamente

28
00:01:16,430 --> 00:01:18,129
una gestión

29
00:01:18,129 --> 00:01:19,790
súper simple de clientes

30
00:01:19,790 --> 00:01:22,109
y lo que hace es que guarda los datos

31
00:01:22,109 --> 00:01:23,189
en un ficherito

32
00:01:23,189 --> 00:01:26,090
¿vale? y ya está, no hace más

33
00:01:26,090 --> 00:01:28,329
es muy sencillo

34
00:01:28,329 --> 00:01:30,170
el código este no lo he hecho yo

35
00:01:30,170 --> 00:01:35,609
Entonces, bueno, pues tiene cosas que a mí no me alegran mucho

36
00:01:35,609 --> 00:01:38,569
Por ejemplo, la estructura en la que almacena la información

37
00:01:38,569 --> 00:01:41,670
Pues es un array bidimensional que se llama cliente

38
00:01:41,670 --> 00:01:45,329
Donde va almacenando datos de tipo string de cada cliente

39
00:01:45,329 --> 00:01:51,189
Pues yo creo que deberíamos utilizar una estructura de las que hemos estudiado, ¿no?

40
00:01:51,310 --> 00:01:54,329
Precisamente, almacenar objetos del tipo cliente sería lo suyo

41
00:01:54,329 --> 00:01:58,750
Pero bueno, lo hace así, da igual, porque el objetivo de este programa básicamente es el acceso a disk

42
00:01:58,750 --> 00:02:01,629
entonces, bueno, pues tenemos los típicos

43
00:02:01,629 --> 00:02:03,450
menús de añadir, un listado

44
00:02:03,450 --> 00:02:05,609
buscamos cliente, borramos, borramos el fichero

45
00:02:05,609 --> 00:02:06,790
y salimos de la aplicación, vale

46
00:02:06,790 --> 00:02:09,250
entonces lo más interesante de esto, ya les digo

47
00:02:09,250 --> 00:02:11,449
lo tienen en el aula virtual

48
00:02:11,449 --> 00:02:13,389
le pueden echar un vistazo, vale

49
00:02:13,389 --> 00:02:15,629
es muy interesante y simplemente

50
00:02:15,629 --> 00:02:17,150
vamos a ver un poquitín

51
00:02:17,150 --> 00:02:18,530
lo que es la grabación, para que vean lo

52
00:02:18,530 --> 00:02:21,509
extremadamente simple que es la grabación de datos

53
00:02:21,509 --> 00:02:23,270
y su recuperación, miren

54
00:02:23,270 --> 00:02:25,490
para cargar

55
00:02:25,490 --> 00:02:26,990
el dato, fíjense lo que hacen, simplemente

56
00:02:26,990 --> 00:02:31,250
abrimos el ficherito que llama clientes.data, lo han denunciado

57
00:02:31,250 --> 00:02:36,490
y pues nada, vamos a preguntar aquí si existe

58
00:02:36,490 --> 00:02:41,469
lo primero que hay que comprobarlo, por supuesto hay que verificar

59
00:02:41,469 --> 00:02:44,669
siempre que trabajemos con ficheros y operaciones de entrada y salida

60
00:02:44,669 --> 00:02:50,469
siempre recuerden que tenemos que utilizar el formato de trabajo de excepciones

61
00:02:50,469 --> 00:02:53,770
porque pueden pasar algunas cosas, como por ejemplo que no se haya encontrado el archivo

62
00:02:53,770 --> 00:02:56,229
o algún error en la carga del archivo o algo

63
00:02:56,229 --> 00:03:00,129
Pueden pasar problemas de entrada y salida

64
00:03:00,129 --> 00:03:02,030
Que esos se manejan siempre con excepciones

65
00:03:02,030 --> 00:03:03,129
Miren lo que hacemos

66
00:03:03,129 --> 00:03:06,550
Simplemente hacemos el read object del objeto

67
00:03:06,550 --> 00:03:10,110
Que es este array bidimensional de streams

68
00:03:10,110 --> 00:03:13,889
Donde están almacenados todos los datos de todos estos clientes

69
00:03:13,889 --> 00:03:17,270
Ya está, vemos eso directamente

70
00:03:17,270 --> 00:03:20,129
Y eso lo almacenamos en nuestro array bidimensional cliente

71
00:03:20,129 --> 00:03:21,949
Que lo hemos definido en la parte superior

72
00:03:21,949 --> 00:03:24,409
Y con esto accedemos ya a todos los datos de todos los clientes

73
00:03:24,409 --> 00:03:29,289
Se le dio una estructura un poco, es poco elaborada, ¿vale?

74
00:03:30,270 --> 00:03:35,409
Merecería más la pena trabajar con alguna estructura un poco más del tipo de colecciones que hemos trabajado,

75
00:03:35,469 --> 00:03:36,729
pero bueno, es con la que se trabaja y esto.

76
00:03:36,830 --> 00:03:41,289
Entonces, como ven, es extremadamente simple y a la hora de grabar los datos, pues nos ocurre lo mismo.

77
00:03:41,729 --> 00:03:46,370
Simplemente, fíjense lo que hacemos aquí, esto ya digo que lo tienen ahí en el aula virtual.

78
00:03:47,270 --> 00:03:53,229
Nada, abrimos nuestro fichero, le ponemos como para que vamos a producir en la salida

79
00:03:53,229 --> 00:03:59,409
y escribimos, con write object, escribimos directamente toda la estructura cliente

80
00:03:59,409 --> 00:04:06,069
y automáticamente se nos almacena toda la estructura cliente de array bidimensional, ¿vale?

81
00:04:07,210 --> 00:04:09,849
Capturamos la excepción por si tenemos algún tipo de problema o lo que sea,

82
00:04:10,169 --> 00:04:16,470
capturamos la excepción si se produce algún problemita en el camino y lo realizaríamos ya.

83
00:04:17,089 --> 00:04:18,649
Y ya está, y es que no tiene más.

84
00:04:18,730 --> 00:04:22,829
Luego, bueno, el resto ya es un acceso al array bidimensional, que eso lo hemos visto ya con anterioridad,

85
00:04:23,230 --> 00:04:30,089
Vamos leyendo la información y vamos visualizándola o cualquier cosa que sea, la vamos metiendo, lo que sea, pero el resto no tiene interés.

86
00:04:30,769 --> 00:04:34,730
Recuerden un poquito, esto es importante, acuérdense, el tema de expresiones regulares, ¿vale?

87
00:04:35,170 --> 00:04:37,949
Muy interesante, pues, para verificar cosas, ¿eh?

88
00:04:38,790 --> 00:04:43,189
¿Vale? Entonces, esto, por ejemplo, estamos verificando que es un DNI correcto, ¿lo ven?

89
00:04:43,790 --> 00:04:49,870
Formado por ocho dígitos, ¿vale? Ocho elementos del tipo D, que se queda dígitos,

90
00:04:49,870 --> 00:05:00,529
y a continuación una letra de entre las que ponen aquí, que son las letras que están permitidas en los DNIs, ¿vale?

91
00:05:00,910 --> 00:05:05,050
Una de ellas, lo que no sabemos, lo que no hace la comprobación de expresiones regulares

92
00:05:05,050 --> 00:05:12,490
es si realmente la letra corresponde a la combinación de lígidos, que eso se hace, recuerden, con el exceso de 23,

93
00:05:12,490 --> 00:05:20,589
con el operador de resto, la parte entera del resto de la división entre 23, ¿vale?

94
00:05:20,589 --> 00:05:27,230
Esto nos lo verifica, pero por lo menos que tenga una estructura correcta, que sea de 8 dígitos y una letra a continuación, ¿vale?

95
00:05:27,329 --> 00:05:34,569
Pues, muy interesante, ¿vale? Esto nos lo verifica, recuerden, con una expresión regular, ¿eh? Acuérdense de esto.

96
00:05:37,459 --> 00:05:40,660
Y, bueno, por lo demás, creo que no hay muchísimo más que comentar.

97
00:05:40,660 --> 00:05:42,680
aquí tienen otra, simplemente el número de teléfono

98
00:05:42,680 --> 00:05:44,139
nos pide que tenga nueve

99
00:05:44,139 --> 00:05:45,680
dígitos, también con una

100
00:05:45,680 --> 00:05:46,959
versión regular

101
00:05:46,959 --> 00:05:49,620
de las que vimos en su momento

102
00:05:49,620 --> 00:05:52,160
y pues nada, el resto pues vamos

103
00:05:52,160 --> 00:05:54,180
introduciendo la información y demás

104
00:05:54,180 --> 00:05:56,399
o visualizándola o lo que sea, ya es el acceso

105
00:05:56,399 --> 00:05:57,819
a raíces bidimensionales y tal

106
00:05:57,819 --> 00:06:00,540
que todo esto ya lo hemos visto y no vamos a perder

107
00:06:00,540 --> 00:06:01,920
más tiempo en ello, ahora mismo

108
00:06:01,920 --> 00:06:02,379
¿vale?

109
00:06:03,660 --> 00:06:06,579
el código del programa lo tienen ahí en el

110
00:06:06,579 --> 00:06:08,720
en el aula virtual y lo pueden revisar

111
00:06:08,720 --> 00:06:13,000
Y vamos a pasar a ver un poquito el otro que me interesa un poquito más, ¿vale?

112
00:06:15,079 --> 00:06:20,120
Me interesa un poquitín más porque sí que trabaja con estructura de datos un poquito más avanzada, ¿no?

113
00:06:20,120 --> 00:06:21,339
Con colecciones, ¿vale?

114
00:06:22,339 --> 00:06:25,399
Bueno, esto último simplemente, pues nada, se hace un delete del fichero,

115
00:06:25,879 --> 00:06:28,759
está, nosotros abrimos el fichero y lo borramos y ya está.

116
00:06:29,160 --> 00:06:34,019
Y si no pasa nada y esto vuelve true, el archivo se ha borrado perfectamente

117
00:06:34,019 --> 00:06:37,800
y si no nos da false es que ha habido algún problema y algo está perdido, ¿vale?

118
00:06:37,800 --> 00:06:40,000
no tiene más, ya le digo que es que no tiene

119
00:06:40,000 --> 00:06:41,040
muchísimo, miren

120
00:06:41,040 --> 00:06:43,720
sí que me interesa un poquito más

121
00:06:43,720 --> 00:06:45,620
este ejercicio, ¿vale?

122
00:06:45,680 --> 00:06:47,879
y lo tenemos en dos versiones, ¿vale? este ejercicio

123
00:06:47,879 --> 00:06:49,139
lo que hace es que

124
00:06:49,139 --> 00:06:53,439
lo que hace es

125
00:06:53,439 --> 00:06:55,399
que nada, pues simula una partida de cartas

126
00:06:55,399 --> 00:06:57,220
una cosa muy interesante, muy sencillita

127
00:06:57,220 --> 00:06:58,959
pero bueno, pues está muy bien porque

128
00:06:58,959 --> 00:07:00,620
desde un punto de vista programático es muy interesante

129
00:07:00,620 --> 00:07:02,920
nos simula una partida de cartas

130
00:07:02,920 --> 00:07:05,500
y nos hace

131
00:07:05,500 --> 00:07:07,240
yo he hecho el programa de dos maneras distintas

132
00:07:07,240 --> 00:07:10,459
una primera sencilla y una versión un poquitín más avanzada

133
00:07:10,459 --> 00:07:13,399
con alguna opción más, vale, voy a ver primero

134
00:07:13,399 --> 00:07:16,740
la versión sencilla y luego vamos a ver los aspectos

135
00:07:16,740 --> 00:07:19,740
relevantes de la versión avanzada, vale, donde ustedes pueden

136
00:07:19,740 --> 00:07:22,459
cotejar un poco, vale, las tienen

137
00:07:22,459 --> 00:07:25,699
en el aula virtual, las tienen, ahí las tienen y las pueden echar a ver

138
00:07:25,699 --> 00:07:27,500
entonces miren, le voy a abrir una ventana

139
00:07:27,500 --> 00:07:32,759
un poquitín más grande esto, vale

140
00:07:32,759 --> 00:07:36,939
esto está basado en una práctica

141
00:07:36,939 --> 00:07:41,339
que tienen aquí la borrela y pueden observar, entonces miren lo que hace esto

142
00:07:41,339 --> 00:07:45,040
tenemos, vamos a jugar cuatro manos

143
00:07:45,040 --> 00:07:49,240
y cuatro cartas por cada mano, es decir, va a haber como cuatro

144
00:07:49,240 --> 00:07:52,720
¿vale? y le vamos a dar cuatro cartas a cada una de esas manos

145
00:07:52,720 --> 00:07:57,139
entonces miren, primero declaramos los palos, espadas, oros, bastos y copas

146
00:07:57,139 --> 00:08:01,319
y declaramos las cartas, ¿qué cartas tenemos disponibles

147
00:08:01,319 --> 00:08:05,120
en una baraja? pues el as, el dos, el tres, el siete, la sota, el caballo y el rey

148
00:08:05,120 --> 00:08:11,019
Esto lo hace con una ArrayList, fíjense lo que vamos haciendo

149
00:08:11,019 --> 00:08:18,939
Recorremos todos los palos, todos los palos, es decir, espadas, oros, bastos y copas

150
00:08:18,939 --> 00:08:22,480
Recorremos cada uno de ellos y recorremos todas las cartas

151
00:08:22,480 --> 00:08:28,339
¿Qué ocurre? Nos va a generar, con esto de aquí, que está en el doble bucle

152
00:08:28,339 --> 00:08:35,360
Va a generar una carta, un número de carta a dos tres total de cada palo

153
00:08:35,360 --> 00:08:40,559
Es decir, cuando palo sea espadas, tendremos as de espadas, dos de espadas, tres de espadas.

154
00:08:40,600 --> 00:08:42,159
Es decir, ¿qué estamos haciendo aquí?

155
00:08:42,360 --> 00:08:46,519
En mazo, ad, mazo, será donde metamos todas las cartas.

156
00:08:46,679 --> 00:08:48,500
Estamos añadiendo cada una de esas cartas.

157
00:08:49,240 --> 00:08:53,080
Al estar en un bucle anidado aquí, metemos todas las cartas de la baraja.

158
00:08:54,080 --> 00:08:58,320
¿Qué estamos haciendo aquí? Generar este mazo, que nos va a permitir trabajar.

159
00:08:58,860 --> 00:09:04,080
Claro, al generarlo con este doble bucle anidado, con este orden, se nos va a generar en orden.

160
00:09:04,080 --> 00:09:06,860
va a estar primero, pues el as de espadas

161
00:09:06,860 --> 00:09:08,620
2 de espadas, 3 de espadas

162
00:09:08,620 --> 00:09:10,720
así está el rey de espadas, cuando termine con el

163
00:09:10,720 --> 00:09:12,919
palo de espadas, pasamos al siguiente del palo

164
00:09:12,919 --> 00:09:14,559
el bucle externo, el de palo

165
00:09:14,559 --> 00:09:16,580
oros, as de oros, 2 de oros

166
00:09:16,580 --> 00:09:18,379
así está el rey de oros, a continuación

167
00:09:18,379 --> 00:09:20,940
as de base de las leyes, tendríamos una baraja ordenada

168
00:09:20,940 --> 00:09:21,940
al salir de aquí

169
00:09:21,940 --> 00:09:23,700
y fíjense lo siguiente que hacemos

170
00:09:23,700 --> 00:09:26,059
recuerden que teníamos

171
00:09:26,059 --> 00:09:28,179
un método de collections

172
00:09:28,179 --> 00:09:29,639
que afecta a cualquier

173
00:09:29,639 --> 00:09:32,080
organización de datos

174
00:09:32,080 --> 00:09:34,120
estructura de datos que derive de collection

175
00:09:34,120 --> 00:09:35,600
se llama shuffle, shuffle es

176
00:09:35,600 --> 00:09:37,799
barajar, desordenar

177
00:09:37,799 --> 00:09:40,000
descolocar, no sé cómo se traduce

178
00:09:40,000 --> 00:09:42,179
mezclar, de acuerdo, mezclar

179
00:09:42,179 --> 00:09:44,259
de forma aleatoria y no tenemos que hacer

180
00:09:44,259 --> 00:09:45,820
nada, lo hace ya el todo

181
00:09:45,820 --> 00:09:48,200
entonces nosotros obtenemos de este doble bucle

182
00:09:48,200 --> 00:09:50,139
anidado un mazo perfectamente ordenado

183
00:09:50,139 --> 00:09:52,159
por espadas, oros, bastos y copas

184
00:09:52,159 --> 00:09:54,000
y después de aplicar shuffle

185
00:09:54,000 --> 00:09:56,259
todos los elementos de esta collection

186
00:09:56,259 --> 00:09:58,139
se desordenan

187
00:09:58,700 --> 00:09:59,940
se mezclan

188
00:09:59,940 --> 00:10:04,019
de forma más o menos supuestamente aleatoria.

189
00:10:05,139 --> 00:10:09,179
Y entonces con eso ya hemos barajado la carta, o sea, el mazo, perdón,

190
00:10:09,220 --> 00:10:10,460
hemos barajado el mazo y están todas.

191
00:10:11,460 --> 00:10:14,519
Una vez que tenemos el mazo y a continuación lo tenemos barajado,

192
00:10:14,899 --> 00:10:17,840
¿qué hacemos a continuación? Pues nada, nos ponemos a repartir cartas.

193
00:10:19,399 --> 00:10:22,940
¿Cómo repartimos las cartas? Pues decimos cuántas manos queremos dar.

194
00:10:23,039 --> 00:10:27,360
Hemos dicho antes que eran cuatro, desde cero, mientras que sea número de manos,

195
00:10:27,360 --> 00:10:30,759
Pues era 0, 1, 2, 3, que son 4 manos

196
00:10:30,759 --> 00:10:33,460
La mano 0, la mano 1, la mano 2 y la mano 3

197
00:10:33,460 --> 00:10:34,440
4 manos, ¿vale?

198
00:10:35,299 --> 00:10:36,600
Y repartimos las cartas

199
00:10:36,600 --> 00:10:37,740
¿Cómo repartimos las cartas?

200
00:10:37,840 --> 00:10:41,659
Pues al jugador yésimo le mandamos

201
00:10:41,659 --> 00:10:48,419
Hacemos una llamada al método reparte cartas por cada mano

202
00:10:48,419 --> 00:10:51,240
Lo ven aquí, este método reparte del mazo

203
00:10:51,240 --> 00:10:53,700
El número de cartas por mano que vamos a dar

204
00:10:53,700 --> 00:10:55,899
se recoge del mazo

205
00:10:55,899 --> 00:10:57,620
y le dice cuántas cartas le voy a dar

206
00:10:57,620 --> 00:10:59,759
pues lo indicamos en cartas por mano, vamos a ver este método

207
00:10:59,759 --> 00:11:01,320
que es muy interesante, aquí lo tenemos

208
00:11:01,320 --> 00:11:03,779
este método reparte, fíjense

209
00:11:03,779 --> 00:11:05,259
lo que hace, me devuelve una lista

210
00:11:05,259 --> 00:11:07,899
¿vale? el método me devuelve una lista, miren lo que hace

211
00:11:07,899 --> 00:11:09,740
primero, dice

212
00:11:09,740 --> 00:11:12,159
¿qué tamaño tengo en el mazo ahora mismo?

213
00:11:12,600 --> 00:11:13,659
yo le he pasado el mazo

214
00:11:13,659 --> 00:11:15,539
le digo pues mazo size

215
00:11:15,539 --> 00:11:17,139
entonces me dice el tamaño que tiene el mazo

216
00:11:17,139 --> 00:11:19,440
entonces miren lo que hace, extrae una

217
00:11:19,440 --> 00:11:21,279
hand view, ¿vale? una hand view

218
00:11:21,279 --> 00:11:23,299
es que selecciona las

219
00:11:23,299 --> 00:11:25,320
n últimas cartas

220
00:11:25,320 --> 00:11:26,320
de arriba

221
00:11:26,320 --> 00:11:29,360
¿cuánto es n? el número de cartas

222
00:11:29,360 --> 00:11:30,299
que yo quiero repartir

223
00:11:30,299 --> 00:11:31,919
entonces digo de can view

224
00:11:31,919 --> 00:11:33,460
al mazo

225
00:11:33,460 --> 00:11:36,659
le extraemos una sublista

226
00:11:36,659 --> 00:11:39,419
desde mazo

227
00:11:39,419 --> 00:11:41,259
menos n hasta tamaño del mazo

228
00:11:41,259 --> 00:11:43,480
¿ven la idea de esto?

229
00:11:45,480 --> 00:11:47,139
¿lo ven aquí? desde tamaño de mazo

230
00:11:47,139 --> 00:11:49,179
menos el número de cartas que yo quiero repartir

231
00:11:49,179 --> 00:11:51,059
hasta el final del mazo

232
00:11:51,059 --> 00:11:52,700
y lo extraemos

233
00:11:52,700 --> 00:11:56,740
con una sublista. A continuación, ¿qué es lo que hacemos?

234
00:11:56,860 --> 00:12:00,299
Decimos, bueno, pues voy a hacer una nueva mano, me declaro una nueva mano que es una lista

235
00:12:00,299 --> 00:12:03,419
con un ArrayList nuevo

236
00:12:03,419 --> 00:12:08,299
que contiene las cartas que hemos extraído con esa HandView

237
00:12:08,299 --> 00:12:12,539
¿Vale? ¿Sí? Vale

238
00:12:12,539 --> 00:12:16,820
Pero fíjense lo importante de esto, es nuevo, es un ArrayList

239
00:12:16,820 --> 00:12:20,820
nuevo, porque a continuación, justo lo que hago a continuación

240
00:12:20,820 --> 00:12:24,120
es aprovechar una de las propiedades de las sublistas

241
00:12:24,120 --> 00:12:25,659
y al hacer un HandViewClear

242
00:12:25,659 --> 00:12:30,000
estamos quitando esas cartas de la sublista HandView

243
00:12:30,000 --> 00:12:33,600
pero como HandView es una sublista del mazo

244
00:12:33,600 --> 00:12:34,940
que mazo es una lista

245
00:12:34,940 --> 00:12:37,620
realmente las estoy quitando también del mazo

246
00:12:37,620 --> 00:12:40,840
pues acuérdense que las operaciones sobre sublistas

247
00:12:40,840 --> 00:12:42,799
afectan a la lista original

248
00:12:42,799 --> 00:12:45,620
¿y por qué no afecta a Hand?

249
00:12:45,700 --> 00:12:49,480
porque Hand es una nueva ArrayList

250
00:12:49,480 --> 00:12:50,480
lo ven aquí, ¿no?

251
00:12:50,820 --> 00:12:59,340
Entonces, lo que hacemos es que extraigo las cartas en una sublista, esa sublista la copio en una nueva lista donde ya se almacena permanentemente

252
00:12:59,340 --> 00:13:07,519
y borro la sublista, y al borrar la sublista, borro la sublista y borro las cartas del mazo, que es la lista original.

253
00:13:08,419 --> 00:13:15,240
HandView es una sublista de mazo, entonces al borrar HandView, borro, HandView y borro también las borro de mazo.

254
00:13:15,240 --> 00:13:22,940
y una vez que he hecho eso, lo que hago es que devuelvo esas cartas que he extraído de la lista original

255
00:13:22,940 --> 00:13:28,139
las devuelvo y se pueden utilizar para lo que sea en este caso, pues para visualizarlas simplemente

256
00:13:28,139 --> 00:13:32,980
en el más aquí, eso tiene un toString, ¿vale? ese list tiene un toString

257
00:13:32,980 --> 00:13:37,940
ese toString al salir aquí, pues lo que vamos a hacer es ver, miren la salida, 5 de espadas

258
00:13:37,940 --> 00:13:43,080
las primeras cartas que he repartido, 5 de espadas, sota de copas, sota de espadas, 5 de copas

259
00:13:43,080 --> 00:13:46,580
En la segunda vuelta repartimos otras cuatro

260
00:13:46,580 --> 00:13:50,240
Seis de copas, cuatro de bastos, dos de bastos, caballo de bastos

261
00:13:50,240 --> 00:13:53,779
En la siguiente vuelta de este bucle repartimos otras cuatro

262
00:13:53,779 --> 00:13:55,440
Caballo de espadas, as de copas

263
00:13:55,440 --> 00:13:58,220
Y fíjense que cada vez que sacamos las cartas ya no vuelven a existir

264
00:13:58,220 --> 00:14:01,200
Cosa que tiene que ser, una vez que saco una carta de un palo

265
00:14:01,200 --> 00:14:04,480
No vuelve a existir en el mazo y no la puedo volver a repartir

266
00:14:04,480 --> 00:14:08,980
Entonces fíjense con qué poquito código y de qué forma tan sencillita

267
00:14:08,980 --> 00:14:11,460
Organizamos una partida de cartas

268
00:14:11,460 --> 00:14:17,700
Esto sería una partida de cuatro manos con cuatro cartas por cada mano

269
00:14:17,700 --> 00:14:22,720
Muy bien, pues como ven, fíjense que simple

270
00:14:22,720 --> 00:14:26,600
Y miren, vamos a ver esto mismo en versión avanzada

271
00:14:26,600 --> 00:14:30,639
Es lo mismo pero con un poquitín más de funcionalidad

272
00:14:30,639 --> 00:14:34,720
¿Qué funcionalidades añadidas tiene esta versión avanzada?

273
00:14:35,820 --> 00:14:38,639
Aquí hay algunas referencias donde pueden mirar a ver

274
00:14:38,639 --> 00:14:44,039
Como por ejemplo vamos a realizar la utilización de argumentos en los programas

275
00:14:44,039 --> 00:14:48,279
Ustedes saben que los programas pueden recibir información del sistema operativo

276
00:14:48,279 --> 00:14:52,320
Por ejemplo, si ustedes en Linux escriben ls menos la

277
00:14:52,320 --> 00:14:58,379
S menos la es información, es un parámetro que ustedes pasan al programa ls

278
00:14:58,379 --> 00:15:01,379
Si ustedes en Windows dicen dir asterisco punto asterisco

279
00:15:01,379 --> 00:15:07,220
Pues este asterisco punto asterisco es un parámetro que están pasando al programa dir punto exe o como sea

280
00:15:07,220 --> 00:15:10,139
En Windows es .s, en Linux no lleva extensión

281
00:15:10,139 --> 00:15:12,940
¿Vale? Pero todo eso son parámetros que se pasan

282
00:15:12,940 --> 00:15:15,259
Entonces eso en Java también se pueden recibir esos parámetros

283
00:15:15,259 --> 00:15:16,639
Y es una de las cosas que vamos a hacer aquí

284
00:15:16,639 --> 00:15:20,399
Vamos a recibir parámetros y vamos a utilizarlos

285
00:15:20,399 --> 00:15:21,940
¿Sí?

286
00:15:22,600 --> 00:15:23,220
Entonces miren

287
00:15:23,220 --> 00:15:26,120
Vamos a ver, primero, trabajamos con el main

288
00:15:26,120 --> 00:15:28,799
Donde, fíjense, muy importante, recibimos aquí los argumentos

289
00:15:28,799 --> 00:15:29,899
Del sistema operativo, vienen aquí

290
00:15:29,899 --> 00:15:31,679
En el main, ¿vale?

291
00:15:31,679 --> 00:15:34,799
Estos args, que es un array de strings

292
00:15:34,799 --> 00:15:39,360
Los argumentos van a ser siempre una colección de cadenas de caracteres que pasamos a los programas

293
00:15:39,360 --> 00:15:41,399
Y como tal se tratan dentro del programa

294
00:15:41,399 --> 00:15:45,500
Como strings dentro de una array de strings que se llama args

295
00:15:45,500 --> 00:15:47,440
Ahí es donde vamos a tener

296
00:15:47,440 --> 00:15:52,700
Bien, entonces definimos dos variables, número de manos y cartas por cada mano

297
00:15:52,700 --> 00:15:55,100
Y luego definimos otra variable más que es la baraja

298
00:15:55,100 --> 00:15:56,860
Y decimos que, indicamos que

299
00:15:56,860 --> 00:16:01,559
Con un 0 indicamos baraja española, con un 1 baraja francesa

300
00:16:01,559 --> 00:16:02,799
Entonces miren

301
00:16:02,799 --> 00:16:06,240
si la longitud

302
00:16:06,240 --> 00:16:08,279
de los argumentos

303
00:16:08,279 --> 00:16:09,600
es mayor que 1

304
00:16:09,600 --> 00:16:11,840
es decir que se han pasado parámetros

305
00:16:11,840 --> 00:16:12,539
¿vale?

306
00:16:13,320 --> 00:16:15,960
y el orden de los parámetros que hay que pasar es el siguiente

307
00:16:15,960 --> 00:16:18,000
los parámetros se indican en el ID

308
00:16:18,000 --> 00:16:19,659
en el entorno de desarrollo integrado

309
00:16:19,659 --> 00:16:21,799
para indicar los parámetros está en

310
00:16:21,799 --> 00:16:23,919
ejecutar, establecer configuración por efecto

311
00:16:23,919 --> 00:16:25,740
personalizar, run

312
00:16:25,740 --> 00:16:27,679
set project settings

313
00:16:27,679 --> 00:16:29,259
customize ¿vale? y con esto

314
00:16:29,259 --> 00:16:31,820
pues si queremos jugar una partida de mus

315
00:16:31,820 --> 00:16:34,480
hay que poner 4 jugadores, 4 cartas

316
00:16:34,480 --> 00:16:37,659
y 0 que es la baraja española

317
00:16:37,659 --> 00:16:40,100
si queremos jugar al póker pues son

318
00:16:40,100 --> 00:16:45,940
4 jugadores, si queremos jugar 4 jugadores, 5 cartas

319
00:16:45,940 --> 00:16:48,360
por jugador y la baraja francesa

320
00:16:48,360 --> 00:16:52,039
la que tiene picas, tréboles, corazones y rombo

321
00:16:52,039 --> 00:16:54,120
y por ejemplo si queremos jugar al tute

322
00:16:54,120 --> 00:16:57,700
pues necesitamos 4 jugadores, 10 cartas

323
00:16:57,700 --> 00:17:00,740
por jugador y la baraja española

324
00:17:00,740 --> 00:17:02,259
que es la 0 para jugar al tute

325
00:17:02,259 --> 00:17:11,220
Entonces este programa es un poquito más avanzado porque a través de parámetros podemos indicar el tipo de juego en el que queremos repartir las cartas, ¿vale?

326
00:17:12,819 --> 00:17:19,420
Entonces, si es que se han avanzado los parámetros, vamos a indicar que el número de manos será el primer parámetro.

327
00:17:19,519 --> 00:17:24,099
El primer parámetro es args de 0, ¿vale? Este 4 sería el primer parámetro.

328
00:17:24,220 --> 00:17:30,460
¿Qué hacemos con este args de 0? A través del parseInt, del wrapperInteger, lo transformamos en número entero y se lo asignamos al número de manos.

329
00:17:30,460 --> 00:17:33,200
el segundo parámetro sería

330
00:17:33,200 --> 00:17:35,500
el número de cartas

331
00:17:35,500 --> 00:17:36,900
que hay que repartir en cada mano

332
00:17:36,900 --> 00:17:39,420
en el caso del Mu sería 4

333
00:17:39,420 --> 00:17:41,079
en el caso del Poker 5

334
00:17:41,079 --> 00:17:42,859
en el caso del Tute 10

335
00:17:42,859 --> 00:17:45,299
y el último es la baraja

336
00:17:45,299 --> 00:17:47,519
que vamos a usar, si es española o es francesa

337
00:17:47,519 --> 00:17:50,019
y el último está en arjas de 2

338
00:17:50,019 --> 00:17:51,680
0 español, 1 francés

339
00:17:51,680 --> 00:17:53,779
esto es cuando se han pasado parámetros

340
00:17:53,779 --> 00:17:55,380
si no se pasa parámetros, ¿qué hacemos?

341
00:17:55,839 --> 00:17:56,559
pues establecemos

342
00:17:56,559 --> 00:17:58,900
una parametrización por defecto

343
00:17:58,900 --> 00:18:01,279
decimos que cuatro manos, cuatro cartas

344
00:18:01,279 --> 00:18:03,259
por mano, baraja española, es decir, una partida

345
00:18:03,259 --> 00:18:04,980
de mus, cuatro jugadores

346
00:18:04,980 --> 00:18:07,400
cuatro cartas de una baraja española

347
00:18:07,400 --> 00:18:08,460
pues con eso se suele jugar

348
00:18:08,460 --> 00:18:10,880
y pues nada

349
00:18:10,880 --> 00:18:13,180
vamos a construir el mazo, lo primero

350
00:18:13,180 --> 00:18:15,259
que hacemos es que el palo de las

351
00:18:15,259 --> 00:18:16,960
cartas españolas es espadas, oros

352
00:18:16,960 --> 00:18:19,099
bastos y copas, lo guardamos en una

353
00:18:19,099 --> 00:18:20,839
raid strings, el palo

354
00:18:20,839 --> 00:18:23,059
para las francesas es rombos, corazones

355
00:18:23,059 --> 00:18:23,819
picas y tréboles

356
00:18:23,819 --> 00:18:26,819
y definimos la variable

357
00:18:26,819 --> 00:18:28,839
la referencia palo con valor

358
00:18:28,839 --> 00:18:32,400
nul, ¿vale? bien, luego, fíjense lo que hacemos

359
00:18:32,400 --> 00:18:35,579
si la baraja es cero, ¿vale? si es española

360
00:18:35,579 --> 00:18:40,799
copiamos, ¿vale? en palo, copiamos

361
00:18:40,799 --> 00:18:42,880
el array del palo español

362
00:18:42,880 --> 00:18:48,539
y si la baraja no es cero, entonces vamos a leerse

363
00:18:48,539 --> 00:18:52,279
copiamos el palo francés, que son los nombres

364
00:18:52,279 --> 00:18:58,309
de los palos, ¿no? de la baraja francesa

365
00:18:58,309 --> 00:19:00,269
Rombos, corazones, picas y lejos.

366
00:19:01,309 --> 00:19:03,430
Aquí simplemente se establece la función de la baraja.

367
00:19:03,549 --> 00:19:04,750
Si trabajamos con uno, trabajamos con otro.

368
00:19:05,089 --> 00:19:06,190
Y lo metemos en palo.

369
00:19:07,109 --> 00:19:07,769
Ahí lo guardamos.

370
00:19:08,769 --> 00:19:11,349
A continuación, definimos las cartas de la baraja española.

371
00:19:11,470 --> 00:19:14,049
Son estas de aquí, A2, 3, 4, 6, 7, J, caballo y rey.

372
00:19:14,569 --> 00:19:20,089
Y en la baraja francesa son A2, 3, 4, 6, 7, 8, 9, 10, J, dama y rey.

373
00:19:20,930 --> 00:19:22,289
Y hacemos exactamente lo mismo.

374
00:19:22,569 --> 00:19:25,029
Definimos la referencia carta, que no le damos datos,

375
00:19:25,029 --> 00:19:28,890
porque la vamos a sacar de si la baraja es española o la baraja no es española.

376
00:19:29,269 --> 00:19:37,809
¿Que la baraja es española? Pues le copiamos en carta los mismos datos que está en carta española.

377
00:19:38,269 --> 00:19:42,829
Y si no es española, es decir, baraja es igual a 1, es 0, es otra cosa,

378
00:19:43,289 --> 00:19:46,809
entonces copiamos los datos de las cartas, los nombres de las cartas francesas.

379
00:19:47,009 --> 00:19:50,670
¿Y qué hacemos a continuación? Una vez que ya tenemos carta y tenemos mazo,

380
00:19:50,670 --> 00:19:52,329
y palo, perdón, tenemos ya palo

381
00:19:52,329 --> 00:19:54,829
tenemos ya carta, pues entonces ya podemos

382
00:19:54,829 --> 00:19:56,769
generar el mazo, ya sabemos los

383
00:19:56,769 --> 00:19:58,509
palos que tenemos y las cartas que tenemos

384
00:19:58,509 --> 00:20:00,150
y hacemos exactamente lo mismo que antes

385
00:20:00,150 --> 00:20:01,769
creamos una lista

386
00:20:01,769 --> 00:20:03,930
del tipo ArrayList

387
00:20:03,930 --> 00:20:08,380
que llamamos mazo y lo hacemos

388
00:20:08,380 --> 00:20:10,279
igual que antes con un doble bucle anidado

389
00:20:10,279 --> 00:20:12,640
que recorre primero los palos y luego las cartas

390
00:20:12,640 --> 00:20:14,559
para cada uno de los palos

391
00:20:14,559 --> 00:20:16,720
metemos todas las cartas del palo correspondiente

392
00:20:16,720 --> 00:20:17,660
¿qué estamos generando?

393
00:20:18,059 --> 00:20:20,079
cada una de las cartas de la baraja de una luna

394
00:20:20,079 --> 00:20:25,680
Pues será, el primer palo era, vamos a verlo por aquí, la española

395
00:20:25,680 --> 00:20:28,299
Espadas, oros, bastos y copas

396
00:20:28,299 --> 00:20:30,019
Pues sería, espadas

397
00:20:30,019 --> 00:20:35,779
Pues as de, espadas, dos de, espadas, tres de, espadas, hasta rey de, espadas

398
00:20:35,779 --> 00:20:38,339
A continuación se terminarán las cartas, pasamos al siguiente palo

399
00:20:38,339 --> 00:20:42,119
Oros, as de, oros, dos de, oros, tres de, oros, así hasta el rey de oros

400
00:20:42,119 --> 00:20:47,220
Se genera todo el mazo y ya una vez que salimos de este doble bucle anidado

401
00:20:47,220 --> 00:20:49,720
hemos generado todo el mazo

402
00:20:49,720 --> 00:20:51,019
de la baraja, ¿de acuerdo?

403
00:20:52,839 --> 00:20:53,359
luego

404
00:20:53,359 --> 00:20:54,400
detalles

405
00:20:54,400 --> 00:20:58,039
solamente cuando la baraja sea la francesa

406
00:20:58,039 --> 00:20:59,559
hay que meter dos cartas más

407
00:20:59,559 --> 00:21:01,559
que son los comodines, los joker

408
00:21:01,559 --> 00:21:03,680
pero eso solo ocurre

409
00:21:03,680 --> 00:21:06,140
cuando sea la baraja francesa

410
00:21:06,140 --> 00:21:07,819
entonces si la baraja es francesa hay que meter

411
00:21:07,819 --> 00:21:09,980
los comodines, ¿vale? porque la baraja francesa

412
00:21:09,980 --> 00:21:12,400
se juega con dos comodines en muchos juegos

413
00:21:12,400 --> 00:21:13,819
luego a veces se pueden sacar o lo que sea

414
00:21:13,819 --> 00:21:15,940
pero esto ya son opciones que podríamos

415
00:21:15,940 --> 00:21:18,039
añadir al programa, pero nosotros, si es francesa

416
00:21:18,039 --> 00:21:19,460
le ponemos sus comodines ahí para poder

417
00:21:19,460 --> 00:21:22,220
una vez que ya hemos creado nuestro mazo

418
00:21:22,220 --> 00:21:24,140
bien sea, se habrá creado el español

419
00:21:24,140 --> 00:21:25,960
se habrá creado el francés, lo que sea, una vez que

420
00:21:25,960 --> 00:21:28,000
está creado y ordenadito, vamos a

421
00:21:28,000 --> 00:21:29,960
lo siguiente que es, barajamos

422
00:21:29,960 --> 00:21:31,960
el mazo de cartas

423
00:21:31,960 --> 00:21:35,589
¿cómo barajamos el mazo de cartas?

424
00:21:35,650 --> 00:21:36,890
pues podríamos haber hecho una función

425
00:21:36,890 --> 00:21:39,369
que a través de la función, que el método

426
00:21:39,369 --> 00:21:41,130
random los vaya sacando y

427
00:21:41,130 --> 00:21:43,009
desordenando, pero

428
00:21:43,009 --> 00:21:45,289
es mucho más inteligente utilizar algo

429
00:21:45,289 --> 00:21:47,150
que ya está hecho, y hay

430
00:21:47,150 --> 00:21:49,529
algo ya está hecho que, como hemos dicho antes, es el método

431
00:21:49,529 --> 00:21:50,890
shuffle de collection

432
00:21:50,890 --> 00:21:53,190
el método shuffle de collection desordena

433
00:21:53,190 --> 00:21:54,809
aleatoriamente una colección, entonces

434
00:21:54,809 --> 00:21:57,349
si nos lo han hecho, ¿para qué nos vamos a complicar la existencia?

435
00:21:57,609 --> 00:21:59,369
si nos lo han hecho, lo hacemos y ya está

436
00:21:59,369 --> 00:22:01,349
y además tenemos

437
00:22:01,349 --> 00:22:03,269
ciertas garantías de que más o menos

438
00:22:03,269 --> 00:22:04,950
funciona bien, es pseudoalatorio

439
00:22:04,950 --> 00:22:07,450
como todo en programación, no en la aleatoriedad

440
00:22:07,450 --> 00:22:09,390
presente, en programación no existe, en computadoras

441
00:22:09,390 --> 00:22:09,789
de momento

442
00:22:09,789 --> 00:22:13,230
pero bueno, para nosotros es

443
00:22:13,230 --> 00:22:14,970
más que muy suficiente

444
00:22:14,970 --> 00:22:17,990
Y con ello trabajamos

445
00:22:17,990 --> 00:22:20,410
Tampoco sería perfectamente aleatorio

446
00:22:20,410 --> 00:22:22,069
El random que vamos a utilizar

447
00:22:22,069 --> 00:22:22,950
Con lo cual nos da igual

448
00:22:22,950 --> 00:22:25,910
Uno que no sea perfecto, otro que no sea perfecto

449
00:22:25,910 --> 00:22:28,549
Sin embargo shuffle nos ahorra muchísimo

450
00:22:28,549 --> 00:22:30,170
Código y mucho tiempo de trabajo

451
00:22:30,170 --> 00:22:31,410
Eso es muy importante

452
00:22:31,410 --> 00:22:34,049
Una vez que hemos desordenado, pues decimos nada

453
00:22:34,049 --> 00:22:36,089
Vamos a jugar una partida de tantas manos

454
00:22:36,089 --> 00:22:38,529
Con tantas cartas

455
00:22:38,529 --> 00:22:39,150
Por cada mano

456
00:22:39,150 --> 00:22:42,250
Y sacamos las cartas de cada una a la baraja

457
00:22:42,250 --> 00:22:44,430
Siendo la baraja española o francesa

458
00:22:44,430 --> 00:22:45,890
En función de si la baraja es cero española

459
00:22:45,890 --> 00:22:46,990
Si no, vamos a sacar a francesa

460
00:22:46,990 --> 00:22:49,289
Y mostramos para cada jugador

461
00:22:49,289 --> 00:22:51,349
El número de jugador

462
00:22:51,349 --> 00:22:53,109
Y exactamente lo mismo que antes

463
00:22:53,109 --> 00:22:55,150
El método reparte

464
00:22:55,150 --> 00:22:57,630
Que del mazo extrae

465
00:22:57,630 --> 00:23:00,190
El número de cartas que se dan cada mazo

466
00:23:00,190 --> 00:23:01,950
Reparte a cada jugador

467
00:23:01,950 --> 00:23:02,950
El número de cartas que hay que darle

468
00:23:02,950 --> 00:23:04,789
4, 5, 7, 10

469
00:23:04,789 --> 00:23:06,849
Imagínense con que sean 7

470
00:23:06,849 --> 00:23:08,349
No sé con ningún juego

471
00:23:08,349 --> 00:23:11,569
Pero el mus son 4, la brisca serían 3

472
00:23:11,569 --> 00:23:13,549
El tute serían 10

473
00:23:13,549 --> 00:23:17,670
el póker serían 5, bueno, pues lo pasamos eso en cartas por cada mano, ¿vale?

474
00:23:18,170 --> 00:23:22,369
Y el método de parte es exactamente el mismo que antes, es sub, fíjense qué interesante,

475
00:23:23,029 --> 00:23:27,630
haciendo uso de las propiedades de las sublistas, cómo se resuelve este problema, qué sencillo.

476
00:23:28,049 --> 00:23:35,089
Yo quiero extraer un número de elementos de un conjunto, hago una sublista con ese número de elementos,

477
00:23:35,630 --> 00:23:41,430
esa sublista la copio en una lista nueva donde reside esa información ya de forma permanente

478
00:23:41,430 --> 00:23:45,789
y al borrar la sublista, las borro de la lista original

479
00:23:45,789 --> 00:23:50,890
y las tengo perfectamente separadas de la lista original

480
00:23:50,890 --> 00:23:54,670
y las puedo devolver, esto es lo que hace exactamente el reparto

481
00:23:54,670 --> 00:23:58,809
exactamente lo que les digo, hand view, extraes

482
00:23:58,809 --> 00:24:02,849
esas del mazo, extraes las cartas

483
00:24:02,849 --> 00:24:03,569
que se le piden

484
00:24:03,569 --> 00:24:10,049
ese hand view, extraes esas cartas del mazo

485
00:24:10,049 --> 00:24:12,829
una vez que las extrae, las copia

486
00:24:12,829 --> 00:24:14,450
en la mano que llama hand

487
00:24:14,450 --> 00:24:16,809
mano de cartas, en inglés mano de cartas

488
00:24:16,809 --> 00:24:18,650
lo copia con new

489
00:24:18,650 --> 00:24:20,869
muy importante, al hacerlo nuevo

490
00:24:20,869 --> 00:24:22,890
esas referencias

491
00:24:22,890 --> 00:24:23,970
ya son permanentes

492
00:24:23,970 --> 00:24:25,970
están en un new, es una nueva

493
00:24:25,970 --> 00:24:28,990
una nueva lista, un nuevo array list en este caso

494
00:24:28,990 --> 00:24:30,670
y al borrar

495
00:24:30,670 --> 00:24:32,910
hand view, esto de aquí no se había afectado

496
00:24:32,910 --> 00:24:34,609
pero si se había afectado hand list

497
00:24:34,609 --> 00:24:37,109
vuelvo a repetir, es una sub list

498
00:24:37,109 --> 00:24:38,069
de mazo

499
00:24:38,069 --> 00:24:40,529
las operaciones sobre las sublistas

500
00:24:40,529 --> 00:24:42,990
afectan la lista original, cosa que es que queremos

501
00:24:42,990 --> 00:24:44,890
aprovecharlo, y entonces

502
00:24:44,890 --> 00:24:46,869
lo que hacemos es que al borrar un clear

503
00:24:46,869 --> 00:24:48,849
al borrar ese hand view, estamos

504
00:24:48,849 --> 00:24:50,890
borrando esos elementos del

505
00:24:50,890 --> 00:24:52,690
mazo, pero no se borran

506
00:24:52,690 --> 00:24:54,289
permanentemente porque los tenemos en hand

507
00:24:54,289 --> 00:24:57,009
y hand lo que hacemos con ella es que la devolvemos

508
00:24:57,009 --> 00:24:58,690
no hay problema con el mazo

509
00:24:58,690 --> 00:25:00,750
porque el mazo no lo habían pasado a través de este parámetro de aquí

510
00:25:00,750 --> 00:25:02,210
el mazo sigue estando en su sitio

511
00:25:02,210 --> 00:25:03,750
no hay ningún problema

512
00:25:03,750 --> 00:25:06,670
fíjense esa mano la devolvemos y la recogemos

513
00:25:06,670 --> 00:25:08,609
en este caso, la recoge este

514
00:25:08,609 --> 00:25:10,630
println, este operador

515
00:25:10,630 --> 00:25:12,589
es un operador en este caso, es un más, pero es una

516
00:25:12,589 --> 00:25:14,670
concatenación de cadenas, entonces este

517
00:25:14,670 --> 00:25:16,630
reparte y vuelve un list, ese list

518
00:25:16,630 --> 00:25:18,710
tiene un toString, que es el que se

519
00:25:18,710 --> 00:25:20,670
utiliza para visualizar a través del

520
00:25:20,670 --> 00:25:22,650
operador concatenación, el

521
00:25:22,650 --> 00:25:24,609
contenido de esa mano que se

522
00:25:24,609 --> 00:25:26,589
reparte, pues imagínate, 8

523
00:25:26,589 --> 00:25:28,609
de copas, 4 de bastos, rey de

524
00:25:28,609 --> 00:25:30,670
espadas, nota de bastos, y eso

525
00:25:30,670 --> 00:25:32,589
es lo que se va a ver, ¿vale? Luego

526
00:25:32,589 --> 00:25:34,690
siguiente, jugador 2, pues

527
00:25:34,690 --> 00:25:36,009
sus cartas, imagínense que fuera

528
00:25:36,009 --> 00:25:38,509
caballo de

529
00:25:38,509 --> 00:25:40,849
espadas, rey de

530
00:25:40,849 --> 00:25:42,809
oros, tres de bastos y el as de

531
00:25:42,809 --> 00:25:44,730
oros, pues tiene una jugada fantástica

532
00:25:44,730 --> 00:25:46,809
para el mus, y ahí quedaría, ¿vale?

533
00:25:47,829 --> 00:25:48,890
y nada, pues mira

534
00:25:48,890 --> 00:25:49,950
aquí tiene el ejemplo de salida

535
00:25:49,950 --> 00:25:52,390
con una partida de mus, que sería esta de aquí

536
00:25:52,390 --> 00:25:54,930
cuatro jugadores, cuatro cartas por mano

537
00:25:54,930 --> 00:25:56,329
y

538
00:25:56,329 --> 00:25:58,589
baraja cero, que es la española, pues

539
00:25:58,589 --> 00:26:00,089
en esta salida en concreto sería

540
00:26:00,089 --> 00:26:02,329
cinco de espadas, otra de bastos, tal, tal, tal

541
00:26:02,329 --> 00:26:04,990
el jugador dos tendría seis de copas, tal, tal, tal

542
00:26:04,990 --> 00:26:07,069
caballo de oros, jugador 3

543
00:26:07,069 --> 00:26:09,089
tendría caballo de espadas, as de copas, tal tal tal

544
00:26:09,089 --> 00:26:11,210
y el último jugador tendría la sota de bastos

545
00:26:11,210 --> 00:26:13,150
as de oros, 5 de oros

546
00:26:13,150 --> 00:26:15,230
y 6 de bastos, pues el último se daríamos seguro

547
00:26:15,230 --> 00:26:16,730
y el resto

548
00:26:16,730 --> 00:26:19,210
no, porque mire, rey 3

549
00:26:19,210 --> 00:26:21,029
as y caballo, eso tiene un 31

550
00:26:21,029 --> 00:26:22,890
con dos reyes, vamos este corta seguro

551
00:26:22,890 --> 00:26:24,930
así que

552
00:26:24,930 --> 00:26:26,529
bueno pues nada, esto sería

553
00:26:26,529 --> 00:26:27,430
un poquito

554
00:26:27,430 --> 00:26:30,190
un poquitín lo de hoy, vale

555
00:26:30,190 --> 00:26:32,730
voy a pausar la grabación

556
00:26:32,730 --> 00:26:34,950
por si tienen alguna duda o algo que me comenten

557
00:26:34,950 --> 00:26:37,250
me imagino que me han escuchado, ¿verdad?

558
00:26:39,049 --> 00:26:41,529
Decía que el ejercicio este es muy ilustrativo de lo siguiente

559
00:26:41,529 --> 00:26:45,609
si utilizamos correcta y adecuadamente las colecciones que nos proporciona Java

560
00:26:45,609 --> 00:26:48,150
o cualquier otro lenguaje con el que estemos trabajando

561
00:26:48,150 --> 00:26:52,650
el desarrollo de código se reduce sustancialmente y eso es muy importante

562
00:26:52,650 --> 00:26:58,529
conocer bien el lenguaje, conocer las propiedades de los elementos de los que disponemos

563
00:26:58,529 --> 00:27:04,670
y utilizarlos adecuadamente, pero fíjense con qué poquito código se organiza una partida de cartas

564
00:27:04,670 --> 00:27:11,710
simplemente por utilizar adecuadamente y correctamente todos los elementos propios de colecciones

565
00:27:11,710 --> 00:27:14,529
y de los diferentes elementos derivados unos de otros.

566
00:27:15,029 --> 00:27:19,910
Esto es muy importante, es muy importante dominar estos elementos y ser capaz de trabajar con ellos

567
00:27:19,910 --> 00:27:25,609
porque cosas como el shuffle, como la utilización de sublistas y demás, pues nos resuelven problemas

568
00:27:25,609 --> 00:27:30,069
pero claro, eso hay que conocerlo, entonces es muy importante estudiarse muy bien la teoría, entenderla muy bien

569
00:27:30,069 --> 00:27:31,589
y luego, claro, aplicarlo

570
00:27:31,589 --> 00:27:33,750
y lo que pasa es que ahí no hay reglas

571
00:27:33,750 --> 00:27:36,029
ahí no hay una norma que me diga

572
00:27:36,029 --> 00:27:37,730
bueno, pues aquí tienes que aplicar esto y allí el otro

573
00:27:37,730 --> 00:27:39,549
entonces le tiene que ocurrir a cada uno

574
00:27:39,549 --> 00:27:41,210
esto es un poco el arte de programar

575
00:27:41,210 --> 00:27:42,089
viene un poquito por aquí

576
00:27:42,089 --> 00:27:44,849
pero lo que es muy importante es estudiarse bien las cosas

577
00:27:44,849 --> 00:27:47,849
y saber de qué herramientas dispone uno

578
00:27:47,849 --> 00:27:49,630
para luego poderlas aplicar

579
00:27:49,630 --> 00:27:50,950
en los desarrollos algorítmicos

580
00:27:50,950 --> 00:27:52,450
de la resolución de los problemas

581
00:27:52,450 --> 00:27:54,289
esto es muy importante

582
00:27:54,289 --> 00:27:54,789
¿de acuerdo?

583
00:27:55,349 --> 00:27:55,529
sí

584
00:27:55,529 --> 00:27:57,390
muy bien