1
00:00:01,710 --> 00:00:08,910
La semana pasada habíamos empezado ya, bueno hace dos en realidad, que tuvimos el problema con el audio, habíamos empezado a hablar ya de...

2
00:00:08,910 --> 00:00:13,490
Bueno, ¿tenéis alguna pregunta que me queréis hacer antes de arrancar yo a contaros nuevas cosas?

3
00:00:20,920 --> 00:00:26,480
Si no hay nada en particular, pues ya os digo, continúo un poco con el repaso de los contenidos del tema.

4
00:00:27,320 --> 00:00:31,219
Si durante la clase os surge alguna cosita, pues ya me vais diciendo.

5
00:00:31,219 --> 00:00:34,020
os estaba diciendo que hace un par de semanas

6
00:00:34,020 --> 00:00:36,719
habíamos hecho ya un primer repaso del tema de colecciones

7
00:00:36,719 --> 00:00:38,960
con las clases genéricas y colecciones

8
00:00:38,960 --> 00:00:42,500
como no se grabó la semana pasada volvimos a reincidir en lo mismo

9
00:00:42,500 --> 00:00:46,259
y nos hemos quedado a mitad de ver el temario

10
00:00:46,259 --> 00:00:48,619
que contempla esta unidad

11
00:00:48,619 --> 00:00:50,539
pues vamos a ir con ello

12
00:00:50,539 --> 00:00:55,799
la semana que viene estamos en vacaciones

13
00:00:55,799 --> 00:00:58,979
y luego incluso me parece que después

14
00:00:58,979 --> 00:01:01,039
a la vuelta de Semana Santa creo que

15
00:01:01,039 --> 00:01:02,939
volvemos un martes, con lo cual ese lunes tampoco

16
00:01:02,939 --> 00:01:05,280
tendremos clase. Entre medias

17
00:01:05,280 --> 00:01:06,939
durante Semana Santa abre

18
00:01:06,939 --> 00:01:08,939
un tema. Igual la

19
00:01:08,939 --> 00:01:11,019
planificación no la teníamos que haber hecho para que abriera

20
00:01:11,019 --> 00:01:13,000
un tema en mitad de día lectivos.

21
00:01:13,439 --> 00:01:15,060
O sea, de día no lectivos, pero bueno,

22
00:01:15,140 --> 00:01:17,000
al fin y al cabo, en vuestro caso da un poco

23
00:01:17,000 --> 00:01:18,120
igual, al ser a distancia.

24
00:01:19,000 --> 00:01:20,719
Lo que yo creo que voy a hacer va a ser dejarlo abierto

25
00:01:20,719 --> 00:01:22,180
el siguiente tema

26
00:01:22,180 --> 00:01:24,939
pues justo durante esta semana para que lo

27
00:01:24,939 --> 00:01:26,560
tengáis disponible desde el día uno de

28
00:01:26,560 --> 00:01:28,540
las vacaciones de Semana Santa.

29
00:01:28,980 --> 00:01:53,540
que, bueno, que están bien para descansar, pero si alguien tiene algún ratillo y le apetece mirar cosas, pues, bueno, que lo tenga ya el siguiente tema abierto. El siguiente tema trata sobre el flujo de datos. En cuanto a flujos de datos, hemos estado ya trabajando con algunos. Los flujos de datos se puede decir que son las vías de comunicación del programa con fuentes externas, pues, tanto para enviar datos del programa hacia afuera como para recibirlos.

30
00:01:53,540 --> 00:01:59,519
y bueno pues con cuáles hemos trabajado principalmente pues con la lectura de teclado

31
00:01:59,519 --> 00:02:05,719
y la salida a pantalla pues ya son dos flujos de datos y luego y luego aparte de estos dos flujos

32
00:02:05,719 --> 00:02:11,460
de datos no sé si tenéis el micrófono abierto a alguien por ahí a lo mejor para que no se mezclen

33
00:02:11,460 --> 00:02:18,000
los sonidos si no vais a participar ahora mejor silenciarlo y nada os decía que en cuanto a los

34
00:02:18,000 --> 00:02:23,080
flujos de datos pues las comunicaciones de programa no sólo se realizan a través de teclado

35
00:02:23,080 --> 00:02:27,039
y pantalla, que sí que es verdad que es una de las fuentes

36
00:02:27,039 --> 00:02:30,659
de comunicación más habituales. También leemos de ficheros.

37
00:02:31,280 --> 00:02:35,280
El año que viene trabajaréis mucho con conexiones con sockets en la asignatura

38
00:02:35,280 --> 00:02:39,120
de programación de servicios y procesos. Bueno, pues diferentes caminos

39
00:02:39,120 --> 00:02:43,000
para comunicar nuestra aplicación con otras fuentes

40
00:02:43,000 --> 00:02:46,759
o con otra aplicación directamente. Entonces, todo esto son flujos de datos

41
00:02:46,759 --> 00:02:51,280
y veremos los flujos de datos, pero en particular para la lectura de ficheros,

42
00:02:51,280 --> 00:02:54,439
lectura y escritura. Pero bueno, no me adelanto porque eso

43
00:02:54,439 --> 00:02:57,479
es el siguiente tema y ya tendremos las tutorías para trabajar

44
00:02:57,479 --> 00:03:00,520
sobre eso. Retomando en la que

45
00:03:00,520 --> 00:03:03,379
estamos ahora, que son las estructuras dinámicas de datos, pues habíamos

46
00:03:03,379 --> 00:03:05,979
hablado de que teníamos dos tipos, las colecciones

47
00:03:05,979 --> 00:03:09,719
y los mapas. Hemos estado trabajando

48
00:03:09,719 --> 00:03:12,439
sobre las colecciones principalmente o

49
00:03:12,439 --> 00:03:15,520
exclusivamente durante estas dos sesiones

50
00:03:15,520 --> 00:03:18,419
y las colecciones, bueno, pues las

51
00:03:18,419 --> 00:03:22,580
vamos a escribir aquí un poquito, aunque ahora lo borre, las colecciones eran aquellas

52
00:03:22,580 --> 00:03:26,919
que almacenaban datos, el uso

53
00:03:26,919 --> 00:03:30,599
de la memoria es dinámico, no como los arrays, una de las diferencias que teníamos

54
00:03:30,599 --> 00:03:34,699
y almacenábamos datos que podían ser de diferentes tipos, o bien primitivos

55
00:03:34,699 --> 00:03:38,659
datos primitivos, como enteros, aunque fueran a través de su, enteros

56
00:03:38,659 --> 00:03:42,020
long, todos estos, aunque fueran a través de sus clases wrapper

57
00:03:42,020 --> 00:03:46,699
o bien referenciados, pues objetos de clases que tengamos nosotros en el

58
00:03:46,699 --> 00:03:50,800
programa como por ejemplo aquí la principal que hemos estado trabajando el otro día sobre ella

59
00:03:50,800 --> 00:03:57,500
todos los datos que se guardan en una colección pues son del mismo tipo entonces en el momento

60
00:03:57,500 --> 00:04:02,800
que definimos la colección entre el símbolo de mayor y menor decimos el tipo sobre el que va a

61
00:04:02,800 --> 00:04:10,740
trabajar esa colección podría ser string o igual podría ser string como podría ser de tipo de

62
00:04:10,740 --> 00:04:19,709
objetos de la clase principal. Acordaros que esto del símbolo menor y mayor tiene mucho que ver con

63
00:04:19,709 --> 00:04:24,449
las clases genéricas. ¿Por qué? Porque en la librería de Java aquel código que trabaja con

64
00:04:24,449 --> 00:04:30,350
las colecciones trabaja de forma genérica con los tipos de tal forma que el mismo código nos sirve

65
00:04:30,350 --> 00:04:35,970
para cualquier tipo que queramos asociar a la colección con la que estemos trabajando. Y luego

66
00:04:35,970 --> 00:04:39,649
dentro de las librerías tenemos diferentes tipos

67
00:04:39,649 --> 00:04:43,629
de colecciones. Tenemos unas colecciones

68
00:04:43,629 --> 00:04:48,189
que son las que llaman durante el tema listas

69
00:04:48,189 --> 00:04:53,980
que son los ArrayList y los

70
00:04:53,980 --> 00:04:59,360
LinkedHashCode

71
00:05:00,459 --> 00:05:03,120
Esto yo creo. Bueno, pues estos dos

72
00:05:03,120 --> 00:05:06,379
lo que permiten es almacenar tantos datos como

73
00:05:06,379 --> 00:05:10,540
vayamos solicitando mediante los métodos que tenemos disponibles

74
00:05:10,540 --> 00:05:14,819
para las colecciones, que la mayoría de ellos son comunes

75
00:05:14,819 --> 00:05:18,800
para todas las colecciones porque todas ellas implementan un interfaz

76
00:05:18,800 --> 00:05:22,120
que es el interfaz collection que nos define estos métodos que veíamos el otro día

77
00:05:22,120 --> 00:05:26,740
y bueno, pues estos dos principalmente trabajan con colecciones

78
00:05:26,740 --> 00:05:30,800
que permiten tanto duplicados, es decir, meter

79
00:05:30,800 --> 00:05:34,279
varias veces el mismo dato y

80
00:05:34,279 --> 00:05:37,839
no tienen un orden, orden en particular

81
00:05:37,839 --> 00:05:42,220
y luego tenemos las que

82
00:05:42,220 --> 00:05:46,519
podemos ordenar bajo un criterio que tengamos

83
00:05:46,519 --> 00:05:49,579
nosotros definido en nuestro algoritmo, que son aquellas que aparecen como tree

84
00:05:49,579 --> 00:05:53,959
como árbol, por ejemplo una tree set

85
00:05:53,959 --> 00:05:58,220
como tiene la parte tree, está ordenado

86
00:05:58,220 --> 00:06:02,420
por el concepto, por la parte tree

87
00:06:02,420 --> 00:06:11,579
Y esta que tenemos tiene un orden en base a un criterio que definamos nosotros en el programa.

88
00:06:12,100 --> 00:06:18,079
A un criterio definido como requisito para el programa.

89
00:06:19,639 --> 00:06:23,339
Y luego las que aparecen en el set, que también está incluido aquí el set,

90
00:06:23,779 --> 00:06:26,639
estas colecciones no tienen duplicados.

91
00:06:26,639 --> 00:06:49,500
Bueno, en toda esta jugada, en esta distribución de la que estamos hablando, nos fijábamos, por ejemplo, en una colección de tipo triset y decíamos, si está ordenado y no tiene duplicados, en base a que el programa decide que algo está ordenado y no tiene duplicados.

92
00:06:49,500 --> 00:06:54,160
parece más o menos evidente, por ejemplo, si estamos utilizando una colección

93
00:06:54,160 --> 00:06:59,589
que sea de tipo integer, la clase gripper

94
00:06:59,589 --> 00:07:04,050
del tipo primitivo int, pues parece que tiene

95
00:07:04,050 --> 00:07:07,829
toda la lógica que el orden será de menor a mayor y que los duplicados

96
00:07:07,829 --> 00:07:11,910
si intentamos meter un 7 dos veces, pues eso estaría

97
00:07:11,910 --> 00:07:16,269
duplicado, pero el orden y la cuestión de duplicados

98
00:07:16,269 --> 00:07:19,850
cuando empezamos a pensar en clases propias, como por ejemplo podría ser la clase

99
00:07:19,850 --> 00:07:25,220
persona aquí. Resulta que esta clase de personas, según la hemos definido nosotros

100
00:07:25,220 --> 00:07:29,100
en nuestro programa, porque así nos lo sugería, digamos el enunciado que pudiéramos

101
00:07:29,100 --> 00:07:33,420
tener, tiene como atributos un nombre y una edad.

102
00:07:34,319 --> 00:07:37,300
Entonces, en un programa resulta que las personas

103
00:07:37,300 --> 00:07:40,959
podrían estar ordenadas por nombre, pero en otro a lo mejor nos interesa que estén

104
00:07:40,959 --> 00:07:44,939
ordenadas por edad, o a lo mejor nos interesa que esté ordenado por edad

105
00:07:44,939 --> 00:07:48,180
de forma descendente. Entonces, cuando las colecciones van a

106
00:07:48,180 --> 00:07:51,319
vamos a utilizar una colección de tipo

107
00:07:51,319 --> 00:07:53,680
tree que va a estar ordenado

108
00:07:53,680 --> 00:07:57,459
según el criterio de personas y esto puede ser cambiante

109
00:07:57,459 --> 00:07:59,980
aquel código que está en la librería de java

110
00:07:59,980 --> 00:08:02,800
se tendrá que fijar en algo para ver cuál es ese criterio

111
00:08:02,800 --> 00:08:05,959
como la clase personal estamos codificando

112
00:08:05,959 --> 00:08:09,240
nosotros el criterio que va a utilizar para la ordenación

113
00:08:09,240 --> 00:08:12,040
y a su vez para si es un triset

114
00:08:12,040 --> 00:08:14,980
para que no haya duplicados va a ser el que definamos

115
00:08:14,980 --> 00:08:18,000
tenemos dos opciones que el otro día trabajamos con

116
00:08:18,000 --> 00:08:25,959
una. Sobre la clase que vamos a utilizar en la colección, en este caso triset, para ir almacenando

117
00:08:25,959 --> 00:08:31,500
elementos, lo que podemos hacer, una de ellas es implementar el interfaz comparable. El interfaz

118
00:08:31,500 --> 00:08:37,259
comparable nos obliga a meter el método compareTo. Entonces, desde aquel código que está en las

119
00:08:37,259 --> 00:08:43,779
librerías, cuando vayamos añadiendo nuevas personas a la colección y quiera mirar a ver si ya están

120
00:08:43,779 --> 00:08:47,879
duplicadas y quiera ir manteniendo un orden bajo un criterio

121
00:08:47,879 --> 00:08:51,720
lo que hará desde la colección, aunque no seamos directamente conscientes

122
00:08:51,720 --> 00:08:55,740
aunque sí que pusimos estas trazas y vimos que efectivamente hacía accesos este método

123
00:08:55,740 --> 00:08:58,600
es buscarlo aquí en este método compareTo

124
00:08:58,600 --> 00:09:03,740
que nos comparará en este caso las dos

125
00:09:03,740 --> 00:09:07,799
personas con las que estamos trabajando para ordenarlas o para ver si están

126
00:09:07,799 --> 00:09:11,840
duplicadas, una será aquel que esté llamando al método y la

127
00:09:11,840 --> 00:09:15,179
segunda será aquella persona que reciba aquí como

128
00:09:15,179 --> 00:09:19,480
atributo este método. Entonces fijaros como este atributo lo cargamos

129
00:09:19,480 --> 00:09:23,559
que sea de tipo object para que sea genérico, lo hacemos un casting

130
00:09:23,559 --> 00:09:27,600
a un objeto de clase persona y a partir de aquí comparamos este

131
00:09:27,600 --> 00:09:31,620
que hemos recibido con this, que es el que está haciendo la llamada

132
00:09:31,620 --> 00:09:35,720
al método. De esta comparación resulta que nos tiene que devolver

133
00:09:35,720 --> 00:09:39,740
un entero que podrá ser cero si se consideran los dos iguales

134
00:09:39,740 --> 00:09:43,519
en cuyo caso, si nos termina devolviendo el compareTo

135
00:09:43,519 --> 00:09:48,000
un cero entre esas dos personas, si es un triset, ya no lo añadirá

136
00:09:48,000 --> 00:09:51,419
porque se estaría considerando que es la misma persona

137
00:09:51,419 --> 00:09:55,840
que igual en este compareTo hemos dicho que dos personas iguales son aquellas que tienen el mismo nombre

138
00:09:55,840 --> 00:09:59,600
o aquellas que tienen la misma edad, aunque sean personas

139
00:09:59,600 --> 00:10:02,080
diferentes en sí, objetos de personas diferentes

140
00:10:02,080 --> 00:10:06,519
y si una es mayor que otra, devolverá un valor mayor que cero

141
00:10:06,519 --> 00:10:12,179
y si la otra es la otra mayor que una pues un valor menor que cero no hay un menos uno por ejemplo

142
00:10:12,639 --> 00:10:18,049
y esto lo que estoy moviendo el otro día para ver un poco más el desarrollo en profundidad

143
00:10:18,750 --> 00:10:23,990
pues nada os invito a que veáis el vídeo del otro día y así avanzamos para seguir viendo cosas

144
00:10:25,769 --> 00:10:32,409
Fijaros pensad que aquí en este programa donde estamos hablando de ver este call que tiene

145
00:10:33,210 --> 00:10:37,009
este es anterior en este programa estábamos estamos considerando

146
00:10:37,830 --> 00:10:41,850
por ejemplo, una colección de tipo triset de personas.

147
00:10:42,029 --> 00:10:43,210
Aquí lo tenemos, de personas.

148
00:10:43,950 --> 00:10:48,110
Y para ver si hay duplicados y ver el orden,

149
00:10:48,110 --> 00:10:52,049
hemos dicho que hemos implementado el interfaz comparable

150
00:10:52,049 --> 00:10:55,629
en la clase persona, de lo que estamos hablando.

151
00:10:56,230 --> 00:10:59,389
Pero pensad que a lo mejor en este programa

152
00:10:59,389 --> 00:11:01,149
y en todo el programa en su conjunto,

153
00:11:01,230 --> 00:11:03,549
que podría tener más clases o incluso dentro de este mismo

154
00:11:03,549 --> 00:11:06,470
método main de la clase principal,

155
00:11:07,830 --> 00:11:35,789
Resulta que en un tramo me interesa tener una colección de objetos de la clase persona ordenados bajo el criterio que esté aquí, que parece que es la edad, ¿verdad? Y en caso de la misma edad, el nombre. Y resulta que en otro contexto de la ejecución del programa, también me interesa tener un triset de personas, pero justo en este caso no me interesa que estén ordenadas esa colección por la edad y luego por el nombre en caso de empate.

156
00:11:35,789 --> 00:11:39,629
entonces si yo utilizo este criterio

157
00:11:39,629 --> 00:11:42,350
el interfaz comparable

158
00:11:42,350 --> 00:11:45,649
el único criterio por el que se ordenan las personas

159
00:11:45,649 --> 00:11:48,350
en una, en dos o en veinte colecciones que tenga

160
00:11:48,350 --> 00:11:51,110
será el que indica aquí en el compare tú

161
00:11:51,110 --> 00:11:54,690
entonces si yo aquí, porque en una parte del programa me interesa ordenarlos

162
00:11:54,690 --> 00:11:56,990
por edad, he puesto este criterio

163
00:11:56,990 --> 00:11:59,610
como vimos que el otro día funcionaba razonablemente

164
00:11:59,610 --> 00:12:03,470
en otra parte del código donde me interese también

165
00:12:03,470 --> 00:12:12,529
en una colección de personas, objetos de esta misma clase, pero cuyo criterio sea el orden por nombre, pues ya no me valdrá. ¿Por qué?

166
00:12:12,669 --> 00:12:19,889
Porque si vuelvo a utilizar el interfaz comparable, seguirá siendo exactamente este el criterio que utiliza, el que está en el método compareTo.

167
00:12:21,070 --> 00:12:32,690
¿Cómo podemos resolver esto? Pues para identificar en un triset, por ejemplo, si los duplicados y el orden tenemos una segunda alternativa.

168
00:12:32,690 --> 00:12:34,450
Esta segunda alternativa es la siguiente.

169
00:12:36,799 --> 00:12:38,120
A ver en qué proyecto estamos, por aquí.

170
00:12:39,080 --> 00:12:40,379
Este es el proyecto call, yo creo.

171
00:12:41,059 --> 00:12:45,990
A ver, sí, aquí estamos.

172
00:12:46,409 --> 00:12:50,190
Pues mirad, en lugar de hacerlo directamente sobre la clase persona,

173
00:12:50,590 --> 00:12:52,909
tenemos la posibilidad de definir una nueva clase

174
00:12:52,909 --> 00:12:58,889
que va a tener dedicación exclusiva a definir un criterio de orden,

175
00:12:59,350 --> 00:13:00,990
en este caso, por ejemplo, entre personas,

176
00:13:01,789 --> 00:13:03,110
entre objetos de la clase persona.

177
00:13:03,809 --> 00:13:06,070
Entonces vamos a llamar, por ejemplo, a esta clase comparar.

178
00:13:06,070 --> 00:13:09,570
estoy definiendo una nueva clase independiente de la clase persona

179
00:13:09,570 --> 00:13:15,940
en esta clase comparar, lo que vamos a hacer va a ser implementar

180
00:13:15,940 --> 00:13:19,980
un interfaz diferente, aquí implementamos en la clase persona

181
00:13:19,980 --> 00:13:23,559
el interfaz comparable en uno de los criterios, pues aquí

182
00:13:23,559 --> 00:13:29,980
vamos a implementar el interfaz comparator

183
00:13:29,980 --> 00:13:38,899
java útil por aquí me dice que añada los métodos que no están

184
00:13:38,899 --> 00:13:43,019
implementados y el interfaz comparator me obliga

185
00:13:43,019 --> 00:13:46,519
a tener un método, el método compare. Fijaros, este método

186
00:13:46,519 --> 00:13:52,539
si en la clase persona teníamos, recibíamos

187
00:13:52,539 --> 00:13:56,120
en el compareTo un objeto que al final iba a ser una persona

188
00:13:56,120 --> 00:13:59,120
que comparábamos este objeto en el compareTo

189
00:13:59,120 --> 00:14:03,899
del interfaz comparable con el que estaba llamando al método compareTo

190
00:14:03,899 --> 00:14:07,500
el otro objeto de la clase persona, aquí lo que recibimos son dos objetos.

191
00:14:08,039 --> 00:14:11,299
Es decir, vamos a comparar dos objetos que estemos recibiendo por aquí.

192
00:14:11,299 --> 00:14:16,179
entonces imaginaos que son dos objetos de la clase

193
00:14:16,179 --> 00:14:20,360
persona, por ejemplo, para los que lo vamos a utilizar

194
00:14:20,360 --> 00:14:23,539
pues ¿qué podemos hacer? Pues mirad, podemos coger y decir

195
00:14:23,539 --> 00:14:27,779
fijaros que devuelve, el criterio de devolver es también un entero que será

196
00:14:27,779 --> 00:14:31,220
cero, si ambos son iguales, un valor mayor que cero

197
00:14:31,220 --> 00:14:36,019
si una de las personas es mayor que la otra y un valor menor que cero si lo es la otra

198
00:14:36,019 --> 00:14:39,580
en este aspecto es la misma idea que antes

199
00:14:39,580 --> 00:14:43,399
y lo que hacemos aquí es definir, definimos un objeto de la clase persona

200
00:14:43,399 --> 00:14:48,159
per 1, una referencia

201
00:14:48,159 --> 00:14:52,120
para hacer un casting a 1, que es uno de los dos

202
00:14:52,120 --> 00:14:55,379
que estamos recibiendo, como lo recibimos con formato object

203
00:14:55,379 --> 00:14:58,940
hacemos un casting a la persona y ponemos aquí a 1

204
00:14:58,940 --> 00:15:06,100
las dos personas que vamos a comparar las hemos recibido

205
00:15:06,100 --> 00:15:10,299
aquí como atributo, hacemos un casting al tipo

206
00:15:10,299 --> 00:15:14,360
propio de lo que queremos comparar para no estar trabajando con

207
00:15:14,360 --> 00:15:19,700
uno que en realidad es de tipo object. Y ahora vamos a poner aquí

208
00:15:19,700 --> 00:15:23,700
int y result. Igual a cero.

209
00:15:25,179 --> 00:15:27,980
Y aquí vamos a poner la variable que queremos

210
00:15:27,980 --> 00:15:31,840
devolver. Y ahora aquí en medio vamos a ver

211
00:15:31,840 --> 00:15:35,980
según el criterio con el que queramos comparar estas dos personas, vamos a

212
00:15:35,980 --> 00:15:37,500
trabajarlo aquí entre medias.

213
00:15:37,500 --> 00:15:43,559
mirad, las personas tenían por ejemplo edad, vamos a suponer que queremos hacer una comparación

214
00:15:43,559 --> 00:15:47,629
de esas dos personas por edad, entonces digo

215
00:15:47,629 --> 00:15:56,039
if per1, que es esta persona que he recibido aquí como parámetro

216
00:15:56,039 --> 00:15:59,440
punto y edad, es mayor

217
00:15:59,440 --> 00:16:03,120
que per2 punto y edad

218
00:16:03,120 --> 00:16:07,399
pues entonces esta variable que es la que voy a devolver al final

219
00:16:07,399 --> 00:16:11,419
voy a decir un 1. Esto indica que la primera

220
00:16:11,419 --> 00:16:14,759
de las personas es mayor que la segunda. Devolver un valor mayor que 0.

221
00:16:19,600 --> 00:16:26,720
El SIF es menor si es, este era

222
00:16:26,720 --> 00:16:30,320
el caso si era mayor, pues si es menor uno que otro devuelvo un menos uno.

223
00:16:30,899 --> 00:16:34,860
Y si no es ni mayor ni menor, pues quiere decir que es igual. Y como lo he inicializado

224
00:16:34,860 --> 00:16:38,980
aquí a 0, no hace falta poner un SIF de igual. Si queréis

225
00:16:38,980 --> 00:16:42,460
si alguien lo ve más claro, podríamos decir que si los SIF

226
00:16:42,460 --> 00:16:48,690
Si son iguales, podríamos decir aquí que sea igual a cero.

227
00:16:49,570 --> 00:16:53,029
Ya os digo que esto es innecesario, porque si no pasa por ninguna de estas dos,

228
00:16:54,090 --> 00:16:57,169
pues lógicamente mantendrá el cero de aquí de la inicialización.

229
00:16:58,110 --> 00:16:58,470
Voy a quitar.

230
00:16:59,409 --> 00:17:04,710
Lo que estamos haciendo es comparar las dos personas de acuerdo a un criterio, que es la edad.

231
00:17:06,839 --> 00:17:09,619
Bien, ya tenemos aquí el mecanismo para comparar a las dos personas.

232
00:17:09,619 --> 00:17:11,519
¿Cómo lo estábamos haciendo hasta ahora?

233
00:17:11,519 --> 00:17:20,839
considerando el interfaz comparable en principal, pues nada, directamente creamos el triset

234
00:17:20,839 --> 00:17:26,660
y ya él iba cogiendo y iba llamando al compareTo del interfaz comparable.

235
00:17:26,960 --> 00:17:33,519
¿Qué tenemos que hacer en caso de no querer considerar el comparable y utilizar este otro criterio?

236
00:17:33,519 --> 00:17:38,920
Pues lo que podemos hacer aquí es crear un objeto de la clase comparar,

237
00:17:38,920 --> 00:17:51,109
un objeto de la clase comparar, que es la que acabamos de

238
00:17:51,109 --> 00:17:55,950
implementar aquí, de desarrollar aquí, que implementa

239
00:17:55,950 --> 00:17:59,829
el interfaz comparator y en el método compare hemos dado el

240
00:17:59,829 --> 00:18:03,750
criterio por el cual comparamos dos objetos que resultan ser

241
00:18:03,750 --> 00:18:07,710
dos personas, ¿verdad? Y para asociarlo a la colección

242
00:18:07,710 --> 00:18:10,430
lo que hacemos ahora es, en el triset

243
00:18:10,430 --> 00:18:16,069
comento este del otro día, lo mantengo ahí, lo que hago es pasarle

244
00:18:16,069 --> 00:18:18,589
este objeto de esta clase al constructor

245
00:18:18,589 --> 00:18:22,910
que tenemos en el momento en el que creamos la colección.

246
00:18:23,769 --> 00:18:28,009
Al pasarle, digamos, el constructor del triset está

247
00:18:28,009 --> 00:18:32,049
sobrecargado. Por un lado tiene el constructor vacío y por otro

248
00:18:32,049 --> 00:18:36,089
un constructor que permite recibir un

249
00:18:36,089 --> 00:18:40,049
objeto de una clase, sea la que sea, con la condición

250
00:18:40,049 --> 00:18:44,009
de que esté implementando esa clase el interfaz

251
00:18:44,009 --> 00:18:48,009
comparator. Con lo cual, la ordenación

252
00:18:48,009 --> 00:18:51,690
que vamos a tener de esta colección, mi ARCOL, que es de la clase

253
00:18:51,690 --> 00:18:57,319
persona, en principio lo que buscamos es que tenga

254
00:18:57,319 --> 00:19:01,279
en cuenta los criterios que habíamos puesto en este objeto, que es

255
00:19:01,279 --> 00:19:06,859
un objeto de la clase comparar. Vamos a hacer una ejecución, tengo ahora mismo dudas, no recuerdo

256
00:19:06,859 --> 00:19:10,920
muy bien si es necesario quitar la interfaz comparable en la clase

257
00:19:10,920 --> 00:19:14,279
persona o aunque exista, no le importa porque al haberlo

258
00:19:14,279 --> 00:19:18,799
al haber inicializado la colección

259
00:19:18,799 --> 00:19:22,000
con este constructor, ya va a ir a tener este criterio.

260
00:19:22,339 --> 00:19:25,700
En caso de que no sea así, pues le quitamos el...

261
00:19:25,700 --> 00:19:28,480
Como estamos ahora apoyándonos en el interfaz

262
00:19:28,480 --> 00:19:33,759
implementando el interfaz comparator, quitaríamos en ese caso el interfaz

263
00:19:33,759 --> 00:19:37,759
comparable y con lo cual haríamos desaparecer este método. Pero yo creo que no es

264
00:19:37,759 --> 00:19:43,640
necesario. El criterio que hemos puesto aquí ha sido de edad, ¿verdad?

265
00:19:43,640 --> 00:19:47,119
pues vamos a ver si esta colección nos funciona de esta forma.

266
00:19:50,609 --> 00:19:54,410
Vamos a poner, por ejemplo, primero, vamos a considerar que los dos objetos

267
00:19:54,410 --> 00:19:58,710
que metemos en la colección tienen la misma edad. Esto hará que al tener la misma edad

268
00:19:58,710 --> 00:20:02,430
los considere por esta interfaz como la misma persona.

269
00:20:03,289 --> 00:20:05,349
Vamos a cambiar aquí para que solamente sea la edad.

270
00:20:06,210 --> 00:20:10,470
El nombre de una sea August, el nombre de otra Miguel, y los dos con la misma edad.

271
00:20:12,859 --> 00:20:16,259
Según este criterio, al ser los dos con la misma edad, no entraría

272
00:20:16,259 --> 00:20:20,519
ni por el if ni por el else nos devolvería un 0 y que nos devuelva un 0 implica

273
00:20:20,519 --> 00:20:23,660
mismo elemento como es set

274
00:20:23,660 --> 00:20:28,079
al ser un triset es set, no admite duplicados, pues solamente

275
00:20:28,079 --> 00:20:32,319
debería meter uno de los elementos, esto debería decirnos que solamente tiene un elemento

276
00:20:32,319 --> 00:20:38,019
vamos a ver, fijaros como efectivamente nos dice

277
00:20:38,019 --> 00:20:44,779
que tiene un solo elemento, si cogemos y le cambiamos y le ponemos aquí 21

278
00:20:44,779 --> 00:20:50,380
para que tenga edad diferente, ya tiene dos elementos

279
00:20:50,380 --> 00:20:58,710
es decir se está apoyando en éste para que no tengamos ninguna duda de que va por ahí vamos a

280
00:20:58,710 --> 00:21:09,559
quitar a la clase persona esto y vamos a quitarle el método también pues si lo queremos retomar lo

281
00:21:09,559 --> 00:21:18,700
que voy a hacer va a ser comentarlo mantengo una línea con un comentario ahí arriba y esto

282
00:21:18,700 --> 00:21:37,400
ahora lo comentas la clase persona ya no tiene de aumentar más abajo yo creo aquí quizás a ver

283
00:21:38,740 --> 00:21:45,359
la clase persona se quedará con los dos atributos solos y aún así el programa no sigue funcionando

284
00:21:45,359 --> 00:21:52,099
porque ahora el tríceps en realidad utiliza la clase un objeto a la clase comparar no el compare

285
00:21:52,099 --> 00:21:58,759
tú de la clase persona vamos a ver si sigue funcionando efectivamente vale pues como ahora

286
00:21:58,759 --> 00:22:05,160
los datos son 21 y 20 fijaros pues el criterio en la edad pues ya me dice que tenemos dos elementos

287
00:22:05,160 --> 00:22:22,119
Y además, observad cómo, a pesar de que he insertado primero mi PER que tiene la edad 21 y en segundo lugar mi PER2 que tiene la edad 20, a la hora de mostrármelos en este iterador, me muestra primero el del 20. ¿Por qué? Por el criterio de ordenación.

288
00:22:22,119 --> 00:22:25,599
si aquí en comparar me vengo y le cambio

289
00:22:25,599 --> 00:22:27,980
justo el criterio, le pongo aquí el menos uno y aquí el uno

290
00:22:27,980 --> 00:22:34,049
al ejecutar, pues ahora el criterio de ordenación es

291
00:22:34,049 --> 00:22:37,549
de mayor edad a menor edad y ya me dice

292
00:22:37,549 --> 00:22:40,509
que August que tiene 21 es el primero de los elementos

293
00:22:40,509 --> 00:22:44,980
que se encuentra en esta colección. Hasta aquí

294
00:22:44,980 --> 00:22:47,539
si tenemos una única colección, pues bueno pues

295
00:22:47,539 --> 00:22:51,220
de personas, pues nos valen

296
00:22:51,220 --> 00:22:54,279
por igual los dos interfaces, como lo teníamos antes

297
00:22:54,279 --> 00:22:57,059
así como lo teníamos ahora. En un caso, en el compare tú de la clase persona,

298
00:22:57,200 --> 00:23:00,279
metemos el criterio de ordenación por edad y en otro caso

299
00:23:00,279 --> 00:23:02,059
lo estamos definiendo en esta otra clase.

300
00:23:02,940 --> 00:23:04,420
Pero la principal ventaja que tiene,

301
00:23:05,380 --> 00:23:09,140
si os apetece hacerlo más con una clase extra,

302
00:23:11,630 --> 00:23:13,690
es que podemos tener dos colecciones

303
00:23:13,690 --> 00:23:16,890
de la clase persona en nuestro programa

304
00:23:16,890 --> 00:23:20,529
que a lo mejor es necesario, con criterios de ordenación distintos.

305
00:23:23,220 --> 00:23:24,640
Entonces, si cogemos y aquí definimos

306
00:23:24,640 --> 00:23:36,220
una segunda clase, que llamamos, por ejemplo, comparar2, comparar2, ahí la tenemos, vamos

307
00:23:36,220 --> 00:24:02,900
a hacer copy-pega de esto, aquí el import, tengo que decirle que implemente comparator

308
00:24:02,900 --> 00:24:11,210
también, esta nueva, ahí lo tenemos, al implementar comparator en esta nueva clase

309
00:24:11,210 --> 00:24:18,069
nos obliga a tener el método compare. Este es el criterio de orden de mayor a menor que

310
00:24:18,069 --> 00:24:25,640
teníamos aquí pues mirad en esta colección vamos a volver a poner el orden de mayor a menor podríamos

311
00:24:25,640 --> 00:24:29,279
poner cualquier otro criterio que estuviera que ver por ejemplo con el nombre de la persona a la

312
00:24:29,279 --> 00:24:38,599
hora de ordenarlo aquí por código definirse el que sea esta colección decimos que se base la

313
00:24:38,599 --> 00:24:42,740
ordenación en este objeto que es de la clase comparar con lo cual aquí estamos manteniendo

314
00:24:42,740 --> 00:24:56,720
el criterio de orden de mayor a menor por edad y ahora lo que vamos a hacer aquí abajo vamos a

315
00:24:56,720 --> 00:25:00,160
voy a hacer copy-pega y ahora vamos haciendo los cambios oportunos

316
00:25:00,160 --> 00:25:04,759
para que vaya más rápido. Digo, quiero definir un objeto de la clase

317
00:25:04,759 --> 00:25:12,960
comparar2 que sea mi.com.2, que es esta otra, a la cual

318
00:25:12,960 --> 00:25:16,839
os recuerdo que le hemos dado la vuelta a estos números para que la forma de ordenación

319
00:25:16,839 --> 00:25:20,480
siga siendo por edad, que ya os digo, podría ser otro criterio, pero en este caso

320
00:25:20,480 --> 00:25:25,079
comparar2 ordena de menor a mayor, comparar1 de mayor a menor.

321
00:25:25,220 --> 00:25:28,119
El menos uno está aquí en este caso y el menos uno aquí en este otro.

322
00:25:28,119 --> 00:25:35,920
creo un objeto, creo una colección diferente en mi programa

323
00:25:35,920 --> 00:25:38,960
que también es de la clase persona, si estuviéramos utilizando

324
00:25:38,960 --> 00:25:43,480
la forma de ordenación a través de

325
00:25:43,480 --> 00:25:47,740
el interfaz comparable aquí, no tendríamos opción de ordenar de dos formas porque este

326
00:25:47,740 --> 00:25:50,680
método en toda la clase persona es único, el compare tú

327
00:25:50,680 --> 00:25:54,920
pero aquí sí que a cada una de las dos colecciones le vamos a dar

328
00:25:54,920 --> 00:25:59,839
un criterio diferente, a pesar de que las dos colecciones son

329
00:25:59,839 --> 00:26:05,160
de la clase persona. Bueno, pues

330
00:26:05,160 --> 00:26:08,799
a esta nueva colección le volvemos a meter los dos

331
00:26:08,799 --> 00:26:11,759
mismos elementos, si os parece, por no andar perdiendo mucho

332
00:26:11,759 --> 00:26:14,859
el tiempo. MiPer y MiPer2, que son

333
00:26:14,859 --> 00:26:17,559
los dos objetos que habíamos dado de alta aquí,

334
00:26:17,900 --> 00:26:21,380
hemos metido información aquí, aquí se lo añadimos a una colección

335
00:26:21,380 --> 00:26:24,339
y aquí se lo estamos añadiendo ahora a la segunda colección.

336
00:26:24,500 --> 00:26:31,920
Fijaros el 2. Creamos un iterador

337
00:26:31,920 --> 00:26:34,660
para mostrar los datos, no sobre la primera colección,

338
00:26:34,660 --> 00:26:50,480
sino sobre la segunda, y ya lo tenemos, entonces si ejecutamos ahora, voy a meter aquí algo que

339
00:26:50,480 --> 00:26:58,250
nos claramente nos separe la información de una colección y la de otra, vamos a meter aquí unos

340
00:26:58,250 --> 00:27:15,579
asteriscos por ejemplo, entonces si ejecutamos, a ver qué he hecho, bueno me falta aquí modificar

341
00:27:15,579 --> 00:27:20,490
ese dato, ahí estamos, ejecutamos

342
00:27:20,490 --> 00:27:25,049
y aquí lo tenemos. Los datos son los mismos porque hemos metido los dos

343
00:27:25,049 --> 00:27:28,609
mismos objetos, pero fijaros como esta nos ha mostrado la

344
00:27:28,609 --> 00:27:33,230
ordenación de los elementos de mayor a menor edad y esta

345
00:27:33,230 --> 00:27:36,809
de menor a mayor, que es justo los criterios que hemos puesto por aquí.

346
00:27:39,240 --> 00:27:42,539
Bueno, pues esta otra técnica tenemos para los trisets.

347
00:27:46,700 --> 00:27:53,950
No sé si hay alguna pregunta por ahí y si no, pues a lo sigo contando

348
00:27:53,950 --> 00:27:57,049
más cosas. Dentro de las colecciones

349
00:27:57,049 --> 00:28:01,710
tenemos, estamos hablando ahora de cómo

350
00:28:01,710 --> 00:28:05,930
podemos trabajar con los trisets, que

351
00:28:05,930 --> 00:28:09,750
decimos que tienen orden y no permiten duplicados, habíamos hablado de

352
00:28:09,750 --> 00:28:13,690
luego después os hago un comentario más sobre los ArrayList o los

353
00:28:13,690 --> 00:28:18,109
LinkedList, que lo que tienen, permiten duplicados

354
00:28:18,109 --> 00:28:21,869
y no tienen un orden, al menos con criterio propio en el

355
00:28:21,869 --> 00:28:28,170
programa, pero luego tenemos otras colecciones que son los set, pero que no son tree, es decir, no están

356
00:28:28,170 --> 00:28:36,369
ordenados, pero no permiten duplicados. Por ejemplo, en este caso podríamos hablar de los, a ver,

357
00:28:36,369 --> 00:28:49,319
de cuáles, por ejemplo, de los linked set, como son, no recuerdo cómo son estas, de los hash set, por ejemplo.

358
00:28:49,319 --> 00:28:57,380
Estas colecciones, las colecciones Haset, que también las tenemos disponibles en las colecciones de Java, aquí tenemos uno de ellos.

359
00:28:58,240 --> 00:29:17,380
Fijaros cómo no permite duplicados, pero al no tener el tree, no tiene una ordenación en particular. Si no tiene una ordenación en particular, aunque solo sea por nombre, no parece que tenga mucho sentido que sea el interfaz implement comparable que tiene el compare to el que nos permita hacer las comprobaciones de los duplicados.

360
00:29:17,380 --> 00:29:21,480
duplicados. ¿Qué utilizan los set que no están ordenados?

361
00:29:21,599 --> 00:29:23,400
Pues utilizan otros métodos diferentes.

362
00:29:31,119 --> 00:29:40,099
Vamos a hacer un, para verlo por código, voy a comentar todo esto,

363
00:29:40,440 --> 00:29:43,779
luego voy cogiendo código si lo necesito. Vamos a hacer, por ejemplo, un

364
00:29:43,779 --> 00:30:02,210
has set de personas. Cada nueva persona cañada

365
00:30:02,210 --> 00:30:06,450
habrá que comprobar si ya existe en la colección,

366
00:30:06,450 --> 00:30:10,650
bueno, habrá que comprobar, la colección comprueba si ya existe en la colección

367
00:30:10,650 --> 00:30:14,589
para evitar que haya duplicados. No le preocupa el orden

368
00:30:14,589 --> 00:30:18,650
porque no es un tree, pero sí que es un conjunto, no nos permite

369
00:30:18,650 --> 00:30:22,650
duplicados. Entonces, si tenemos aquí dos personas

370
00:30:22,650 --> 00:30:26,630
damos de alta las dos personas de antes

371
00:30:26,630 --> 00:30:36,859
podríamos coger y decir, bien, añado

372
00:30:36,859 --> 00:30:49,240
una persona y otra, y luego miro el

373
00:30:49,240 --> 00:30:53,279
tamaño que tiene la colección

374
00:30:53,279 --> 00:30:58,900
y ejecutándolo así de primeras, pues me dice que hay dos elementos

375
00:30:58,900 --> 00:31:02,640
en la colección. Pero según mi enunciado

376
00:31:02,640 --> 00:31:07,059
podríamos tener un criterio para decir, oye, estas dos personas son iguales

377
00:31:07,059 --> 00:31:11,400
si tienen la misma edad. Si, un enunciado será

378
00:31:11,400 --> 00:31:15,140
si tienen el mismo nombre. Solamente son iguales si tienen

379
00:31:15,140 --> 00:31:18,900
la misma edad y a la vez tienen el mismo nombre. Bueno, pues todo ese criterio

380
00:31:18,900 --> 00:31:23,000
igual que antes hacíamos en el compare tool, lo podemos programar nosotros por código

381
00:31:23,000 --> 00:31:29,000
y qué métodos son los que se utilizan para los set que no son tres y para los conjuntos que no

382
00:31:29,000 --> 00:31:35,720
están ordenados pues en la clase persona igual que antes para los tres utilizábamos el compare

383
00:31:35,720 --> 00:31:42,859
tú en este caso son otros dos métodos los con los que se trabajan que son una combinación del

384
00:31:42,859 --> 00:32:03,250
public int hashCode y otra una combinación de estos dos métodos y otra el public boolean equals

385
00:32:06,190 --> 00:32:24,079
que recibe un parámetro del tipo object combinando estas dos estos dos métodos el hashCode estos dos

386
00:32:24,079 --> 00:32:29,039
métodos son luego ponemos un system out de una colección que sea por ejemplo un hashSet son los

387
00:32:29,039 --> 00:32:39,299
que la colección desde aquel código que está en las librerías consultará para determinar si, ya que es una colección tipo set, esos dos objetos son duplicados.

388
00:32:39,859 --> 00:32:50,799
Como son dos métodos de la clase persona, estará comparando en particular el método, el equals, porque del Hasco de ahora os voy a decir que en principio vamos a olvidarnos un poco,

389
00:32:50,799 --> 00:32:56,000
mirará este objeto con el objeto

390
00:32:56,000 --> 00:32:59,599
del que está haciendo la llamada. Para centralizar

391
00:32:59,599 --> 00:33:03,799
todo en un solo método, lo que podemos hacer es directamente

392
00:33:03,799 --> 00:33:06,819
el hashCode decir que el return 0, ya está.

393
00:33:07,740 --> 00:33:12,119
Vamos a poner un system out aquí para luego ver que efectivamente va pasando en las comprobaciones

394
00:33:12,119 --> 00:33:23,119
por este método, pero digamos que de esta forma nos olvidamos

395
00:33:23,119 --> 00:33:27,160
de cualquier codificación aquí. Y todo el criterio de comparación lo podemos poner

396
00:33:27,160 --> 00:33:31,220
aquí. Para esto lo que hacemos es, igual que antes en el compareTo, pues decimos

397
00:33:31,220 --> 00:33:34,740
persona, mi per

398
00:33:34,740 --> 00:33:40,740
o per aus, vamos a poner que sea igual, hacemos un casting

399
00:33:40,740 --> 00:33:47,009
de persona del atributo que estamos recibiendo como parámetro

400
00:33:47,009 --> 00:33:52,500
y ahora aquí hacemos la comparación que nos interesa

401
00:33:52,500 --> 00:33:55,359
que nos interese para nuestro programa

402
00:33:55,359 --> 00:34:04,170
la comparación que nos interese para determinar si la persona que está llamando al método

403
00:34:04,170 --> 00:34:06,289
y la que ha recibido como parámetros son iguales.

404
00:34:07,009 --> 00:34:11,409
Y en base a esto, la colección añadirá o no añadirá el método

405
00:34:11,409 --> 00:34:14,949
porque al ser un set solamente lo hará en caso de que sean diferentes.

406
00:34:15,869 --> 00:34:17,590
Como estábamos diciendo que tenga la misma edad,

407
00:34:17,710 --> 00:34:19,030
pues podríamos decir id, sí.

408
00:34:20,550 --> 00:34:26,469
Dis yo mi edad es igual a la edad de la persona

409
00:34:26,469 --> 00:34:28,510
que estoy recibiendo como parámetro aquí,

410
00:34:35,679 --> 00:34:39,460
per aus punto y edad, si es igual,

411
00:34:39,460 --> 00:34:53,230
lo vamos a iniciar a falso, falso significa

412
00:34:53,230 --> 00:34:56,630
no son iguales y en caso de que sea igual

413
00:34:56,630 --> 00:35:00,099
lo ponemos a true

414
00:35:00,099 --> 00:35:03,519
y ahora devolvemos bReturn

415
00:35:03,519 --> 00:35:08,880
si cuando se llame a este método se determina

416
00:35:08,880 --> 00:35:11,619
que la persona que estamos recibiendo como parámetro

417
00:35:11,619 --> 00:35:15,199
comparándola con la persona actual bajo el criterio

418
00:35:15,199 --> 00:35:18,039
de que sea la misma edad porque nuestro enunciado en este ejercicio

419
00:35:18,039 --> 00:35:20,679
es el criterio que hemos tenido para que dos personas sean iguales

420
00:35:20,679 --> 00:35:23,840
así es, lo que hago es poner la variable bReturn a true

421
00:35:23,840 --> 00:35:27,780
para que nos devuelva true, indicador de que ambas dos son iguales

422
00:35:27,780 --> 00:35:32,239
si no entra por aquí, pues tendremos el valor en bReturn

423
00:35:32,239 --> 00:35:36,000
de la inicialización que es falso y nos estará devolviendo falso, es decir, son diferentes

424
00:35:36,000 --> 00:35:40,039
para ver también que pasa por ahí cuando está haciendo

425
00:35:40,039 --> 00:35:51,050
este criterio, vamos a poner que nos pasa equals

426
00:35:51,050 --> 00:35:59,250
vamos a ponerlo aquí para que nos haga el mensaje de tanto cuando son iguales

427
00:35:59,250 --> 00:36:00,869
como cuando no, que ha pasado por ahí

428
00:36:00,869 --> 00:36:05,150
pues ya está, igual que antes el compareTool

429
00:36:05,150 --> 00:36:07,590
el que utilizábamos en el triset, pues ahora son estas dos

430
00:36:07,590 --> 00:36:10,510
esta la fijamos para que no tenga

431
00:36:10,510 --> 00:36:14,030
trascendencia a la hora de hacer la comparación

432
00:36:14,030 --> 00:36:16,909
entre las dos personas y en este caso es donde metemos el código

433
00:36:16,909 --> 00:36:19,389
según la lógica que nos interese programar

434
00:36:19,389 --> 00:36:25,340
entonces fijaros, aquí estamos añadiendo dos personas

435
00:36:25,340 --> 00:36:28,860
en un hashSet, es previsible

436
00:36:28,860 --> 00:36:32,380
que se vaya a fijar precisamente en estos métodos para determinar

437
00:36:32,380 --> 00:36:35,199
si son iguales, vamos a hacer una ejecución a ver qué pasa.

438
00:36:35,940 --> 00:36:38,360
Si hacemos una primera ejecución con edades diferentes,

439
00:36:38,360 --> 00:36:41,699
como el criterio que hemos puesto para que las personas sean iguales,

440
00:36:41,920 --> 00:36:43,159
tendría que añadir los dos.

441
00:36:45,659 --> 00:36:48,980
Y fijaros cómo, aunque nosotros no tenemos aquí llamadas

442
00:36:48,980 --> 00:36:52,400
a esos métodos, nos salen las trazas que hemos puesto aquí

443
00:36:52,400 --> 00:36:58,900
porque desde el código que tenemos en las librerías

444
00:36:58,900 --> 00:37:01,139
para el HashCode se apoyan estos métodos

445
00:37:01,139 --> 00:37:02,320
para hacer esas comprobaciones.

446
00:37:04,570 --> 00:37:06,909
Y si cogemos y decimos que las dos personas sean iguales,

447
00:37:06,909 --> 00:37:11,820
fijaros como ahora efectivamente solamente añade una

448
00:37:11,820 --> 00:37:15,199
porque el criterio que hemos programado en esos métodos es

449
00:37:15,199 --> 00:37:18,699
que tengan la misma edad para que estén repetidos

450
00:37:18,699 --> 00:37:24,539
en otro ejercicio, bueno pues si el criterio que fuésemos a considerar

451
00:37:24,539 --> 00:37:26,739
fuese que dos personas con el mismo nombre

452
00:37:26,739 --> 00:37:30,019
son aquellas que son iguales, pues lo que tendríamos que hacer

453
00:37:30,019 --> 00:37:32,320
si vamos a utilizar un hashSet

454
00:37:32,320 --> 00:37:35,239
sería en la clase persona aquí programar

455
00:37:35,239 --> 00:37:37,039
para que devuelva verdadero o falso

456
00:37:37,039 --> 00:37:41,139
en el caso en que los nombres sean iguales, simplemente

457
00:37:41,139 --> 00:37:43,800
no voy a incidir mucho en esto porque

458
00:37:43,800 --> 00:37:50,590
creo que ya más o menos lo sabréis hacer, pero lo único que

459
00:37:50,590 --> 00:37:54,309
cuidado que los nombres no los podemos comparar de esta forma

460
00:37:54,309 --> 00:38:00,360
con el igual igual los nombres hay que compararlos con

461
00:38:00,360 --> 00:38:05,789
punto compareTo, fijaros el método compareTo

462
00:38:05,789 --> 00:38:09,070
y aquí pondríamos

463
00:38:09,070 --> 00:38:10,610
miper

464
00:38:10,610 --> 00:38:12,530
y

465
00:38:12,530 --> 00:38:14,210
peraus

466
00:38:14,210 --> 00:38:27,869
Ah, bueno, con el equals también, sí

467
00:38:27,869 --> 00:38:28,929
Sí, sí, vale

468
00:38:28,929 --> 00:38:32,210
Si lo hacemos así, de hecho es más directo el equals

469
00:38:32,210 --> 00:38:33,630
Me preguntan que

470
00:38:33,630 --> 00:38:35,829
para la grabación si con el equals se puede comparar

471
00:38:35,829 --> 00:38:37,809
porque esto devolvería un valor

472
00:38:37,809 --> 00:38:39,809
numérico 0, 1, menos 1

473
00:38:39,809 --> 00:38:41,809
Este, para que se convierta en boolean, habría que

474
00:38:41,809 --> 00:38:42,349
hacer esto

475
00:38:42,349 --> 00:38:45,530
Y en cambio con el equals fue mucho mejor, la verdad

476
00:38:45,530 --> 00:38:47,309
En ese caso

477
00:38:47,309 --> 00:38:50,690
pero el equals de la clase string

478
00:38:50,690 --> 00:38:52,489
porque esto es un string, entonces podríamos

479
00:38:52,489 --> 00:39:05,190
equals y aquí le diríamos

480
00:39:05,190 --> 00:39:20,219
peraus y bueno pues aquí

481
00:39:20,219 --> 00:39:22,539
esta sería la forma de comparar dos strings

482
00:39:22,539 --> 00:39:26,139
el equals este nos devolvería verdadero o falso si los dos

483
00:39:26,139 --> 00:39:28,599
strings son iguales, esto sería otra forma la verdad

484
00:39:28,599 --> 00:39:31,820
si el compare tú las dos son iguales nos devuelve cero

485
00:39:31,820 --> 00:39:35,400
pero este nos da más información que en este caso no necesitamos

486
00:39:35,400 --> 00:39:42,360
si hay alguna duda para los set

487
00:39:42,360 --> 00:39:54,280
Bueno, pues si no tenéis más dudas, os sigo contando más cosas.

488
00:39:57,159 --> 00:40:00,420
Mirad, otro tipo de datos que, voy a seguir comentando por aquí,

489
00:40:03,480 --> 00:40:09,380
otra estructura de datos que se da típicamente en la algoritmia

490
00:40:09,380 --> 00:40:15,099
son las pilas y las colas.

491
00:40:16,460 --> 00:40:17,780
¿Una pila qué es?

492
00:40:17,780 --> 00:40:38,920
Pues siempre se comenta, se pone el ejemplo de una pila de platos cuando estamos, si no hemos puesto el lavavajillas porque lo tenemos averiado y tenemos que fregar los platos ahí a mano, pues según vamos cogiendo cada uno de los platos, lo ponemos encima, después de lavarlo, lo ponemos encima del fregadero, ¿no hay? O encima de la encimera.

493
00:40:38,920 --> 00:40:42,760
el segundo plato va encima del primero, el tercero va encima

494
00:40:42,760 --> 00:40:46,739
del segundo y así, vamos haciendo una pila de platos

495
00:40:46,739 --> 00:40:51,119
cuando lo vamos a recoger, a no ser que queramos correr el riesgo

496
00:40:51,119 --> 00:40:54,840
de que se nos rompa a todos, ¿qué es lo que hacemos? Pues el primero que cogemos es

497
00:40:54,840 --> 00:40:59,059
el último que hemos puesto, que es el que está arriba del todo, el segundo que cogemos, para ya guardarlo

498
00:40:59,059 --> 00:41:03,460
ahí en el cajón, el segundo que cogemos es el penúltimo que pusimos

499
00:41:03,460 --> 00:41:07,300
entonces, las pilas

500
00:41:07,300 --> 00:41:10,079
son estructura de datos

501
00:41:10,079 --> 00:41:11,519
como se llaman, LIFO

502
00:41:11,519 --> 00:41:14,000
LIFO, LAST

503
00:41:14,000 --> 00:41:16,059
último en entrar, LAST INPUT

504
00:41:16,059 --> 00:41:18,380
FIRST primero en salir, son estructuras

505
00:41:18,380 --> 00:41:18,800
LIFO

506
00:41:18,800 --> 00:41:21,239
y luego las colas

507
00:41:21,239 --> 00:41:28,719
pues estas son cuando vamos a comprar

508
00:41:28,719 --> 00:41:30,739
a la carnicería

509
00:41:30,739 --> 00:41:32,840
si no hay alguno con un poquito más cara

510
00:41:32,840 --> 00:41:34,760
o que lleva más prisa y pide permiso

511
00:41:34,760 --> 00:41:36,679
lo normal es que el primero que llega

512
00:41:36,679 --> 00:41:38,440
es el primero que se atiende

513
00:41:38,440 --> 00:41:40,840
y llegas tú allí, coges tu

514
00:41:40,840 --> 00:41:44,900
número y tienes el número 1 y llega otro, coge el número 2, otro el número 3,

515
00:41:45,019 --> 00:41:48,579
pues cuando el carnicero quiere atender a uno, dice el número 1, el primero que llegó,

516
00:41:48,659 --> 00:41:52,639
es el primero que atiende. Al contrario que en las pilas, que el último que llega es el primero que

517
00:41:52,639 --> 00:41:56,480
es atendido. Esas estructuras son las FIFO. Entonces,

518
00:41:56,920 --> 00:41:59,780
estas dos estructuras se dan en la algoritmia

519
00:41:59,780 --> 00:42:04,219
muy habitualmente y podemos trabajar con

520
00:42:04,219 --> 00:42:08,519
colecciones de datos un poco bajo este

521
00:42:08,519 --> 00:42:14,920
criterio. ¿Qué colección de datos tiene métodos que nos permiten trabajar con este criterio de

522
00:42:14,920 --> 00:42:34,480
pilas o de colas? Pues la LinkedList. Vamos a hacer una LinkedList, por ejemplo, enteros, integer.

523
00:42:43,849 --> 00:42:50,489
La LinkedList, fijaros, son colecciones que no son ni tree ni set, es decir, admiten duplicados y en

524
00:42:50,489 --> 00:42:59,389
principio no tiene una ordenación especial una colección linkedin leads pues tendrá el método

525
00:42:59,389 --> 00:43:06,750
add como todas las colecciones que le viene heredado de colección pero la link el dis además

526
00:43:06,750 --> 00:43:14,889
como se pueden comportar como en su código que a lo mejor no la tienen todas las colecciones ya que

527
00:43:14,889 --> 00:43:23,289
no todas soportan el concepto de pilas y colas si vamos a hacer primero vamos a trabajar primero con

528
00:43:23,289 --> 00:43:34,289
una con una pila vamos a ver la pila pues las pilas tienen el método push el método push es

529
00:43:34,289 --> 00:43:41,150
el que nos permite ir apilando los elementos es decir saco del fregadero el plato que acabo de

530
00:43:41,150 --> 00:43:45,809
limpiar y lo pongo sobre la encimera. Poner el plato

531
00:43:45,809 --> 00:43:49,989
sobre la encimera es hacer un push. El segundo plato haría un segundo push

532
00:43:49,989 --> 00:43:54,289
que lo pondría sobre el primero. Es decir, va guardando en la colección

533
00:43:54,289 --> 00:43:58,070
los datos bajo el criterio de una

534
00:43:58,070 --> 00:44:00,650
pila. Después, como hemos hecho

535
00:44:00,650 --> 00:44:05,929
una linked list de integers, podría ser de cualquier tipo, igual que estamos

536
00:44:05,929 --> 00:44:09,929
viendo en las colecciones, vamos a poner, por ejemplo, que almacenamos

537
00:44:09,929 --> 00:44:14,650
el dato 4, el siguiente

538
00:44:14,650 --> 00:44:21,110
vamos a poner que anotamos el 6, el siguiente el 2

539
00:44:21,110 --> 00:44:26,690
estamos guardando la información en esta colección

540
00:44:26,690 --> 00:44:30,789
que en particular es de elementos integer, podría ser de cualquier

541
00:44:30,789 --> 00:44:34,050
otro y como queremos hacerlo bajo el criterio de pila

542
00:44:34,050 --> 00:44:39,070
utilizamos el método push de la colección linked list

543
00:44:39,070 --> 00:44:42,530
para recuperar los datos

544
00:44:42,530 --> 00:45:05,300
es decir, ir cogiendo los platos y supuestamente el primero que tendrá que coger, ya que las pilas tienen un criterio LIFO, Last Input, First Output, el último que entra es el primero que sale, si se comporta de verdad bajo el criterio de LIFO, el primero que debería salir sería este el 2, el segundo el 6 y el tercero el 4.

545
00:45:05,300 --> 00:45:30,650
¿Cómo podemos ir recuperando los datos? Pues con el método pop. Este método pop me devolverá un elemento de este tipo, que es el que tiene la colección, y si sigue el comportamiento de pila, tendría que ser el último elemento que hemos metido, que por la secuencia aquí de inserción de elementos sería el 2.

546
00:45:30,650 --> 00:45:35,150
si lo que me devuelve lo voy a meter en un system.println

547
00:45:35,150 --> 00:45:39,489
para de verdad comprobar que se comporta como

548
00:45:39,489 --> 00:45:46,809
una pila, decimos que el método

549
00:45:46,809 --> 00:45:52,340
pop, vamos a sacar un primer elemento y vamos a sacar

550
00:45:52,340 --> 00:45:55,019
un segundo, el primer elemento debería sacarnos este, el segundo

551
00:45:55,019 --> 00:45:58,119
debería sacarnos el 6, hacemos una ejecución

552
00:45:58,119 --> 00:46:01,980
veis el primero que saca es el 2

553
00:46:01,980 --> 00:46:05,059
y el segundo el 6, si saco un tercer

554
00:46:05,059 --> 00:46:11,000
elemento, pues cuál sería, pues el siguiente elemento que tenemos

555
00:46:11,000 --> 00:46:34,829
aquí el 4, 2, 6 y 4. Su comportamiento es como una pila. Sí, os cuento justo esto. Ahora, ¿en qué situación podemos trabajar con una pila? Pues bueno, podemos trabajar con una pila según nos lo demande el ejercicio.

556
00:46:34,829 --> 00:46:46,610
Ahora tenemos una herramienta más ahí en la mochila, que es poder trabajar con pilas de elementos, en este caso, cuyo tipo es integer y en otro caso podría ser de otro tipo.

557
00:46:46,610 --> 00:46:51,030
bueno, preguntabais que si en el momento

558
00:46:51,030 --> 00:46:55,190
que se pierde de la pila el dato, se pierde de la pila si utilizamos el método

559
00:46:55,190 --> 00:46:59,070
pop, si queremos trabajar con el elemento

560
00:46:59,070 --> 00:47:02,010
que toca en la pila, pero que no se pierda de ahí

561
00:47:02,010 --> 00:47:07,550
la colección linked list nos ofrece

562
00:47:07,550 --> 00:47:10,250
otro método diferente que es el system

563
00:47:10,250 --> 00:47:15,170
que es el system.out, no, este lo pongo para que lo podamos ver

564
00:47:15,170 --> 00:47:26,989
por pantalla mi colet punto pic pic nos recupera el elemento que tenemos arriba del todo en la

565
00:47:26,989 --> 00:47:35,090
pila pero no lo elimina de la no lo elimina de tal forma que si por ejemplo aquí cogemos vamos

566
00:47:35,090 --> 00:47:42,289
a poner el pic aquí qué comportamiento sería el previsible del programa ahora lo comprobamos

567
00:47:42,289 --> 00:48:07,670
Aquí hacemos un pop, nos cogerá el último elemento. Como es un pop, este elemento lo eliminará de la pila y se vendrá aquí. En este caso hacemos un pick. Este pick, al tener ahora mismo el dedito que apunta a la pila en el 6, nos devolverá un 6, pero al ser un pick y no ser un pop, no elimina el 6.

568
00:48:07,670 --> 00:48:09,710
con lo cual aquí es previsible que nos muestre

569
00:48:09,710 --> 00:48:11,550
el 6 y luego este pop es previsible

570
00:48:11,550 --> 00:48:13,650
que nos vuelva a mostrar el 6 y este siguiente

571
00:48:13,650 --> 00:48:15,769
pop que nos muestre ya el 4

572
00:48:15,769 --> 00:48:17,690
eso es lo que yo creo que debería

573
00:48:17,690 --> 00:48:19,650
pasar, vamos a hacer una ejecución y comprobamos

574
00:48:19,650 --> 00:48:23,550
mirad, primero nos saca

575
00:48:23,550 --> 00:48:25,570
este system out, el dato

576
00:48:25,570 --> 00:48:27,670
que recogemos de aquí, que es un 2

577
00:48:27,670 --> 00:48:29,809
el 2, el último que había entrado

578
00:48:29,809 --> 00:48:31,429
el pick

579
00:48:31,429 --> 00:48:33,530
recupera el siguiente, donde está

580
00:48:33,530 --> 00:48:35,469
apuntando ahora el indicador en la pila

581
00:48:35,469 --> 00:48:37,550
que es el 6, pero no avanza porque luego

582
00:48:37,550 --> 00:48:41,610
el siguiente pop vuelve a ofrecernos para mostrar

583
00:48:41,610 --> 00:48:45,989
el system out, el 6, pero en este caso sí, es un pop, entonces avanzamos

584
00:48:45,989 --> 00:48:49,289
y el siguiente pop ya nos muestra un 4, entonces con pick

585
00:48:49,289 --> 00:48:55,780
cogemos el dato, pero no lo muestra, mira, si fuera una pila

586
00:48:55,780 --> 00:48:59,420
de personas

587
00:48:59,420 --> 00:49:09,099
volver un poco más a la variedad, personas, pues aquí meteríamos en la

588
00:49:09,099 --> 00:49:16,280
pila, mi per 1 y mi per 2, las dos personas

589
00:49:16,280 --> 00:49:25,039
que tenemos aquí vale hemos metido dos personas entonces ahora si hacemos un pop lo que haría

590
00:49:25,039 --> 00:49:30,179
se recupera sería recuperar esta primera persona de lo que podríamos hacer aquí fijaros en este

591
00:49:30,179 --> 00:49:38,519
caso como no es tan directo podríamos decir persona de aus es igual y hacemos un poco esto

592
00:49:38,519 --> 00:49:45,480
me devolverá este pop la primera de las personas la referencia a la primera de las personas que

593
00:49:45,480 --> 00:49:47,500
apuntará a PAUS y ahora podemos hacer aquí

594
00:49:47,500 --> 00:49:50,119
un System of Println

595
00:49:50,119 --> 00:49:51,659
de este PAUS

596
00:49:51,659 --> 00:49:53,440
que estará apuntando a la primera de las

597
00:49:53,440 --> 00:49:55,219
personas que me ha devuelto la pila

598
00:49:55,219 --> 00:49:56,900
que será la última que metimos

599
00:49:56,900 --> 00:49:58,619
es previsible que sea PER2

600
00:49:58,619 --> 00:50:01,119
vamos a poner los datos para poder

601
00:50:01,119 --> 00:50:02,599
identificarlos

602
00:50:02,599 --> 00:50:09,579
que será PER2, que PER2

603
00:50:09,579 --> 00:50:11,119
tiene por nombre

604
00:50:11,119 --> 00:50:13,739
Miguel, entonces si hacemos ahora aquí un System

605
00:50:13,739 --> 00:50:14,679
of Println

606
00:50:14,679 --> 00:50:18,489
de PAUS

607
00:50:18,489 --> 00:50:22,199
punto ese nombre

608
00:50:22,199 --> 00:50:26,219
lo previsible es que nos diga que ese

609
00:50:26,219 --> 00:50:33,380
es Miguel, si luego cogemos y cogemos de la pila

610
00:50:33,380 --> 00:50:41,019
bueno, hacemos, mira en lugar de

611
00:50:41,019 --> 00:50:44,880
este, para ver todos los métodos vamos a hacer aquí un pick primero

612
00:50:44,880 --> 00:50:48,659
que nos coja este, pero no avance la pila, con lo cual

613
00:50:48,659 --> 00:50:52,340
se supone que peaus será per2, luego hacemos un pop

614
00:50:52,340 --> 00:50:56,920
y peaus volverá a ser per2, vamos a mostrar de nuevo

615
00:50:56,920 --> 00:50:59,280
dos veces el nombre de Miguel. Y luego

616
00:50:59,280 --> 00:51:01,920
hacemos un nuevo pop

617
00:51:01,920 --> 00:51:06,320
que nos muestre ya el nombre de PAUS, este nuevo pop

618
00:51:06,320 --> 00:51:08,639
ya sería pop1 porque

619
00:51:08,639 --> 00:51:12,300
este pop habría hecho avanzar al penúltimo

620
00:51:12,300 --> 00:51:14,699
de los elementos que tenemos en la pila.

621
00:51:17,460 --> 00:51:19,699
¿Veis? Entonces tenemos dos Miguel y un PAUS.

622
00:51:25,760 --> 00:51:28,380
No sé si lo veis, pero que sí.

623
00:51:30,610 --> 00:51:33,190
Si queremos que, avanzo si no me decís

624
00:51:33,190 --> 00:51:37,010
nada, si queremos que el comportamiento en lugar de una pila

625
00:51:37,010 --> 00:51:45,780
que tiene esa forma sea una cola, es decir, su comportamiento

626
00:51:45,780 --> 00:51:49,199
sea fifo, los cambios respecto a la pila

627
00:51:49,199 --> 00:51:53,159
son muy pocos, luego funcionalmente nos dará ese otro comportamiento

628
00:51:53,159 --> 00:51:57,280
que será el que querremos, pero son muy pocos, a la hora de hacer las inserciones

629
00:51:57,280 --> 00:52:02,369
lo que tenemos que hacer es en lugar de utilizar el método pub

630
00:52:02,369 --> 00:52:06,230
push, podemos utilizar el método que tenemos

631
00:52:06,230 --> 00:52:17,429
siempre para las colecciones el método ata porque los linked list tiene una ordenación no según

632
00:52:17,429 --> 00:52:23,829
nuestro criterio como sería si fuera un tri pero sí según el criterio de inserción entonces el

633
00:52:23,829 --> 00:52:29,670
hecho de cambiar esto al crítica este criterio lo que hace es que nuestra colección tenga linked

634
00:52:29,670 --> 00:52:33,949
list tenga el comportamiento típico de cuando vamos a la carnicería que el primero que coge

635
00:52:33,949 --> 00:52:37,050
el ticket para el turno, pues es el primero que llaman.

636
00:52:39,750 --> 00:52:41,329
Entonces, si ahora aquí metemos Miper

637
00:52:41,329 --> 00:52:45,329
antes que Miper2,

638
00:52:45,570 --> 00:52:47,409
estaremos metiendo Agus antes que Miguel

639
00:52:47,409 --> 00:52:51,389
y ahora al hacer aquí el pop o el pick

640
00:52:51,389 --> 00:52:54,369
nos dirá Agus, Agus, Miguel, la ejecución.

641
00:52:57,159 --> 00:52:57,719
Ahí lo tenéis.

642
00:52:58,340 --> 00:53:00,480
Su comportamiento ya es según una cola.

643
00:53:01,079 --> 00:53:01,440
FIFO.

644
00:53:09,599 --> 00:53:13,820
No sé si tenéis alguna cosa por ahí.

645
00:53:19,409 --> 00:53:19,510
No.

646
00:53:21,449 --> 00:53:33,849
Vale, pues avanzamos un poquito más y nos vamos a, de momento vamos a dejar aparcados las colecciones y vamos a hablar un poco de los mapas.

647
00:53:34,809 --> 00:53:37,449
¿Cuál es la diferencia principal entre una colección y un mapa?

648
00:53:37,449 --> 00:53:53,019
Una colección almacena datos de tipos a través de grupos primitivos o referenciados, pero un solo dato.

649
00:53:53,280 --> 00:53:57,500
el dato que almacena, pues será así, pues será de tipo string o de lo que sea.

650
00:53:57,639 --> 00:54:03,219
Los mapas lo que hacen es que en su estructura de memoria guardan pares.

651
00:54:04,679 --> 00:54:10,380
Y estos pares, bueno, pues son, hay un primero y separado de una coma, un segundo.

652
00:54:12,889 --> 00:54:17,349
Cualquiera de estos dos puede ser de cualquier tipo, al igual que el tema de las colecciones.

653
00:54:18,750 --> 00:54:24,210
Con la diferencia de que este primero se convierte en una clave que identifica el segundo de los datos.

654
00:54:24,590 --> 00:54:37,900
Yo creo que se entiende, el otro día lo comentaba, si pensamos en un array de los que conocemos, entre los corchetes, para acceder a uno, si es un array de enteros,

655
00:54:37,900 --> 00:54:48,139
para acceder a uno u otro, aquí lo que ponemos es un numerito que va de 0 hasta la longitud del array menos 1.

656
00:54:48,139 --> 00:55:02,800
Pues esto en ese caso vendría a ser el criterio para acceder al elemento. El tipo de elementos en el array al que estamos accediendo sería este segundo que identificamos aquí en el mapa y el primero sería este.

657
00:55:02,800 --> 00:55:21,119
En un array solamente este primero podría ser de tipo integer, porque los índices de los arrays son siempre posicionales, pero en un mapa puede ser cualquier tipo, puede ser la clave que no se puede nunca repetir, podrá ser un string, podrá ser lo que sea.

658
00:55:21,119 --> 00:55:25,519
en una clase persona, si tuviéramos un mapa de la clase persona

659
00:55:25,519 --> 00:55:29,940
¿quién podría ser un típico candidato en la mayor parte de los mapas

660
00:55:29,940 --> 00:55:33,199
en los que trabajas en personas? Pues su DNI, los DNI son

661
00:55:33,199 --> 00:55:38,079
números o combinaciones de números y una letra al final

662
00:55:38,079 --> 00:55:41,900
que nos identifica a cada uno y que además no hay posibilidad

663
00:55:41,900 --> 00:55:45,860
de repetirlo, aquí podría ser el DNI, pero ya digo que puede ser cualquier cosa

664
00:55:45,860 --> 00:55:49,760
si nosotros definimos un mapa

665
00:55:49,760 --> 00:55:56,670
con estas características, pues resulta que podría tener en este mapa

666
00:55:56,670 --> 00:55:58,949
una entrada cada uno de los DNIs.

667
00:55:59,530 --> 00:56:03,929
Yo, con mi objeto persona, con mi dato, mi edad, mi nombre,

668
00:56:04,090 --> 00:56:10,469
los atributos que tenga la clase persona, en este mapa estoy identificado por mi DNI.

669
00:56:10,869 --> 00:56:13,050
Cualquier otra persona está identificado por su DNI.

670
00:56:13,610 --> 00:56:17,929
Para acceder a todos mis datos, desde el mapa puedo hacer un get

671
00:56:17,929 --> 00:56:22,650
y decirle que lo haga y meter el dato de mi DNI

672
00:56:22,650 --> 00:56:26,610
y que me devolverá el objeto persona que está almacenado en el mapa

673
00:56:26,610 --> 00:56:28,329
asociado a mi clave.

674
00:56:28,630 --> 00:56:31,389
Igual que aquí, en el array, poníamos una posición

675
00:56:31,389 --> 00:56:34,110
y nos devolvía un objeto de la clase persona también,

676
00:56:34,210 --> 00:56:35,150
si es un array de personas.

677
00:56:38,989 --> 00:56:44,570
Las colecciones hablábamos de aquellas que permiten duplicados

678
00:56:44,570 --> 00:56:46,769
y sin orden.

679
00:56:47,949 --> 00:56:49,949
Y luego los otros criterios que teníamos eran

680
00:56:49,949 --> 00:57:00,480
sin duplicados y sin duplicados y además y ordenados.

681
00:57:03,690 --> 00:57:07,210
Los mapas, el tema de los duplicados no ha lugar.

682
00:57:07,610 --> 00:57:09,530
Todos los mapas son sin duplicados.

683
00:57:12,679 --> 00:57:17,480
Y el criterio para mirar a ver si hay duplicados es la clave, este primero.

684
00:57:18,699 --> 00:57:24,679
Tú si pones para una persona, haces trampas y dices una misma persona con sus datos

685
00:57:24,679 --> 00:57:27,760
tiene tres DNIs, podrás tener tres entradas ahí.

686
00:57:28,860 --> 00:57:32,880
Lo que nunca podrás tener es, incluso siendo dos diferentes personas,

687
00:57:33,579 --> 00:57:37,099
el mismo DNI para diferentes objetos de la clase Persona.

688
00:57:39,630 --> 00:57:42,130
Y teniendo en consideración que nunca permite duplicados,

689
00:57:44,369 --> 00:57:49,230
lo que sí que puede estar es ordenados o sin orden.

690
00:57:50,610 --> 00:57:54,210
Si tienen un orden establecido a través de un criterio

691
00:57:54,210 --> 00:57:58,170
que tengamos nosotros como requisito en el programa

692
00:57:58,170 --> 00:58:02,010
serán los tree, otra vez, en este caso los tree map

693
00:58:02,010 --> 00:58:08,320
pues nada, vamos a implementar un mapa

694
00:58:08,320 --> 00:58:13,000
y vemos ahí un ejemplo de como podemos trabajar

695
00:58:13,000 --> 00:58:25,730
un poco con él, y vamos a empezar

696
00:58:25,730 --> 00:58:29,389
haciendo un mapa de

697
00:58:29,389 --> 00:58:35,630
un mapa que no está ordenado, un hash map

698
00:58:35,630 --> 00:59:05,659
Vamos a poner, por ejemplo, para empezar, que su clave sea un integer y que almacene un integer. MiMapa, metemos de la librería Java útil el HashMap y ahí lo tenemos.

699
00:59:05,659 --> 00:59:09,840
como podemos añadir elementos a un mapa

700
00:59:09,840 --> 00:59:11,519
pues ponemos mi mapa

701
00:59:11,519 --> 00:59:15,300
punto put, el método put

702
00:59:15,300 --> 00:59:18,239
fijaros que ahora me pide dos atributos, uno es la clave

703
00:59:18,239 --> 00:59:21,880
y otro es el valor que quiero meter

704
00:59:21,880 --> 00:59:24,519
entonces digo put y digo

705
00:59:24,519 --> 00:59:27,800
con la clave 1 que meta un 10

706
00:59:27,800 --> 00:59:34,340
con la clave 2 que meta un 20

707
00:59:34,340 --> 00:59:37,599
ahora voy a decir que con la clave 1 meta un 30

708
00:59:37,599 --> 00:59:40,099
repitiendo clave de aquí

709
00:59:40,099 --> 00:59:45,719
con la clave 3 que meta a 40

710
00:59:45,719 --> 00:59:48,659
estos datos por los que nos fuera pidiendo el programa

711
00:59:48,659 --> 00:59:50,519
y con la clave 4 que meta en 50

712
00:59:50,519 --> 00:59:57,230
si hago un system.out.println

713
00:59:57,230 --> 01:00:01,849
del mapa, miMapa.site

714
01:00:01,849 --> 01:00:04,730
pues es de esperar que tengamos

715
01:00:04,730 --> 01:00:06,949
como el criterio es la clave

716
01:00:06,949 --> 01:00:08,769
y nunca permite repetidos

717
01:00:08,769 --> 01:00:10,690
que tengamos 1, 2, 3 y 4

718
01:00:10,690 --> 01:00:12,849
porque este no lo considerará

719
01:00:12,849 --> 01:00:13,949
al estar metido este

720
01:00:13,949 --> 01:00:27,070
En realidad los mapas yo creo que nos actualizará el valor, mantendrá esta clave pero el mecanismo de actualización es a través de un put, es decir no mete un nuevo registro pero yo creo que el valor final que va a tener va a ser este, ahora después lo comprobamos.

721
01:00:27,989 --> 01:00:36,909
Vamos a hacer una primera ejecución, me dice que tengo cuatro elementos, uno, dos, tres y cuatro, este no ha metido dos entradas con esta clave.

722
01:00:36,909 --> 01:01:10,840
Si queremos recorrer el mapa, hay un mecanismo para hacer un iterador y otro con los for estos más rápidos, pues podemos decir for, vamos a decir que, integer, ahora repasamos justo esta instrucción que estamos metiendo, mi clave del mapa, mi mapa, tiene un método que es el kset, que es el conjunto de claves,

723
01:01:10,840 --> 01:01:16,409
aquí lo que estamos diciendo es

724
01:01:16,409 --> 01:01:23,679
estamos diciendo

725
01:01:23,679 --> 01:01:26,880
para todo el conjunto

726
01:01:26,880 --> 01:01:27,880
de claves del mapa

727
01:01:27,880 --> 01:01:30,480
ves una a una

728
01:01:30,480 --> 01:01:32,679
cargándolo en la variable

729
01:01:32,679 --> 01:01:34,099
mi clave y mi clave

730
01:01:34,099 --> 01:01:36,480
es de tipo integer porque

731
01:01:36,480 --> 01:01:38,599
las claves que tiene el mapa

732
01:01:38,599 --> 01:01:40,860
hemos hecho aquí que sean de tipo integer

733
01:01:40,860 --> 01:01:46,030
entonces aquí para

734
01:01:46,030 --> 01:01:48,090
coger el valor fijaros el mapa tiene

735
01:01:48,090 --> 01:01:50,050
el conjunto de claves a través del método

736
01:01:50,050 --> 01:01:52,250
case cell lo podemos recuperar para recorrer

737
01:01:52,250 --> 01:01:57,210
todos ellos y el tipo de datos que nos devuelve fijaros es también de tipo entero en este caso

738
01:01:57,210 --> 01:02:03,650
entonces podemos decir mira devuelve voy a cargar mi val aquí en una variable de tipo entero y vamos

739
01:02:03,650 --> 01:02:10,670
a decir mi clave mi clave en cada una de las iteraciones del ford será una de las claves

740
01:02:10,670 --> 01:02:16,889
que me está devolviendo el case set del mapa el conjunto de claves que tiene el mapa punto

741
01:02:16,889 --> 01:02:18,849
.get

742
01:02:18,849 --> 01:02:26,519
.get

743
01:02:26,519 --> 01:02:28,659
de la variable

744
01:02:28,659 --> 01:02:33,920
mi clave, .get

745
01:02:33,920 --> 01:02:42,530
no, perdón

746
01:02:42,530 --> 01:02:43,130
el mapa

747
01:02:43,130 --> 01:02:45,349
mapa.get

748
01:02:45,349 --> 01:02:47,590
mirad esto

749
01:02:47,590 --> 01:02:50,210
si lo intentamos llevar

750
01:02:50,210 --> 01:02:52,530
conceptualmente a lo que conocemos de los

751
01:02:52,530 --> 01:02:54,210
arrays, pues imaginaos que tenemos

752
01:02:54,210 --> 01:02:55,230
un array de integers

753
01:02:55,230 --> 01:03:06,019
que tiene esta definición

754
01:03:06,019 --> 01:03:09,969
bueno, le hemos hecho un new

755
01:03:09,969 --> 01:03:16,070
le hemos metido datos vamos a suponer entonces el array sería mirar el nombre del array para

756
01:03:16,070 --> 01:03:23,530
acceder al primero al segundo de los elementos y aquí pondríamos un 2 pues este 2 es el que

757
01:03:23,530 --> 01:03:28,389
estamos poniendo aquí como clave la clave es cada una de las claves que tiene el mapa cuando estamos

758
01:03:28,389 --> 01:03:35,699
recorriendo el ford que será cada una de estas que hemos metido en el punto y que nos devuelve

759
01:03:35,699 --> 01:03:40,400
esto, el nombre del array y aquí decimos del mapa

760
01:03:40,400 --> 01:03:44,420
para el mapa dame esta clave con el get y que me está

761
01:03:44,420 --> 01:03:48,460
devolviendo, pues me está devolviendo el dato que tenga, en este caso es de tipo integer

762
01:03:48,460 --> 01:03:51,699
nos está cargando aquí en una variable de tipo integer

763
01:03:51,699 --> 01:03:56,940
ahora si hacemos aquí un system.out.println

764
01:03:56,940 --> 01:04:03,769
de mi val, pues nada, hacemos un recorrido

765
01:04:03,769 --> 01:04:07,469
de todos los elementos que tiene ese mapa, fijaros los datos

766
01:04:07,469 --> 01:04:10,889
que me muestra son 30, 20, 40 y 50.

767
01:04:11,369 --> 01:04:14,849
Es decir, para este, no ha metido un duplicado,

768
01:04:15,010 --> 01:04:17,250
pero el dato que ha terminado metiendo es este, ¿veis?

769
01:04:20,960 --> 01:04:21,440
Un 30.

770
01:04:24,469 --> 01:04:25,329
Es decir, lo ha sobrescrito.

771
01:04:25,429 --> 01:04:28,190
No permite duplicados, pero el put, en este caso,

772
01:04:28,269 --> 01:04:31,190
lo que hace es sobrescribirlo, no ignorarlo porque ya existe

773
01:04:31,190 --> 01:04:32,349
un elemento dentro del mapa.

774
01:04:35,909 --> 01:04:41,670
Otro pasito más para trasladarlo a código un poco más,

775
01:04:42,409 --> 01:04:43,550
que nos dé más alternativas.

776
01:04:43,550 --> 01:04:50,150
Imaginaos que tenemos un mapa de, por ejemplo, íntegros, pero cuyos elementos son de la clase persona.

777
01:05:03,920 --> 01:05:11,179
Indicamos aquí por dos sitios y ahora el put, nos volvemos a traer las dos personas que tenemos por aquí, dar de alta ya más veces.

778
01:05:18,000 --> 01:05:25,199
Fijaros cómo ella se queja, ¿por qué? Porque es verdad que la clave es íntegro, pero el dato es de persona, entonces vamos a meterle persona aquí.

779
01:05:25,199 --> 01:05:34,449
bueno, vamos a hacer otra cosa antes

780
01:05:34,449 --> 01:05:39,820
no lo voy a eliminar esto

781
01:05:39,820 --> 01:05:41,980
pero porque me vale la estructura

782
01:05:41,980 --> 01:05:44,159
que tengo de antes, va a ser más rápido

783
01:05:44,159 --> 01:05:45,880
que no luego volver a escribir

784
01:05:45,880 --> 01:05:50,159
todo el código, bueno he vuelto al ejercicio

785
01:05:50,159 --> 01:05:51,860
de antes, veis, el mapa vuelve a ser

786
01:05:51,860 --> 01:05:53,840
de enteros y estamos

787
01:05:53,840 --> 01:05:55,199
metiendo datos de enteros

788
01:05:55,199 --> 01:05:57,900
estábamos trabajando con un hash map

789
01:05:57,900 --> 01:06:00,199
no permite

790
01:06:00,199 --> 01:06:02,000
duplicados, es verdad, por clave

791
01:06:02,000 --> 01:06:03,880
como hemos comprobado, ningún mapa lo permite

792
01:06:03,880 --> 01:06:06,219
este 4 es de este size, es del tamaño

793
01:06:06,219 --> 01:06:15,260
y luego cada uno de los datos, pero si yo utilizo un tree map

794
01:06:15,260 --> 01:06:19,280
¿qué es lo que mete el tree? pues el tree lo que nos

795
01:06:19,280 --> 01:06:30,769
mete es orden, ¿verdad? voy a importar

796
01:06:30,769 --> 01:06:36,650
con un tree map lo que nos mete es orden, ¿orden bajo qué criterio?

797
01:06:36,710 --> 01:06:39,769
bajo el criterio del integer, entonces

798
01:06:39,769 --> 01:06:44,829
justo los había puesto ordenados aquí

799
01:06:44,829 --> 01:06:49,460
a la hora de insertarlos, voy a volver al hash map

800
01:06:49,460 --> 01:06:54,420
y lo voy a insertar de forma desordenada para hacer una ejecución

801
01:06:54,420 --> 01:06:57,519
con desorden, meto primero el 3

802
01:06:57,519 --> 01:07:08,630
luego el 2, voy a quitar este 1

803
01:07:08,630 --> 01:07:14,130
ya el tema del duplicado ya lo hemos comprobado, meto el 3, el 2, el 1 y el 4

804
01:07:14,130 --> 01:07:17,090
con un hashMap hago una ejecución

805
01:07:17,090 --> 01:07:27,639
vaya me lo ha sacado aquí, busca un criterio de ordenación

806
01:07:27,639 --> 01:07:32,159
el hashMap, ah bueno porque busca un criterio de ordenación

807
01:07:32,159 --> 01:07:33,820
propio de este.

808
01:07:40,480 --> 01:07:41,920
Bueno, pues el HashMap

809
01:07:41,920 --> 01:07:44,079
me lo está ordenando también según el criterio

810
01:07:44,079 --> 01:07:46,079
este, bajo este criterio

811
01:07:46,079 --> 01:07:48,019
de ordenación. Curioso.

812
01:07:50,809 --> 01:07:51,789
No esperaba yo que lo fuera

813
01:07:51,789 --> 01:07:53,849
a hacer esto. Bueno, pues

814
01:07:53,849 --> 01:07:55,929
nos hace esto. Si le metemos un TRIMAP

815
01:07:55,929 --> 01:07:57,949
pues nos va a dar lo mismo, porque ya estoy viendo que lo está

816
01:07:57,949 --> 01:08:05,840
metiendo ordenado. Un TRIMAP

817
01:08:05,840 --> 01:08:07,599
sí que claramente

818
01:08:07,599 --> 01:08:11,219
hace esto. Vamos a meter

819
01:08:11,219 --> 01:08:11,579
aquí

820
01:08:11,579 --> 01:08:15,079
vamos a irnos a un HashMap

821
01:08:15,079 --> 01:08:18,020
y a un trimap, pero de la clase persona, para intentar ver la diferencia

822
01:08:18,020 --> 01:08:24,560
entre los dos. HisMap de la clase persona.

823
01:08:28,829 --> 01:08:30,850
Porque con el tipo integer

824
01:08:30,850 --> 01:08:32,250
se han comportado los dos igual.

825
01:08:36,239 --> 01:08:54,829
Deja un poco descolocado, porque yo pensaba que el orden

826
01:08:54,829 --> 01:08:59,430
lo iba a poner no según el dato, sino según

827
01:08:59,430 --> 01:09:02,250
la clave. Y claro, los ha ordenado según el dato.

828
01:09:05,029 --> 01:09:07,090
A ver, bueno, vamos a ir investigando.

829
01:09:07,369 --> 01:09:08,850
Nos sirve para investigarlo.

830
01:09:10,510 --> 01:09:12,710
De tal forma, si no llegamos a una conclusión definitiva,

831
01:09:12,710 --> 01:09:32,920
luego intento echarle un ojo y os digo por el foro. Yo pensaba que desde luego el criterio de duplicado sí que está utilizando la clave, sí o sí, y yo pensaba que el criterio de orden de todo el mapa iba a ser según la clave, pero por lo que estamos viendo aquí no, está utilizando como criterio de orden el dato.

832
01:09:32,920 --> 01:09:36,720
nos lo ha ordenado tanto con el hash map como con el tree map

833
01:09:36,720 --> 01:09:40,760
al 10, 20, 40, 50, que no es precisamente el orden

834
01:09:40,760 --> 01:09:49,340
en el que habíamos insertado por aquí, ah bueno, pero también tiene justo este mismo

835
01:09:49,340 --> 01:09:55,899
orden, la clave, perdonad que estoy aquí divagando un poco

836
01:09:55,899 --> 01:10:03,359
vamos por lo menos a comprobar que el criterio de ordenación lo hace a través

837
01:10:03,359 --> 01:10:05,239
de clave, el hash map

838
01:10:05,239 --> 01:10:19,930
bien, vamos a poner

839
01:10:19,930 --> 01:10:24,189
es que justo ha coincidido que fijaros, aunque aquí nos ha mostrado un 10

840
01:10:24,189 --> 01:10:28,109
que me estaba haciendo a mí dudar que el dato era el criterio de ordenación, resulta que el 10

841
01:10:28,109 --> 01:10:32,170
tiene el 1, que el 20 tiene el 2, el siguiente

842
01:10:32,170 --> 01:10:36,270
muestra es el 40 que tiene el 3 y el siguiente muestra es el 50 que tiene el 5

843
01:10:36,270 --> 01:10:38,949
entonces coincide el orden tanto del dato como de la clave

844
01:10:38,949 --> 01:10:44,329
entonces voy a poner aquí un 1, un 1 solo

845
01:10:44,329 --> 01:10:47,829
y vamos a ver si el tercero que muestra es el 1, entonces es

846
01:10:47,829 --> 01:11:23,539
el criterio de ordenación lo hace a través de la clave, no me muestra ninguno porque he comentado aquí, efectivamente, bueno, efectivamente ordena el HashMap, pero los criterios de ordenación y de duplicados son a través de la clave, porque fijaros como ahora, este que en cuanto a clave es el tercero, es el tercero que nos aparece a pesar de que uno es menor que algunos de los datos que hay por aquí y menor que el último también, y aparece por ahí, es decir, el criterio de ordenación es por clave, eso sí.

847
01:11:23,539 --> 01:11:44,159
Vamos a ver, como el criterio de ordenación es por la persona, si queremos trabajar nosotros según nuestro criterio el orden del trimap, tendremos que poner algo aquí que sea ordenable a cuyo código podamos llegar nosotros,

848
01:11:44,159 --> 01:11:51,399
si no siempre va a trabajar por el código que tenemos en la librería de Java en la clase integer.

849
01:11:51,560 --> 01:11:53,180
Entonces vamos a decir lo contrario.

850
01:11:53,340 --> 01:12:01,140
Mirad, que esté ordenado por persona, es decir, la clave sea una persona y el dato sea un integer.

851
01:12:38,539 --> 01:12:50,960
Como se supone que va a estar ordenado por la clase persona, vamos a ponerlo aquí igual.

852
01:12:57,829 --> 01:12:58,710
Vamos a aumentar por aquí.

853
01:12:58,710 --> 01:13:12,810
el criterio para ver cómo el mapa ordena dos personas

854
01:13:12,810 --> 01:13:16,770
pues volverá a ser el que tengamos aquí

855
01:13:16,770 --> 01:13:23,590
en el compare to, entonces retomamos aquí el implement comparable

856
01:13:23,590 --> 01:13:31,649
ahora se nos queja porque tenemos que descomentar aquí

857
01:13:31,649 --> 01:13:39,500
el compare to, y el primer criterio que tenemos para ordenar es la edad

858
01:13:39,500 --> 01:13:41,699
en el trimap

859
01:13:41,699 --> 01:14:00,670
le falta por aquí una llave

860
01:14:00,670 --> 01:14:13,159
y le falta un return

861
01:14:13,159 --> 01:14:19,180
vale, por aquí lo tenemos, ya nos compila

862
01:14:19,180 --> 01:14:29,279
entonces vamos a añadir ahora al mapa las dos personas

863
01:14:29,279 --> 01:14:36,039
que tenemos, que son estas dos, que tendrán que estar por encima

864
01:14:36,039 --> 01:14:52,710
del momento en el que las añadimos, fijaros en este

865
01:14:52,710 --> 01:14:56,390
según la definición de este ejercicio ahora, la clave es una persona

866
01:14:56,390 --> 01:15:00,710
y añadimos un integer como dato

867
01:15:00,710 --> 01:15:10,710
Es una situación funcional quizás un poco rara, es más normal que sea un entero aquí, para el que sea el DNI y la persona, pero nos vamos a retorcer un poco para ver cómo trabaja.

868
01:15:15,979 --> 01:15:20,239
Vamos a ver aquí el tamaño.

869
01:15:21,279 --> 01:15:35,159
En principio esta persona y esta son diferentes porque aquí tenemos la misma edad, vamos a poner diferente edad, 20.

870
01:15:35,159 --> 01:15:43,020
Entonces serían dos personas diferentes porque lo que estamos comparando en el compare aquí de las compare tú de las personas es la edad de las dos.

871
01:15:43,779 --> 01:15:50,180
Si damos aquí una ejecución, nos dice que el tamaño es dos, es decir, se añaden las dos personas perfectamente.

872
01:15:50,880 --> 01:15:56,939
Si ponemos aquí que sea la misma edad, nos dice dos.

873
01:15:58,000 --> 01:16:01,060
Pues no está mirando, si pasa por aquí por el compare tú, a ver.

874
01:16:01,060 --> 01:16:03,960
vale, lo que sucede es que

875
01:16:03,960 --> 01:16:08,380
en caso de tener la misma edad, compara el nombre

876
01:16:08,380 --> 01:16:14,439
lo que tenemos en el compareto, entonces si a los dos lo llamamos Agus

877
01:16:14,439 --> 01:16:20,340
también, en la clase persona, estamos diciendo

878
01:16:20,340 --> 01:16:23,020
que dos personas son iguales cuando tienen la misma edad

879
01:16:23,020 --> 01:16:31,890
y tienen el mismo nombre, en ese caso se ha ido a uno

880
01:16:31,890 --> 01:16:36,569
es decir, la clave para mirar si están duplicados

881
01:16:36,569 --> 01:16:45,670
en un mapa va según el criterio de la clave y en la clave esta hemos dicho que dos personas son

882
01:16:45,670 --> 01:16:50,029
iguales según lo que hemos codificado aquí al implementar igual que hacemos en las colecciones

883
01:16:50,029 --> 01:16:56,609
el interfaz comparable dentro del código compare tú que hemos dicho que dos personas sean iguales

884
01:16:56,609 --> 01:17:02,770
aquí se devuelve a un cero que es a lo que lo iniciamos aquí cuando dos personas con la misma

885
01:17:02,770 --> 01:17:11,500
edad tienen el mismo nombre es el único caso en el que no se modifica el valor diva al def si ya

886
01:17:11,500 --> 01:17:19,159
tienen diferente edad ya nos inserta las dos y fijaros como nos muestra el pasa por aquí porque

887
01:17:19,159 --> 01:17:24,800
efectivamente la comprobación la está haciendo mediante la llamada al compare tú con esta traza

888
01:17:30,899 --> 01:17:39,659
como es un trimap se entiende que el criterio para ordenar los mapas se basan en la clave y

889
01:17:39,659 --> 01:17:46,000
Y al basarse en la clave, aunque el HashMap también habíamos visto que hacía algo parecido y no es un TRIMAP.

890
01:17:46,640 --> 01:17:49,140
No sé si es por orden de inserción por lo que no lo estaba poniendo.

891
01:17:49,859 --> 01:17:55,840
Bueno, el TRIMAP se basa en la, en principio es así que por definición la clave sí o sí.

892
01:17:56,340 --> 01:18:02,699
Entonces al basarse en la clave, mira el compare tú y ordenará según este criterio.

893
01:18:02,939 --> 01:18:06,279
En principio la edad y segundo el nombre.

894
01:18:06,279 --> 01:18:27,710
Entonces, si ahora cogemos y mostramos aquí los datos, vamos a hacer un recorrido de todo el mapa, les comentamos por aquí, y decimos, vamos a recuperar cada una de las claves que tiene el mapa.

895
01:18:27,710 --> 01:18:32,810
Pero cada una de las claves ahora ya no son Integer, son personas.

896
01:18:33,590 --> 01:18:36,449
Entonces, para cada una de las personas que se mete aquí,

897
01:18:37,289 --> 01:18:47,060
obtén de la clave y lo que devuelve es un entero, Integer.

898
01:18:50,229 --> 01:18:50,750
Ahí está.

899
01:18:51,710 --> 01:18:53,149
Y lo que hacemos es mostrarlo por pantalla.

900
01:18:53,510 --> 01:19:01,130
Fijaros cómo para la primera de las personas, que es Agus,

901
01:19:01,130 --> 01:19:04,329
hemos metido un valor de un 1 y para la segunda de las personas,

902
01:19:04,430 --> 01:19:10,819
que es Miguel, hemos metido un valor 20

903
01:19:10,819 --> 01:19:13,640
que son los dos valores que estamos intentando recuperar por aquí

904
01:19:13,640 --> 01:19:18,460
vamos a ejecutar por aquí, bueno, me muestra

905
01:19:18,460 --> 01:19:22,640
dice 2 el tamaño, aquí está con las comparaciones pasando por ahí

906
01:19:22,640 --> 01:19:26,500
y me devuelve 1 y 20, este 1 y este 20

907
01:19:26,500 --> 01:19:30,779
son estos dos datos y me los ha devuelto según el criterio de orden

908
01:19:30,779 --> 01:19:33,500
que tenemos para mi per y mi per2

909
01:19:33,500 --> 01:19:38,439
si cambiamos la edad aquí, fijaros que acordaros que el primer

910
01:19:38,439 --> 01:19:41,399
criterio de ordenación era a través de la edad

911
01:19:41,399 --> 01:19:46,239
con mi per a dos

912
01:19:46,239 --> 01:19:50,560
de edad, me ha dicho que el primero de ellos era el que tenía

913
01:19:50,560 --> 01:19:54,380
como dato un uno y el segundo el que tenía un veinte

914
01:19:54,380 --> 01:19:58,500
si le cambiamos la edad aquí y ponemos aquí veintidós para que esta edad ahora sea mayor que esta

915
01:19:58,500 --> 01:20:02,359
es de esperar que estos dos datos estén intercambiados en cuanto

916
01:20:02,359 --> 01:20:05,880
al orden, entonces fijaros como ahora pone aquí 20 y aquí 1

917
01:20:05,880 --> 01:20:13,850
y ahora ya lo único que nos queda es comprobar a ver que

918
01:20:13,850 --> 01:20:18,890
hace con un HashMap, habría que ir a la teoría a ver como se comporta

919
01:20:18,890 --> 01:20:22,489
en cuanto al orden los HashMap, vamos a ver que hace, bueno fijaros

920
01:20:22,489 --> 01:20:27,090
aquí ya con el, cuando la clave era un entero

921
01:20:27,090 --> 01:20:30,569
pues no sabemos muy bien lo que estaba pasando por ahí en las librerías de Java

922
01:20:30,569 --> 01:20:34,710
seguro que tiene su explicación, otra cosa es que yo

923
01:20:34,710 --> 01:20:39,890
contaros la hora, pero fijaros, con el trimap sí que está respondiendo

924
01:20:39,890 --> 01:20:43,670
como estábamos viendo al criterio de ordenación que estábamos diciendo, entonces con estos datos

925
01:20:43,670 --> 01:20:47,449
ahora, fijaros como el orden, me lo decía

926
01:20:47,449 --> 01:20:51,329
20 y 1, cambio esta misma colección, si la pongo como hash map

927
01:20:51,329 --> 01:20:58,220
bueno, pues ya se irá al, entiendo que se estará yendo al criterio de ordenación

928
01:20:58,220 --> 01:21:03,770
de nada, porque es sobre la clave, pero fijaros

929
01:21:03,770 --> 01:21:07,829
como aquí con el trimap me han mostrado 20 y 1 en el orden, y aquí me muestra

930
01:21:07,829 --> 01:21:08,710
1 y 20.

931
01:21:10,289 --> 01:21:11,829
Y claro, ahora por más... A ver si...

932
01:21:13,930 --> 01:21:15,909
Porque es un HashMap

933
01:21:15,909 --> 01:21:17,329
que ya no se preocupa de la ordenación.

934
01:21:18,270 --> 01:21:19,930
De hecho, fijaros, ahora ya está mirando

935
01:21:19,930 --> 01:21:21,770
en el HashMap... Vale, vale.

936
01:21:21,810 --> 01:21:23,510
En el HashMap está mirando el método

937
01:21:23,510 --> 01:21:25,850
Equals y el HashCode.

938
01:21:27,130 --> 01:21:27,930
Tiene sentido.

939
01:21:28,109 --> 01:21:28,229
Vale.

940
01:21:30,069 --> 01:21:31,170
Creo que ya lo he entendido.

941
01:21:31,569 --> 01:21:32,649
Vamos a intentar recapitular.

942
01:21:33,829 --> 01:21:35,750
El TreeMap, fijaros,

943
01:21:35,750 --> 01:21:36,590
en las colecciones,

944
01:21:36,590 --> 01:21:46,069
cuando teníamos una colección que era una set pero no map

945
01:21:46,069 --> 01:21:50,109
no tree, que era que métodos hemos dicho que mirábamos para ver

946
01:21:50,109 --> 01:21:54,090
si eran iguales y sobre que métodos trabajaba, pues trabajaba

947
01:21:54,090 --> 01:21:59,600
sobre el método hashCode y el método equals

948
01:21:59,600 --> 01:22:02,619
y le daba un poco igual el orden

949
01:22:02,619 --> 01:22:10,210
y cuando teníamos una colección, una que era tree, todas las comprobaciones

950
01:22:10,210 --> 01:22:14,210
se hacían ya sobre el método compareTo

951
01:22:14,210 --> 01:22:17,970
y en los mapas pasa algo parecido

952
01:22:17,970 --> 01:22:21,829
fijaros ahora que tenemos un hashMap que ya no es tree

953
01:22:21,829 --> 01:22:26,310
fijaros que traza nos está mostrando aquí, pasa por hashCode y pasa por

954
01:22:26,310 --> 01:22:30,630
equals de la clase persona, es decir, no está utilizando el compareTo

955
01:22:30,630 --> 01:22:34,489
y para ver si son duplicados está utilizando estas dos

956
01:22:34,489 --> 01:22:37,869
igual que en las colecciones, en cambio cuando teníamos el treeMap

957
01:22:37,869 --> 01:22:40,689
el criterio lo buscaba de ordenación en el compareTo

958
01:22:40,689 --> 01:22:50,079
alguna pregunta

959
01:22:50,079 --> 01:22:52,279
que os surja

960
01:22:52,279 --> 01:22:53,939
alguna cosilla nos queda clara

961
01:22:53,939 --> 01:22:58,939
por ahí

962
01:22:58,939 --> 01:23:06,960
bueno pues nada vamos a ver

963
01:23:06,960 --> 01:23:09,020
una cosa más que todavía nos queda un poquito

964
01:23:09,020 --> 01:23:11,300
tiempo aunque ya vayamos

965
01:23:11,300 --> 01:23:12,960
cerrando en realidad yo creo

966
01:23:12,960 --> 01:23:14,619
que hemos dado un repaso grande

967
01:23:14,619 --> 01:23:16,279
a las colecciones y los mapas

968
01:23:16,279 --> 01:23:18,960
si tenéis más dudas luego me vais

969
01:23:18,960 --> 01:23:20,720
preguntando por los foros en cualquier caso

970
01:23:20,720 --> 01:23:22,239
mirad las

971
01:23:22,239 --> 01:23:28,159
la clase colección tiene

972
01:23:28,159 --> 01:23:33,199
algunos métodos que bueno que son interesantes para trabajar directamente con colecciones

973
01:23:33,199 --> 01:23:40,460
directamente como como métodos estáticos de la clase colección y una de ellas por ejemplo es

974
01:23:40,460 --> 01:23:48,159
el método sufre este que es bueno para jarno es un método que nos viene bien para la tarea

975
01:23:48,159 --> 01:23:53,340
así si no lo habéis trabajado la estéis trabajando porque hay un momento que habla la tarea de una

976
01:23:53,340 --> 01:23:59,600
baraja y dice barajar las cartas que las tendré guardadas en una colección pues igual con este

977
01:23:59,600 --> 01:24:08,220
método lo podéis hacer entonces si tenemos una colección que sea una por ejemplo una linked

978
01:24:08,220 --> 01:24:22,960
list de tipo entero enteros de ver y mi lista vamos a poner que es una lista como es una link

979
01:24:22,960 --> 01:24:29,840
el dis amite duplicados verdad no se preocupa del orden en especial se puede estar no tiene

980
01:24:29,840 --> 01:24:37,399
un orden definido lo cual nos va a permitir barajar o mezclar en un orden diferente sus

981
01:24:37,399 --> 01:24:48,680
datos me falta el new por aquí y la definido de enteros pues entonces podría hacer aquí mi lista

982
01:24:48,680 --> 01:24:50,539
punto, add

983
01:24:50,539 --> 01:24:55,439
y voy a meter aquí enteros

984
01:24:55,439 --> 01:24:56,500
voy a decir un 2

985
01:24:56,500 --> 01:24:59,890
un 5

986
01:24:59,890 --> 01:25:01,609
un 1

987
01:25:01,609 --> 01:25:03,810
y un 3

988
01:25:03,810 --> 01:25:07,149
en principio nos sigue un orden según los he metido

989
01:25:07,149 --> 01:25:08,170
en particular

990
01:25:08,170 --> 01:25:19,560
vamos a recorrer esta colección

991
01:25:19,560 --> 01:25:22,840
voy a llevar aquí

992
01:25:22,840 --> 01:25:26,300
la estructura de un iterador

993
01:25:26,300 --> 01:25:27,340
por no escribir tanto

994
01:25:27,340 --> 01:25:32,180
definimos un iterador, en este caso

995
01:25:32,180 --> 01:25:34,659
un iterador de tipos enteros

996
01:25:34,659 --> 01:25:36,239
la colección se llama mi lista

997
01:25:36,239 --> 01:25:40,159
mientras haya elementos

998
01:25:40,159 --> 01:25:53,909
y muestro el valor del iterador

999
01:25:53,909 --> 01:25:55,210
vale

1000
01:25:55,210 --> 01:25:56,810
entonces si ejecuto por aquí

1001
01:25:56,810 --> 01:26:00,390
bueno pues fijaros como

1002
01:26:00,390 --> 01:26:03,489
me muestra los datos en el orden en los que

1003
01:26:03,489 --> 01:26:05,289
lo he introducido, no tiene un orden

1004
01:26:05,289 --> 01:26:06,789
funcional como si fuera

1005
01:26:06,789 --> 01:26:09,210
un trimap o algo de eso

1006
01:26:09,210 --> 01:26:11,529
según enteros, si esto fuese un trimap

1007
01:26:11,529 --> 01:26:15,229
pues me los habría ordenado a través de los números

1008
01:26:15,229 --> 01:26:16,250
vamos a hacerlo en un momento

1009
01:26:16,250 --> 01:26:21,689
como cambiamos muy rápido de uno a otro

1010
01:26:21,689 --> 01:26:27,250
no un trimap, no, un triset

1011
01:26:27,250 --> 01:26:32,359
para que sea una colección

1012
01:26:32,359 --> 01:26:35,920
de aquí que tiene el orden según los hemos metido

1013
01:26:35,920 --> 01:26:38,640
fijaros con un triset, pues ahora ya me salen según

1014
01:26:38,640 --> 01:26:41,819
un orden definido

1015
01:26:41,819 --> 01:26:44,340
para los enteros en las librerías de Java

1016
01:26:44,340 --> 01:26:47,779
en el integer no podemos sobreescribir el método compareTo

1017
01:26:47,779 --> 01:26:49,460
como sí que hemos hecho en la clase persona

1018
01:26:49,460 --> 01:26:55,260
volvemos al linked list y del

1019
01:26:55,260 --> 01:26:58,199
orden numérico del dato, pues ahora vemos que está

1020
01:26:58,199 --> 01:27:02,529
del orden según los hemos ido introduciendo. Pues si yo cojo aquí

1021
01:27:02,529 --> 01:27:11,619
y llamo al método estático

1022
01:27:11,619 --> 01:27:16,500
shuffle y le paso como parámetro una colección, en este

1023
01:27:16,500 --> 01:27:19,500
caso la colección con la que estoy trabajando

1024
01:27:19,500 --> 01:27:24,560
pues se supone que de este orden que es el que tiene cuando arranca

1025
01:27:24,560 --> 01:27:28,760
pues los está mezclando. Entonces si yo ahora cojo y establezco

1026
01:27:28,760 --> 01:27:35,060
otra vez el iterador y vuelvo a mostrarlo por pantalla, voy a definir dos veces

1027
01:27:35,060 --> 01:27:39,060
la variable, fijaros lo que estoy haciendo, defino

1028
01:27:39,060 --> 01:27:42,800
la colección, añado unos cuantos elementos, con el iterador los muestro

1029
01:27:42,800 --> 01:27:47,180
barajo, mezclo de forma aleatoria

1030
01:27:47,180 --> 01:27:50,220
los datos que tiene esa colección y los vuelvo a muestrar

1031
01:27:50,220 --> 01:27:58,819
entonces aquí, damos una ejecución, voy a meter aquí una separación

1032
01:27:58,819 --> 01:28:12,359
entre los dos, un momento para que se vea más claro, mirad el primer orden

1033
01:28:12,359 --> 01:28:16,720
iba 2, 5, 1, 3, que coincide con como los hemos metido

1034
01:28:16,720 --> 01:28:25,069
y después de hacer la mezcla, la mezcla que le hago aquí,

1035
01:28:25,529 --> 01:28:28,930
bueno, me saca esta línea, ¿verdad? La mezcla la hago aquí, vuelvo a meter

1036
01:28:28,930 --> 01:28:32,909
los datos y ahora saben, bueno, pues mezcla con otro orden diferente

1037
01:28:32,909 --> 01:28:36,689
el que le ha querido dar el método SAFEL. Fijaros en diferentes

1038
01:28:36,689 --> 01:28:40,949
ejecuciones. Salen aquí una vez mezclados diferentes

1039
01:28:40,949 --> 01:28:44,649
datos. 1, 2, 5, 3. 5, 3, 2, 1.

1040
01:28:45,470 --> 01:28:48,850
5, 1, 3, 2. Bueno, pues nada, un método

1041
01:28:48,850 --> 01:28:50,430
que tenemos ahí en Colesions.

1042
01:28:51,649 --> 01:28:53,050
Hay algunos métodos más

1043
01:28:53,050 --> 01:28:54,770
que están disponibles

1044
01:28:54,770 --> 01:28:57,090
para coger de una lista a una sublista

1045
01:28:57,090 --> 01:28:59,010
y algunas otras alternativas.

1046
01:28:59,569 --> 01:29:01,189
Bueno, pues echarles un ojillo

1047
01:29:01,189 --> 01:29:04,789
y si se os atascan,

1048
01:29:04,850 --> 01:29:05,710
pues ya me vais diciendo.

1049
01:29:08,989 --> 01:29:10,810
Y no sé si contaron muchas más cosas.

1050
01:29:11,609 --> 01:29:13,649
Lo siguiente que tenía por aquí apuntado,

1051
01:29:14,989 --> 01:29:15,850
pero eso es una cosa

1052
01:29:15,850 --> 01:29:17,050
que igual nos lleva una clase entera

1053
01:29:17,050 --> 01:29:19,890
y es un poco

1054
01:29:19,890 --> 01:29:23,130
por culturilla general y ver cómo se puede programar, era

1055
01:29:23,130 --> 01:29:27,789
programar nosotros, no sé si lo haremos algún día, si nos sobra

1056
01:29:27,789 --> 01:29:31,810
algún día igual lo retomamos, programar nosotros lo que podría ser

1057
01:29:31,810 --> 01:29:38,420
por ejemplo una ArrayList, una colección que en lugar

1058
01:29:38,420 --> 01:29:42,520
de estar llamando a las librerías, nos cree una lista que a medida

1059
01:29:42,520 --> 01:29:46,220
por ejemplo duplicados y que esté enlazado uno detrás de otro, a ver cómo lo podríamos

1060
01:29:46,220 --> 01:29:50,340
hacer nosotros intentando simular el código que las

1061
01:29:50,340 --> 01:29:52,680
librerías tienen para las colecciones?

1062
01:29:53,319 --> 01:29:53,819
Bueno, pues

1063
01:29:53,819 --> 01:29:56,260
no es una cosa muy

1064
01:29:56,260 --> 01:29:58,199
necesaria en el fondo, es más

1065
01:29:58,199 --> 01:30:00,140
por ahondar un poco en tema

1066
01:30:00,140 --> 01:30:02,199
de algoritmo y ver cómo se puede organizar eso

1067
01:30:02,199 --> 01:30:04,119
porque en verdad cuando necesitáis

1068
01:30:04,119 --> 01:30:06,159
una lista no la vais a programar vosotros, vais a utilizar

1069
01:30:06,159 --> 01:30:08,319
una de las que están disponibles ya en las colecciones.

1070
01:30:12,539 --> 01:30:13,520
Y en principio yo creo

1071
01:30:13,520 --> 01:30:15,539
que ya os he contado muchas cosas hoy, no sé

1072
01:30:15,539 --> 01:30:17,279
si echáis alguna cosa

1073
01:30:17,279 --> 01:30:19,479
en falta, que creéis que le demos una

1074
01:30:19,479 --> 01:30:21,380
vuelta o alguna cosa no entendéis de lo que

1075
01:30:21,380 --> 01:30:24,890
hemos hablado, o necesitáis madurar

1076
01:30:24,890 --> 01:30:27,029
o quizás un poco para que os surjan

1077
01:30:27,029 --> 01:30:35,140
las dudas. Si no tenéis

1078
01:30:35,140 --> 01:30:37,119
nada en particular, yo creo que vamos a ir terminando

1079
01:30:37,119 --> 01:30:37,680
ya por hoy.

1080
01:30:39,000 --> 01:30:40,680
Por no hacer esto ya mucho más largo.

1081
01:30:43,880 --> 01:30:44,760
¿No tenéis

1082
01:30:44,760 --> 01:30:46,140
alguna pregunta así en particular?

1083
01:30:46,779 --> 01:30:47,439
¿Qué queréis hacerme?

1084
01:30:50,720 --> 01:30:52,239
Pues nada, pues

1085
01:30:52,239 --> 01:30:53,939
os voy dejando entonces.

1086
01:30:55,279 --> 01:30:56,720
Si tenéis alguna cosita,

1087
01:30:57,140 --> 01:30:58,720
bueno, pues en Semana Santa igual

1088
01:30:58,720 --> 01:31:00,680
no soy tan ágil para responderos, pero

1089
01:31:00,680 --> 01:31:02,880
iré echando un ojo de vez en cuando, así que

1090
01:31:02,880 --> 01:31:04,819
si me preguntáis alguna cosita por ahí

1091
01:31:04,819 --> 01:31:06,899
os intentaré ir respondiendo

1092
01:31:06,899 --> 01:31:08,539
aunque también por descargar

1093
01:31:08,539 --> 01:31:11,380
descansar, cargar las pilas

1094
01:31:11,380 --> 01:31:12,779
y luego ya a la vuelta

1095
01:31:12,779 --> 01:31:17,859
seguimos dándole ahí duro

1096
01:31:17,859 --> 01:31:19,960
claro, tenemos dentro de mucho

1097
01:31:19,960 --> 01:31:22,039
porque vienen estas dos

1098
01:31:22,039 --> 01:31:23,439
que caen justo Semana Santa

1099
01:31:23,439 --> 01:31:25,760
y luego volvemos justo en un martes

1100
01:31:25,760 --> 01:31:27,079
así que sí, en tres semanitas

1101
01:31:27,079 --> 01:31:28,539
eso es

1102
01:31:28,539 --> 01:31:33,479
bueno

1103
01:31:33,479 --> 01:31:34,600
pues

1104
01:31:34,600 --> 01:31:36,800
que paséis

1105
01:31:36,800 --> 01:31:38,600
que descanséis estos días

1106
01:31:38,600 --> 01:31:40,880
descanséis o no descanséis, lo que mejor os venga

1107
01:31:40,880 --> 01:31:41,560
a cada uno

1108
01:31:41,560 --> 01:31:45,060
venga, nos vemos a la vuelta, hasta luego