Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Ej099901BarajaCartasEj109901FichClientes

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 27 de abril de 2020 por Andres R.

131 visualizaciones

Ej099901BarajaCartasEj109901FichClientes

Más información Transcripción

Descargar la transcripción

Me da un poco de miedo quedarme sin sitio y tener problemas con la grabación. 00:00:00
Bueno, vale, pues va bien. 00:00:07
Venga, muy bien, pues vamos a empezar ya, ahora sí que vamos a empezar. 00:00:14
Bueno, pues buenas tardes, noches. 00:00:18
Hoy estrenamos una herramienta nueva de sesiones online, vamos a probar ya, 00:00:21
ya le digo que la cuarta o la quinta creo que probamos, 00:00:27
y vamos a hablar con 00:00:29
con este Webex 00:00:32
de Cisco 00:00:34
la verdad es que tiene muy buena pinta 00:00:35
y yo creo que tiene una cantidad de recursos 00:00:38
interesantes, entonces vamos a 00:00:40
vamos a ir cogiendo un poquito el tranquillo, con lo cual vamos a hacer una sesión 00:00:41
un poco ligera 00:00:44
vamos a ver algún ejercicio de los interesantes 00:00:45
en sesiones posteriores pues ya 00:00:51
vamos a profundizar un poquito más cuando 00:00:53
controlemos un poco más la herramienta 00:00:55
sobre todo yo, claro, yo es la primera vez que la voy a usar 00:00:58
a ver qué tal, a ver qué tal 00:01:00
bueno, pues miren, tengo dos cositas que vamos a ver 00:01:01
un poquito, ambas las tienen en 00:01:06
el aula virtual, las dos 00:01:08
¿vale? este cliente lo voy a ir un poquitín rápido 00:01:09
con él, porque es un programita 00:01:12
muy sencillo, lo que hace es básicamente 00:01:14
una gestión 00:01:16
súper simple de clientes 00:01:18
y lo que hace es que guarda los datos 00:01:19
en un ficherito 00:01:22
¿vale? y ya está, no hace más 00:01:23
es muy sencillo 00:01:26
el código este no lo he hecho yo 00:01:28
Entonces, bueno, pues tiene cosas que a mí no me alegran mucho 00:01:30
Por ejemplo, la estructura en la que almacena la información 00:01:35
Pues es un array bidimensional que se llama cliente 00:01:38
Donde va almacenando datos de tipo string de cada cliente 00:01:41
Pues yo creo que deberíamos utilizar una estructura de las que hemos estudiado, ¿no? 00:01:45
Precisamente, almacenar objetos del tipo cliente sería lo suyo 00:01:51
Pero bueno, lo hace así, da igual, porque el objetivo de este programa básicamente es el acceso a disk 00:01:54
entonces, bueno, pues tenemos los típicos 00:01:58
menús de añadir, un listado 00:02:01
buscamos cliente, borramos, borramos el fichero 00:02:03
y salimos de la aplicación, vale 00:02:05
entonces lo más interesante de esto, ya les digo 00:02:06
lo tienen en el aula virtual 00:02:09
le pueden echar un vistazo, vale 00:02:11
es muy interesante y simplemente 00:02:13
vamos a ver un poquitín 00:02:15
lo que es la grabación, para que vean lo 00:02:17
extremadamente simple que es la grabación de datos 00:02:18
y su recuperación, miren 00:02:21
para cargar 00:02:23
el dato, fíjense lo que hacen, simplemente 00:02:25
abrimos el ficherito que llama clientes.data, lo han denunciado 00:02:26
y pues nada, vamos a preguntar aquí si existe 00:02:31
lo primero que hay que comprobarlo, por supuesto hay que verificar 00:02:36
siempre que trabajemos con ficheros y operaciones de entrada y salida 00:02:41
siempre recuerden que tenemos que utilizar el formato de trabajo de excepciones 00:02:44
porque pueden pasar algunas cosas, como por ejemplo que no se haya encontrado el archivo 00:02:50
o algún error en la carga del archivo o algo 00:02:53
Pueden pasar problemas de entrada y salida 00:02:56
Que esos se manejan siempre con excepciones 00:03:00
Miren lo que hacemos 00:03:02
Simplemente hacemos el read object del objeto 00:03:03
Que es este array bidimensional de streams 00:03:06
Donde están almacenados todos los datos de todos estos clientes 00:03:10
Ya está, vemos eso directamente 00:03:13
Y eso lo almacenamos en nuestro array bidimensional cliente 00:03:17
Que lo hemos definido en la parte superior 00:03:20
Y con esto accedemos ya a todos los datos de todos los clientes 00:03:21
Se le dio una estructura un poco, es poco elaborada, ¿vale? 00:03:24
Merecería más la pena trabajar con alguna estructura un poco más del tipo de colecciones que hemos trabajado, 00:03:30
pero bueno, es con la que se trabaja y esto. 00:03:35
Entonces, como ven, es extremadamente simple y a la hora de grabar los datos, pues nos ocurre lo mismo. 00:03:36
Simplemente, fíjense lo que hacemos aquí, esto ya digo que lo tienen ahí en el aula virtual. 00:03:41
Nada, abrimos nuestro fichero, le ponemos como para que vamos a producir en la salida 00:03:47
y escribimos, con write object, escribimos directamente toda la estructura cliente 00:03:53
y automáticamente se nos almacena toda la estructura cliente de array bidimensional, ¿vale? 00:03:59
Capturamos la excepción por si tenemos algún tipo de problema o lo que sea, 00:04:07
capturamos la excepción si se produce algún problemita en el camino y lo realizaríamos ya. 00:04:10
Y ya está, y es que no tiene más. 00:04:17
Luego, bueno, el resto ya es un acceso al array bidimensional, que eso lo hemos visto ya con anterioridad, 00:04:18
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. 00:04:23
Recuerden un poquito, esto es importante, acuérdense, el tema de expresiones regulares, ¿vale? 00:04:30
Muy interesante, pues, para verificar cosas, ¿eh? 00:04:35
¿Vale? Entonces, esto, por ejemplo, estamos verificando que es un DNI correcto, ¿lo ven? 00:04:38
Formado por ocho dígitos, ¿vale? Ocho elementos del tipo D, que se queda dígitos, 00:04:43
y a continuación una letra de entre las que ponen aquí, que son las letras que están permitidas en los DNIs, ¿vale? 00:04:49
Una de ellas, lo que no sabemos, lo que no hace la comprobación de expresiones regulares 00:05:00
es si realmente la letra corresponde a la combinación de lígidos, que eso se hace, recuerden, con el exceso de 23, 00:05:05
con el operador de resto, la parte entera del resto de la división entre 23, ¿vale? 00:05:12
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? 00:05:20
Pues, muy interesante, ¿vale? Esto nos lo verifica, recuerden, con una expresión regular, ¿eh? Acuérdense de esto. 00:05:27
Y, bueno, por lo demás, creo que no hay muchísimo más que comentar. 00:05:37
aquí tienen otra, simplemente el número de teléfono 00:05:40
nos pide que tenga nueve 00:05:42
dígitos, también con una 00:05:44
versión regular 00:05:45
de las que vimos en su momento 00:05:46
y pues nada, el resto pues vamos 00:05:49
introduciendo la información y demás 00:05:52
o visualizándola o lo que sea, ya es el acceso 00:05:54
a raíces bidimensionales y tal 00:05:56
que todo esto ya lo hemos visto y no vamos a perder 00:05:57
más tiempo en ello, ahora mismo 00:06:00
¿vale? 00:06:01
el código del programa lo tienen ahí en el 00:06:03
en el aula virtual y lo pueden revisar 00:06:06
Y vamos a pasar a ver un poquito el otro que me interesa un poquito más, ¿vale? 00:06:08
Me interesa un poquitín más porque sí que trabaja con estructura de datos un poquito más avanzada, ¿no? 00:06:15
Con colecciones, ¿vale? 00:06:20
Bueno, esto último simplemente, pues nada, se hace un delete del fichero, 00:06:22
está, nosotros abrimos el fichero y lo borramos y ya está. 00:06:25
Y si no pasa nada y esto vuelve true, el archivo se ha borrado perfectamente 00:06:29
y si no nos da false es que ha habido algún problema y algo está perdido, ¿vale? 00:06:34
no tiene más, ya le digo que es que no tiene 00:06:37
muchísimo, miren 00:06:40
sí que me interesa un poquito más 00:06:41
este ejercicio, ¿vale? 00:06:43
y lo tenemos en dos versiones, ¿vale? este ejercicio 00:06:45
lo que hace es que 00:06:47
lo que hace es 00:06:49
que nada, pues simula una partida de cartas 00:06:53
una cosa muy interesante, muy sencillita 00:06:55
pero bueno, pues está muy bien porque 00:06:57
desde un punto de vista programático es muy interesante 00:06:58
nos simula una partida de cartas 00:07:00
y nos hace 00:07:02
yo he hecho el programa de dos maneras distintas 00:07:05
una primera sencilla y una versión un poquitín más avanzada 00:07:07
con alguna opción más, vale, voy a ver primero 00:07:10
la versión sencilla y luego vamos a ver los aspectos 00:07:13
relevantes de la versión avanzada, vale, donde ustedes pueden 00:07:16
cotejar un poco, vale, las tienen 00:07:19
en el aula virtual, las tienen, ahí las tienen y las pueden echar a ver 00:07:22
entonces miren, le voy a abrir una ventana 00:07:25
un poquitín más grande esto, vale 00:07:27
esto está basado en una práctica 00:07:32
que tienen aquí la borrela y pueden observar, entonces miren lo que hace esto 00:07:36
tenemos, vamos a jugar cuatro manos 00:07:41
y cuatro cartas por cada mano, es decir, va a haber como cuatro 00:07:45
¿vale? y le vamos a dar cuatro cartas a cada una de esas manos 00:07:49
entonces miren, primero declaramos los palos, espadas, oros, bastos y copas 00:07:52
y declaramos las cartas, ¿qué cartas tenemos disponibles 00:07:57
en una baraja? pues el as, el dos, el tres, el siete, la sota, el caballo y el rey 00:08:01
Esto lo hace con una ArrayList, fíjense lo que vamos haciendo 00:08:05
Recorremos todos los palos, todos los palos, es decir, espadas, oros, bastos y copas 00:08:11
Recorremos cada uno de ellos y recorremos todas las cartas 00:08:18
¿Qué ocurre? Nos va a generar, con esto de aquí, que está en el doble bucle 00:08:22
Va a generar una carta, un número de carta a dos tres total de cada palo 00:08:28
Es decir, cuando palo sea espadas, tendremos as de espadas, dos de espadas, tres de espadas. 00:08:35
Es decir, ¿qué estamos haciendo aquí? 00:08:40
En mazo, ad, mazo, será donde metamos todas las cartas. 00:08:42
Estamos añadiendo cada una de esas cartas. 00:08:46
Al estar en un bucle anidado aquí, metemos todas las cartas de la baraja. 00:08:49
¿Qué estamos haciendo aquí? Generar este mazo, que nos va a permitir trabajar. 00:08:54
Claro, al generarlo con este doble bucle anidado, con este orden, se nos va a generar en orden. 00:08:58
va a estar primero, pues el as de espadas 00:09:04
2 de espadas, 3 de espadas 00:09:06
así está el rey de espadas, cuando termine con el 00:09:08
palo de espadas, pasamos al siguiente del palo 00:09:10
el bucle externo, el de palo 00:09:12
oros, as de oros, 2 de oros 00:09:14
así está el rey de oros, a continuación 00:09:16
as de base de las leyes, tendríamos una baraja ordenada 00:09:18
al salir de aquí 00:09:20
y fíjense lo siguiente que hacemos 00:09:21
recuerden que teníamos 00:09:23
un método de collections 00:09:26
que afecta a cualquier 00:09:28
organización de datos 00:09:29
estructura de datos que derive de collection 00:09:32
se llama shuffle, shuffle es 00:09:34
barajar, desordenar 00:09:35
descolocar, no sé cómo se traduce 00:09:37
mezclar, de acuerdo, mezclar 00:09:40
de forma aleatoria y no tenemos que hacer 00:09:42
nada, lo hace ya el todo 00:09:44
entonces nosotros obtenemos de este doble bucle 00:09:45
anidado un mazo perfectamente ordenado 00:09:48
por espadas, oros, bastos y copas 00:09:50
y después de aplicar shuffle 00:09:52
todos los elementos de esta collection 00:09:54
se desordenan 00:09:56
se mezclan 00:09:58
de forma más o menos supuestamente aleatoria. 00:09:59
Y entonces con eso ya hemos barajado la carta, o sea, el mazo, perdón, 00:10:05
hemos barajado el mazo y están todas. 00:10:09
Una vez que tenemos el mazo y a continuación lo tenemos barajado, 00:10:11
¿qué hacemos a continuación? Pues nada, nos ponemos a repartir cartas. 00:10:14
¿Cómo repartimos las cartas? Pues decimos cuántas manos queremos dar. 00:10:19
Hemos dicho antes que eran cuatro, desde cero, mientras que sea número de manos, 00:10:23
Pues era 0, 1, 2, 3, que son 4 manos 00:10:27
La mano 0, la mano 1, la mano 2 y la mano 3 00:10:30
4 manos, ¿vale? 00:10:33
Y repartimos las cartas 00:10:35
¿Cómo repartimos las cartas? 00:10:36
Pues al jugador yésimo le mandamos 00:10:37
Hacemos una llamada al método reparte cartas por cada mano 00:10:41
Lo ven aquí, este método reparte del mazo 00:10:48
El número de cartas por mano que vamos a dar 00:10:51
se recoge del mazo 00:10:53
y le dice cuántas cartas le voy a dar 00:10:55
pues lo indicamos en cartas por mano, vamos a ver este método 00:10:57
que es muy interesante, aquí lo tenemos 00:10:59
este método reparte, fíjense 00:11:01
lo que hace, me devuelve una lista 00:11:03
¿vale? el método me devuelve una lista, miren lo que hace 00:11:05
primero, dice 00:11:07
¿qué tamaño tengo en el mazo ahora mismo? 00:11:09
yo le he pasado el mazo 00:11:12
le digo pues mazo size 00:11:13
entonces me dice el tamaño que tiene el mazo 00:11:15
entonces miren lo que hace, extrae una 00:11:17
hand view, ¿vale? una hand view 00:11:19
es que selecciona las 00:11:21
n últimas cartas 00:11:23
de arriba 00:11:25
¿cuánto es n? el número de cartas 00:11:26
que yo quiero repartir 00:11:29
entonces digo de can view 00:11:30
al mazo 00:11:31
le extraemos una sublista 00:11:33
desde mazo 00:11:36
menos n hasta tamaño del mazo 00:11:39
¿ven la idea de esto? 00:11:41
¿lo ven aquí? desde tamaño de mazo 00:11:45
menos el número de cartas que yo quiero repartir 00:11:47
hasta el final del mazo 00:11:49
y lo extraemos 00:11:51
con una sublista. A continuación, ¿qué es lo que hacemos? 00:11:52
Decimos, bueno, pues voy a hacer una nueva mano, me declaro una nueva mano que es una lista 00:11:56
con un ArrayList nuevo 00:12:00
que contiene las cartas que hemos extraído con esa HandView 00:12:03
¿Vale? ¿Sí? Vale 00:12:08
Pero fíjense lo importante de esto, es nuevo, es un ArrayList 00:12:12
nuevo, porque a continuación, justo lo que hago a continuación 00:12:16
es aprovechar una de las propiedades de las sublistas 00:12:20
y al hacer un HandViewClear 00:12:24
estamos quitando esas cartas de la sublista HandView 00:12:25
pero como HandView es una sublista del mazo 00:12:30
que mazo es una lista 00:12:33
realmente las estoy quitando también del mazo 00:12:34
pues acuérdense que las operaciones sobre sublistas 00:12:37
afectan a la lista original 00:12:40
¿y por qué no afecta a Hand? 00:12:42
porque Hand es una nueva ArrayList 00:12:45
lo ven aquí, ¿no? 00:12:49
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 00:12:50
y borro la sublista, y al borrar la sublista, borro la sublista y borro las cartas del mazo, que es la lista original. 00:12:59
HandView es una sublista de mazo, entonces al borrar HandView, borro, HandView y borro también las borro de mazo. 00:13:08
y una vez que he hecho eso, lo que hago es que devuelvo esas cartas que he extraído de la lista original 00:13:15
las devuelvo y se pueden utilizar para lo que sea en este caso, pues para visualizarlas simplemente 00:13:22
en el más aquí, eso tiene un toString, ¿vale? ese list tiene un toString 00:13:28
ese toString al salir aquí, pues lo que vamos a hacer es ver, miren la salida, 5 de espadas 00:13:32
las primeras cartas que he repartido, 5 de espadas, sota de copas, sota de espadas, 5 de copas 00:13:37
En la segunda vuelta repartimos otras cuatro 00:13:43
Seis de copas, cuatro de bastos, dos de bastos, caballo de bastos 00:13:46
En la siguiente vuelta de este bucle repartimos otras cuatro 00:13:50
Caballo de espadas, as de copas 00:13:53
Y fíjense que cada vez que sacamos las cartas ya no vuelven a existir 00:13:55
Cosa que tiene que ser, una vez que saco una carta de un palo 00:13:58
No vuelve a existir en el mazo y no la puedo volver a repartir 00:14:01
Entonces fíjense con qué poquito código y de qué forma tan sencillita 00:14:04
Organizamos una partida de cartas 00:14:08
Esto sería una partida de cuatro manos con cuatro cartas por cada mano 00:14:11
Muy bien, pues como ven, fíjense que simple 00:14:17
Y miren, vamos a ver esto mismo en versión avanzada 00:14:22
Es lo mismo pero con un poquitín más de funcionalidad 00:14:26
¿Qué funcionalidades añadidas tiene esta versión avanzada? 00:14:30
Aquí hay algunas referencias donde pueden mirar a ver 00:14:35
Como por ejemplo vamos a realizar la utilización de argumentos en los programas 00:14:38
Ustedes saben que los programas pueden recibir información del sistema operativo 00:14:44
Por ejemplo, si ustedes en Linux escriben ls menos la 00:14:48
S menos la es información, es un parámetro que ustedes pasan al programa ls 00:14:52
Si ustedes en Windows dicen dir asterisco punto asterisco 00:14:58
Pues este asterisco punto asterisco es un parámetro que están pasando al programa dir punto exe o como sea 00:15:01
En Windows es .s, en Linux no lleva extensión 00:15:07
¿Vale? Pero todo eso son parámetros que se pasan 00:15:10
Entonces eso en Java también se pueden recibir esos parámetros 00:15:12
Y es una de las cosas que vamos a hacer aquí 00:15:15
Vamos a recibir parámetros y vamos a utilizarlos 00:15:16
¿Sí? 00:15:20
Entonces miren 00:15:22
Vamos a ver, primero, trabajamos con el main 00:15:23
Donde, fíjense, muy importante, recibimos aquí los argumentos 00:15:26
Del sistema operativo, vienen aquí 00:15:28
En el main, ¿vale? 00:15:29
Estos args, que es un array de strings 00:15:31
Los argumentos van a ser siempre una colección de cadenas de caracteres que pasamos a los programas 00:15:34
Y como tal se tratan dentro del programa 00:15:39
Como strings dentro de una array de strings que se llama args 00:15:41
Ahí es donde vamos a tener 00:15:45
Bien, entonces definimos dos variables, número de manos y cartas por cada mano 00:15:47
Y luego definimos otra variable más que es la baraja 00:15:52
Y decimos que, indicamos que 00:15:55
Con un 0 indicamos baraja española, con un 1 baraja francesa 00:15:56
Entonces miren 00:16:01
si la longitud 00:16:02
de los argumentos 00:16:06
es mayor que 1 00:16:08
es decir que se han pasado parámetros 00:16:09
¿vale? 00:16:11
y el orden de los parámetros que hay que pasar es el siguiente 00:16:13
los parámetros se indican en el ID 00:16:15
en el entorno de desarrollo integrado 00:16:18
para indicar los parámetros está en 00:16:19
ejecutar, establecer configuración por efecto 00:16:21
personalizar, run 00:16:23
set project settings 00:16:25
customize ¿vale? y con esto 00:16:27
pues si queremos jugar una partida de mus 00:16:29
hay que poner 4 jugadores, 4 cartas 00:16:31
y 0 que es la baraja española 00:16:34
si queremos jugar al póker pues son 00:16:37
4 jugadores, si queremos jugar 4 jugadores, 5 cartas 00:16:40
por jugador y la baraja francesa 00:16:45
la que tiene picas, tréboles, corazones y rombo 00:16:48
y por ejemplo si queremos jugar al tute 00:16:52
pues necesitamos 4 jugadores, 10 cartas 00:16:54
por jugador y la baraja española 00:16:57
que es la 0 para jugar al tute 00:17:00
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? 00:17:02
Entonces, si es que se han avanzado los parámetros, vamos a indicar que el número de manos será el primer parámetro. 00:17:12
El primer parámetro es args de 0, ¿vale? Este 4 sería el primer parámetro. 00:17:19
¿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. 00:17:24
el segundo parámetro sería 00:17:30
el número de cartas 00:17:33
que hay que repartir en cada mano 00:17:35
en el caso del Mu sería 4 00:17:36
en el caso del Poker 5 00:17:39
en el caso del Tute 10 00:17:41
y el último es la baraja 00:17:42
que vamos a usar, si es española o es francesa 00:17:45
y el último está en arjas de 2 00:17:47
0 español, 1 francés 00:17:50
esto es cuando se han pasado parámetros 00:17:51
si no se pasa parámetros, ¿qué hacemos? 00:17:53
pues establecemos 00:17:55
una parametrización por defecto 00:17:56
decimos que cuatro manos, cuatro cartas 00:17:58
por mano, baraja española, es decir, una partida 00:18:01
de mus, cuatro jugadores 00:18:03
cuatro cartas de una baraja española 00:18:04
pues con eso se suele jugar 00:18:07
y pues nada 00:18:08
vamos a construir el mazo, lo primero 00:18:10
que hacemos es que el palo de las 00:18:13
cartas españolas es espadas, oros 00:18:15
bastos y copas, lo guardamos en una 00:18:16
raid strings, el palo 00:18:19
para las francesas es rombos, corazones 00:18:20
picas y tréboles 00:18:23
y definimos la variable 00:18:23
la referencia palo con valor 00:18:26
nul, ¿vale? bien, luego, fíjense lo que hacemos 00:18:28
si la baraja es cero, ¿vale? si es española 00:18:32
copiamos, ¿vale? en palo, copiamos 00:18:35
el array del palo español 00:18:40
y si la baraja no es cero, entonces vamos a leerse 00:18:42
copiamos el palo francés, que son los nombres 00:18:48
de los palos, ¿no? de la baraja francesa 00:18:52
Rombos, corazones, picas y lejos. 00:18:58
Aquí simplemente se establece la función de la baraja. 00:19:01
Si trabajamos con uno, trabajamos con otro. 00:19:03
Y lo metemos en palo. 00:19:05
Ahí lo guardamos. 00:19:07
A continuación, definimos las cartas de la baraja española. 00:19:08
Son estas de aquí, A2, 3, 4, 6, 7, J, caballo y rey. 00:19:11
Y en la baraja francesa son A2, 3, 4, 6, 7, 8, 9, 10, J, dama y rey. 00:19:14
Y hacemos exactamente lo mismo. 00:19:20
Definimos la referencia carta, que no le damos datos, 00:19:22
porque la vamos a sacar de si la baraja es española o la baraja no es española. 00:19:25
¿Que la baraja es española? Pues le copiamos en carta los mismos datos que está en carta española. 00:19:29
Y si no es española, es decir, baraja es igual a 1, es 0, es otra cosa, 00:19:38
entonces copiamos los datos de las cartas, los nombres de las cartas francesas. 00:19:43
¿Y qué hacemos a continuación? Una vez que ya tenemos carta y tenemos mazo, 00:19:47
y palo, perdón, tenemos ya palo 00:19:50
tenemos ya carta, pues entonces ya podemos 00:19:52
generar el mazo, ya sabemos los 00:19:54
palos que tenemos y las cartas que tenemos 00:19:56
y hacemos exactamente lo mismo que antes 00:19:58
creamos una lista 00:20:00
del tipo ArrayList 00:20:01
que llamamos mazo y lo hacemos 00:20:03
igual que antes con un doble bucle anidado 00:20:08
que recorre primero los palos y luego las cartas 00:20:10
para cada uno de los palos 00:20:12
metemos todas las cartas del palo correspondiente 00:20:14
¿qué estamos generando? 00:20:16
cada una de las cartas de la baraja de una luna 00:20:18
Pues será, el primer palo era, vamos a verlo por aquí, la española 00:20:20
Espadas, oros, bastos y copas 00:20:25
Pues sería, espadas 00:20:28
Pues as de, espadas, dos de, espadas, tres de, espadas, hasta rey de, espadas 00:20:30
A continuación se terminarán las cartas, pasamos al siguiente palo 00:20:35
Oros, as de, oros, dos de, oros, tres de, oros, así hasta el rey de oros 00:20:38
Se genera todo el mazo y ya una vez que salimos de este doble bucle anidado 00:20:42
hemos generado todo el mazo 00:20:47
de la baraja, ¿de acuerdo? 00:20:49
luego 00:20:52
detalles 00:20:53
solamente cuando la baraja sea la francesa 00:20:54
hay que meter dos cartas más 00:20:58
que son los comodines, los joker 00:20:59
pero eso solo ocurre 00:21:01
cuando sea la baraja francesa 00:21:03
entonces si la baraja es francesa hay que meter 00:21:06
los comodines, ¿vale? porque la baraja francesa 00:21:07
se juega con dos comodines en muchos juegos 00:21:09
luego a veces se pueden sacar o lo que sea 00:21:12
pero esto ya son opciones que podríamos 00:21:13
añadir al programa, pero nosotros, si es francesa 00:21:15
le ponemos sus comodines ahí para poder 00:21:18
una vez que ya hemos creado nuestro mazo 00:21:19
bien sea, se habrá creado el español 00:21:22
se habrá creado el francés, lo que sea, una vez que 00:21:24
está creado y ordenadito, vamos a 00:21:25
lo siguiente que es, barajamos 00:21:28
el mazo de cartas 00:21:29
¿cómo barajamos el mazo de cartas? 00:21:31
pues podríamos haber hecho una función 00:21:35
que a través de la función, que el método 00:21:36
random los vaya sacando y 00:21:39
desordenando, pero 00:21:41
es mucho más inteligente utilizar algo 00:21:43
que ya está hecho, y hay 00:21:45
algo ya está hecho que, como hemos dicho antes, es el método 00:21:47
shuffle de collection 00:21:49
el método shuffle de collection desordena 00:21:50
aleatoriamente una colección, entonces 00:21:53
si nos lo han hecho, ¿para qué nos vamos a complicar la existencia? 00:21:54
si nos lo han hecho, lo hacemos y ya está 00:21:57
y además tenemos 00:21:59
ciertas garantías de que más o menos 00:22:01
funciona bien, es pseudoalatorio 00:22:03
como todo en programación, no en la aleatoriedad 00:22:04
presente, en programación no existe, en computadoras 00:22:07
de momento 00:22:09
pero bueno, para nosotros es 00:22:09
más que muy suficiente 00:22:13
Y con ello trabajamos 00:22:14
Tampoco sería perfectamente aleatorio 00:22:17
El random que vamos a utilizar 00:22:20
Con lo cual nos da igual 00:22:22
Uno que no sea perfecto, otro que no sea perfecto 00:22:22
Sin embargo shuffle nos ahorra muchísimo 00:22:25
Código y mucho tiempo de trabajo 00:22:28
Eso es muy importante 00:22:30
Una vez que hemos desordenado, pues decimos nada 00:22:31
Vamos a jugar una partida de tantas manos 00:22:34
Con tantas cartas 00:22:36
Por cada mano 00:22:38
Y sacamos las cartas de cada una a la baraja 00:22:39
Siendo la baraja española o francesa 00:22:42
En función de si la baraja es cero española 00:22:44
Si no, vamos a sacar a francesa 00:22:45
Y mostramos para cada jugador 00:22:46
El número de jugador 00:22:49
Y exactamente lo mismo que antes 00:22:51
El método reparte 00:22:53
Que del mazo extrae 00:22:55
El número de cartas que se dan cada mazo 00:22:57
Reparte a cada jugador 00:23:00
El número de cartas que hay que darle 00:23:01
4, 5, 7, 10 00:23:02
Imagínense con que sean 7 00:23:04
No sé con ningún juego 00:23:06
Pero el mus son 4, la brisca serían 3 00:23:08
El tute serían 10 00:23:11
el póker serían 5, bueno, pues lo pasamos eso en cartas por cada mano, ¿vale? 00:23:13
Y el método de parte es exactamente el mismo que antes, es sub, fíjense qué interesante, 00:23:18
haciendo uso de las propiedades de las sublistas, cómo se resuelve este problema, qué sencillo. 00:23:23
Yo quiero extraer un número de elementos de un conjunto, hago una sublista con ese número de elementos, 00:23:28
esa sublista la copio en una lista nueva donde reside esa información ya de forma permanente 00:23:35
y al borrar la sublista, las borro de la lista original 00:23:41
y las tengo perfectamente separadas de la lista original 00:23:45
y las puedo devolver, esto es lo que hace exactamente el reparto 00:23:50
exactamente lo que les digo, hand view, extraes 00:23:54
esas del mazo, extraes las cartas 00:23:58
que se le piden 00:24:02
ese hand view, extraes esas cartas del mazo 00:24:03
una vez que las extrae, las copia 00:24:10
en la mano que llama hand 00:24:12
mano de cartas, en inglés mano de cartas 00:24:14
lo copia con new 00:24:16
muy importante, al hacerlo nuevo 00:24:18
esas referencias 00:24:20
ya son permanentes 00:24:22
están en un new, es una nueva 00:24:23
una nueva lista, un nuevo array list en este caso 00:24:25
y al borrar 00:24:28
hand view, esto de aquí no se había afectado 00:24:30
pero si se había afectado hand list 00:24:32
vuelvo a repetir, es una sub list 00:24:34
de mazo 00:24:37
las operaciones sobre las sublistas 00:24:38
afectan la lista original, cosa que es que queremos 00:24:40
aprovecharlo, y entonces 00:24:42
lo que hacemos es que al borrar un clear 00:24:44
al borrar ese hand view, estamos 00:24:46
borrando esos elementos del 00:24:48
mazo, pero no se borran 00:24:50
permanentemente porque los tenemos en hand 00:24:52
y hand lo que hacemos con ella es que la devolvemos 00:24:54
no hay problema con el mazo 00:24:57
porque el mazo no lo habían pasado a través de este parámetro de aquí 00:24:58
el mazo sigue estando en su sitio 00:25:00
no hay ningún problema 00:25:02
fíjense esa mano la devolvemos y la recogemos 00:25:03
en este caso, la recoge este 00:25:06
println, este operador 00:25:08
es un operador en este caso, es un más, pero es una 00:25:10
concatenación de cadenas, entonces este 00:25:12
reparte y vuelve un list, ese list 00:25:14
tiene un toString, que es el que se 00:25:16
utiliza para visualizar a través del 00:25:18
operador concatenación, el 00:25:20
contenido de esa mano que se 00:25:22
reparte, pues imagínate, 8 00:25:24
de copas, 4 de bastos, rey de 00:25:26
espadas, nota de bastos, y eso 00:25:28
es lo que se va a ver, ¿vale? Luego 00:25:30
siguiente, jugador 2, pues 00:25:32
sus cartas, imagínense que fuera 00:25:34
caballo de 00:25:36
espadas, rey de 00:25:38
oros, tres de bastos y el as de 00:25:40
oros, pues tiene una jugada fantástica 00:25:42
para el mus, y ahí quedaría, ¿vale? 00:25:44
y nada, pues mira 00:25:47
aquí tiene el ejemplo de salida 00:25:48
con una partida de mus, que sería esta de aquí 00:25:49
cuatro jugadores, cuatro cartas por mano 00:25:52
baraja cero, que es la española, pues 00:25:56
en esta salida en concreto sería 00:25:58
cinco de espadas, otra de bastos, tal, tal, tal 00:26:00
el jugador dos tendría seis de copas, tal, tal, tal 00:26:02
caballo de oros, jugador 3 00:26:04
tendría caballo de espadas, as de copas, tal tal tal 00:26:07
y el último jugador tendría la sota de bastos 00:26:09
as de oros, 5 de oros 00:26:11
y 6 de bastos, pues el último se daríamos seguro 00:26:13
y el resto 00:26:15
no, porque mire, rey 3 00:26:16
as y caballo, eso tiene un 31 00:26:19
con dos reyes, vamos este corta seguro 00:26:21
así que 00:26:22
bueno pues nada, esto sería 00:26:24
un poquito 00:26:26
un poquitín lo de hoy, vale 00:26:27
voy a pausar la grabación 00:26:30
por si tienen alguna duda o algo que me comenten 00:26:32
me imagino que me han escuchado, ¿verdad? 00:26:34
Decía que el ejercicio este es muy ilustrativo de lo siguiente 00:26:39
si utilizamos correcta y adecuadamente las colecciones que nos proporciona Java 00:26:41
o cualquier otro lenguaje con el que estemos trabajando 00:26:45
el desarrollo de código se reduce sustancialmente y eso es muy importante 00:26:48
conocer bien el lenguaje, conocer las propiedades de los elementos de los que disponemos 00:26:52
y utilizarlos adecuadamente, pero fíjense con qué poquito código se organiza una partida de cartas 00:26:58
simplemente por utilizar adecuadamente y correctamente todos los elementos propios de colecciones 00:27:04
y de los diferentes elementos derivados unos de otros. 00:27:11
Esto es muy importante, es muy importante dominar estos elementos y ser capaz de trabajar con ellos 00:27:15
porque cosas como el shuffle, como la utilización de sublistas y demás, pues nos resuelven problemas 00:27:19
pero claro, eso hay que conocerlo, entonces es muy importante estudiarse muy bien la teoría, entenderla muy bien 00:27:25
y luego, claro, aplicarlo 00:27:30
y lo que pasa es que ahí no hay reglas 00:27:31
ahí no hay una norma que me diga 00:27:33
bueno, pues aquí tienes que aplicar esto y allí el otro 00:27:36
entonces le tiene que ocurrir a cada uno 00:27:37
esto es un poco el arte de programar 00:27:39
viene un poquito por aquí 00:27:41
pero lo que es muy importante es estudiarse bien las cosas 00:27:42
y saber de qué herramientas dispone uno 00:27:44
para luego poderlas aplicar 00:27:47
en los desarrollos algorítmicos 00:27:49
de la resolución de los problemas 00:27:50
esto es muy importante 00:27:52
¿de acuerdo? 00:27:54
sí 00:27:55
muy bien 00:27:55
Idioma/s:
es
Autor/es:
Andrés Ramos González
Subido por:
Andres R.
Licencia:
Reconocimiento - Compartir igual
Visualizaciones:
131
Fecha:
27 de abril de 2020 - 23:02
Visibilidad:
Público
Centro:
IES ALONSO DE AVELLANEDA
Duración:
27′ 57″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
58.41 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid