1
00:00:00,000 --> 00:00:27,699
Sí, entonces bueno, en verdad, estaba comentando ya, lo repito para que quede en la grabación, que nada, que la semana pasada después de grabarla, yo si queréis os lo comparto, no lo borré y lo subí, pero no lo puse visible, pero en realidad yo creo que resulta poco útil ver hacer cosas ahí y además que habrá ratos que estaremos hablando y no estaremos haciendo nada, pues estar viendo ahí algo sin mucho movimiento en la pantalla igual no resulta útil.

2
00:00:27,699 --> 00:00:30,219
Entonces bueno, como este tema es un poquito largo

3
00:00:30,219 --> 00:00:32,859
Si queréis, podemos hoy volver a

4
00:00:32,859 --> 00:00:34,420
Igual nos viene bien de repaso

5
00:00:34,420 --> 00:00:36,140
Para los que estuvisteis también en la clase pasada

6
00:00:36,140 --> 00:00:38,039
Y además ya lo dejamos grabado

7
00:00:38,039 --> 00:00:39,380
Por si lo queréis volver a ver

8
00:00:39,380 --> 00:00:41,140
Y como tenemos varios días

9
00:00:41,140 --> 00:00:42,899
Aunque sea un poquito más rápido

10
00:00:42,899 --> 00:00:45,060
Lo volvemos a repasar, si os parece

11
00:00:45,060 --> 00:00:47,119
Más o menos estáis parecidos

12
00:00:47,119 --> 00:00:49,439
Los que estabais la semana pasada y los que estáis ahora incorporados

13
00:00:49,439 --> 00:00:51,179
Si me decís que no

14
00:00:51,179 --> 00:00:53,179
Pues continúo desde donde estábamos

15
00:00:53,179 --> 00:00:55,500
Yo creo que sí que puede resultar a lo mejor interesante

16
00:00:55,500 --> 00:00:56,859
Volver a hacer un pequeño repaso

17
00:00:56,859 --> 00:01:07,739
pues venga pues nada pues eso hacemos pues eso hacemos y además arranco eclipse y empezamos a

18
00:01:07,739 --> 00:01:15,230
hablar de ello ya vamos ya digo vamos un poquito más rápido y llegamos hasta donde el otro día y

19
00:01:15,230 --> 00:01:20,109
avanzamos algo más de todas formas de este tema nos queda todavía no solamente esta clase la que

20
00:01:20,109 --> 00:01:25,750
viene por lo menos también y no sé si incluso la última antes de semana santa en la de lunes que

21
00:01:25,750 --> 00:01:31,810
viene porque luego ya otro lunes es semana santa y no sé si incluso tenemos otro día más de este

22
00:01:31,810 --> 00:01:37,950
tema todavía algo después así que entre bueno pero entre esta clase y la siguiente seguro que nos da

23
00:01:37,950 --> 00:01:50,129
para verlo mira el otro día os comentaba a la hora de trabajar con la con temas de memoria en los

24
00:01:50,129 --> 00:01:55,349
programas pues tenemos las variables al uso que pueden ser o bien primitivas o referenciadas que

25
00:01:55,349 --> 00:02:01,269
son los objetos de los cuales hacemos los niños y luego hemos trabajado con agrupaciones de objetos

26
00:02:01,269 --> 00:02:08,129
que típicamente son del mismo tipo con los arrays ya ya conoces un poco la dinámica de los arrays y

27
00:02:08,129 --> 00:02:13,710
cómo podemos trabajar con ellos en particular cuando estamos con bucles para recorrer todos

28
00:02:13,710 --> 00:02:20,270
los elementos y todo esto que nos permite automatizar un montón el código pues en

29
00:02:20,270 --> 00:02:29,509
En este contexto de guardar en memoria variables que típicamente son del mismo tipo y manejarla luego con nuestros algoritmos,

30
00:02:30,509 --> 00:02:38,569
como os digo, tenemos los arrays, pero la ventaja que tienen los arrays es que el nombre del array en sí se nos guarda.

31
00:02:40,129 --> 00:02:47,990
Cuando hacemos una reserva de espacio de memoria para un array, lo que hacemos es que el nombre del array coge una posición de memoria

32
00:02:47,990 --> 00:02:51,169
y a partir de esa posición es a partir de la cual se van

33
00:02:51,169 --> 00:02:53,349
aguardando los elementos y luego

34
00:02:53,349 --> 00:02:56,830
vamos a suponer que estamos hablando de una variable

35
00:02:56,830 --> 00:03:00,090
de tipo entero, un array de tipo

36
00:03:00,090 --> 00:03:03,150
entero, pues lo que sucede es que el siguiente elemento

37
00:03:03,150 --> 00:03:05,990
está en esa misma zona de memoria donde está el nombre

38
00:03:05,990 --> 00:03:09,110
del array desplazado, el segundo de los

39
00:03:09,110 --> 00:03:12,009
enteros que está en el array, el tamaño de un array y el tercero

40
00:03:12,009 --> 00:03:15,169
desplazado, dos por el tamaño de un entero y el cuarto

41
00:03:15,169 --> 00:03:18,990
2, 3 por el tamaño de un entero. Esto que supone que como está

42
00:03:18,990 --> 00:03:23,110
muy identificado el sitio donde están esas variables, los accesos son muy

43
00:03:23,110 --> 00:03:27,330
rápidos y tienen muy buen rendimiento en términos de ejecución

44
00:03:27,330 --> 00:03:31,069
en el manejo de los arrays. ¿Cuál es el principal

45
00:03:31,069 --> 00:03:35,069
inconveniente que tenemos en los arrays? Vamos a llamarlo

46
00:03:35,069 --> 00:03:38,569
aquí call, que ya tenemos uno de colecciones,

47
00:03:38,569 --> 00:03:42,590
para ir haciéndolo desde cero. El inconveniente

48
00:03:42,590 --> 00:03:45,750
que tienen los Arrays es que en el momento

49
00:03:45,750 --> 00:03:48,430
en el que definimos el Array, recordad que os decía el otro día

50
00:03:48,430 --> 00:03:51,449
que tenemos que identificar el tamaño que va a tener

51
00:03:51,449 --> 00:03:54,669
ese Array. Si lo dimensionamos

52
00:03:54,669 --> 00:03:57,409
muy grande, probablemente habrá elementos que no utilizamos

53
00:03:57,409 --> 00:04:00,409
de ese Array, pero habremos

54
00:04:00,409 --> 00:04:03,490
hecho esa reserva de espacio de memoria, es decir, esos recursos los tendremos

55
00:04:03,490 --> 00:04:06,669
bloqueados en nuestro programa, aunque luego no vayamos

56
00:04:06,669 --> 00:04:09,409
a utilizarlos y si intentamos

57
00:04:09,409 --> 00:04:12,569
ajustar mucho el tamaño del número de elementos

58
00:04:12,569 --> 00:04:26,910
De cara a no reservar mucha memoria RAM, el inconveniente que tenemos es que si no tenemos certeza del número de variables que vamos a tener al final en el array, pues se nos pueda quedar pequeño y ya no podemos redimensionarlo a algo más grande.

59
00:04:26,910 --> 00:04:40,529
El ejemplo que os ponía era el de un estadio de fútbol de un equipo grande que tenga 40.000 espectadores, pero habrá días que jugarán los Benjamines del equipo y irán 100 personas y otros días irán 40.000.

60
00:04:40,529 --> 00:04:57,149
Si el programa es el mismo, si reservamos para 40.000, bloqueamos muchos recursos para el día que van los infantiles, que van 100 personas, pero si hacemos un tamaño de un array de 100, lógicamente cuando vayan 40.000 ya no nos va a valer ese array.

61
00:04:57,149 --> 00:05:20,800
A los Array lo llamamos estructuras estáticas de datos y con lo que vamos a trabajar en este tema, que son las colecciones y los mapas, son estructuras dinámicas.

62
00:05:20,800 --> 00:05:52,709
¿Qué pasa con las estructuras dinámicas? Las estructuras dinámicas cuando las definimos no tenemos que identificar el número de elementos que van a guardarse en esa colección o en ese mapa, con lo cual no hacemos una reserva previa y según vayamos incorporando elementos, instancias de objetos referenciados o de variables a las colecciones o los mapas, en ese momento para cada una de ellas se hace su propia reserva.

63
00:05:52,709 --> 00:05:57,689
si utilizamos una colección, el día que van

64
00:05:57,689 --> 00:06:01,829
100 personas al campo con el ejemplo anterior, pues añadiremos

65
00:06:01,829 --> 00:06:05,529
100 elementos a la colección y se hará la reserva para esas 100 personas

66
00:06:05,529 --> 00:06:09,850
no para 40.000 como nos veíamos obligados a hacer con el array, pero el día que

67
00:06:09,850 --> 00:06:13,990
vayan 40.000, pues al añadir 40.000 veces elementos a la colección

68
00:06:13,990 --> 00:06:17,790
pues la reserva será de 40.000, en este aspecto

69
00:06:17,790 --> 00:06:22,009
es mucho más flexible las colecciones, que es lo que sucede con las colecciones

70
00:06:22,009 --> 00:06:43,449
Aparte de esa característica que las convierte en estructuras dinámicas, las colecciones trabajan con ciertos algoritmos por detrás cuando están programadas que permiten que puedan admitir o no admitir duplicados al almacenar esa información, cosa que no tenemos control a no ser que la hagamos de forma externa con los arrays.

71
00:06:43,449 --> 00:06:55,769
Si nosotros en nuestro programa gestionamos, hacemos las comprobaciones para que no haya duplicados en un array, claro que no los tendrá, pero en sí un array no tiene un software asociado para evitar esto.

72
00:06:56,209 --> 00:07:00,949
Las colecciones, ciertas colecciones, tienen esa característica de que no van a admitir duplicados.

73
00:07:02,009 --> 00:07:07,170
Los elementos de un array pueden estar ordenados, pero será en función de si le aplicamos algoritmos.

74
00:07:07,170 --> 00:07:28,449
Si un día tenemos tiempo, hacemos algún algoritmo de los más sencillos, por ejemplo el de la burbuja o algunos por ahí que típicamente se trabajan sobre datos para ver cómo se ordenan, pero en principio los arrays no están pensados para tener un código que esté asociado con que estén ordenados.

75
00:07:28,449 --> 00:07:49,050
En cambio, las colecciones, algunas sí que están ordenadas. Es decir, hay diferentes colecciones, que después las identificamos unas y otras en el gráfico de colecciones que tenemos, que unas están ordenadas, otras no están ordenadas, unas permiten duplicados y otras no permiten duplicados.

76
00:07:49,050 --> 00:07:54,269
¿Qué sucede? Que claro, el hecho de que los datos de las colecciones y los mapas

77
00:07:54,269 --> 00:07:57,810
nos permitan gestionar todas estas cosas, que haya diferentes tipos

78
00:07:57,810 --> 00:08:03,430
y que no sean contiguos en tanto en cuanto al almacenamiento en memoria RAM

79
00:08:03,430 --> 00:08:08,529
cuando las vamos guardando, pues supone la ventaja de no tener que reservar

80
00:08:08,529 --> 00:08:13,250
toda esa memoria RAM y tener esos servicios, pero la desventaja de que

81
00:08:13,250 --> 00:08:17,910
todo eso lleva cierto tiempo. Al final estará corriendo en esas librerías

82
00:08:17,910 --> 00:08:23,250
que implementa la colección, un código que cada vez que añadamos un elemento

83
00:08:23,250 --> 00:08:26,970
no será directamente como un array, aquí lo pongo en esta posición de memoria,

84
00:08:27,069 --> 00:08:28,870
es un entero, guardo el 5 y se acabó.

85
00:08:29,410 --> 00:08:33,350
Una colección tendrá que hacer sus comprobaciones de si ya está en la colección,

86
00:08:33,610 --> 00:08:37,409
si es un caso de duplicados, si es ordenado tendrá que posicionarlo

87
00:08:37,409 --> 00:08:39,769
en un determinado sitio en lugar de otro.

88
00:08:41,669 --> 00:08:44,049
Un poco esas son las diferencias entre unos y otros.

89
00:08:44,049 --> 00:09:02,009
Las colecciones y los mapas se apoyan en ciertas tecnologías que tenemos en Java ya disponibles, que son las interfaces, por ejemplo, que ya conocemos.

90
00:09:02,009 --> 00:09:07,549
acordaros que en cualquier clase hemos visto en temas anteriores que pueden implementar una interfaz

91
00:09:07,549 --> 00:09:14,350
que viene a ser que la interfaz define una serie de métodos pero no los desarrolla

92
00:09:14,350 --> 00:09:21,149
entonces si implementas interfaz es como si firmases un contrato diciendo yo que ahora mismo estoy poniendo en el código

93
00:09:21,149 --> 00:09:25,129
que voy a implementar esta interfaz me obligo a desarrollar estos métodos

94
00:09:25,129 --> 00:09:35,789
Y otras cosas que tienen son las clases genéricas, que es sobre lo que estuvimos echando un buen rato el otro día y que paso a contaros ahora.

95
00:09:36,070 --> 00:09:44,590
Entonces vamos a ver un poco el concepto de clases genéricas, básicamente porque luego es algo que utilizan los mapas y las colecciones.

96
00:09:44,590 --> 00:09:53,889
entonces una una cuando cada vez que nosotros definimos una clase las clases y los métodos

97
00:09:53,889 --> 00:09:59,409
genéricos cada vez que nosotros definimos una clase pues aquí tenemos una serie de atributos

98
00:09:59,409 --> 00:10:11,139
será de tipo int y valor por ejemplo en este caso string ese info y qué sucede si en otra

99
00:10:11,139 --> 00:10:27,139
Ahora necesitamos, imaginaos que esta clase que la hemos llamado call, que vamos a suponer que tiene estos dos atributos, aguarda en un momento dado información que tiene que ver con valores enteros de un determinado rango, el que aceptan los enteros.

100
00:10:27,139 --> 00:10:47,440
Podríamos definirlo así. Pero si luego resulta que tenemos una clase que es prácticamente igual que esta, pero, bueno, pues es en otro contexto. Imaginaos que es la distancia, esto es distancias en kilómetros y estamos, pues un entero, claro, admite números muy grandes.

101
00:10:47,440 --> 00:11:10,990
Imaginaos que está este ejercicio, esta clase hecha ahora en el contexto de distancias entre ciudades en un continente. Pues bueno, pues con las distancias que permite un entero en kilómetros perfectamente nos vale una variable que sea de este tipo, entera.

102
00:11:10,990 --> 00:11:34,529
Pero imaginaos que ahora cogemos y decimos, oye, aparte de la distancia en kilómetros, estamos pensando que igual también podríamos aplicarlo a distancia planetaria, con lo cual ya igual la distancia en kilómetros entre diferentes planetas, no sé exactamente decirlo, pero bueno, por buscar un ejemplo de algo muy lejano, un planeta que esté muy lejos, pues igual ya el número que nos permite el rango de un entero no nos da.

103
00:11:34,529 --> 00:11:39,429
entonces en ese contexto a lo mejor sería interesante que esta variable fuera de tipo long

104
00:11:39,429 --> 00:11:46,409
¿qué sucede? que al uso con las clases que tenemos al uso si esto lo definimos como entero es entero

105
00:11:46,409 --> 00:11:52,789
y si esto lo definimos como long es long pero nos gustaría que en unos contextos esto fuera un entero

106
00:11:52,789 --> 00:11:58,889
y en otros contextos esta clase fuese un long pues para esto es para lo que podemos utilizar

107
00:11:58,889 --> 00:12:04,250
las clases genéricas para que en el momento de construir un determinado objeto de esta clase

108
00:12:04,250 --> 00:12:08,029
sin tener necesidad de crear dos clases distintas

109
00:12:08,029 --> 00:12:10,990
simplemente por este matiz, uno de los objetos

110
00:12:10,990 --> 00:12:13,289
considera esta distancia como entero

111
00:12:13,289 --> 00:12:15,909
y otro de los objetos lo considere como long

112
00:12:15,909 --> 00:12:20,190
la sintaxis que nos permite trabajar con esto

113
00:12:20,190 --> 00:12:23,250
es la siguiente

114
00:12:23,250 --> 00:12:24,049
podemos poner aquí

115
00:12:24,049 --> 00:12:28,389
entre el símbolo de mayor y menor

116
00:12:28,389 --> 00:12:29,889
un nombrecito, una S

117
00:12:29,889 --> 00:12:33,289
y esta S está intentando identificar un tipo

118
00:12:33,289 --> 00:12:37,450
que pertenece al rango entero de toda la clase genérica.

119
00:12:38,190 --> 00:12:41,830
Entonces, si yo pongo aquí ahora S, resulta que S

120
00:12:41,830 --> 00:12:45,889
es este tipo, que no hemos dicho de momento si es

121
00:12:45,889 --> 00:12:49,950
un long o es un entero, pero cuando instanciemos un objeto de la

122
00:12:49,950 --> 00:12:54,029
clase call, en ese momento será cuando le daremos, identificaremos

123
00:12:54,029 --> 00:12:57,169
este tipo. Entonces, para un objeto que lo identificamos como

124
00:12:57,169 --> 00:13:01,370
int la S, resultará que esta S trabajará como

125
00:13:01,370 --> 00:13:04,889
un entero y lo podremos tener en el contexto

126
00:13:04,889 --> 00:13:08,149
de distancia entre diferentes localidades en Europa

127
00:13:08,149 --> 00:13:11,149
y cuando instanciamos otro objeto diferente

128
00:13:11,149 --> 00:13:14,370
si estamos pensando en distancias

129
00:13:14,370 --> 00:13:17,529
planetarias, pues al definir ese objeto

130
00:13:17,529 --> 00:13:19,870
lo pondremos como un long, con lo cual esta variable

131
00:13:19,870 --> 00:13:22,789
será un long. Ambos dos valores son

132
00:13:22,789 --> 00:13:25,629
de tipo entero, pero los diferencia

133
00:13:25,629 --> 00:13:28,210
el rango y la cantidad de memoria RAM que

134
00:13:28,210 --> 00:13:30,889
tienen que reservar para guardar esos datos.

135
00:13:31,370 --> 00:13:47,799
Entonces, mira, si cogemos aquí y definimos otra clase, que sea la clase principal, por ejemplo, voy a marcarle aquí para un escribir public static void main, que directamente me lo haga él.

136
00:13:47,799 --> 00:13:52,179
entonces tenemos a la clase principal, la clase stackall

137
00:13:52,179 --> 00:13:54,720
si yo lo que quiero es

138
00:13:54,720 --> 00:13:59,960
definir

139
00:13:59,960 --> 00:14:00,580
bueno, una

140
00:14:00,580 --> 00:14:04,820
si yo lo que quiero es definir

141
00:14:04,820 --> 00:14:08,480
que este valor

142
00:14:08,480 --> 00:14:12,299
trabaje como un entero, pues entonces lo que podría

143
00:14:12,299 --> 00:14:14,659
hacer aquí es definir un objeto de la clase call

144
00:14:14,659 --> 00:14:17,419
mi c, vamos a decir

145
00:14:17,419 --> 00:14:22,600
y a la hora de identificar el tipo que va a ser este

146
00:14:22,600 --> 00:14:26,159
esta variable esa se la ponemos aquí

147
00:14:26,159 --> 00:14:30,100
y aquí vamos a poner el primero int que no nos va a dejar

148
00:14:30,100 --> 00:14:36,840
fijaros, tendríamos que hacer un new int aquí

149
00:14:36,840 --> 00:14:44,559
un new call y se me queja

150
00:14:44,559 --> 00:14:48,740
¿por qué motivo se me queja? pues se queja porque los tipos primitivos

151
00:14:48,740 --> 00:14:52,879
tal cual no se pueden meter como tipos en las clases genéricas

152
00:14:52,879 --> 00:14:56,860
entonces si lo que me interesa es un int tendré que utilizar su clase

153
00:14:56,860 --> 00:15:01,120
grupper, esta que teníamos, acordaros que tenía las funciones

154
00:15:01,120 --> 00:15:05,340
asociadas con cada uno de los tipos primitivos. Para el tipo primitivo

155
00:15:05,340 --> 00:15:09,039
int, teníamos la clase grupper integer. Y esta

156
00:15:09,039 --> 00:15:12,740
tiene una serie de métodos que aplican a los datos int, porque en sí

157
00:15:12,740 --> 00:15:16,940
las variables primitivas no tienen

158
00:15:16,940 --> 00:15:21,179
métodos con los que trabajar. Acordaros, por ejemplo, el método parseInt que tenemos en la clase

159
00:15:21,179 --> 00:15:24,860
grupper integer. Entonces aquí le diríamos integer.

160
00:15:24,860 --> 00:15:33,340
ahora ya me compila veis de lo que le estoy diciendo aquí es que este objeto en particular

161
00:15:33,340 --> 00:15:44,620
tendrá un parámetro que será que será genérico y este parámetro genérico queremos que sea

162
00:15:44,620 --> 00:15:50,279
considerado como un íntegro entonces lo que pongo íntegro cuando estoy dando de alta este objeto es

163
00:15:50,279 --> 00:16:28,210
es lo que se asocia a esta S, entonces todo lo que aparezca en el ámbito de la clase call como S lo estará considerando justo para este objeto en particular como un íntegro, entonces en este caso esto sería un íntegro, si yo cojo y aquí defino otro objeto, el long no sé cómo es la clase grupper del long, vamos a poner double, mi C2 otro objeto diferente y hago un new call

164
00:16:33,460 --> 00:16:49,340
Pues en este caso, double, que no es long como decía, es que long es igual que el tipo, la clase grupper, porque mirad aquí me compila, pero con la L mayúscula.

165
00:16:49,340 --> 00:17:04,880
Bueno, pues si consideramos que para otra ejecución el objeto miC2, cuando trabajemos con este objeto de la clase call, va a ser para distancias entre planetas, pues me interesaba que la S tuviera un rango más grande.

166
00:17:04,880 --> 00:17:19,299
Entonces utilizo el wrapper del tipo long, entonces esto es a lo que se asocia esta S y todo lo que aparezca en el rango, en el ámbito de la clase, por lo tanto para el objeto donde haya una S, para ese otro será un long.

167
00:17:19,299 --> 00:17:23,160
En un caso es un entero y en otro caso es un long.

168
00:17:25,119 --> 00:17:40,299
Esto es lo que nos permite este tipo de clases, son muy útiles en tanto en cuanto no tengo que redefinir código para diferentes clases simplemente por algún tipo de alguno de sus atributos o alguna de sus variables que tenga por aquí.

169
00:17:40,299 --> 00:18:00,279
Y esta definición de tipos abstractos se puede hacer tanto a nivel de clase entera, como es el caso, como a nivel de método. Entonces, para definir un método que tenga información también de esta genérica, vamos a definir un método.

170
00:18:00,279 --> 00:18:06,650
aquí decíamos public class, aquí para el método, volvemos a definirlo

171
00:18:06,650 --> 00:18:10,490
como entre corchetes, ponemos ahí

172
00:18:10,490 --> 00:18:15,839
un par de variables, y el otro día tengo aquí una chuletilla

173
00:18:15,839 --> 00:18:18,980
de lo que hicimos el otro día, definimos un método tamaño

174
00:18:18,980 --> 00:18:21,599
que recibía aquí

175
00:18:21,599 --> 00:18:27,980
unos parámetros, por aquí

176
00:18:27,980 --> 00:18:31,900
public, vamos a decirle que no devuelva nada, public void

177
00:18:31,900 --> 00:18:34,880
el tema genérico

178
00:18:34,880 --> 00:18:36,519
lo estamos identificando por aquí

179
00:18:36,519 --> 00:18:37,799
como ya me compila

180
00:18:37,799 --> 00:18:40,839
y este tamaño decíamos por ejemplo que recibiese

181
00:18:40,839 --> 00:18:42,519
del tipo T

182
00:18:42,519 --> 00:18:44,720
que este tipo para este método

183
00:18:44,720 --> 00:18:46,799
será una vez una cosa, otra vez otra

184
00:18:46,799 --> 00:18:48,200
cuando estemos llamando al método

185
00:18:48,200 --> 00:18:50,660
pues definíamos un array

186
00:18:50,660 --> 00:18:55,130
del tipo J

187
00:18:55,130 --> 00:18:56,250
definíamos otro array

188
00:18:56,250 --> 00:19:01,279
del tipo T

189
00:19:01,279 --> 00:19:04,099
definíamos una variable, volvemos a utilizar

190
00:19:04,099 --> 00:19:05,420
el tipo T, igual que aquí

191
00:19:05,420 --> 00:19:14,579
que será el que está asociado y luego identificado al llamar al método con esta variable.

192
00:19:16,980 --> 00:19:24,759
Y aquí poníamos, para ver que como ese está definido en todo el ámbito de la clase,

193
00:19:24,759 --> 00:19:30,440
pues también lo podemos utilizar no solo como atributo aquí, sino que lo podemos utilizar dentro de nuestro código.

194
00:19:30,680 --> 00:19:32,779
Aquí, por ejemplo, podríamos poner ese dato.

195
00:19:32,779 --> 00:19:37,859
y aquí podríamos definir una variable local en este método que fuera SA

196
00:19:37,859 --> 00:19:41,799
pues ya está, esta S será del tipo en cada una de las

197
00:19:41,799 --> 00:19:45,839
instanciaciones de objetos según se haya pasado por aquí

198
00:19:45,839 --> 00:19:49,640
según estábamos haciendo aquí pues una vez sería integer y otra long

199
00:19:49,640 --> 00:19:59,930
entonces al llamar este método, fijaros que recibe este método

200
00:19:59,930 --> 00:20:03,250
una raíz de T, una raíz de J

201
00:20:03,250 --> 00:20:08,089
una variable T y una variable de lo que sea esto

202
00:20:08,089 --> 00:20:26,900
si yo pongo mid punto el método tamaño por aquí lo tenemos este va a recibir una raíz de t como

203
00:20:26,900 --> 00:20:34,640
como identificamos que va a ser t y j cuando llamemos al método de igual forma que aquí

204
00:20:34,640 --> 00:20:42,349
lo habíamos definido al instanciar el objeto aquí pues aquí lo definimos creo que es aquí

205
00:20:42,349 --> 00:20:52,759
donde hay que ponerlo a que van a corresponder esos esas variables entonces por ejemplo ponemos

206
00:20:52,759 --> 00:20:57,039
que sean integer, string e integer, es decir, el primero

207
00:20:57,039 --> 00:21:01,059
de los dos tipos que estamos pasándole de forma genérica

208
00:21:01,059 --> 00:21:04,680
en este caso al método tamaño, que se considere un string

209
00:21:04,680 --> 00:21:09,240
y el segundo un integer, es decir, el primero donde aparezca

210
00:21:09,240 --> 00:21:12,799
t, pues estará considerado como string y el segundo donde aparezca j

211
00:21:12,799 --> 00:21:16,880
estará considerado como entero. Además, esta s

212
00:21:16,880 --> 00:21:19,180
en particular, como es para el objeto

213
00:21:19,180 --> 00:21:48,680
mid, para el objeto mid es un íntegro, entonces la s será un íntegro, la t será un string y la j será otro íntegro, esto podría ser cualquier tipo, incluso de clases propias nuestras, si tenemos aquí una clase persona, pues podríamos decir que donde aparece k la j, pues que sea persona, pues ya está, pues persona, lo que tocase, bueno, para hacer una ejecución que tenga sentido, vamos a definir estas cosas, este recordad que

214
00:21:49,180 --> 00:21:55,240
es un string un array de t

215
00:21:56,440 --> 00:22:00,940
una raíz de té y te hemos dicho que es un stream pues vamos a hacer una raíz de strings string

216
00:22:04,539 --> 00:22:06,539
desear

217
00:22:06,539 --> 00:22:09,660
igual año

218
00:22:09,660 --> 00:22:12,920
string damos tamaño al string y decimos que sea de por ejemplo de 10

219
00:22:14,799 --> 00:22:19,119
Este primer dato que le pasamos es una raíz de string el segundo

220
00:22:19,680 --> 00:22:21,680
es una raíz de j

221
00:22:21,680 --> 00:22:23,680
jota es el segundo de los

222
00:22:23,680 --> 00:22:25,680
atributos genéricos que tenemos aquí

223
00:22:26,900 --> 00:22:31,680
y estamos diciendo que sea íntegra pues nos hacemos una red íntegra íntegra

224
00:22:33,299 --> 00:22:35,119
y

225
00:22:35,119 --> 00:22:36,460
ar

226
00:22:36,460 --> 00:22:40,289
igual año

227
00:22:40,390 --> 00:22:41,750
íntegra

228
00:22:41,750 --> 00:22:47,680
a su manera de cinco

229
00:22:47,680 --> 00:22:49,200
lotes y

230
00:22:49,200 --> 00:22:51,200
se asignamos aquí

231
00:22:52,000 --> 00:22:55,440
el tercero de ellos es una variable de tipo t

232
00:22:56,079 --> 00:22:58,079
que recordamos que es esta

233
00:22:58,079 --> 00:23:31,000
que es string, pues decimos string s info, vamos a poner s info, se me queja porque no está inicializado, vamos a decirle aquí hola, y el cuarto, pues bueno, pues es una variable que aquí se va a llamar de forma local dato, que es del tipo s, y ese lo tenemos identificado, también es genérico, pero a nivel de toda la clase,

234
00:23:31,000 --> 00:23:37,099
y en particular para este objeto hemos dicho que esa S sea un integer.

235
00:23:37,359 --> 00:23:45,799
Entonces podemos poner aquí integer igual a 5.

236
00:23:46,799 --> 00:23:49,480
Fijaros que estamos definiendo objetos de la clase Grouper

237
00:23:49,480 --> 00:23:52,920
porque para que sea genérica nos obliga a que sea la clase Grouper

238
00:23:52,920 --> 00:23:55,299
no valdría meter la int.

239
00:23:56,200 --> 00:23:56,880
Pues ahí lo tenemos.

240
00:23:56,880 --> 00:24:03,940
pues ahí tenemos una llamada y en particular otra llamada con este con mitos pues podría

241
00:24:03,940 --> 00:24:10,200
ser completamente diferente podríamos tener imaginaos que tenemos aquí vamos a los bailamos

242
00:24:10,200 --> 00:24:17,480
estos el primero que sea el íntegro y el segundo que sea el estrés ya no le gusta porque porque no

243
00:24:17,480 --> 00:24:22,960
existe con esta distribución verdad es el primero en una raíz de esto pues vamos a poner aquí este

244
00:24:22,960 --> 00:24:54,079
array, el segundo sería este otro, esto sería, seguiría siendo mid, vale, el tercero sería un entero, vamos a poner un, no lo deja directamente, así, y el cuarto, bueno, pues sería, se mantendría siendo un entero, ¿por qué?, porque sigue siendo el objeto mid, que lo tenemos aquí, fijaros, si cogemos y hacemos esto, pero en lugar de para el objeto mid, ponemos mid2,

245
00:24:55,900 --> 00:25:01,700
MIG2, resulta que este tiene un long aquí. Es decir, este valor no le está gustando ya.

246
00:25:02,799 --> 00:25:06,819
Sí que es verdad que en el método estamos manteniendo los dos mismos que aquí, con lo cual le gustan,

247
00:25:07,319 --> 00:25:15,339
pero este, que es un integer, realmente no es. Recordad que este es este tipo de datos.

248
00:25:15,900 --> 00:25:25,319
Y MIG2, he dicho que ese sea long. Con lo cual aquí tendría que meter un long.

249
00:25:25,319 --> 00:25:50,839
directamente si yo pongo aquí un literal resulta que lo considera un íntegra entonces dice

250
00:25:50,839 --> 00:25:58,039
no me gusta esto vamos a poner aquí vamos a hacer un casting a long no tampoco le gusta

251
00:25:58,039 --> 00:26:14,319
y de que se me queja a crear un casting a long pero al tipo primitivo me dice bueno pues ahí

252
00:26:14,319 --> 00:26:23,029
lo tenemos y ya me compila veis bueno pues un poco esta es la idea de los de los casting de

253
00:26:23,029 --> 00:26:33,390
las clases genéricas aquí poníamos el otro día vamos a completar la parte de esta del ejercicio

254
00:26:34,529 --> 00:26:41,849
poníamos un sistema println y mostramos las diferentes longitudes la información y el

255
00:26:41,849 --> 00:26:51,119
dato entonces para el método este tamaño entonces podemos a poner aquí ar 1 punto

256
00:26:51,119 --> 00:27:06,069
lens muestra una longitud más ar 2 punto lens también más y la información de

257
00:27:06,069 --> 00:27:11,809
estos dos datos veníamos separamos otra vez con otro guión

258
00:27:11,809 --> 00:27:19,559
info volvemos a separar con un guión más

259
00:27:19,559 --> 00:27:31,460
datos y bueno vamos a hacer una ejecución a ver qué pinta tiene para que nos saca la información

260
00:27:31,460 --> 00:27:40,500
fijaros primero muestra este este este tenía una raíz de strings que tenía de tamaño 10 esto es

261
00:27:40,500 --> 00:27:47,220
sistema este sistema println es el que muestra el método tamaño aquí que acabamos de codificar

262
00:27:47,220 --> 00:27:54,200
pero bueno pues mostraba primero el tamaño del primero de los arrays estábamos diciendo que

263
00:27:54,200 --> 00:27:58,200
fuera de tipo string y efectivamente el array lo hemos dimensionado

264
00:27:58,200 --> 00:28:02,420
con tamaño 10, luego el segundo de los bloques

265
00:28:02,420 --> 00:28:06,380
mostraba la longitud del segundo de los arrays, este segundo array era de tipo

266
00:28:06,380 --> 00:28:10,339
j y el tipo j que estamos identificando

267
00:28:10,339 --> 00:28:13,960
aquí es el de integer y el array justo es este que le hemos pasado

268
00:28:13,960 --> 00:28:18,480
fijaros, que tiene tamaño 5, pues aquí tenéis el 5

269
00:28:18,480 --> 00:28:22,359
luego pasamos

270
00:28:22,359 --> 00:28:26,339
una variable tipo string y le decíamos que fuese ese info

271
00:28:26,339 --> 00:28:30,099
fijaros hola, pues aquí tenemos el hola y luego un valor

272
00:28:30,099 --> 00:28:34,200
que en particular era tipo entero y ese entero

273
00:28:34,200 --> 00:28:38,220
era justo de este tipo, fijaros como es el que

274
00:28:38,220 --> 00:28:42,259
identificamos aquí, es decir entero

275
00:28:42,259 --> 00:28:45,400
fijaros como es un integer que le hemos asignado valor 5

276
00:28:45,400 --> 00:28:50,400
y es aquí donde lo tenemos. Y aquí hemos bailado

277
00:28:50,400 --> 00:28:54,440
estos dos datos, el 5 sigue siendo lo mismo, porque sigue siendo sobre el mismo

278
00:28:54,440 --> 00:28:58,500
objeto que le hemos indicado que sea aquí integer, y hemos vuelto a pasarle

279
00:28:58,500 --> 00:29:02,460
el mismo valor, y val, y aquí al bailar los datos, los dos

280
00:29:02,460 --> 00:29:05,900
a raíz, hemos puesto integer y string, pues ya las

281
00:29:05,900 --> 00:29:10,339
longitudes están cambiadas, 5, 10, y

282
00:29:10,339 --> 00:29:16,259
este era una variable que teníamos

283
00:29:16,259 --> 00:29:20,019
de tipo t, info, que para esta segunda llamada

284
00:29:20,019 --> 00:29:25,200
bueno, pues como es de tipo T sin T, le estamos pasando un 3 aquí fijo

285
00:29:25,200 --> 00:29:30,859
está un poco la jugada, y el otro día ya para terminar de

286
00:29:30,859 --> 00:29:35,119
dejar un poco, dar una vuelta y dejar claro cómo funcionaba

287
00:29:35,119 --> 00:29:38,319
esto y terminar de creernos de verdad lo de los tipos

288
00:29:38,319 --> 00:29:42,900
que estábamos considerando, pues lo que hacíamos era

289
00:29:42,900 --> 00:29:47,059
crear un método que habíamos llamado validar

290
00:29:47,059 --> 00:29:50,500
public void validar o algo así

291
00:29:50,500 --> 00:29:54,619
nombres da un poco igual en realidad, ahora lo llamábamos

292
00:29:54,619 --> 00:29:59,359
y bueno, para tener certeza de que efectivamente

293
00:29:59,359 --> 00:30:03,380
el tipo de S era el que

294
00:30:03,380 --> 00:30:07,680
nosotros teníamos, el que nosotros le pasábamos a distanciar el objeto

295
00:30:07,680 --> 00:30:16,630
se nos ocurría utilizar, bueno, pues algo con lo que hemos

296
00:30:16,630 --> 00:30:20,009
trabajado ya en alguna tarea, que era el instanceOf

297
00:30:20,009 --> 00:30:26,140
entonces decíamos, sí, la variable

298
00:30:26,140 --> 00:30:32,690
y distancia, distance of, es del tipo

299
00:30:32,690 --> 00:30:37,349
integer, pues que haga algo

300
00:30:37,349 --> 00:30:40,809
si no es del tipo integer, pues no entrará por aquí

301
00:30:40,809 --> 00:30:49,849
y decíamos else if, si la variable es de tipo long

302
00:30:49,849 --> 00:30:55,490
fijaros que es esta variable que está aquí identificada con s

303
00:30:55,490 --> 00:30:58,970
en realidad, podría ser cualquiera según el objeto que vayamos creando

304
00:30:58,970 --> 00:31:03,730
pues que haga alguna otra cosa, vamos a poner un else por si no es ninguna de las dos

305
00:31:03,730 --> 00:31:11,599
y entonces aquí ponemos un system.out.println

306
00:31:11,599 --> 00:31:25,250
ese es de tipo, y si entra por este

307
00:31:25,250 --> 00:31:28,990
entendemos que es porque va a ser un entero, la variable esa

308
00:31:28,990 --> 00:31:36,960
más integer, no puede ser eso, tengo que ponerlo aquí

309
00:31:36,960 --> 00:31:43,029
así, ese es de tipo integer en este caso

310
00:31:43,029 --> 00:31:49,420
en este otro caso vamos a decir

311
00:31:49,420 --> 00:31:58,960
que es de tipo long, y aquí decimos que es de otro tipo

312
00:31:58,960 --> 00:32:11,039
y aquí fijaros, vamos a definir un objeto que sea

313
00:32:11,039 --> 00:32:15,769
S de tipo integer, otro

314
00:32:15,769 --> 00:32:19,210
objeto, en este caso mi C2 que sea de tipo

315
00:32:19,210 --> 00:32:24,160
long y en mi C3 otro objeto diferente que sea

316
00:32:24,160 --> 00:32:30,930
de tipo string, por ejemplo, o como luego además lo vamos a necesitar

317
00:32:30,930 --> 00:32:36,470
vamos a crear una clase persona para dentro

318
00:32:36,470 --> 00:32:39,490
del proyecto para poder decir que para que no sean

319
00:32:39,490 --> 00:32:42,750
solo los tipos propios en la clase genérica

320
00:32:42,750 --> 00:32:45,630
de lo que tenemos ya en Java, pues que sea de tipo

321
00:32:45,630 --> 00:32:53,930
persona vale entonces para mi C3 como le estamos diciendo aquí que sea de tipo persona resultará que

322
00:32:55,309 --> 00:33:03,049
ese será de tipo persona y ahora lo que vamos a hacer va a ser mi C punto validar

323
00:33:04,410 --> 00:33:21,099
y C2 punto validar y mi C3 punto validar y el resto lo voy a comentar vale pues entonces

324
00:33:21,099 --> 00:33:26,259
le damos aquí a ejecutar y me dice que todos son de otro tipo, pues muy bien, estupendo

325
00:33:26,259 --> 00:34:00,420
a ver si vemos qué es lo que ha pasado, pues no lo sé, qué es lo que ha pasado, no lo entiendo

326
00:34:00,420 --> 00:34:42,199
a ver, vamos a poner aquí, a ver, vamos a poner aquí this, no veo qué es lo que nos está pasando

327
00:34:42,199 --> 00:35:00,039
a ver, vamos a crear un constructor, vamos a hacer una, a ver, object voy a poner aquí

328
00:35:00,039 --> 00:35:15,960
a ver si inicialmente lo está considerando object todos, no, no entiendo

329
00:35:15,960 --> 00:35:29,380
vamos a inicializarlo por si al no haber tenido

330
00:35:29,380 --> 00:35:33,760
ningún acceso, no entiendo que es lo que está pasando

331
00:35:33,760 --> 00:35:37,099
vamos a poner aquí ese dato, constructor típico

332
00:35:37,099 --> 00:35:40,280
constructor copia, decimos y distancia

333
00:35:40,280 --> 00:35:50,050
igual a dato y aquí entonces le tendríamos

334
00:35:50,050 --> 00:35:52,949
que pasar un integer, un 2

335
00:35:52,949 --> 00:35:57,690
un log, un 4 y aquí

336
00:35:57,690 --> 00:36:24,849
una persona, de verdad que no me entiendo, me dice que son todos sin Tigger

337
00:36:24,849 --> 00:36:43,500
Tigger Long, persona, pues no sé qué es lo que ha pasado aquí

338
00:36:43,500 --> 00:36:50,110
el otro día yo juraría que no funcionó esto, le echo un ojo un minuto más

339
00:36:50,110 --> 00:36:53,929
y no pierdo más tiempo, porque tampoco es especialmente

340
00:36:53,929 --> 00:36:56,429
trascendente para entender las colecciones esto, pero

341
00:36:56,429 --> 00:37:12,260
Tigger Long, ¿veis alguien lo que puede estar pasando?

342
00:37:12,639 --> 00:37:23,820
¿veis alguna cosa rara? Bueno, para aquí

343
00:37:23,820 --> 00:37:34,199
Y luego, cuando acabemos la clase, una vez que hayamos cerrado la grabación, por no estar aquí mareando mucho, intento echarle un ojo y si veo el por qué, os lo pongo en el aula virtual.

344
00:37:34,400 --> 00:37:48,420
De todas formas, teníamos aquí el ejercicio de la semana pasada. No, no, no, no se te preocupes. Esto de las genéricas es porque entendéis cómo va, pero yo no creo que vayamos a hacer mucho más.

345
00:37:48,420 --> 00:37:50,599
a ver, genérica

346
00:37:50,599 --> 00:38:03,219
no llegamos a hacer esto el otro día

347
00:38:03,219 --> 00:38:04,119
por lo que veo, bueno

348
00:38:04,119 --> 00:38:07,280
luego en cualquier caso lo he hecho un ojo y si lo veo

349
00:38:07,280 --> 00:38:09,260
no entiendo muy bien

350
00:38:09,260 --> 00:38:10,340
el por qué no está

351
00:38:10,340 --> 00:38:12,380
indicándonos el tipo

352
00:38:12,380 --> 00:38:15,159
yo pensaba que no lo iba a indicar y creía también que lo habíamos

353
00:38:15,159 --> 00:38:17,039
hecho el otro día y que había funcionado pero no lo veo

354
00:38:17,039 --> 00:38:18,739
en el código del otro día, vale

355
00:38:18,739 --> 00:38:20,940
aquí dejamos esto aparcado

356
00:38:20,940 --> 00:38:23,239
yo, ya os digo, esperaba que aquí

357
00:38:23,239 --> 00:38:25,320
me fuese a indicar cada uno de los tipos

358
00:38:25,320 --> 00:38:27,119
ahora ya sí que no entiendo nada porque me dice

359
00:38:27,119 --> 00:38:28,679
que todos son integer

360
00:38:28,820 --> 00:38:32,780
cuando además, porque antes cuando decía no es de ningún tipo, digo a lo mejor es que es de

361
00:38:32,780 --> 00:38:36,320
object y no he hecho un casting o algo, pero que me diga que persona es

362
00:38:36,320 --> 00:38:40,480
de un integer, no lo entiendo, bueno, nada, aquí

363
00:38:40,480 --> 00:38:44,500
dejamos las genéricas, si veo luego algo de por qué es, os lo digo

364
00:38:44,500 --> 00:38:48,820
pasamos a las colecciones, vale, fijaros como

365
00:38:48,820 --> 00:38:52,699
en la teoría tenemos este

366
00:38:52,699 --> 00:38:56,599
diagrama que os comentaba, una vez ya hemos hecho la diferenciación

367
00:38:56,599 --> 00:39:03,920
entre arrays y colecciones que diferencian unas y otras comentaros que las las colecciones tienen

368
00:39:03,920 --> 00:39:11,820
bueno se organizan con las colecciones son colecciones y los mapas mapas pero en línea

369
00:39:11,820 --> 00:39:18,960
general las estructuras dinámicas bien son mapas o bien son colecciones y con esa diferenciación

370
00:39:18,960 --> 00:39:26,219
luego tenemos dos criterios principalmente para trabajar con ellos si están si no se preocupan

371
00:39:26,219 --> 00:39:29,820
de tener orden, no están ordenados sus datos

372
00:39:29,820 --> 00:39:34,480
y el otro criterio es si se pueden repetir,

373
00:39:34,559 --> 00:39:40,000
si hay repetidos. Pues según el enunciado de un ejercicio

374
00:39:40,000 --> 00:39:43,579
pues resultará que me interesará que estén con un determinado orden o que no.

375
00:39:43,579 --> 00:39:47,920
Yo que sé, hay más que deciros. Imaginaos que es una colección

376
00:39:47,920 --> 00:39:51,599
con el listado de clase, pues típicamente nos va a interesar que estén

377
00:39:51,599 --> 00:39:55,599
ordenados o estamos acostumbrados por el primer apellido. Nuestro número

378
00:39:55,599 --> 00:39:59,960
de lista, va por el primer apellido, si es igual el primer apellido, alfabéticamente

379
00:39:59,960 --> 00:40:03,860
por el segundo. Pero por ejemplo, entonces ahí

380
00:40:03,860 --> 00:40:07,699
igual me interesaba que fuese algo ordenado

381
00:40:07,699 --> 00:40:11,820
utilizar una de las colecciones que están ordenadas. En otro contexto

382
00:40:11,820 --> 00:40:15,679
yo que sé, vamos a comprar una tienda, la gente que va a comprar, pues bueno

383
00:40:15,679 --> 00:40:19,659
me interesa tener un registro de la gente que va a comprar, pero no necesariamente con un orden

384
00:40:19,659 --> 00:40:23,940
simplemente si fulanito viene a tal hora, pues ya está

385
00:40:23,940 --> 00:40:26,900
pues la incorporo, pero que no esté por delante

386
00:40:26,900 --> 00:40:30,239
en el orden de toda la colección de datos

387
00:40:30,239 --> 00:40:32,960
de otra persona que haya venido antes porque su apellido

388
00:40:32,960 --> 00:40:35,760
alfabéticamente sea anterior, pues nada, pues ya está

389
00:40:35,760 --> 00:40:39,019
en ese contexto me interesa que sea sin orden, pues utilizamos

390
00:40:39,019 --> 00:40:41,559
una que no tenga orden, y luego

391
00:40:41,559 --> 00:40:45,079
el criterio de repetidos, pues tenemos colecciones con

392
00:40:45,079 --> 00:40:48,099
o sin repetidos, y los que tienen repetidos

393
00:40:48,099 --> 00:40:50,920
pues nuevamente vuelve a ser un poco en el contexto

394
00:40:50,920 --> 00:40:52,719
funcional de la aplicación que estamos haciendo

395
00:40:52,719 --> 00:40:59,860
es la gente que quiere acceder a un supermercado pero justo lo que me interesa este dato recogerlo

396
00:40:59,860 --> 00:41:05,300
este dato con independencia de si es una persona ha venido tres veces este día o ha venido una

397
00:41:05,300 --> 00:41:10,960
sola vez bueno pues si me interesa si ha venido tres veces que quede registrado en tres ocasiones

398
00:41:10,960 --> 00:41:18,400
pues lo que haré será utilizar una colección que me permita repetidos con lo cual una persona con

399
00:41:18,400 --> 00:41:21,400
determinado nombre y ese DNI, pues aparecerá

400
00:41:21,400 --> 00:41:24,380
en tres líneas, tres registros dentro de la colección

401
00:41:24,380 --> 00:41:27,219
para esa persona. Y por el contrario

402
00:41:27,219 --> 00:41:29,420
podría ser al contrario. Quiero identificar

403
00:41:29,420 --> 00:41:33,099
los clientes que tengo

404
00:41:33,099 --> 00:41:35,860
pero no me preocupa tanto

405
00:41:35,860 --> 00:41:39,000
si vienen más o menos veces, sino

406
00:41:39,000 --> 00:41:42,320
saber todos los que vienen. Pues esa colección

407
00:41:42,320 --> 00:41:45,380
podría ser sin repetidos. Entonces, combinando

408
00:41:45,380 --> 00:41:48,139
estas dos cosas, lo que haremos será crear

409
00:41:48,139 --> 00:41:59,150
objetos de una colección o de otra se puede eso se puede enfocar desde poco estos dos criterios

410
00:41:59,150 --> 00:42:05,809
se pueden enfocar desde diferentes puntos de vista yo como siempre me ha resultado más claro lo decía

411
00:42:05,809 --> 00:42:12,409
el otro día es los que no admiten duplicados son aquellos son los que aquí os habla como conjuntos

412
00:42:12,409 --> 00:42:19,349
el 9c y por aquí en la parte de colecciones esta parte derecha es colecciones esta parte de

413
00:42:19,349 --> 00:42:25,349
izquierda es mapas, es una visión parcial de la posibilidad de colecciones y mapas, hay más que

414
00:42:25,349 --> 00:42:31,849
estas, pero bueno, es más o menos representativo, son los más utilizados. Pues a la derecha que

415
00:42:31,849 --> 00:42:37,449
tenemos las colecciones, aquellos que no permiten duplicados son los que aparecen con set, por aquí.

416
00:42:39,599 --> 00:42:45,920
Y luego tenemos los que no aparecen con set, es decir, este no admite duplicados, el hash set,

417
00:42:45,920 --> 00:42:49,840
el triset tampoco, el linked has set tampoco, admiten duplicados.

418
00:42:50,739 --> 00:42:53,860
Y luego los que admiten duplicados,

419
00:42:54,000 --> 00:42:58,199
pues bueno, aquí aparece la ArrayList y hay algún otro, el LinkedList.

420
00:43:00,119 --> 00:43:01,519
Hablaremos un poco de los dos,

421
00:43:01,739 --> 00:43:05,460
si no es hoy, el próximo lunes. Y luego,

422
00:43:06,159 --> 00:43:09,139
en cuanto al criterio de orden, normalmente si tenemos

423
00:43:09,139 --> 00:43:13,500
un orden funcional porque queremos que esté ordenado, yo que sé,

424
00:43:13,500 --> 00:43:17,460
que deciros, si son objetos de la clase persona, en un programa

425
00:43:17,460 --> 00:43:20,699
podemos querer que estén ordenados alfabéticamente según el apellido.

426
00:43:21,900 --> 00:43:25,300
Pero en otro programa, aunque sea la misma clase persona, igual queremos que estén

427
00:43:25,300 --> 00:43:29,539
ordenados por el nombre. Y en otro, igual lo que nos interesa

428
00:43:29,539 --> 00:43:33,059
es un orden, pero en función de edad de más jovencito,

429
00:43:33,440 --> 00:43:37,019
los recién nacidos con cero años, hasta los más mayores, 150.

430
00:43:37,659 --> 00:43:41,519
O al revés, igual nos interesa ordenados de los más mayores, desde los que

431
00:43:41,519 --> 00:43:45,559
tienen 150 hasta los que tienen cero añitos. Pues si

432
00:43:45,559 --> 00:43:49,860
hay un criterio que queremos nosotros aplicar funcional a esa colección

433
00:43:49,860 --> 00:43:53,380
para que tenga aplicado ese orden, son los que aparecen con tree.

434
00:43:53,860 --> 00:43:57,619
Tree son los que están ordenados. En principio los ArrayList

435
00:43:57,619 --> 00:44:01,880
no tienen orden de ningún tipo y estos, los LinkedHash

436
00:44:01,880 --> 00:44:05,559
mantienen el orden de según se vayan insertando. Este que es el primero que

437
00:44:05,559 --> 00:44:09,300
inserto, el primero que está en la colección. El segundo, el segundo que está en la colección.

438
00:44:09,300 --> 00:44:12,760
pero es simplemente un orden de inserción y no tanto

439
00:44:12,760 --> 00:44:15,739
un orden definido según un criterio de nuestro

440
00:44:15,739 --> 00:44:19,000
programa, que esos son los TRI. A grandes rasgos

441
00:44:19,000 --> 00:44:20,980
no me preocupa ni ordenar

442
00:44:20,980 --> 00:44:24,300
ni ordenación, ni que haya repetidos. Ya está, es

443
00:44:24,300 --> 00:44:26,679
un cajón de salse donde voy guardando la información

444
00:44:26,679 --> 00:44:30,639
que vayan repitiéndose sin orden. ArrayList

445
00:44:30,639 --> 00:44:31,579
en

446
00:44:31,579 --> 00:44:37,920
en lo que aparece aquí en el dibujo

447
00:44:37,920 --> 00:44:39,119
o linked list

448
00:44:39,119 --> 00:44:45,780
luego hablamos de ello

449
00:44:45,780 --> 00:44:46,219
bueno

450
00:44:46,219 --> 00:44:50,260
a ver, las pilas

451
00:44:50,260 --> 00:44:51,639
las pilas LIFO

452
00:44:51,639 --> 00:44:54,239
los linked has set, dices

453
00:44:54,239 --> 00:44:56,099
los linked list

454
00:44:56,099 --> 00:45:06,690
bueno

455
00:45:06,690 --> 00:45:10,030
en tanto en cuanto

456
00:45:10,030 --> 00:45:11,730
se los va guardando

457
00:45:11,730 --> 00:45:14,409
en las pilas

458
00:45:14,409 --> 00:45:15,889
los LIFO y los FIFO

459
00:45:15,889 --> 00:45:18,329
una pila

460
00:45:18,329 --> 00:45:20,030
y otra la típica fila esta

461
00:45:20,030 --> 00:45:21,190
del supermercado

462
00:45:21,190 --> 00:45:23,849
al que vamos que el primero que atiende es el primero que llega

463
00:45:23,849 --> 00:45:25,829
o la pila que el último que llega

464
00:45:25,829 --> 00:45:26,869
es el primero que se atiende

465
00:45:26,869 --> 00:45:29,369
sí que siguen un criterio

466
00:45:29,369 --> 00:45:31,690
de ordenación según van entrando

467
00:45:31,690 --> 00:45:33,929
pero según los vas recuperando

468
00:45:33,929 --> 00:45:35,809
se van eliminando

469
00:45:35,809 --> 00:45:36,750
digamos que

470
00:45:36,750 --> 00:45:39,610
tiene cierta similitud pero tiene alguna

471
00:45:39,610 --> 00:45:40,929
funcionalidad más añadida

472
00:45:40,929 --> 00:45:43,590
a la hora de recuperar tú recuperas

473
00:45:43,590 --> 00:45:45,309
si es una pila el de arriba

474
00:45:45,309 --> 00:45:47,230
y en un nickel list

475
00:45:47,230 --> 00:45:49,269
podrías recuperar cualquier otro

476
00:45:49,269 --> 00:45:50,130
de la lista

477
00:45:50,130 --> 00:45:56,789
pero en el momento de irse ordenando sí que esos dos que dices y el link el dis tienen un criterio

478
00:45:56,789 --> 00:46:04,030
de ordenación de inserción según se vayan ordenando se van colocando pero a la hora de recuperarlos

479
00:46:04,030 --> 00:46:12,119
quizás no tanto necesariamente y aquí a la izquierda en este lado tenemos los mapas y

480
00:46:12,119 --> 00:46:17,199
a la izquierda perdones a la derecha tenemos las colecciones y la izquierda los mapas y los mapas

481
00:46:17,199 --> 00:46:21,860
la característica que tienen es que trabajan con pares, ¿vale?

482
00:46:21,980 --> 00:46:24,960
Entonces tiene una clave y tiene un valor.

483
00:46:26,000 --> 00:46:31,320
La clave, si pensamos un poco en los arrays y también hablamos de clave y valor,

484
00:46:31,519 --> 00:46:36,340
pues diríamos que el índice en un array podría ser la clave, la posición 5,

485
00:46:36,440 --> 00:46:38,800
pues esa sería la clave del valor que quiero recuperar.

486
00:46:38,880 --> 00:46:44,800
Si es un array de enteros, pues diríamos mi array y entre corchetes ponemos 5,

487
00:46:44,800 --> 00:46:48,300
pues el índice sería 5, que sería un índice de posición en el array

488
00:46:48,300 --> 00:46:52,519
y recupero el valor que es un string o si es un array de personas, la persona

489
00:46:52,519 --> 00:46:56,480
o lo que corresponda. Un poco los mapas serían esa idea.

490
00:46:56,900 --> 00:47:00,440
Accedemos a los diferentes valores según un índice

491
00:47:00,440 --> 00:47:04,519
o una clave que dice aquí y obtenemos un valor

492
00:47:04,519 --> 00:47:08,840
en el mapa. La clave si es por ejemplo entero, pues diríamos

493
00:47:08,840 --> 00:47:12,699
el tercer valor, imaginaos que es

494
00:47:12,699 --> 00:47:16,679
un mapa de personas, ¿no? Pues entonces podríamos decir que la clave

495
00:47:16,679 --> 00:47:20,579
sea el DNI y el valor, todo el objeto

496
00:47:20,579 --> 00:47:24,440
persona en sí, con el nombre, apellidos, nuevamente el DNI podría estar

497
00:47:24,440 --> 00:47:27,940
la dirección, bueno, pues todos los atributos que tenga la clase persona.

498
00:47:28,679 --> 00:47:32,440
Entonces diría, dame de la colección aquel valor que

499
00:47:32,440 --> 00:47:36,239
tenga como clave y ponemos un DNI y que me devuelve

500
00:47:36,239 --> 00:47:40,500
el dato, el objeto de la persona que tendrá ya toda la información

501
00:47:40,500 --> 00:48:09,199
completa de esa persona. Mientras que las colecciones pues tienen un solo dato, no tienen clave y valor, tienen directamente el valor. Y los mapas, es decir, este lado izquierdo, el criterio set, nos olvidamos de él porque los mapas no pueden tener duplicados por clave, la clave tiene que ser única, es decir, digamos que todos los maps serían equivalentes a lo que en las colecciones hemos dicho de set, pero en función de la clave.

502
00:48:09,199 --> 00:48:12,699
y luego eso sí, pueden estar ordenadas o no ordenadas

503
00:48:12,699 --> 00:48:15,159
y las que están ordenadas según un criterio

504
00:48:15,159 --> 00:48:18,460
del programa son las que

505
00:48:18,460 --> 00:48:21,420
vuelven a aparecer por aquí el tree, ordenación

506
00:48:21,420 --> 00:48:23,760
según mi criterio de programa tree, tree map

507
00:48:23,760 --> 00:48:29,309
fijaros este, en cuanto a la colección era

508
00:48:29,309 --> 00:48:32,170
el que estaba ordenado según el criterio de inserción

509
00:48:32,170 --> 00:48:35,690
pues si es según el criterio de inserción la ordenación

510
00:48:35,690 --> 00:48:37,750
del mapa vuelve a ser linked hash

511
00:48:37,750 --> 00:48:40,510
en este caso map y en este caso set

512
00:48:40,510 --> 00:48:45,510
criterio, repito de nuevo, el criterio set

513
00:48:45,510 --> 00:48:49,829
en los mapas no ha lugar, porque nunca habrá duplicado según clave

514
00:48:49,829 --> 00:48:53,889
y el criterio ordenado, que vuelve a ser

515
00:48:53,889 --> 00:48:57,349
la ordenación según la clave, estará

516
00:48:57,349 --> 00:49:01,670
según lo que tengamos definido funcional en nuestro

517
00:49:01,670 --> 00:49:05,489
en nuestro enunciado, de acuerdo a los trimap

518
00:49:05,489 --> 00:49:08,829
y hashmap, pues nada, no tiene ningún tipo de orden

519
00:49:08,829 --> 00:49:12,550
sí que tendrá clave, pero sí que tendrá clave

520
00:49:12,550 --> 00:49:14,869
esa clave nunca podrá estar repetida

521
00:49:14,869 --> 00:49:18,630
pero no tiene ningún orden, el programa

522
00:49:18,630 --> 00:49:21,590
podrá elegir según los guarda, es algo que

523
00:49:21,590 --> 00:49:24,389
es intrascendente para nuestro programa, con lo cual

524
00:49:24,389 --> 00:49:27,570
igual los termina guardando con un orden

525
00:49:27,570 --> 00:49:30,349
como el link de HashMap, pero no te lo garantiza si has definido

526
00:49:30,349 --> 00:49:37,119
un HashMap, entonces vamos a código para ir viendo

527
00:49:37,119 --> 00:49:39,440
todo esto un poco, bueno, otra cosilla

528
00:49:39,440 --> 00:49:40,920
que os quería decir

529
00:49:40,920 --> 00:49:52,019
el otro día me pasó igual no sé dónde está ese gráfico bueno todas las colecciones y ahí bueno

530
00:49:52,019 --> 00:49:58,199
pues según la herencia es conocido la herencia que conocemos todas las colecciones heredan de

531
00:49:58,199 --> 00:50:05,639
o implementan el interfaz java útil colección que es donde nos quedamos el otro día el hecho

532
00:50:05,639 --> 00:50:09,719
de que todas las colecciones me da igual sea la que sea de mapas hablamos luego en otro rato en

533
00:50:09,719 --> 00:50:12,579
otro momento, el lunes que viene

534
00:50:12,579 --> 00:50:15,780
probablemente. Si todas las colecciones implementan

535
00:50:15,780 --> 00:50:18,739
esta interfaz, pues todas están obligadas

536
00:50:18,739 --> 00:50:21,900
a tener descrito qué tienen

537
00:50:21,900 --> 00:50:24,820
que hacer para estos métodos, que son a los

538
00:50:24,820 --> 00:50:26,019
que obliga el interfaz.

539
00:50:27,599 --> 00:50:30,380
Todos ellos hacen lo que nos dice por aquí.

540
00:50:30,760 --> 00:50:33,619
Entonces, cualquier colección, me da igual que acabe en set

541
00:50:33,619 --> 00:50:36,820
porque no tenga duplicados, o acabe en tree

542
00:50:36,820 --> 00:50:42,559
porque tengo una ordenación o directamente sea una que ni tiene ordenación ni nada,

543
00:50:43,260 --> 00:50:47,840
si utilicemos el método site nos tendrá que decir el número de elementos que tiene esa colección.

544
00:50:49,989 --> 00:50:54,230
Si es, por ejemplo, el método add que añade un elemento a la colección,

545
00:50:55,289 --> 00:51:01,750
pues aquí tendrá unas validaciones diferentes si estamos hablando de una que permite duplicados

546
00:51:01,750 --> 00:51:02,969
y una que no permite duplicados.

547
00:51:03,090 --> 00:51:05,469
Si es una de estas que acaban en set o no lo es.

548
00:51:05,469 --> 00:51:08,510
una que acaba en set, dentro de su código tendrá que hacer

549
00:51:08,510 --> 00:51:11,769
la comprobación en todos los elementos

550
00:51:11,769 --> 00:51:14,610
que tiene ya incluidos de si el nuevo elemento

551
00:51:14,610 --> 00:51:17,730
que estoy intentando añadir ya existe. Si existe

552
00:51:17,730 --> 00:51:20,610
¿qué devolverá? Pues devolverá un boolean, dirá false, no he sido

553
00:51:20,610 --> 00:51:23,650
capaz de insertarlo porque ya existe el elemento

554
00:51:23,650 --> 00:51:26,769
y no se pondrá. Si es una colección que admite

555
00:51:26,769 --> 00:51:29,710
duplicados, pues dentro del código

556
00:51:29,710 --> 00:51:32,469
Java que tenemos en las librerías para el método add

557
00:51:32,469 --> 00:51:36,769
de esa clase que implementa una librería con duplicado, una colección

558
00:51:36,769 --> 00:51:40,530
con duplicados, no hará esa comprobación y directamente

559
00:51:40,530 --> 00:51:43,989
lo meterá. Las dos obligatoriamente tendrán que tener

560
00:51:43,989 --> 00:51:47,889
el método ADD porque las dos implementan el interfaz Java

561
00:51:47,889 --> 00:51:51,949
UtilCollection, pero una hará una cosa y otra otra

562
00:51:51,949 --> 00:51:56,409
en función de la característica que tenga esa colección en particular.

563
00:51:57,130 --> 00:51:59,969
Lo cual nos resulta a nosotros muy útil porque el mismo

564
00:51:59,969 --> 00:52:04,289
programa se comportará de una forma o de otra sin tener que programar

565
00:52:04,289 --> 00:52:07,989
nosotros nada adicional, para que tenga o no tenga esos duplicados.

566
00:52:09,570 --> 00:52:12,070
¿Qué métodos tenemos? Que ahora los repasamos un poco

567
00:52:12,070 --> 00:52:16,309
por aquí. Pues fijaros, size nos dice el tamaño, si está vacía la colección,

568
00:52:16,429 --> 00:52:17,969
tiene algún elemento o no tiene ninguno.

569
00:52:19,449 --> 00:52:23,710
Nos devuelve un boolean el método contains diciendo verdadero

570
00:52:23,710 --> 00:52:28,070
si este objeto, este tipo, este elemento ya está en la colección

571
00:52:28,070 --> 00:52:31,250
o no, para incluir un elemento, para borrar un elemento.

572
00:52:32,349 --> 00:52:35,929
Un iterador es algo que nos permite hacer un bucle de todos

573
00:52:35,929 --> 00:52:39,110
los elementos que tiene la colección. Sería como hacer

574
00:52:39,110 --> 00:52:44,050
un while de todos los elementos de un array, pues a través del iterador podemos hacer

575
00:52:44,050 --> 00:52:48,860
esto. Convertir una colección a un array,

576
00:52:50,960 --> 00:52:53,500
decir si en una colección

577
00:52:53,500 --> 00:52:57,460
todos los elementos de otra colección existen. Imaginaros que tenéis una colección

578
00:52:57,460 --> 00:53:01,639
de colores, que tienen 50 colores, entre ellos está incluido

579
00:53:01,639 --> 00:53:05,800
el blanco y el negro. Y tienes una segunda colección

580
00:53:05,800 --> 00:53:09,420
que es blanco y negro solamente. Puedes decir, a ver si

581
00:53:09,420 --> 00:53:14,019
en la colección con más datos existen todos los elementos

582
00:53:14,019 --> 00:53:17,579
que tiene la colección que tiene menos. En este caso, como era blanco y negro y estaba

583
00:53:17,579 --> 00:53:21,699
también en la que tiene más elementos, nos devolverá true. Y en caso

584
00:53:21,699 --> 00:53:25,820
de que la colección pequeña tuviera el blanco, negro y amarillo

585
00:53:25,820 --> 00:53:29,219
y el amarillo no está en la que tiene más elementos, pues nos devolvería

586
00:53:29,219 --> 00:53:32,019
false. Bueno, pues diferentes herramientas con las que

587
00:53:32,019 --> 00:53:35,119
podemos ir trabajando. Añadir todos los elementos

588
00:53:35,119 --> 00:53:38,099
de una colección en otra. Tenemos una colección más grande,

589
00:53:38,199 --> 00:53:41,099
pues intentamos añadir otra colección que tiene menos

590
00:53:41,099 --> 00:53:43,960
o que tiene más los elementos de una colección en una segunda.

591
00:53:44,719 --> 00:53:46,940
Borrar todos los elementos que existen

592
00:53:46,940 --> 00:53:48,980
en una colección en otra.

593
00:53:51,440 --> 00:53:54,719
Esta hace la lógica inversa, solo mantiene

594
00:53:54,719 --> 00:54:01,800
los que no aparecen los que están en la colección al hacer lo contrario y conciliar borramos los

595
00:54:01,800 --> 00:54:11,579
datos de la colección completa vamos a trabajar un poquito algunos de estos datos algunos de estos

596
00:54:11,579 --> 00:54:27,960
métodos que tienen que estar disponibles te digo en todas las colecciones entonces mirad una de las

597
00:54:27,960 --> 00:54:32,860
colecciones que admiten duplicados en la colección y que no están ordenados son la colección a rail

598
00:54:32,860 --> 00:54:40,090
list. Fijaros lo que pongo aquí, que os sonará a lo que poníamos

599
00:54:40,090 --> 00:54:45,510
aquí, ¿verdad? De mi clase esta que había hecho genérica.

600
00:54:46,170 --> 00:54:49,030
Podemos decir que es un ArrayList, por ejemplo, de strings.

601
00:54:54,269 --> 00:54:58,030
Mi ArrayCollection, Call de Collection, y hago un new.

602
00:55:00,010 --> 00:55:04,210
Cuando, típicamente, para que busquéis un poco similitud a lo

603
00:55:04,210 --> 00:55:06,769
que estamos haciendo normalmente, si hacemos un objeto de la clase

604
00:55:06,769 --> 00:55:12,809
persona y pongo mi pair, que lo definimos una referencia a una clase que es la clase

605
00:55:12,809 --> 00:55:20,369
persona. Luego hacemos un new y el constructor de la clase persona. Pues si os fijáis aquí

606
00:55:20,369 --> 00:55:27,230
decimos que definimos una referencia a una clase que es la clase ArrayList y resulta

607
00:55:27,230 --> 00:55:32,789
que esa clase como es genérica le tenemos que indicar un dato. Esta clase ArrayList

608
00:55:32,789 --> 00:55:36,929
que está definida en las bibliotecas de Java, tendrá algo

609
00:55:36,929 --> 00:55:40,909
como esta cuando se está definiendo, donde estamos diciendo

610
00:55:40,909 --> 00:55:48,340
que uno de los datos que recibe es genérico. Y aquí decíamos

611
00:55:48,340 --> 00:55:52,300
luego poníamos new y el constructor persona, pues aquí hacemos

612
00:55:52,300 --> 00:55:54,280
new y el constructor de la ArrayList.

613
00:55:56,099 --> 00:56:01,989
No me compila porque tenemos que importar la clase de Java útil.

614
00:56:03,789 --> 00:56:06,289
Pues ahí lo tenemos. Fijaros

615
00:56:06,289 --> 00:56:09,230
en el contexto de mi ejercicio, resulta que

616
00:56:09,230 --> 00:56:13,610
deduzco, según el enunciado, que necesito empezar a almacenar

617
00:56:13,610 --> 00:56:18,210
valores de tipo string, no sé

618
00:56:18,210 --> 00:56:21,889
la cantidad, con lo cual me he decidido irme por una colección en lugar de por un array,

619
00:56:22,030 --> 00:56:26,070
como no sé la cantidad, no me voy a arriesgar a eso, y

620
00:56:26,070 --> 00:56:30,090
según este contexto, no necesito ni que estén, vale

621
00:56:30,090 --> 00:56:34,590
que estén duplicados los valores y no necesito que estén

622
00:56:34,590 --> 00:56:37,110
ordenados, porque he hecho un ArrayList

623
00:56:37,110 --> 00:56:42,079
el nombre que tiene ese Array

624
00:56:42,079 --> 00:56:43,719
es miArcCol

625
00:56:43,719 --> 00:56:45,539
y justo

626
00:56:45,539 --> 00:56:47,760
no voy a necesitar

627
00:56:47,760 --> 00:56:48,840
definir

628
00:56:48,840 --> 00:56:51,639
dentro de las librerías de Java

629
00:56:51,639 --> 00:56:53,780
un montón de clases ArrayList

630
00:56:53,780 --> 00:56:55,980
no voy a necesitar definir una ArrayList de String

631
00:56:55,980 --> 00:56:58,019
y otra que sea

632
00:56:58,019 --> 00:56:59,119
ArrayList

633
00:56:59,119 --> 00:57:01,019
de Integer

634
00:57:01,019 --> 00:57:03,739
no voy a necesitar esto, ¿por qué?

635
00:57:03,739 --> 00:57:05,139
porque estoy haciendo

636
00:57:05,139 --> 00:57:07,440
que los datos con los que trabaja, que esa clase

637
00:57:07,440 --> 00:57:10,980
sea genérica y se lo indico aquí. Entonces podría definir una ArrayList

638
00:57:10,980 --> 00:57:15,159
de Integers y otra de Strings. Que si solamente

639
00:57:15,159 --> 00:57:18,860
trabajásemos, os decía el otro día, con los tipos primitivos, a lo mejor no sería

640
00:57:18,860 --> 00:57:22,780
descabellado no hacer la genérica y hacer 10 clases ArrayList

641
00:57:22,780 --> 00:57:27,019
y tenerlas en las librerías. Podríamos permitírnoslo para Integer, para

642
00:57:27,019 --> 00:57:30,940
Non, para Boolean, para... Pero tened en cuenta que las colecciones

643
00:57:30,940 --> 00:57:34,659
luego tendremos una ArrayList que será para

644
00:57:34,659 --> 00:57:36,780
de objetos de la clase persona.

645
00:57:37,840 --> 00:57:40,219
Y en el momento en el que entramos ya en la dinámica de clases

646
00:57:40,219 --> 00:57:42,059
que definimos nosotros en nuestro programa,

647
00:57:42,659 --> 00:57:44,179
esto ya se convierte en algo infinito,

648
00:57:44,320 --> 00:57:46,639
porque habrá clases en unos programas que sea la clase persona,

649
00:57:46,760 --> 00:57:48,059
en otra que sea la clase gato,

650
00:57:48,219 --> 00:57:49,820
en otra que sea la clase para las personas,

651
00:57:50,000 --> 00:57:53,280
ya se convierte en algo infinito

652
00:57:53,280 --> 00:57:55,960
y no podemos tener en las librerías infinitos ArrayList.

653
00:57:56,079 --> 00:57:56,920
¿Cómo lo solucionamos?

654
00:57:56,920 --> 00:58:01,400
Con un código único donde el tipo con el que va a trabajar

655
00:58:01,400 --> 00:58:04,579
esa colección se lo indiquemos de forma genérica.

656
00:58:04,659 --> 00:58:08,739
es decir, es súper útil en este caso

657
00:58:08,739 --> 00:58:12,579
este concepto. Este es el motivo por el que hemos estado

658
00:58:12,579 --> 00:58:16,400
antes durante la primera parte de la tutoría entendiendo cómo funcionan

659
00:58:16,400 --> 00:58:17,719
las clases genéricas.

660
00:58:21,340 --> 00:58:24,800
Los ArrayLinks, ¿qué son? Son colecciones y como son colecciones

661
00:58:24,800 --> 00:58:28,719
implementan el interfaz Collision y si implementan

662
00:58:28,719 --> 00:58:32,900
el interfaz Collision o están mal los apuntes

663
00:58:32,900 --> 00:58:36,679
o mal la librería, o tendremos que tener disponibles todos estos métodos.

664
00:58:38,539 --> 00:58:42,820
Vamos a empezar trabajando con el método add, vamos a insertar algún elemento.

665
00:58:44,639 --> 00:58:50,039
Entonces ponemos aquí, miArcCall.add,

666
00:58:51,699 --> 00:58:57,059
clic, sé que es un id listo, pues ya nos dice que este add está esperando un string.

667
00:58:59,480 --> 00:59:01,400
¿Por qué? Porque aquí hemos dicho que esto es un string.

668
00:59:05,269 --> 00:59:07,869
Entonces cojo y le meto aquí, hola.

669
00:59:09,269 --> 00:59:11,989
o le meto una, vamos a definir una variable.

670
00:59:24,340 --> 00:59:26,159
Le puedo poner el string directamente o

671
00:59:26,159 --> 00:59:35,079
voy a volver a añadir la misma, voy a añadir la misma otra vez

672
00:59:35,079 --> 00:59:51,150
y ahora voy a poner aquí un system.out

673
00:59:51,150 --> 00:59:58,630
println y otro de los métodos

674
00:59:58,630 --> 01:00:01,309
que nos dice que tenemos aquí, ¿verdad? Es el método size.

675
01:00:02,030 --> 01:00:04,250
Número de elementos que tiene la colección.

676
01:00:11,000 --> 01:00:12,320
Entonces cojo y digo mi

677
01:00:12,320 --> 01:00:19,960
ar.col.size. Entonces hago aquí

678
01:00:19,960 --> 01:00:22,659
una ejecución y me dice que tiene tres elementos. Fijaros,

679
01:00:22,659 --> 01:01:15,789
1, 2 y 3, 3 ADD que hemos hecho. Fijaros, si yo esta colección en lugar de una ArrayList decido que es una HashSet, vamos a decir que es una HashSet, las Set decimos que no tienen duplicados, ¿verdad? Entonces digo que me la incorpore, las HashSet no admiten duplicados, entonces si yo ahora ejecuto aquí, ¿cuántos elementos me dice que tiene? 2, en lugar de 3, ¿qué he hecho? He hecho 3 ADD, pero este es el mismo elemento, ¿no?

680
01:01:15,789 --> 01:01:21,809
Como es el mismo elemento, resulta que solamente me lo ha puesto una vez y esta me la ha puesto dos veces.

681
01:01:22,550 --> 01:01:39,599
El método ADD, fijaros por aquí, como nos dice que el método ADD devuelve un boolean que dice si permite añadir el elemento a la colección.

682
01:01:41,860 --> 01:01:49,739
Entonces si yo cojo y lo que me devuelve el método ADD, voy a aprovechar y lo voy a meter aquí en un system.out.println.

683
01:01:49,739 --> 01:02:07,139
simplemente voy a sacar lo que me devuelva el System.out, el ADD

684
01:02:07,139 --> 01:02:14,030
ahí tenemos, son las mismas transacciones que hacíamos antes

685
01:02:14,030 --> 01:02:18,230
añadir tres elementos a la colección, pero lo que me devuelve él lo voy a sacar

686
01:02:18,230 --> 01:02:24,269
por pantalla, que es un Boolean, acordaros, entonces yo si vuelvo

687
01:02:24,269 --> 01:02:30,340
a la ArrayList de nuevo, pues me dice true, true, true, y que tiene tres elementos

688
01:02:30,340 --> 01:02:34,239
true, cada uno de los ADD me ha devuelto verdadero, y si cojo

689
01:02:34,239 --> 01:02:42,219
y me voy al HashSet, me dice true, esta la añade

690
01:02:42,219 --> 01:02:48,199
efectivamente está vacía, tiene su lógica, este me dice false, lo quita y este coge y me dice que lo añade

691
01:02:48,199 --> 01:03:00,489
también, true false true, me dice que tiene dos elementos, si hacemos un clear por ejemplo por aquí

692
01:03:00,489 --> 01:03:12,000
y vuelvo a mostrar el tamaño, me dice true false true que tiene dos elementos y después del clear

693
01:03:12,000 --> 01:03:17,559
el tamaño es cero, ¿por qué? porque lo ha vaciado, tiene dos elementos porque mantenemos el hash set

694
01:03:17,559 --> 01:03:26,519
que nos admite duplicados, si yo ahora ejecuto por aquí, pues fijaros

695
01:03:26,519 --> 01:03:30,340
me mantiene los tres elementos y luego después de clear, pues vuelve a tener

696
01:03:30,340 --> 01:03:41,900
cero, por aquí tenemos el triset, ahora después miramos

697
01:03:41,900 --> 01:03:45,800
el criterio, vamos a hacerlo con linked

698
01:03:45,800 --> 01:03:49,699
hash set y con triset, linked hash set y triset

699
01:03:49,699 --> 01:03:54,280
para entender bien la diferencia también que os comentaba

700
01:03:54,280 --> 01:03:59,650
hacemos linked

701
01:03:59,650 --> 01:04:19,170
set, vamos a poner aquí

702
01:04:19,170 --> 01:04:21,190
treset, ahora comentamos una de ellas

703
01:04:21,190 --> 01:04:23,030
y vamos alternando entre una y otra

704
01:04:23,030 --> 01:04:24,289
treset

705
01:04:24,289 --> 01:04:32,679
meto la, le importo

706
01:04:32,679 --> 01:04:34,400
desde java útil y el treset también

707
01:04:34,400 --> 01:04:47,420
mirad, otro de los métodos

708
01:04:47,420 --> 01:04:49,579
ahora vamos al link de haset y al treset

709
01:04:49,579 --> 01:04:50,960
os comento antes otra cosa

710
01:04:50,960 --> 01:04:53,260
otro de los métodos que tenemos por aquí

711
01:04:53,260 --> 01:04:55,679
bueno, recorrer las

712
01:04:55,679 --> 01:04:57,159
colecciones, bueno, tiene

713
01:04:57,159 --> 01:04:59,159
diferentes formas, una de ellas

714
01:04:59,159 --> 01:05:00,780
para recorrer todos los elementos

715
01:05:00,780 --> 01:05:02,559
es a través de

716
01:05:02,739 --> 01:05:31,380
una clase que es la clase iterator, también se puede hacer con un for, luego hacemos algún ejemplo con el for también, entonces toda colección al implementar esta interfaz tiene el método iterator, fijaros que devuelve un objeto de la clase iterator que a su vez es genérico, como podemos hacerlo esto, pues mira para esta colección, voy a comentar este para que tenga datos, por aquí, yo puedo definir un objeto de la clase iterator,

717
01:05:32,739 --> 01:05:35,340
que es también genérico, como hemos estado viendo

718
01:05:35,340 --> 01:05:36,619
en los otros casos.

719
01:05:38,239 --> 01:05:40,199
A ver, ¿dónde está el menos más?

720
01:05:40,340 --> 01:05:47,219
No encuentro el menor mayor ahora en el teclado.

721
01:05:47,519 --> 01:05:49,960
Vamos a decir iterator, un iterator de string

722
01:05:49,960 --> 01:05:51,539
y decimos que sea miIter.

723
01:05:58,940 --> 01:06:01,000
Y ese objeto de la clase iterator,

724
01:06:01,139 --> 01:06:03,579
que en principio va a ser un iterador,

725
01:06:03,719 --> 01:06:06,239
algo que va a ir recorriendo diferentes elementos

726
01:06:06,239 --> 01:06:08,280
de tipo string y que hemos llamado miIter,

727
01:06:08,280 --> 01:06:11,360
lo vamos a cargar desde la colección miArrCall

728
01:06:11,360 --> 01:06:13,059
con el método iterator.

729
01:06:13,360 --> 01:06:33,039
Vamos a importarlo, dejaba útil, y el método iterator se parece un poco a, en los métodos que tiene para su manejo, se parecen un poquito a lo que es la clase scanner, a mí me lo recuerda siempre.

730
01:06:33,039 --> 01:07:01,800
Entonces podemos poner un while mientras mi iter.hasNest, mientras haya elementos que ir recorriendo, lo que vamos a hacer va a ser, vamos a coger string ese info, que sea igual, y aquí hicimos mi iter.nest.

731
01:07:01,800 --> 01:07:27,519
voy a coger el siguiente elemento, ese info no le gusta por, he llamado una variable ya por ahí ese info en algún sitio, ese info 2 tampoco, ese iter, ahí está, lo podemos hacer aquí, hacer un system.out.println de ese iter,

732
01:07:27,519 --> 01:07:38,690
Mira, hasta ahora mismo estamos trabajando con un ArrayList que permite duplicados, con lo cual, al principio deberá añadirnos los tres, tendrá un tamaño de tres.

733
01:07:40,369 --> 01:07:56,179
Luego defino un objeto de la clase iterator, que es, le he puesto string aquí porque estamos trabajando con un ArrayList de strings, si fuera un ArrayList de personas, ahora trabajamos con uno de personas o de otro tipo.

734
01:07:56,179 --> 01:08:00,480
pondríamos que el iterador, cada uno de sus valores, que mi iter en cada una de las

735
01:08:00,480 --> 01:08:04,480
vueltas sea de la clase persona, luego

736
01:08:04,480 --> 01:08:08,360
después, ahora de momento string, y llamamos al método iterator

737
01:08:08,360 --> 01:08:12,300
de miar, que recordad, es una colección de tipo

738
01:08:12,300 --> 01:08:16,579
ArrayList, pero sea del tipo que sea, lo tendríamos disponible

739
01:08:16,579 --> 01:08:20,500
porque es una de las que están definidas en el interfaz

740
01:08:20,500 --> 01:08:26,489
colección. Y lo que hacemos es, cuando se genera el iterador

741
01:08:26,489 --> 01:08:30,109
digamos que se pondría en el primero de los elementos de la colección apuntándolo

742
01:08:30,109 --> 01:08:34,449
dice ¿quedan todavía elementos que recorrer dentro de la colección según

743
01:08:34,449 --> 01:08:38,409
apunta el iterador? Si es hashNest igual que el escáner nos

744
01:08:38,409 --> 01:08:42,350
devolvería un true. Entonces como quedan hago

745
01:08:42,350 --> 01:08:46,109
un nest que lo que hace es leerle ese valor y esto

746
01:08:46,109 --> 01:08:50,470
devolverá al que está apuntando que en principio será una variable

747
01:08:50,470 --> 01:08:54,590
de tipo string. Aquí trabajamos con ella según dijese nuestro enunciado

748
01:08:54,590 --> 01:09:00,930
solamente lo vamos a mostrar por pantalla, y el puntero del literador a la colección avanzará al segundo de los elementos.

749
01:09:01,729 --> 01:09:09,810
Como tenemos tres, todavía habría elementos en el bucle, cogería ese segundo, al coger el segundo lo vuelve a cargar en esta variable,

750
01:09:10,409 --> 01:09:17,989
y el puntero que está identificando el elemento en el que está el literador dentro de la colección avanzaría al siguiente, el tercero.

751
01:09:17,989 --> 01:09:30,989
Aquí lo mostraríamos por pantalla, haríamos la misma jugada con el tercero y al coger ese tercero intentaría apuntar al siguiente que ya no existirá y como no existe el hashnet devolverá falso y nos terminaría el programa.

752
01:09:31,390 --> 01:09:36,670
Esta es un poco la idea. Es algo parecido a recorrer un array elemento a elemento.

753
01:09:38,789 --> 01:09:43,109
Fijaros cómo efectivamente nos dice hola, hola y adiós.

754
01:09:43,109 --> 01:09:48,350
un ArrayList, aunque se supone que no tiene ningún orden, en principio lo está guardando

755
01:09:48,350 --> 01:09:52,569
igual que lo haría un LinkedHashSet, según el orden

756
01:09:52,569 --> 01:09:56,350
en el que están guardados. Bueno, lo ha hecho

757
01:09:56,350 --> 01:10:00,329
pero si lo defines como un ArrayList, es verdad que aquí no lo ha mostrado así

758
01:10:00,329 --> 01:10:03,590
pero si en una ejecución, por lo que sea, la máquina virtual de Java

759
01:10:03,590 --> 01:10:08,250
decidiese ponerlo de forma desordenada, no podríamos culpar a nuestro programa

760
01:10:08,250 --> 01:10:11,630
porque lo hemos definido con un ArrayList que se supone que no tiene por qué estar ordenado

761
01:10:11,630 --> 01:10:15,489
si queremos tener garantías de que está ordenado

762
01:10:15,489 --> 01:10:18,109
y si que nos podríamos quejar de que la máquina virtual lo ha hecho mal

763
01:10:18,109 --> 01:10:22,310
sería si le hacemos un linked hash

764
01:10:22,310 --> 01:10:25,909
bueno, claro, el linked hash set no nos va a permitir

765
01:10:25,909 --> 01:10:28,529
duplicados ya, un hash set

766
01:10:28,529 --> 01:10:32,270
un hash set, este no nos permitiría

767
01:10:32,270 --> 01:10:34,590
duplicados, pero tampoco ningún orden

768
01:10:34,590 --> 01:10:40,220
mirad, un linked hash set se supone que

769
01:10:40,220 --> 01:10:43,260
están ordenados según el criterio de inserción

770
01:10:43,260 --> 01:10:45,920
y no permite duplicados, porque es un set.

771
01:10:49,060 --> 01:10:50,119
Entonces, cogemos y le damos aquí.

772
01:10:51,539 --> 01:10:55,720
Fijaros, según orden, criterio de entrada, hola y adiós.

773
01:10:56,960 --> 01:10:59,640
Y ahora me muestra dos elementos en literador.

774
01:10:59,880 --> 01:11:01,859
¿Por qué? Porque este está duplicado.

775
01:11:02,840 --> 01:11:03,699
Este no lo ha añadido.

776
01:11:04,239 --> 01:11:06,300
Este que corresponde a esta entrada.

777
01:11:11,199 --> 01:11:14,939
Y si lo defino como un triset, pues seguirá un orden,

778
01:11:15,239 --> 01:11:18,760
un criterio de ordenación según identifiquemos nosotros.

779
01:11:18,760 --> 01:11:39,579
Vamos a ver qué es lo que hace aquí el programa. Fijaros, aquí mostraba hola y adiós. Y aquí nos dice que el resultado de recorrer el iterador es adiós, hola. ¿Y cuál es el motivo? Pues el motivo es que la ordenación la ha hecho según el criterio que está definido para el tipo de esta colección, string.

780
01:11:39,579 --> 01:11:56,239
Y normalmente, ¿cómo tenemos definidos los string? Los tenemos definidos de forma alfabética, con lo cual, a la hora de ir insertando esos datos, aunque a Dios lo hemos insertado después, por tratarse de un triset, lo ha colocado en primer lugar y luego después hola.

781
01:11:56,239 --> 01:12:13,619
Como es tree, ha utilizado un criterio funcional para ordenarlos. Primero adiós, luego hola, criterio alfabético, ¿verdad? Al ser un string. Y al ser set, en el tree set, pues ha evitado duplicados. De los tres ha metido dos solo.

782
01:12:13,619 --> 01:12:37,090
Mira, los tipos primitivos, los tipos primitivos lo que tienen es, ya tienen implementado, los tipos primitivos, las clases grupper de los tipos primitivos y los tipos primitivos tienen definido ya un criterio de ordenación preestablecido.

783
01:12:37,090 --> 01:12:41,829
entonces si es un string, el criterio que consideran es alfabético

784
01:12:41,829 --> 01:12:45,989
pero si es un entero

785
01:12:45,989 --> 01:12:49,750
pues es numérico de abajo arriba, el 0 el primero

786
01:12:49,750 --> 01:12:52,909
el 1, el 2, el 3, es el criterio que utilizan

787
01:12:52,909 --> 01:12:57,829
pero en nuestro programa podríamos tener criterios diferentes, entonces vamos a crear

788
01:12:57,829 --> 01:13:02,149
bueno, alguna duda antes de seguir contando más cosas

789
01:13:02,149 --> 01:13:05,470
por no contaros, contaros si hay algún problema ya por ahí en algo

790
01:13:05,470 --> 01:13:11,529
fijaros lo cómodo que es utilizar la librería de Java

791
01:13:11,529 --> 01:13:13,050
porque el mismo código

792
01:13:13,050 --> 01:13:16,770
según tengamos en nuestro enunciado

793
01:13:16,770 --> 01:13:19,069
identificado según diferentes requisitos

794
01:13:19,069 --> 01:13:20,449
lo único que tenemos que hacer es

795
01:13:20,449 --> 01:13:23,029
definir colecciones distintas

796
01:13:23,029 --> 01:13:26,069
las colecciones son súper útiles

797
01:13:26,069 --> 01:13:28,109
en verdad se utilizan mucho

798
01:13:28,109 --> 01:13:35,500
¿alguna dudilla por ahí tenéis?

799
01:13:36,060 --> 01:13:37,699
o sigo contando cosas

800
01:13:37,699 --> 01:13:39,100
si no me paráis sigo

801
01:13:39,100 --> 01:13:49,770
¿Vale? ¿Alguien levantaba la mano por ahí? No. Pues nada, pues sigo contando dos cosas.

802
01:13:50,170 --> 01:14:01,060
Mira, vamos a dar un paso más. En lugar de hacer una colección de strings, vamos a hacer una colección de personas.

803
01:14:12,600 --> 01:14:18,899
Vamos a hacer una colección, vamos a hacer un triset de personas. Luego alternamos con otras.

804
01:14:18,899 --> 01:14:34,640
aquí tenemos, voy a definir dos personas

805
01:14:34,640 --> 01:14:38,460
miper1 y miper2

806
01:14:38,460 --> 01:14:48,840
digo, miar call, nombre de la colección, punto, add

807
01:14:48,840 --> 01:14:52,300
y fijaros como ahora el IDE me dice, oye, que lo que tienes que añadir son personas

808
01:14:52,300 --> 01:14:56,500
¿por qué? pues porque he definido que esta colección es de personas, súper útil

809
01:14:56,500 --> 01:15:01,100
el tema de la posibilidad de definir clases genéricas

810
01:15:01,100 --> 01:15:04,539
útil e imposible gestionarlo de otra forma

811
01:15:04,539 --> 01:15:12,260
Vamos a añadir dos veces la misma persona, igual que estábamos haciendo antes con los strings, y una segunda vez esta otra persona.

812
01:15:13,899 --> 01:15:16,159
Y luego vamos a mostrar aquí el tamaño.

813
01:15:30,210 --> 01:15:36,520
Fijaros, me ha pegado aquí un fallo y me dice algo aquí de comparable.

814
01:15:36,659 --> 01:15:42,239
¿Veis aquí en el error? Dice, oye, que yo no puedo, no tengo definido de ninguna forma.

815
01:15:43,479 --> 01:15:47,140
Fijaros que he creado una colección triset.

816
01:15:47,140 --> 01:16:03,140
Las colecciones triset no admiten duplicados y tienen que estar ordenadas. Y claro, aquí viene la pregunta ahora. Oye, ¿y cómo considero yo que dos personas es la misma persona? ¿Y cómo considero yo el orden?

817
01:16:03,819 --> 01:16:10,359
Porque habrá una clase en la que la clase persona tendrá el DNI y otra en la que no.

818
01:16:10,739 --> 01:16:13,060
Que a lo mejor podría ser un criterio para que no haya duplicados.

819
01:16:13,439 --> 01:16:17,720
Pero a lo mejor en mi ejercicio, aunque estamos acostumbrados, bueno, por lo menos administrativamente,

820
01:16:17,720 --> 01:16:19,840
a tener un DNI cada uno, ¿verdad?

821
01:16:20,020 --> 01:16:24,500
Que en un trised podría ser, seguramente sería uno de los criterios que utilizaríamos habitualmente

822
01:16:24,500 --> 01:16:26,060
para que sean las mismas personas.

823
01:16:26,539 --> 01:16:30,840
Pero resulta que es que en mi ejercicio no me importan los DNIs.

824
01:16:30,840 --> 01:16:33,020
yo lo que quiero es que no haya

825
01:16:33,020 --> 01:16:34,520
en mi tienda

826
01:16:34,520 --> 01:16:36,819
es una situación un poco extraña

827
01:16:36,819 --> 01:16:38,840
pero para intentar buscar un ejemplo

828
01:16:38,840 --> 01:16:40,920
que en mi tienda no haya más de una persona que sea

829
01:16:40,920 --> 01:16:42,819
rubia y no haya más de una persona que sea

830
01:16:42,819 --> 01:16:44,880
morena y no haya más de una persona que sea

831
01:16:44,880 --> 01:16:46,199
pelirroja, entonces si vienen

832
01:16:46,199 --> 01:16:49,060
cinco pelirrojos, por mucho que

833
01:16:49,060 --> 01:16:51,079
tengan diferentes DNI

834
01:16:51,079 --> 01:16:52,819
ese no es el criterio de repetición

835
01:16:52,819 --> 01:16:54,800
que tengo yo en mi ejercicio, el criterio de

836
01:16:54,800 --> 01:16:56,640
repetición que tengo yo es que sea pelirrojo

837
01:16:56,640 --> 01:16:59,140
en el momento que hay un pelirrojo no puede haber un segundo pelirrojo

838
01:16:59,140 --> 01:17:00,800
en el momento que hay un moreno, un rubio

839
01:17:00,800 --> 01:17:28,640
o como sea. Entonces el criterio de gestionar los duplicados puede ser diferente en cada uno de los ejercicios. Eso en cuanto a los duplicados, si resulta que es un set y el criterio de ordenación, ¿cuál es? Si es una persona, si resulta que a lo mejor tiene atributo de edad y tiene atributo de apellidos, oye, mi colección va a estar ordenada alfabéticamente por el primer apellido y si son iguales por el segundo

840
01:17:28,640 --> 01:17:36,720
o va a estar ordenada por la edad o por el DNI, un orden de DNI, pues en cada ejercicio puede ser diferente también.

841
01:17:37,460 --> 01:17:44,920
La colección, en el momento en el que vaya trabajando para ordenarlo, fijaros que es la colección triset

842
01:17:44,920 --> 01:17:50,319
y tiene que valer el orden para un triset para cualquier tipo que tengamos por aquí,

843
01:17:50,500 --> 01:17:56,460
con lo cual tendrán que buscar un punto común que exista en todas las posibles clases

844
01:17:56,460 --> 01:18:00,420
para las que le vayamos a meter aquí un tipo genérico

845
01:18:00,420 --> 01:18:04,340
y que nos garantice que da igual el tipo este termine

846
01:18:04,340 --> 01:18:07,380
ordenando y considerando que no es repetidos.

847
01:18:08,800 --> 01:18:12,840
Y por aquí me chiva, oye, no me gusta porque no está implementando

848
01:18:12,840 --> 01:18:16,520
el interfaz comparable. Entonces, si yo pongo aquí en la clase persona

849
01:18:16,520 --> 01:18:22,789
un implements comparable

850
01:18:22,789 --> 01:18:26,670
y añado los

851
01:18:26,670 --> 01:18:31,470
métodos que están sin implementar, el método que me pone

852
01:18:31,470 --> 01:18:35,090
es el método compareTo. ¿Qué nos hace pensar esto?

853
01:18:35,510 --> 01:18:39,369
Que el triset, para ver cómo ordena

854
01:18:39,369 --> 01:18:43,329
las personas que están en esa colección, y el triset

855
01:18:43,329 --> 01:18:47,270
para ver si dos personas están repetidas, el método

856
01:18:47,270 --> 01:18:50,810
que va a utilizar va a ser el método compareTo. Entonces,

857
01:18:51,770 --> 01:18:55,449
todas las clases, todos los

858
01:18:55,449 --> 01:19:04,289
tipos de colección triset que queramos poner aquí, obligatoriamente, tendrán que tener el método compareTo, que es el que me obliga

859
01:19:04,289 --> 01:19:13,489
al interfaz comparable. Bueno, esto u otro mecanismo que veremos alternativo, pero de momento vamos por aquí. Tendrán que tener implementado

860
01:19:13,489 --> 01:19:23,430
el interfaz comparable para tener posibilidad de ordenar y ver duplicados.

861
01:19:24,430 --> 01:19:29,069
Y ahora aquí ya en la clase persona, sí que tengo yo aquí una zona de código

862
01:19:29,069 --> 01:19:34,970
donde voy a poder gestionar si dos personas son iguales para evitar repetidos

863
01:19:34,970 --> 01:19:37,289
y con qué criterio quiero yo ordenarlos.

864
01:19:37,390 --> 01:19:40,989
Aquí podría decir, quiero ordenar por edad, quiero ordenar por primer apellido.

865
01:19:40,989 --> 01:19:46,090
dos personas que son iguales son las que dos personas que tienen el color de pelo rubio dos

866
01:19:46,090 --> 01:19:51,189
personas que son iguales son dos personas que tienen el color de pelo moreno o dos personas

867
01:19:51,189 --> 01:19:57,510
que son iguales son aquellas que tienen el mismo dni según el criterio particular que tenga mi

868
01:19:57,510 --> 01:20:04,319
ejercicio me ha anunciado que porque más funcionado antes el ejercicio cuando he puesto yo aquí

869
01:20:05,819 --> 01:20:10,739
tristez con string no me ha dado este error y me ha dicho oye el método comparable el

870
01:20:10,739 --> 01:20:16,020
interfaz comparable no lo tienes definido pues porque resulta que string es un tipo de los que

871
01:20:16,020 --> 01:20:21,300
están en las librerías de java que si nos fuésemos a ver su código en las librerías efectivamente

872
01:20:21,300 --> 01:20:26,359
tiene implementado el método con el interfaz comparable y el método compare tú con lo cual

873
01:20:26,359 --> 01:20:33,420
la colección se ha apoyado en ese método del string y la válido mira si yo ahora cojo y ejecutó el

874
01:20:33,420 --> 01:21:02,029
programa, ya con el método compare tú en la clase persona, me dice que hay una sola persona, que ha metido una sola persona. He hecho tres ADDs, ¿verdad? Dos veces la misma y una persona diferente. Y me dice que hay una sola persona. ¿Por qué hay una sola persona? Pues porque el método compare tú devuelve un cero cuando las dos personas son iguales.

875
01:21:02,029 --> 01:21:06,189
devuelve un valor mayor de 0 cuando una de las dos personas es mayor

876
01:21:06,189 --> 01:21:10,170
que la otra y un valor menor de 0

877
01:21:10,170 --> 01:21:15,869
cuando es la otra persona la que es mayor. Aquí ahora mismo

878
01:21:15,869 --> 01:21:19,430
como pone return 0, compare tú, está devolviendo siempre

879
01:21:19,430 --> 01:21:23,529
0 y como devuelve siempre 0, considera las dos personas

880
01:21:23,529 --> 01:21:27,829
iguales. ¿Cómo podemos estar seguros de que se está llamando a este método

881
01:21:27,829 --> 01:21:32,229
en el momento en el que estamos añadiendo aquí elementos? Voy a dejar solamente

882
01:21:32,229 --> 01:21:36,350
dos aquí. Y voy a ejecutar y a pesar de que son

883
01:21:36,350 --> 01:21:40,149
personas diferentes, observad cómo me añade solamente una.

884
01:21:41,909 --> 01:21:44,470
Y ahora tenemos que hacer un acto

885
01:21:44,470 --> 01:21:48,109
de fe diciendo, vale, me estás contando que después de meter el interfaz,

886
01:21:48,250 --> 01:21:52,369
el criterio que utilices es el compare to para ver que las dos personas

887
01:21:52,369 --> 01:21:55,850
son iguales y por eso pone solo uno. Pues mirad, podemos poner aquí

888
01:21:55,850 --> 01:22:01,329
un system.auth.println

889
01:22:01,329 --> 01:22:21,239
Vamos a poner aquí, paso por aquí. Fijaros que nuestro código a la vista, no estamos llamando al método compare tú de la clase persona en ningún sitio, ¿verdad? Lo único que hacemos es el constructor y ya está, y luego añadirlas.

890
01:22:21,239 --> 01:22:41,079
Pero si ejecutamos, fijaros cómo efectivamente en el momento en el que hacemos el ADD en las librerías de Java, se va a los objetos de la clase Persona y utiliza el método compareTo, fijaros cómo nos ha mostrado dos veces aquí la traza que hemos puesto, para ver si las dos personas son iguales.

891
01:22:41,079 --> 01:22:44,460
¿Por qué ha considerado que las dos personas

892
01:22:44,460 --> 01:22:47,699
estas son iguales? Pues porque el compareto

893
01:22:47,699 --> 01:22:50,680
está devolviendo un cero, que es el criterio que tenemos para que dos personas

894
01:22:50,680 --> 01:22:57,989
sean iguales. Mira, si pongo aquí un uno, ¿qué hace?

895
01:22:58,090 --> 01:23:00,810
Me añade las dos personas. ¿Veis el size aquí? ¿Por qué?

896
01:23:00,869 --> 01:23:03,949
Porque ya esas dos personas no son iguales, son diferentes.

897
01:23:04,869 --> 01:23:06,470
¿Qué es lo que devuelve el compareto?

898
01:23:11,420 --> 01:23:25,189
¿Vamos bien? Vamos a definir aquí dos atributos,

899
01:23:27,609 --> 01:23:28,449
la edad y el nombre,

900
01:23:29,670 --> 01:23:30,909
dentro de la clase persona.

901
01:23:37,359 --> 01:23:59,600
Mira, para esta primera persona vamos a decir que se llama, que se llama, y la segunda persona, que se llama.

902
01:24:06,109 --> 01:24:14,449
En principio queremos que el criterio de ordenación sea de forma ascendente para las personas según su nombre.

903
01:24:16,109 --> 01:24:19,689
Esta primera persona hemos dicho que se llame Agus, esta segunda persona que se llame Miguel.

904
01:24:20,449 --> 01:24:27,010
Entonces lo que puedo hacer aquí es poner el criterio codificado que a mí me interese en el compare tú.

905
01:24:27,010 --> 01:24:28,189
entonces digo

906
01:24:28,189 --> 01:24:31,409
las dos personas que se están comparando

907
01:24:31,409 --> 01:24:32,630
en este compareTo es

908
01:24:32,630 --> 01:24:35,310
el objeto que llama al compareTo

909
01:24:35,310 --> 01:24:37,229
y el objeto que se recibe por aquí

910
01:24:37,229 --> 01:24:37,909
como parámetro

911
01:24:37,909 --> 01:24:41,130
alguien estará haciendo desde las librerías de Java

912
01:24:41,130 --> 01:24:43,409
una llamada al método compareTo

913
01:24:43,409 --> 01:24:44,329
de la clase persona

914
01:24:44,329 --> 01:24:47,090
no sé cómo lo estará organizando

915
01:24:47,090 --> 01:24:49,050
pero a lo mejor

916
01:24:49,050 --> 01:24:51,590
miPer está llamando a la clase compareTo

917
01:24:51,590 --> 01:24:52,829
pasándole

918
01:24:52,829 --> 01:24:54,989
como atributo al compareTo

919
01:24:54,989 --> 01:24:55,810
miPer2

920
01:24:55,810 --> 01:24:59,010
entonces aquí podemos coger y decir

921
01:24:59,010 --> 01:25:03,520
persona per house

922
01:25:03,520 --> 01:25:06,319
vamos a poner, vamos a decir, vamos a hacer un casting

923
01:25:06,319 --> 01:25:09,560
porque fijaros que esto recibe un object

924
01:25:09,560 --> 01:25:12,979
para decir que sea una persona

925
01:25:12,979 --> 01:25:16,699
con lo cual la referencia de la segunda persona

926
01:25:16,699 --> 01:25:18,319
que la estamos recibiendo como un object

927
01:25:18,319 --> 01:25:21,739
hacemos un casting para poder trabajar con ella como una persona

928
01:25:21,739 --> 01:25:25,359
y ahora decimos if, si la persona que está llamando

929
01:25:25,359 --> 01:25:29,539
y decimos dis.eseNombre

930
01:25:29,539 --> 01:25:32,340
como es un string

931
01:25:32,340 --> 01:25:35,460
tendremos que utilizarlo para compararlo con compareTo

932
01:25:35,460 --> 01:25:40,199
compare, mira, el método compareTo

933
01:25:40,199 --> 01:25:50,220
devuelve un entero

934
01:25:50,220 --> 01:25:52,500
y bueno, y por aquí

935
01:25:52,500 --> 01:25:55,760
si no leemos todo esto, dice que si las dos

936
01:25:55,760 --> 01:25:58,840
string, como es la cadena string

937
01:25:58,840 --> 01:26:01,500
son exactamente iguales, devuelve un cero

938
01:26:01,500 --> 01:26:16,000
Aquí no lo dice. Son exactamente iguales. Y si una es mayor que otra, alfabéticamente devuelve un valor mayor que cero y si la otra es mayor, devuelve un valor menor que cero. Aquí lo cuenta.

939
01:26:16,000 --> 01:26:44,279
Entonces decimos, si una de las personas, punto, compare tú, respecto al nombre de la otra persona, per aus, punto, ese nombre, si esto es mayor que cero, pues querrá decir, ahora mismo no sé justo el orden, que esta persona es mayor que esta.

940
01:26:44,279 --> 01:26:46,840
vamos a hacer un primer amago, si no luego cambiamos el código

941
01:26:46,840 --> 01:26:52,020
y valor devuelto

942
01:26:52,020 --> 01:26:56,760
vamos a poner aquí que sea 0, vamos a inicializarlo a que las dos personas fuesen igual

943
01:26:56,760 --> 01:27:00,239
entonces si 1 es mayor, decimos que

944
01:27:00,239 --> 01:27:11,739
y es igual a 1, si es la otra persona la que es mayor

945
01:27:11,739 --> 01:27:15,899
devolverá un valor menor que 0, con lo cual vamos a poner aquí un menos 1

946
01:27:15,899 --> 01:27:21,840
y vamos a decir aquí que devuelva y valor def

947
01:27:21,840 --> 01:27:25,560
recapitulamos lo que estamos haciendo aquí en este ejercicio

948
01:27:25,560 --> 01:27:28,439
fijaros, las dos personas que están comparando

949
01:27:28,439 --> 01:27:30,640
una es la que está llamando al método compareTo

950
01:27:30,640 --> 01:27:33,140
que le identificamos con this, recordad

951
01:27:33,140 --> 01:27:34,779
que lo hemos hecho en los constructores

952
01:27:34,779 --> 01:27:38,399
y la otra es la que está recibiendo como atributo

953
01:27:38,399 --> 01:27:40,319
aquí, en el método compareTo

954
01:27:40,319 --> 01:27:44,960
esta persona, hacemos un casting de tipo persona

955
01:27:44,960 --> 01:27:47,439
con perraus y ahora comparamos las dos

956
01:27:47,439 --> 01:27:51,220
las strings, acordaros que no las comparamos con igual, igual o mayor

957
01:27:51,220 --> 01:27:55,279
o diferente, sino que lo utilizábamos con equals o con compareTo.

958
01:27:55,899 --> 01:28:00,239
Y aquí comparamos. El nombre de esta persona comparada con esta

959
01:28:00,239 --> 01:28:04,479
me devuelve un valor mayor que cero. Esto me identifica que una de las dos

960
01:28:04,479 --> 01:28:08,760
es mayor que la otra. Si es la otra la que es mayor, me devuelve un valor menor que cero.

961
01:28:09,000 --> 01:28:12,220
Y si devuelve cero, no entra ni por aquí ni por aquí el compareTo

962
01:28:12,220 --> 01:28:16,460
y es a lo que lo tenemos aquí inicializado. En caso de que sean las dos iguales,

963
01:28:16,539 --> 01:28:20,479
me devolvería un valor de cero.

964
01:28:21,220 --> 01:29:17,659
Vamos a ejecutar, una persona se llama Agus y otra se llama Miguel, ese nombre es Nur, vale, si lo que ha sucedido es que estoy haciendo aquí un ADD fijaros antes de asignarle valor y aquí igual, con lo cual si haciendo esto lógicamente todavía no tienen información los nombres, vamos a poner aquí los ADD justo después, ahora ya aquí en este momento ya ambas personas tienen nombre,

965
01:29:18,420 --> 01:29:20,220
Yo creo que no debería pasar esto ya.

966
01:29:21,739 --> 01:29:22,539
Entonces ejecutamos.

967
01:29:24,600 --> 01:29:24,880
Vale.

968
01:29:25,640 --> 01:29:28,140
Me dice que el tamaño es 2 y ahora lo que vamos a hacer va a ser

969
01:29:28,140 --> 01:29:34,020
un iterador para que nos muestre en el orden en el que se han ido guardando.

970
01:29:35,779 --> 01:29:43,399
Fijaros cómo he añadido 2 porque hemos hecho 2 add y las dos personas tienen nombres distintos.

971
01:29:43,680 --> 01:29:44,880
Hasta ahí nos gusta.

972
01:29:51,689 --> 01:29:52,829
Definimos el iterador.

973
01:29:54,529 --> 01:29:57,170
el literador no es de string

974
01:29:57,170 --> 01:29:59,430
sino que sea de objetos de la clase persona

975
01:29:59,430 --> 01:30:05,880
y aquí decimos

976
01:30:05,880 --> 01:30:07,960
muéstrame el nombre

977
01:30:07,960 --> 01:30:12,689
entonces ejecutamos por aquí

978
01:30:12,689 --> 01:30:14,810
y me dice que el orden

979
01:30:14,810 --> 01:30:15,729
es ausi miguel

980
01:30:15,729 --> 01:30:21,180
perdón

981
01:30:21,180 --> 01:30:24,100
y me generaos que en mi enunciado dice

982
01:30:24,100 --> 01:30:26,260
efectivamente quiero que esté ordenado por el nombre

983
01:30:26,260 --> 01:30:27,760
pero no quiero

984
01:30:27,760 --> 01:30:28,579
el orden

985
01:30:28,579 --> 01:30:31,079
alfabético

986
01:30:31,079 --> 01:30:35,260
de primero A, la B, la C, la D, sino que lo quiero

987
01:30:35,260 --> 01:30:37,920
en el orden inverso alfabético. ¿Qué podríamos hacer aquí?

988
01:30:38,479 --> 01:30:42,680
Nos vendríamos a la clase Persona y diríamos, cuando el nombre de una

989
01:30:42,680 --> 01:30:45,939
sea mayor que el del otro, en lugar de devolver 1, que devuelva menos 1.

990
01:30:46,739 --> 01:30:52,369
Y en este caso, que devuelva el 1. El criterio de ordenación

991
01:30:52,369 --> 01:30:57,090
lo estamos poniendo aquí. Entonces, voy a ver Ejecuto.

992
01:30:57,909 --> 01:31:02,130
Fijaros cómo ya viene ordenado con Miguel y Agus. Es decir, el criterio de ordenación es el que

993
01:31:02,130 --> 01:31:12,020
estamos aplicando en el método compare tú de la clase persona porque es el elemento con el que

994
01:31:12,020 --> 01:31:20,420
estamos trabajando aquí mira vamos a suponer que el criterio de ordenación que queremos tener es

995
01:31:20,420 --> 01:31:29,579
el de edad otro enunciado me dice oye que no que no que no es alfabéticamente es según la edad que

996
01:31:29,579 --> 01:31:35,520
tengan entonces las personas éstas tendrían una determinada edad vamos a ponerle aquí vamos a

997
01:31:35,520 --> 01:31:52,039
decir que mi per.iedad, este tiene 10 años, mi per.2.iedad tiene, vamos a poner 15. Como el criterio de ordenación

998
01:31:52,039 --> 01:31:59,460
que quiero tener ahora es el de edad, fijaros que el método compareTo está siendo llamado en el ADD de la colección

999
01:31:59,460 --> 01:32:07,560
porque estamos trabajando con un triset. Si fuera un ArrayList no lo llamaría, no le preocupa, ni el orden mete todos.

1000
01:32:07,560 --> 01:32:55,979
Ahora después hacemos una ejecución de una ArrayList. Bueno, pues como ahora el criterio es el de la edad, voy a hacer copy de esto y lo modificamos. Decimos, si la edad de 1, este no necesitamos utilizar el compareTo, porque como son números, si la edad de este es mayor que la edad de perAus.iedad, pues que devuelva un 1.

1001
01:32:56,500 --> 01:32:58,460
sino que devuelva aquí menos 1.

1002
01:33:00,970 --> 01:33:07,300
Y si es al contrario, si es menor, que devuelva un menos 1.

1003
01:33:07,739 --> 01:33:09,880
Ahora es la edad el criterio que estamos utilizando.

1004
01:33:14,640 --> 01:33:17,359
Entonces damos aquí una ejecución y me dice Agus Miguel.

1005
01:33:18,300 --> 01:33:20,979
Agus tiene 10 y Miguel tiene 15.

1006
01:33:21,560 --> 01:33:24,180
Pero no, resulta que el criterio que quiero utilizar es

1007
01:33:24,180 --> 01:33:28,220
primero que esté en ordenada la colección según los que sean mayores

1008
01:33:28,220 --> 01:33:29,720
y de mayor a menor en edad.

1009
01:33:30,420 --> 01:33:31,260
Pues entonces, ¿qué haría?

1010
01:33:31,380 --> 01:33:33,460
Pues me vengo aquí en el criterio, pues lo cambio.

1011
01:33:33,460 --> 01:33:38,539
Digo que devuelvo un valor menor aquí y un valor positivo ahí.

1012
01:33:39,460 --> 01:33:45,140
Y si hago la ejecución, en lugar de Agus, Miguel, me ordenará según Miguel y Agus.

1013
01:33:46,100 --> 01:33:48,739
Aquí me muestra Miguel y Agus porque es lo que estoy mostrando aquí, claro.

1014
01:33:49,960 --> 01:33:53,640
Pues aquí podríamos poner más con edad.

1015
01:34:00,159 --> 01:34:03,119
Aquí pongo ese iter.edad.

1016
01:34:07,079 --> 01:34:10,619
O una ejecución y me dice Miguel que tiene 15 y Agus que tiene 10.

1017
01:34:10,619 --> 01:34:32,850
Si vuelvo al criterio de edad, que fijaros lo estoy programando todo aquí en el compare to, a este otro criterio, el criterio de ordenación sería August con 10 y Miguel con 15.

1018
01:34:32,850 --> 01:34:54,470
Y si resulta que las dos personas tienen la misma edad, ¿qué sucede? Pues que, ponemos aquí que los dos tienen la misma edad, fijaros, y al ejecutar, me ha insertado un, como es un triset, ha utilizado el compare tú, ha visto que el criterio que utilizamos para compararlos es el compare tú, la edad, y los dos tienen la misma edad, pues ¿qué ha hecho? Ha insertado uno solo.

1019
01:34:54,470 --> 01:34:58,869
sería repetido, solamente quiero en mi ejercicio

1020
01:34:58,869 --> 01:35:01,829
que haya una persona de cada edad

1021
01:35:01,829 --> 01:35:04,590
en el momento que coincida la edad los considero duplicados

1022
01:35:04,590 --> 01:35:06,529
en este caso, como están los dos duplicados

1023
01:35:06,529 --> 01:35:10,350
por mucho que uno es miper1 o miper2 y tienen diferentes nombres

1024
01:35:10,350 --> 01:35:13,510
como los dos en este criterio denunciado tienen la misma edad

1025
01:35:13,510 --> 01:35:16,630
en la colección solo ha metido uno y ha metido el primero de ellos

1026
01:35:16,630 --> 01:35:18,649
Agus, que es el primero que ha hecho el ADD

1027
01:35:18,649 --> 01:35:26,029
imaginaros que decimos, a ver, yo considero

1028
01:35:26,029 --> 01:35:32,449
¿Qué dos personas son duplicadas en mi ejercicio cuando tienen la misma edad y el mismo nombre?

1029
01:35:32,989 --> 01:35:38,869
Y en caso de tener la misma edad, quiero que el criterio de ordenación sea por nombre.

1030
01:35:40,270 --> 01:35:51,579
Pues entonces cojo y digo, si la edad es igual, sí que me tuneles aquí.

1031
01:35:51,579 --> 01:35:57,699
Y ahora aquí es el momento en el que hay empate de edad, pues voy a utilizar criterio del nombre.

1032
01:36:04,020 --> 01:36:07,079
Solamente si una edad es mayor que otra, me da igual los nombres.

1033
01:36:07,260 --> 01:36:10,399
lo que tenga aquí puesto. En el caso de que los dos tengan

1034
01:36:10,399 --> 01:36:13,319
la misma edad, me voy a fijar en el nombre

1035
01:36:13,319 --> 01:36:16,539
porque en mi enunciado es como dice que tenemos que utilizar

1036
01:36:16,539 --> 01:36:20,979
el criterio. Entonces si hacemos aquí una ejecución, mirad

1037
01:36:20,979 --> 01:36:23,920
me dice primero Miguel, los dos, ¿ha habido empate

1038
01:36:23,920 --> 01:36:26,659
de edad en este caso? Pues primero Miguel porque

1039
01:36:26,659 --> 01:36:29,479
cuando hay empate hemos programado aquí

1040
01:36:29,479 --> 01:36:32,640
que sea el que tiene un nombre

1041
01:36:32,640 --> 01:36:34,920
alfabéticamente, digamos, mayor.

1042
01:36:35,939 --> 01:36:38,560
Aquí, ¿qué se lee cuando hay empate de edad?

1043
01:36:38,699 --> 01:36:44,359
Si le cambiamos aquí el criterio, en caso de empate, ¿qué sucederá?

1044
01:36:44,460 --> 01:36:49,260
Pues sucederá que me mostrará ahora primero Agus.

1045
01:36:52,300 --> 01:36:55,939
Y por mucho que tengamos el mismo nombre, que es el else, cuando hay empate de edad,

1046
01:36:56,539 --> 01:37:00,180
como está esto antes por la edad, si no tiene la misma edad,

1047
01:37:00,699 --> 01:37:02,100
da igual lo que hayamos puesto ahí en el nombre.

1048
01:37:02,100 --> 01:37:10,640
Si pongo que este tiene 15, pues me dice primero Miguel con 10 de edad.

1049
01:37:10,880 --> 01:37:14,319
Y si pongo que este tiene 20, como va a estar el criterio de edad antes,

1050
01:37:14,319 --> 01:37:27,039
pues ahora me dirá que el primero es Agus. ¿Se entiende?

1051
01:37:34,460 --> 01:37:38,369
¿Seguís por ahí? Eso sí, ¿verdad? Vale.

1052
01:37:46,109 --> 01:37:49,590
Sí. Bueno, hay dos formas. Una

1053
01:37:49,590 --> 01:37:54,250
ya está así y la otra que la veremos yo creo el lunes que viene

1054
01:37:54,250 --> 01:37:58,090
porque ya son las 7 y 12, pero que va

1055
01:37:58,090 --> 01:38:02,149
al mismo concepto. Es o implementando la interfaz

1056
01:38:02,149 --> 01:38:05,890
comparable o haciendo una clase que es

1057
01:38:05,890 --> 01:38:10,170
implementando el interfaz comparator y una clase que es comparator

1058
01:38:10,170 --> 01:38:14,090
que vuelve a trabajar sobre el compareTo y hay que pasárselo

1059
01:38:14,090 --> 01:38:18,250
al constructor de la colección. Pero bueno, como llevará un poquito de desarrollo

1060
01:38:18,250 --> 01:38:21,729
el lunes que viene tenemos, yo creo, tiempo para verlo con tranquilidad.

1061
01:38:23,689 --> 01:38:26,229
Pero es un poco, es redundar sobre esta

1062
01:38:26,229 --> 01:38:29,770
idea. Volvemos un poco

1063
01:38:29,770 --> 01:38:33,789
a los tipos de colecciones que tenemos. Cuando

1064
01:38:33,789 --> 01:38:41,710
hablamos de tri set estamos es importante el orden y los duplicados porque es set y porque

1065
01:38:41,710 --> 01:38:47,989
es tri entonces la forma de hacerlo es implementando sobre la clase sobre la que de la que vamos

1066
01:38:47,989 --> 01:38:55,449
almacenando elementos en la colección con el interfaz comparable o una clase que implementa

1067
01:38:55,449 --> 01:38:59,510
tu interfaz que es comparator y luego se mete en el constructor de la clase viene a ser las dos

1068
01:38:59,510 --> 01:39:02,390
un poco equivalentes. Os la cuento la semana que viene.

1069
01:39:03,590 --> 01:39:09,630
Y luego tenemos otras colecciones que son las que tienen el criterio set,

1070
01:39:10,289 --> 01:39:16,090
el criterio set sí, pero el criterio tree no. Es decir, no hay orden,

1071
01:39:16,350 --> 01:39:23,369
pero no queremos duplicados. Y para manejar estas, los métodos sobre los que se trabaja,

1072
01:39:23,449 --> 01:39:26,770
los que tenemos que sobreescribir, si para el tree set es el compare to,

1073
01:39:26,770 --> 01:39:30,590
por el interfaz este, en estas otras

1074
01:39:30,590 --> 01:39:33,649
sobre los que trabajamos son sobre el método equals

1075
01:39:33,649 --> 01:39:38,489
fijaros que equals nos dice si es igual o no es igual

1076
01:39:38,489 --> 01:39:41,529
pero sin darnos un orden, no nos devuelve si uno es mayor

1077
01:39:41,529 --> 01:39:44,510
que otro, un valor mayor que cero y si es el otro un valor

1078
01:39:44,510 --> 01:39:47,470
menor, equals nos dice true o false, pero justo para

1079
01:39:47,470 --> 01:39:50,470
los set donde no hay orden nos resulta

1080
01:39:50,470 --> 01:39:53,109
suficiente porque lo único que queremos es que no haya duplicados

1081
01:39:53,109 --> 01:39:56,250
si nos devuelve true a equals resultará que

1082
01:39:56,250 --> 01:40:00,510
no tengo que insertarlo en la colección, y si nos devuelve false, pues resulta que sí

1083
01:40:00,510 --> 01:40:07,010
que tengo que ponerlo. Bueno, sobre el método

1084
01:40:07,010 --> 01:40:09,229
de equals y sobre otro que es el hashCode

1085
01:40:09,229 --> 01:40:14,770
trabajar sobre estos dos métodos. Lo que vamos a hacer nosotros, ya lo cuento la semana

1086
01:40:14,770 --> 01:40:18,689
que viene, es mantener el hashCode igual para todos

1087
01:40:18,689 --> 01:40:22,529
los casos sin tocarlo, y indicaremos si dos

1088
01:40:22,529 --> 01:40:26,689
elementos son iguales para los set que no son

1089
01:40:26,689 --> 01:40:28,590
tree, sobreescribiendo el método

1090
01:40:28,590 --> 01:40:30,310
de equals. Ya podéis hacer a la idea.

1091
01:40:31,430 --> 01:40:32,710
Sobreescribiremos en lugar del compare

1092
01:40:32,710 --> 01:40:34,270
to el equals y diremos

1093
01:40:34,270 --> 01:40:36,470
si la edad

1094
01:40:36,470 --> 01:40:38,670
es igual a la edad del otro, return

1095
01:40:38,670 --> 01:40:40,670
true. Si es diferente, return

1096
01:40:40,670 --> 01:40:42,670
false. Y ya está. Y las colecciones

1097
01:40:42,670 --> 01:40:44,729
que son set, pero

1098
01:40:44,729 --> 01:40:46,829
no son tree, es decir, que no admiten duplicados

1099
01:40:46,829 --> 01:40:48,550
y no les preocupa el orden,

1100
01:40:49,489 --> 01:40:50,710
cuando vayan a

1101
01:40:50,710 --> 01:40:52,670
chequear algo, chequearán estos dos

1102
01:40:52,670 --> 01:40:54,489
métodos en lugar del método compare to.

1103
01:40:54,489 --> 01:41:27,600
Otra cosilla que me quedaba por enseñaros, mirad, simplemente es por terminar de ir justificando las cosas que vamos contando, intentar ver las que son de verdad, mirad, aquí, aunque está más que demostrado que el trised se va basando en estos criterios para la ordenación, porque según íbamos cambiando aquí, iba sacándonos información diferente por aquí, vamos a meterle para tener total seguridad un system of println de pasa por aquí.

1104
01:41:27,600 --> 01:41:48,720
Este método, como decimos, no lo estamos llamando, ¿verdad? Pero al ir haciendo añadidos, ir metiendo nuevos elementos, es en el que se apoya la librería de Java. Entonces, si damos aquí, fijaros como efectivamente por ahí pasa para hacer sus comprobaciones según esté programada la librería Java, en la librería Java, el método ADD de la clase Triset.

1105
01:41:48,720 --> 01:41:53,239
es decir, está pasando por este compare tú, sí o sí, aquí tenemos las trazas

1106
01:41:53,239 --> 01:41:56,840
si en lugar de tener una librería triset

1107
01:41:56,840 --> 01:42:04,279
una colección triset, perdón, utilizamos la librería

1108
01:42:04,279 --> 01:42:08,399
la ArrayList, la ArrayList

1109
01:42:08,399 --> 01:42:12,159
decimos que no le preocupan en absoluto los duplicados

1110
01:42:12,159 --> 01:42:16,140
ni nada de nada, de la clase persona, fijaros aquí hacemos

1111
01:42:16,140 --> 01:42:20,659
una ejecución y veis como me ha añadido los dos

1112
01:42:20,659 --> 01:42:25,479
ni criterios de nada, ni nombres, ni nada. ¿Por qué? Porque los mete en cualquier caso

1113
01:42:25,479 --> 01:42:28,779
y en este caso no me muestra esta traza. ¿Por qué? Porque

1114
01:42:28,779 --> 01:42:33,180
como no va a hacer comprobaciones de duplicados ni de orden, no necesita apoyarse

1115
01:42:33,180 --> 01:42:36,539
en el método compareTo, que nos ha obligado a meter

1116
01:42:36,539 --> 01:42:41,180
el comparable. Es decir, el método add de las librerías

1117
01:42:41,859 --> 01:42:45,039
de Java, cuando

1118
01:42:45,039 --> 01:42:49,199
utilizamos la colección ArrayList, me da igual para el

1119
01:42:49,199 --> 01:42:52,840
tipo de datos que sea, no tiene que hacer esas comprobaciones, pues no tiene

1120
01:42:52,840 --> 01:42:56,539
accesos al compareto. En la librería de Java

1121
01:42:56,539 --> 01:43:00,840
el código del triset, como necesita un criterio

1122
01:43:00,840 --> 01:43:03,779
para trabajar con ordenados y duplicados

1123
01:43:03,779 --> 01:43:09,039
en lo que se fija es en el compareto, como hemos visto antes con las

1124
01:43:09,039 --> 01:43:13,100
trazas. Fijaros que si ahora estas personas, que los dos únicos criterios

1125
01:43:13,100 --> 01:43:17,100
con los que estábamos trabajando, resulta que tienen las dos la misma

1126
01:43:17,100 --> 01:43:25,800
edad como es una raíz y las dos el mismo nombre aún así a tratarse de una raíz

1127
01:43:25,800 --> 01:43:33,899
buenos metal a los dos si retomamos en la raíz comentamos de

1128
01:43:33,899 --> 01:43:41,060
nuevo la raíz y volvemos al tríceps cuantos tenemos uno porque porque el

1129
01:43:41,060 --> 01:43:45,319
criterio mismo nombre y mirada es lo que estamos aquí de fin bueno ya dice pasa

1130
01:43:45,319 --> 01:43:50,640
por aquí y es lo que hemos definido como para que nos devuelva no se sobreescriba

1131
01:43:50,640 --> 01:44:01,199
esto y nos devuelve al valor de por defecto que era el 0. ¿Alguna duda tenéis

1132
01:44:01,199 --> 01:44:04,800
por ahí que queréis que comentemos antes de cerrar ya por ahí? El próximo día

1133
01:44:04,800 --> 01:44:09,279
me preocupo antes de que se grabara la clase, espero que

1134
01:44:09,279 --> 01:44:13,100
sí, para subirla. Y el próximo día retomamos aquí

1135
01:44:13,100 --> 01:44:18,420
con el otro criterio para las colecciones. Miraremos también

1136
01:44:18,420 --> 01:44:22,000
los que no son tree, como trabajando sobre el equals y el hashcode

1137
01:44:22,000 --> 01:44:26,920
es el mecanismo que tenemos para que compruebe si hay duplicados

1138
01:44:26,920 --> 01:44:32,800
y hacemos alguna cosita con mapas también y bueno con eso más o menos le damos una vuelta a lo que

1139
01:44:32,800 --> 01:44:44,689
es el tema alguna pregunta ya tenéis por ahí bueno pues si no tenéis nada vamos cerrando

1140
01:44:44,689 --> 01:44:50,210
ya son las 7 y 20 y ya tenéis tarea y para que os entretengáis si podéis sacar un rato

1141
01:44:51,590 --> 01:44:54,350
venga para la grabación y que tengáis buena tarde