1
00:00:00,000 --> 00:00:06,500
Entonces, nosotros hemos dicho que anteriormente, en noviembre o algo por el estilo,

2
00:00:06,500 --> 00:00:09,500
hemos aprendido a utilizar los arrays.

3
00:00:09,500 --> 00:00:12,500
Una de las características fundamentales de los arrays es que son estáticos,

4
00:00:12,500 --> 00:00:17,500
que son, una vez creados, esas son las celdas que pueden contener,

5
00:00:17,500 --> 00:00:23,500
y si yo quiero añadir o quitar algo, pues tengo que liarme con cosas complejas.

6
00:00:23,500 --> 00:00:34,460
entonces ha llegado un momento en que nosotros decimos hoy mira para pero porque no simplificó

7
00:00:34,460 --> 00:00:42,859
el utilizo de los arrays como los arrays a mí me molestan porque tengo que hacer siempre código

8
00:00:42,859 --> 00:00:49,679
súper complejo vale para poder trabajar con los arrays porque no me los quito de encima

9
00:00:49,679 --> 00:00:53,640
y tú dices, yo no sé cómo se hace.

10
00:00:53,799 --> 00:00:55,340
Pues sí, sabes cómo se hace.

11
00:00:56,020 --> 00:00:59,679
Vosotros tenéis todas las herramientas para quitaros lo de encima,

12
00:00:59,859 --> 00:01:02,240
solo que no habéis conectado los puntos.

13
00:01:03,240 --> 00:01:08,239
Tenéis el rotulador, tenéis los puntos, pero os falta hacer el dibujo.

14
00:01:08,239 --> 00:01:11,280
Entonces hoy vamos a intentar hacerlo.

15
00:01:11,939 --> 00:01:16,219
Entonces me he creado un nuevo proyecto con un package.

16
00:01:16,219 --> 00:01:20,579
Aquí vamos a crear una interfaz, ¿vale?

17
00:01:21,099 --> 00:01:24,120
Esta interfaz la llamamos, no sé, lista.

18
00:01:26,599 --> 00:01:31,780
Estamos de acuerdo que en el mundo de los arrays,

19
00:01:32,099 --> 00:01:36,439
nosotros principalmente por ahora lo hemos utilizado como una lista, ¿vale?

20
00:01:36,439 --> 00:01:40,840
Yo tenía los alumnos, he puesto los alumnos en una lista que era mi array.

21
00:01:41,140 --> 00:01:44,879
Yo tenía los coches, pues tenía un array de coches donde dentro ponía coches,

22
00:01:44,980 --> 00:01:46,519
una lista de coches, ¿sí?

23
00:01:46,519 --> 00:01:58,180
A veces lo he, como se dice, ordenado, a veces he buscado ahí dentro, he hecho cosas distintas, pero sustancialmente lo que he hecho es utilizarlo como una lista.

24
00:01:58,319 --> 00:02:04,340
Existen otros tipos de estructuras de datos que veremos cuando veremos la teoría de esta parte, ¿vale?

25
00:02:04,519 --> 00:02:06,799
Pero por ahora nosotros pensamos en una lista.

26
00:02:06,799 --> 00:02:16,240
Entonces, cuando yo he usado mis fantásticos arrays en mis proyectos superdifíciles que

27
00:02:16,240 --> 00:02:24,879
pueden ser una escuela, un taller o lo que sea, pues ¿qué operaciones necesitaba hacer

28
00:02:24,879 --> 00:02:34,830
sobre estos arrays antes de recorrer un array?

29
00:02:34,830 --> 00:02:40,560
Va, recorrer un array, ¿qué más?

30
00:02:40,560 --> 00:03:02,939
Sí, es como lo relleno, añadiendo un elemento. Añadamos un elemento. Yo quiero que mi interfaz

31
00:03:02,939 --> 00:03:11,199
lista, cuando yo creo una lista, este objeto mágico que voy a crear, que sustituirá los arrays,

32
00:03:11,199 --> 00:03:21,039
pues tendrá la posibilidad de public void add para añadir a la lista una cosa nueva, ¿vale?

33
00:03:21,039 --> 00:03:31,650
¿Add qué? Oiga, señores, os separo si seguís leyendo. ¿Qué queremos añadir? Element. ¿Y qué

34
00:03:31,650 --> 00:03:51,409
tipo le doy a él? Ni idea. Si fuera un array de string, el elemento sería string. Si fuera

35
00:03:51,409 --> 00:04:00,050
un array de coches, coche. Si fuera un array de gatos, gato. Entonces, ¿cómo hago? ¿Qué

36
00:04:00,050 --> 00:04:18,389
hago aquí? ¡Voilá! Añado un objeto. ¿Gato es un objeto? Hola, buenos días. Clase de programación,

37
00:04:18,389 --> 00:04:24,449
lunes, ya segunda hora. El hecho de no estar dormido porque primera hora ya no vale. ¿Sí?

38
00:04:25,709 --> 00:04:35,240
¿Por qué uso object? Para hacerlo más genérico. ¿Vale? Esto me permite añadir lo que me da la

39
00:04:35,240 --> 00:04:45,060
si no está perfecto vale esto molaría decir que si yo estoy utilizando una red string fuera string

40
00:04:45,060 --> 00:04:51,240
donde de gato gatos mientras esta cosa aquí es un poquito peligrosa porque me permitiría añadir gato

41
00:04:51,240 --> 00:04:58,540
string dentro del mismo a la misma cosa vale pero todavía nos falta saber utilizar bien los tipos

42
00:04:58,540 --> 00:05:06,980
genéricos. Porque aquí lo que me encantaría ponerle tipo T. ¿Qué es tipo T? No lo sé. Ya lo veremos.

43
00:05:08,040 --> 00:05:16,839
Pero podría hacer... Ahí. Ya he utilizado el tipo genérico. No estoy haciendo una lista cualquiera,

44
00:05:16,980 --> 00:05:22,399
estoy haciendo una lista de objetos T que me tendrás que decir cuando lo creas y aquí añades

45
00:05:22,399 --> 00:05:27,980
un elemento T. Pero como todavía no lo entendemos y estamos... ¿Qué es esto? Y añadimos

46
00:05:27,980 --> 00:05:29,920
complejidad, pues por ahora vamos

47
00:05:29,920 --> 00:05:31,680
así. ¿Vale? Pongo objetos.

48
00:05:32,819 --> 00:05:33,980
¿Me podéis hacer un ejemplo

49
00:05:33,980 --> 00:05:34,519
de un object?

50
00:05:42,689 --> 00:05:44,050
¿Coches? ¿Qué más?

51
00:05:45,129 --> 00:05:46,110
¿Gato? ¿Qué más?

52
00:05:46,430 --> 00:05:46,610
¿Malo?

53
00:05:48,069 --> 00:05:49,970
¿Entendéis que todas las clases que

54
00:05:49,970 --> 00:05:51,170
he creado hasta ahora son object?

55
00:05:52,750 --> 00:05:54,009
¿Sí? Porque

56
00:05:54,009 --> 00:05:56,129
heredan de object directamente o

57
00:05:56,129 --> 00:05:58,110
indirectamente. Por lo tanto,

58
00:05:58,209 --> 00:06:00,230
si aquí pongo object, puedo poner cualquier cosa.

59
00:06:01,250 --> 00:06:02,189
¿Sí? Entonces,

60
00:06:02,310 --> 00:06:03,709
si me estoy diciendo, mira,

61
00:06:04,189 --> 00:06:11,189
Quien implemente una lista, tiene que tener la posibilidad de añadir un objeto.

62
00:06:11,189 --> 00:06:19,500
¿Cómo se hace? Me da igual. Lo tienes que saber tú, cómo se hace.

63
00:06:19,500 --> 00:06:27,500
Pero cuando yo usaré tu clase que implementa esta interfaz, sé que puedes añadir un objeto a la lista.

64
00:06:27,500 --> 00:06:30,500
¿Sí? ¿Qué más puede hacer una lista?

65
00:06:30,500 --> 00:06:52,110
public void removeObjectElement, puede ser ¿no? Vamos con calma. ¿Esto qué hace? Pues me tiene que

66
00:06:52,110 --> 00:07:17,350
buscar el objeto elemento y quitar. Podría hacerlo así, pero no. Cuidado, cuando yo uso esto yo tendré

67
00:07:17,350 --> 00:07:25,329
que comprobar que el objeto element es igual al objeto que voy a borrar y borrarlo, cuando uso

68
00:07:25,329 --> 00:07:35,829
esto, borro una posición concreta. Cuando uso esto, me expongo a la posibilidad que haya varias veces

69
00:07:35,829 --> 00:07:41,110
el mismo objeto en la lista y si digo remueve el objeto, ¿qué quiere hacer? ¿Quiere remover el

70
00:07:41,110 --> 00:07:52,420
el primero, quiere removerlos todos, ¿qué quiere hacer? Lo tengo que definir. Entonces,

71
00:07:52,420 --> 00:07:59,579
esto nosotros usamos una versión list sencilla, pero si tuviera que hacerla una compleja,

72
00:07:59,579 --> 00:08:06,980
una seria, debería plantearme estos problemas. Dejamos los dos, ¿por qué no? Sobrecargamos

73
00:08:06,980 --> 00:08:11,279
que el remove se puede eliminar como elemento o como posición.

74
00:08:11,279 --> 00:08:25,509
Más, ¿qué función tiene replace?

75
00:08:25,509 --> 00:08:31,089
Porque replace al fin y al cabo podría ser remueve un objeto y pone otro.

76
00:08:31,089 --> 00:08:34,889
Entonces, más o menos lo tengo, para no complicarme la vida, ¿vale?

77
00:08:34,889 --> 00:08:47,460
Pero sí, cosas que podrían estar interesantes, es, ¿sabes?, dime el tamaño de la lista, public,

78
00:08:47,460 --> 00:09:10,230
ah, bueno, y public object busca, public int, object busca, object,

79
00:09:10,230 --> 00:09:16,970
¿Qué hará esta cosa aquí?

80
00:09:19,879 --> 00:09:21,279
Busca a este señor

81
00:09:21,279 --> 00:09:22,440
Y me devuelve

82
00:09:22,440 --> 00:09:27,480
Su posición

83
00:09:27,480 --> 00:09:31,259
Pero si hay más de un objeto

84
00:09:31,259 --> 00:09:33,639
De este tipo, pues devolvamos esto

85
00:09:33,639 --> 00:09:39,019
Si queremos

86
00:09:39,019 --> 00:09:41,620
Y si no, asumamos que

87
00:09:41,620 --> 00:09:45,320
El busca te dice

88
00:09:45,320 --> 00:09:47,740
La posición del primer objeto

89
00:09:47,740 --> 00:09:49,080
Igual a esto

90
00:09:49,080 --> 00:09:51,100
El primer

91
00:09:51,100 --> 00:09:56,340
Podría haber más, pero él te da el primero que encuentro, ¿si?

92
00:09:56,340 --> 00:10:02,379
Y removeObject para nosotros remueve el primer objeto que se encuentre, ¿vale?

93
00:10:02,379 --> 00:10:19,090
Me lo apunto, remueve el primer objeto igual a element, devuelve la posición del primer

94
00:10:19,090 --> 00:10:40,460
objeto igual a elemento. ¿Sí? ¿Por qué? Porque he decidido yo hacerlo así, ¿vale? Para reducir la

95
00:10:40,460 --> 00:10:46,879
complejidad de esta cosa, ¿sí? Porque si no, debería trabajar con me devuelve un array de

96
00:10:46,879 --> 00:10:53,139
enteros y cosas por el estilo, ¿vale? En un punto más complejo. Entonces, por ahora, lo dejamos así, ¿vale?

97
00:10:53,139 --> 00:11:07,919
también apunto aquí negativo si no lo encuentra. Entonces, si lo encuentra me devuelve la posición

98
00:11:07,919 --> 00:11:15,899
del array allí dentro. La posición del elemento dentro de esta lista. Si en vez de no lo encuentra

99
00:11:15,899 --> 00:11:19,779
me devolverá menos uno, por ejemplo. Entonces, menos uno quiere decir, mira, lo he buscado y no

100
00:11:19,779 --> 00:11:20,279
la he encontrado.

101
00:11:22,139 --> 00:11:23,279
Esto está claro.

102
00:11:23,860 --> 00:11:25,539
Este de aquí creo que está claro también.

103
00:11:25,840 --> 00:11:27,879
¿Dónde lo añade? ¿Al principio, al final, en el

104
00:11:27,879 --> 00:11:29,240
medio? Ordenado.

105
00:11:30,460 --> 00:11:31,700
Al final, claramente.

106
00:11:36,059 --> 00:11:37,080
Lo decidimos nosotros.

107
00:11:38,200 --> 00:11:39,799
¿Vale? No es necesario

108
00:11:39,799 --> 00:11:41,879
saber...

109
00:11:41,879 --> 00:11:43,379
Por ahora estamos creando nuestra

110
00:11:43,379 --> 00:11:45,639
interfaz. Si tuviese una interfaz

111
00:11:45,639 --> 00:11:47,519
ya creada, debería ir a mirar

112
00:11:47,519 --> 00:11:48,600
oye, ¿qué hace?

113
00:11:49,279 --> 00:11:51,320
A lo mejor yo quiero que la lista

114
00:11:51,320 --> 00:11:53,200
mía sea ordenada. Entonces,

115
00:11:53,200 --> 00:11:55,419
cuando lo añado, no lo puedo añadir al azar.

116
00:11:55,679 --> 00:11:57,279
Tengo que añadirlo donde está de acá.

117
00:11:57,419 --> 00:11:59,399
Entonces, no puedo

118
00:11:59,399 --> 00:12:01,100
utilizar Object. Debería utilizar

119
00:12:01,100 --> 00:12:01,659
Comparable.

120
00:12:03,080 --> 00:12:05,259
Para poder estar seguro que

121
00:12:05,259 --> 00:12:07,120
yo puedo añadir los objetos que te da la gana

122
00:12:07,120 --> 00:12:09,340
siempre y cuando implemente Comparable.

123
00:12:09,820 --> 00:12:11,220
Porque si tiene que estar ordenada,

124
00:12:11,360 --> 00:12:13,039
pues tengo que poder compararlos entre ellos.

125
00:12:15,500 --> 00:12:15,659
¿Verdad?

126
00:12:16,120 --> 00:12:18,580
Pero eso no sería Sol en vez de A.

127
00:12:18,860 --> 00:12:21,200
No lo sé.

128
00:12:22,000 --> 00:12:24,080
Si tú quieres añadirlo desordenado

129
00:12:24,080 --> 00:12:25,960
y luego ordenarlo,

130
00:12:25,960 --> 00:12:31,820
sí, podría poner aquí otra cosa. Pero si tú asumes que tu lista siempre esté ordenada,

131
00:12:31,820 --> 00:12:35,720
quiere decir que cuando añades un nuevo elemento no lo puedes ordenar desordenado

132
00:12:35,720 --> 00:12:39,820
esperando a que alguien haga sort. Pues tú lo añades y automáticamente lo sorteas.

133
00:12:41,980 --> 00:12:54,850
¿Queréis el sort? Esto es ya un poquito más complejo. Hablit int sort object. Pero esto

134
00:12:54,850 --> 00:12:58,429
es un poquito más complicado porque nosotros estamos utilizando object entonces podría no

135
00:12:58,429 --> 00:13:09,230
ser comparable, por lo tanto esto es un poco más complejo. Lo tenemos sencillo. Esta es una lista

136
00:13:09,230 --> 00:13:16,789
muy sencilla. Añade, quita, dice el tamaño y busca si hay un objeto o no hay dentro. Si lo encuentra,

137
00:13:16,789 --> 00:13:25,490
de paso me da también... Esto habría podido ponerlo como booleano. Dime si está o no. Contains. Pero

138
00:13:25,490 --> 00:13:29,850
como ya que para saber si lo contiene

139
00:13:29,850 --> 00:13:33,710
lo tengo que buscar, una vez que lo he encontrado, en vez de decir si lo contiene, pues te

140
00:13:33,710 --> 00:13:37,870
devuelvo ya el número y tú sabes que menos uno es, no lo

141
00:13:37,870 --> 00:13:41,610
contiene, cualquier otro número positivo, pues es el índice donde está.

142
00:13:42,990 --> 00:13:45,629
¿Sí? Podríamos ahora añadir

143
00:13:45,629 --> 00:13:48,950
una última cosa que es el public

144
00:13:48,950 --> 00:13:54,580
object get int.

145
00:13:54,580 --> 00:14:03,460
sigue. Esto me sirve para pillar los objetos de la lista. Los puedo pillar de uno en uno,

146
00:14:03,460 --> 00:14:09,039
pero uno, dos, tres, entonces me pillaría el primero, el segundo, el tercero, o podría

147
00:14:09,039 --> 00:14:15,259
buscar un objeto, me da el asistio tres, entonces si yo aquí le pongo tres y él me da el objeto

148
00:14:15,259 --> 00:14:42,419
asociado. Sí? Buscar es como show? Buscar es como show. O sea, sería la misma definición? No lo sé. Show qué? Como mostrar. Pero mostrar, yo si leo un show, me mostraría el entero array. En mi opinión. Busca no lo enseña. Busca tiene igual de tres, que es la posición del objeto que estabas buscando.

149
00:14:42,419 --> 00:14:44,039
¿Queréis un show?

150
00:14:45,399 --> 00:14:46,039
Public

151
00:14:46,039 --> 00:14:48,019
void

152
00:14:48,019 --> 00:14:49,799
toString. ¿Cómo no?

153
00:14:50,580 --> 00:14:52,000
Pero ya lo tiene, public string.

154
00:14:53,539 --> 00:14:54,419
Ya lo tiene

155
00:14:54,419 --> 00:14:56,120
porque cualquier

156
00:14:56,120 --> 00:14:58,539
objeto que implemente esta lista

157
00:14:58,539 --> 00:15:00,200
ya tiene el toString

158
00:15:00,200 --> 00:15:02,399
de object. Por lo tanto, esto es un poco

159
00:15:02,399 --> 00:15:02,799
inútil.

160
00:15:04,659 --> 00:15:07,019
Pero

161
00:15:07,019 --> 00:15:10,120
si quiero que

162
00:15:10,120 --> 00:15:11,220
funcione, pues

163
00:15:11,220 --> 00:15:12,659
imprime lista.

164
00:15:12,659 --> 00:15:27,990
Lo que hace es imprimir la lista. Entonces, ¿qué estoy haciendo aquí? Yo estoy definiendo.

165
00:15:27,990 --> 00:15:33,509
Yo hasta ahora estoy trabajando con los arrays. Odio los arrays porque son mis amigos. Si

166
00:15:33,509 --> 00:15:44,049
seguís hablando y riendo os separo. Segundo aviso. Los arrays no me gustan porque son

167
00:15:44,049 --> 00:15:50,730
complicados y cosas por el estilo pues quiero hacer una nueva entidad una nueva

168
00:15:50,730 --> 00:15:56,710
clase que sea una lista y que cuando yo voy a trabajar con ella en vez de decir

169
00:15:56,710 --> 00:16:01,870
oye mira pilla la red y hablo más grande de una posición de recorre lo llega al

170
00:16:01,870 --> 00:16:06,250
final pone la cosa si es cuestión no yo le digo añade este elemento y él se

171
00:16:06,250 --> 00:16:12,340
encarga yo digo tengo que quitar un elemento

172
00:16:12,340 --> 00:16:14,320
vale, entonces recorre la array, busca dónde está

173
00:16:14,320 --> 00:16:16,440
el elemento, quítalo, reduce la array

174
00:16:16,440 --> 00:16:18,360
y cosas por el estilo, pues no lo quiero hacer más

175
00:16:18,360 --> 00:16:20,580
vale, quiero que yo le diga, remuévelo

176
00:16:20,580 --> 00:16:21,360
y él lo hace

177
00:16:21,360 --> 00:16:23,000
¿ok?

178
00:16:24,139 --> 00:16:26,360
pero para llegar a esto

179
00:16:26,360 --> 00:16:28,080
tengo que hacer

180
00:16:28,080 --> 00:16:30,539
lo de los arrays una última vez

181
00:16:30,539 --> 00:16:31,799
¿vale?

182
00:16:33,240 --> 00:16:34,720
entonces, vamos a verlo

183
00:16:34,720 --> 00:16:36,460
esto se entiende, esto es

184
00:16:36,460 --> 00:16:38,240
un contrato que me dice, para hacer

185
00:16:38,240 --> 00:16:40,019
este nuevo elemento que nosotros hemos llamado

186
00:16:40,019 --> 00:16:44,580
una lista, pues para hacer un objeto que sea una lista tiene que implementar

187
00:16:44,580 --> 00:16:48,320
estos métodos de aquí. Podría añadir más. Podría decir

188
00:16:48,320 --> 00:16:52,399
contains, podría decir remove, pero una

189
00:16:52,399 --> 00:16:56,480
lista de objetos y que él remove a todos esos objetos que están

190
00:16:56,480 --> 00:16:59,519
o añadir una lista y añadir

191
00:16:59,519 --> 00:17:04,400
un array y él me añade todos los elementos de ese array. Puede hacer lo que me da

192
00:17:04,400 --> 00:17:07,599
la gana. Pero esta es mi lista mágica.

193
00:17:07,599 --> 00:17:17,539
¿Sí? Entonces, una vez que yo tengo la lista, tengo la idea de la lista, ahora tengo que hacer la implementación de la lista.

194
00:17:17,980 --> 00:17:20,339
Y nosotros vamos a hacer dos implementaciones.

195
00:17:21,079 --> 00:17:30,019
La primera implementación es la más fácil para vosotros porque estos métodos los habéis implementado ya 5.000 veces.

196
00:17:30,019 --> 00:17:39,670
Me creo una nueva clase que llamaré miListaArray.

197
00:17:39,670 --> 00:17:43,859
¿Vale? Esta clase

198
00:17:43,859 --> 00:17:44,920
listarray

199
00:17:44,920 --> 00:17:46,460
implements

200
00:17:46,460 --> 00:17:48,059
listarray.

201
00:17:49,680 --> 00:17:51,720
Se enfada porque dice no es posible

202
00:17:51,720 --> 00:17:53,519
porque no tiene todos los métodos.

203
00:17:54,039 --> 00:17:55,259
Venga, ponme los métodos.

204
00:18:01,440 --> 00:18:02,319
Y no me da hoy

205
00:18:02,319 --> 00:18:04,599
opciones.

206
00:18:10,779 --> 00:18:12,220
Ahí. Esto me gusta.

207
00:18:13,319 --> 00:18:14,740
¿Ok? Entonces

208
00:18:14,740 --> 00:18:16,539
estos son todos los métodos

209
00:18:16,539 --> 00:18:17,759
que tengo que

210
00:18:17,759 --> 00:18:19,599
¿cómo se dice?

211
00:18:19,599 --> 00:18:23,220
implementar aquí dentro

212
00:18:23,220 --> 00:18:24,579
para que esto funcione.

213
00:18:25,599 --> 00:18:26,980
¿Veis? Entonces empezamos.

214
00:18:27,799 --> 00:18:29,619
Yo tengo ahora que imaginarme

215
00:18:29,619 --> 00:18:31,819
cómo voy a implementar

216
00:18:31,819 --> 00:18:32,440
esta lista.

217
00:18:33,819 --> 00:18:35,259
Tengo que tener

218
00:18:35,259 --> 00:18:37,500
algo por detrás, algo que luego

219
00:18:37,500 --> 00:18:38,619
será escondido.

220
00:18:39,619 --> 00:18:40,339
Pero

221
00:18:40,339 --> 00:18:43,960
me sirve para implementar la funcionalidad

222
00:18:43,960 --> 00:18:45,380
de esta lista por dentro.

223
00:18:46,619 --> 00:18:47,680
¿Vale? Y nosotros

224
00:18:47,680 --> 00:18:50,240
esta primera versión de lista

225
00:18:50,240 --> 00:18:52,039
la vamos a implementar

226
00:18:52,039 --> 00:18:54,000
con un array por dentro.

227
00:18:54,539 --> 00:18:56,180
¿Vale? La última vez que usamos

228
00:18:56,180 --> 00:18:57,920
los arrays, porque a partir de allí

229
00:18:57,920 --> 00:18:59,880
usaré siempre mi lista array

230
00:18:59,880 --> 00:19:00,940
en vez de un array.

231
00:19:02,779 --> 00:19:04,220
Entonces, por

232
00:19:04,220 --> 00:19:06,480
debajo, este señor tiene un array

233
00:19:06,480 --> 00:19:07,720
object

234
00:19:07,720 --> 00:19:09,039
y de aquí

235
00:19:09,039 --> 00:19:11,480
lista

236
00:19:11,480 --> 00:19:13,380
es igual

237
00:19:13,380 --> 00:19:16,180
a new object

238
00:19:16,180 --> 00:19:18,559
0

239
00:19:18,559 --> 00:19:24,599
o podría hacerlo así

240
00:19:24,599 --> 00:19:26,079
public

241
00:19:26,079 --> 00:19:29,140
miListArray

242
00:19:29,140 --> 00:19:40,759
voy a poner esto aquí

243
00:19:40,759 --> 00:19:42,779
vale, entonces ya tengo un constructor

244
00:19:42,779 --> 00:19:44,440
cuando yo creo miListArray

245
00:19:44,440 --> 00:19:46,319
por dentro creo un array vacío

246
00:19:46,319 --> 00:19:48,420
existe, no es null

247
00:19:48,420 --> 00:19:50,380
pero no tiene ninguna

248
00:19:50,380 --> 00:19:51,480
posición dentro

249
00:19:51,480 --> 00:19:53,539
vamos a poderlo con esto

250
00:19:53,539 --> 00:19:56,359
vale, entonces yo ahora tengo

251
00:19:56,359 --> 00:19:58,599
que esconder este señor que no me gusta

252
00:19:58,599 --> 00:20:00,200
porque es un array, utilizando

253
00:20:00,200 --> 00:20:10,680
estos métodos. Empezamos de los más fáciles. Tengo un método size. ¿Quién me tendrá que devolver

254
00:20:10,680 --> 00:20:29,970
size? ¿Tamaño de quién? ¿De qué array? No sabes escribir el código que me dice lo que estás

255
00:20:29,970 --> 00:20:39,819
pensando. Tengo una lista, tengo que saber cuántos elementos hay en la lista. ¿Dónde estarán los

256
00:20:39,819 --> 00:21:03,109
elementos. ¿Están en? Listo. ¿Lista? ¿Qué más? Yo miraré el tamaño del array y eso será cuántos

257
00:21:03,109 --> 00:21:09,230
elementos están. Nada más crearlo tiene cero elementos porque no han añadido nada. Cuando

258
00:21:09,230 --> 00:21:15,410
añadiré tres elementos pues habrá añadido al array tantas posiciones cuantas necesarias para

259
00:21:15,410 --> 00:21:19,910
que contenga los tres elementos, entonces cuando pediré el tamaño de la red me dirá que son tres,

260
00:21:19,910 --> 00:21:25,849
que son los tres elementos que tengo dentro. ¿Entiendes? En este caso, súper fácil.

261
00:21:28,490 --> 00:21:36,009
Vamos a añadir un elemento. Entonces yo tengo este señor, que no sé cuánto grande es,

262
00:21:36,009 --> 00:21:41,250
porque no sé si es la primera vez que hago el add o es la centésima vez que hago el add,

263
00:21:41,250 --> 00:21:47,910
Pero me han dicho, oye, mira, a lista quiero que tú añadas este elemento.

264
00:21:48,750 --> 00:21:49,250
¿Qué hago?

265
00:21:53,369 --> 00:21:53,650
Aux.

266
00:22:02,809 --> 00:22:04,170
New object.

267
00:22:05,549 --> 00:22:06,150
New.

268
00:22:06,710 --> 00:22:11,569
No, aux igual a new object con la longitud de lista más uno.

269
00:22:23,359 --> 00:22:23,759
Así.

270
00:22:24,579 --> 00:22:25,460
¿Qué es lo que más has dicho tú?

271
00:22:27,019 --> 00:22:27,619
¿Dónde?

272
00:22:28,200 --> 00:22:30,039
En lugar de los cuarenta y uno.

273
00:22:30,839 --> 00:22:38,180
¿En lugar de lo falso?

274
00:22:40,180 --> 00:22:42,180
¿Cómo?

275
00:22:44,180 --> 00:22:48,390
¿Así?

276
00:22:48,390 --> 00:22:50,390
Pregunto.

277
00:22:50,390 --> 00:22:52,390
¿En serio, a febrero

278
00:22:52,390 --> 00:22:54,390
vosotros no sabéis

279
00:22:54,390 --> 00:22:56,390
todavía crear un array?

280
00:22:56,390 --> 00:23:00,660
¿Cómo lo hago?

281
00:23:00,660 --> 00:23:38,279
lo que hemos hecho 7000 veces me creo un array más grande

282
00:23:38,920 --> 00:23:42,079
que el array anterior, ¿sí?

283
00:23:45,220 --> 00:23:49,680
Es que es más curva que lista copia, ¿vale?

284
00:23:50,039 --> 00:23:51,240
Además, no es una lista copia.

285
00:23:52,859 --> 00:23:55,880
Es una copia, pero no es esto, entonces...

286
00:23:55,880 --> 00:23:56,980
Vale, ¿y qué hago ahora?

287
00:24:08,279 --> 00:24:15,460
Forinti es igual a cero y menor que lista.length y más más.

288
00:24:15,460 --> 00:24:18,240
Esto lo hemos hecho 7000 veces.

289
00:24:18,880 --> 00:24:21,359
Me encanta que me contesten dos personas.

290
00:24:22,319 --> 00:24:26,920
Nuevo de i es igual a lista de i.

291
00:24:29,359 --> 00:24:30,720
Cuando estoy aquí, ¿qué he hecho?

292
00:24:33,099 --> 00:24:34,440
¿Qué tengo cuando estoy aquí?

293
00:24:34,759 --> 00:24:35,839
Ahora estoy en este punto.

294
00:24:35,980 --> 00:24:36,480
¿Qué tengo?

295
00:24:39,079 --> 00:24:40,460
¿Cuántos objetos tengo?

296
00:24:45,259 --> 00:24:46,480
Que están igual, ¿no?

297
00:24:46,799 --> 00:24:47,700
¿Qué tengo?

298
00:24:51,869 --> 00:24:53,130
¿Qué elementos?

299
00:24:53,450 --> 00:24:55,029
¿Qué tengo cuando llego aquí?

300
00:24:57,230 --> 00:25:00,450
Tienes dos elementos de lista dentro de...

301
00:25:00,450 --> 00:25:00,650
Sí.

302
00:25:00,650 --> 00:25:01,930
En este caso nada.

303
00:25:01,930 --> 00:25:05,089
en este caso no lo sabemos

304
00:25:05,089 --> 00:25:07,109
si fuera vacío

305
00:25:07,109 --> 00:25:08,369
sí, pero si lo estoy llamando

306
00:25:08,369 --> 00:25:10,930
la quinta vez, pues ya hay 5

307
00:25:10,930 --> 00:25:12,630
no lo sé, es genérico

308
00:25:12,630 --> 00:25:15,029
yo aquí tengo dos objetos

309
00:25:15,029 --> 00:25:16,309
tengo lista

310
00:25:16,309 --> 00:25:18,829
que es un array de n posiciones con n

311
00:25:18,829 --> 00:25:19,589
objetos dentro

312
00:25:19,589 --> 00:25:22,269
y luego tengo nuevo

313
00:25:22,269 --> 00:25:25,210
que es un array de n más 1

314
00:25:25,210 --> 00:25:26,950
posiciones con

315
00:25:26,950 --> 00:25:28,410
n objetos dentro

316
00:25:28,410 --> 00:25:30,609
que son los mismos de

317
00:25:30,609 --> 00:25:32,369
lista. ¿Era claro?

318
00:25:34,130 --> 00:25:34,890
Esto lo hemos visto

319
00:25:34,890 --> 00:25:36,490
al menos cuatro o cinco veces.

320
00:25:37,430 --> 00:25:38,930
Hemos hecho gestión

321
00:25:38,930 --> 00:25:40,829
array que hace literalmente esta

322
00:25:40,829 --> 00:25:41,349
cosa aquí.

323
00:25:43,269 --> 00:25:44,930
La clase gestión array que hemos visto

324
00:25:44,930 --> 00:25:46,789
tres o cuatro veces, pues hemos siempre

325
00:25:46,789 --> 00:25:47,390
hecho esto.

326
00:25:48,869 --> 00:25:49,609
¿Qué hago ahora?

327
00:25:50,849 --> 00:25:51,690
Nueve.

328
00:25:52,569 --> 00:25:53,109
Nueve.

329
00:25:54,609 --> 00:25:55,450
Ocho.

330
00:25:56,930 --> 00:25:57,769
Vista.

331
00:25:58,089 --> 00:26:02,119
Igual.

332
00:26:03,079 --> 00:26:14,309
He añadido el elemento que me han dicho para añadir al final de nuevo.

333
00:26:14,309 --> 00:26:22,069
Contaos que en lista, lista.length, me daría array index out of bounds,

334
00:26:22,069 --> 00:26:29,069
porque en un array de 5 posiciones, la posición 5 no está, es de 0 a 4,

335
00:26:29,069 --> 00:26:35,069
pero en nuevo, que es un poquito más grande, sí está, y es la última posición.

336
00:26:35,069 --> 00:26:42,970
Esto habría podido ponerlo como nuevo. .length-1. Mismo número.

337
00:26:44,970 --> 00:26:45,170
¿Eh?

338
00:26:46,109 --> 00:26:47,630
No, que me está poniendo el nuevo mal.

339
00:26:48,329 --> 00:26:53,799
Sí. A lo mejor lo has declarado dentro de tu bloque.

340
00:26:55,380 --> 00:26:56,440
¿Y ahora qué hago?

341
00:26:59,319 --> 00:27:06,690
Ya está. Ya he implementado mi add.

342
00:27:06,690 --> 00:27:09,630
Esto lo he escrito ahora

343
00:27:09,630 --> 00:27:12,069
Y no lo volveré a escribir en mi vida

344
00:27:12,069 --> 00:27:14,009
Porque a partir de ahora

345
00:27:14,009 --> 00:27:16,630
Cuando uso mi array lista

346
00:27:16,630 --> 00:27:18,349
Mi lista array o como se llame

347
00:27:18,349 --> 00:27:19,690
Lo que hago es

348
00:27:19,690 --> 00:27:21,130
Usar add

349
00:27:21,130 --> 00:27:22,730
Para añadir algo

350
00:27:22,730 --> 00:27:25,670
No tengo que pillar el array, extenderlo, ponerlo

351
00:27:25,670 --> 00:27:28,190
Porque lo hace el debajo escondido

352
00:27:28,190 --> 00:27:33,319
Sin que yo lo vea

353
00:27:33,319 --> 00:27:37,299
Claro, esto es lo mismo

354
00:27:37,299 --> 00:27:38,720
Porque os he dicho

355
00:27:38,720 --> 00:27:40,559
Lo podíais haber hecho

356
00:27:40,559 --> 00:27:44,259
Claro, esta cosa de aquí la podríais haber hecho tranquilamente.

357
00:27:44,619 --> 00:27:45,640
De hecho, la hemos hecho.

358
00:27:48,240 --> 00:27:53,079
La hemos hecho como estática, pero nosotros la podríamos hacer como un objeto.

359
00:27:53,359 --> 00:27:57,000
Aquí dentro tengo mi array y este objeto me esconde el array.

360
00:27:57,400 --> 00:28:00,019
De hecho, este array podría ser private.

361
00:28:01,559 --> 00:28:04,180
Porque yo desde fuera ni me puedo enterar que existe.

362
00:28:05,319 --> 00:28:08,519
Y yo trabajo con los métodos estos de aquí.

363
00:28:08,519 --> 00:28:17,400
añade, remueve, y lo hace él por debajo. Él hace el trabajo. ¿Vale? Muy bien. Sizer sigue funcionando.

364
00:28:19,240 --> 00:28:31,329
Podemos hacer esto, que es fácil. Object.getInt.y. ¿Qué hace esto? ¿Cómo lo implemento? Tiene que

365
00:28:31,329 --> 00:28:34,430
devolver el elemento en posición y de mi lista.

366
00:28:34,430 --> 00:28:52,599
Esto, si tú intentas acceder a algo que no existe, pues explotará una excepción. Si tú aquí le pones

367
00:28:52,599 --> 00:28:58,400
100.000 y tienes solo tres objetos, pues él te dirá una null pointer exception, una array index

368
00:28:58,400 --> 00:29:06,579
out of bound exception, que se causará a la hora de intentar acceder a la posición 100 de la array

369
00:29:06,579 --> 00:29:10,019
Y este de aquí, cuando tienes dentro solo tres posiciones.

370
00:29:11,559 --> 00:29:13,519
Pero si la usas bien, funciona.

371
00:29:14,319 --> 00:29:14,440
¿Vale?

372
00:29:14,779 --> 00:29:21,779
Si quieres evitar que explote, lo que podemos hacer es lo siguiente.

373
00:29:25,390 --> 00:29:26,029
Object.

374
00:29:29,990 --> 00:29:30,630
Object.

375
00:29:31,970 --> 00:29:33,130
Es igual a null.

376
00:29:34,490 --> 00:29:34,710
¿Vale?

377
00:29:35,470 --> 00:29:43,900
Try object es igual a esto.

378
00:29:44,359 --> 00:30:09,269
cart.exception o esto sería un array index out of bound exception. Creo que no me parece absolutamente nada.

379
00:30:09,269 --> 00:30:43,630
Entonces, esta cosa de aquí me dice que, oye, mira, el objeto es nul. Intenta ponerle el elemento i de la lista.

380
00:30:43,630 --> 00:30:45,789
Si lo consigues

381
00:30:45,789 --> 00:30:47,930
Perfecto, ahora object es ese elemento

382
00:30:47,930 --> 00:30:48,890
Y lo devuelves

383
00:30:48,890 --> 00:30:51,089
Si no lo consigues

384
00:30:51,089 --> 00:30:52,890
Esto daría un error

385
00:30:52,890 --> 00:30:54,190
Y bloquearía el programa

386
00:30:54,190 --> 00:30:56,029
Yo no quiero que tú bloquees el programa

387
00:30:56,029 --> 00:30:58,269
Pero que tú te recuperes

388
00:30:58,269 --> 00:30:59,470
No hagas nada

389
00:30:59,470 --> 00:31:00,670
Y ahí llegues aquí

390
00:31:00,670 --> 00:31:03,970
Y lo que hace es devolverme object con dentro

391
00:31:03,970 --> 00:31:08,730
Y un null

392
00:31:08,730 --> 00:31:13,109
Porque si aquí explota

393
00:31:13,109 --> 00:31:14,930
Y no ejecuta esta cosa de aquí

394
00:31:14,930 --> 00:31:17,609
pues aquí no hace nada

395
00:31:17,609 --> 00:31:19,589
llega al object y el object dentro

396
00:31:19,589 --> 00:31:21,029
tenía null, entonces

397
00:31:21,029 --> 00:31:23,569
este método de aquí me devuelve

398
00:31:23,569 --> 00:31:25,089
el objeto si el objeto

399
00:31:25,089 --> 00:31:27,650
está en posición y si en vez

400
00:31:27,650 --> 00:31:29,589
he pedido una posición que no es

401
00:31:29,589 --> 00:31:30,970
me devolverá null

402
00:31:30,970 --> 00:31:35,450
y luego cuando uso get puedo

403
00:31:35,450 --> 00:31:37,269
decir, pilla get

404
00:31:37,269 --> 00:31:39,490
este elemento aquí, si este elemento que has

405
00:31:39,490 --> 00:31:41,150
pillado es null, pues entonces

406
00:31:41,150 --> 00:31:43,369
el usuario no existe esta posición

407
00:31:43,369 --> 00:31:45,890
y si no, haz lo que tienes que hacer

408
00:31:45,890 --> 00:31:49,569
dudas hasta aquí

409
00:31:49,569 --> 00:31:52,349
y así estamos repasando

410
00:31:52,349 --> 00:31:53,069
también el 3G

411
00:31:53,069 --> 00:31:56,150
y podría meter

412
00:31:56,150 --> 00:31:57,130
un mensaje error

413
00:31:57,130 --> 00:31:59,769
system.er

414
00:31:59,769 --> 00:32:02,769
.println

415
00:32:02,769 --> 00:32:06,400
acceso

416
00:32:06,400 --> 00:32:09,660
a

417
00:32:09,660 --> 00:32:11,619
índice no

418
00:32:11,619 --> 00:32:13,680
válido

419
00:32:13,680 --> 00:32:16,980
claro es que lo escribo en er

420
00:32:16,980 --> 00:32:18,220
no en out

421
00:32:18,220 --> 00:32:25,200
para que el usuario no se da cuenta, pero yo escribo en un log que alguien ha intentado acceder a una, ¿vale?

422
00:32:25,200 --> 00:32:39,230
Y a lo mejor le puedo poner mase.getMessage, que es la descripción de esta explosión de acto.

423
00:32:43,849 --> 00:32:50,670
Luego este de aquí lo puedo redireccionar en un fichero de log, entonces todos estos intentos de hacer una get que no funciona

424
00:32:50,670 --> 00:32:55,329
me lo escribirá en un fichero y yo como administrador puedo ir al fichero y ver qué ha pasado, cuántos

425
00:32:55,329 --> 00:33:04,009
usuarios han intentado acceder a elementos que no existen. Si me interesa, si no, no.

426
00:33:04,009 --> 00:33:11,970
Dudas hasta aquí. ¿Vale? Entonces sabemos GETTARE y sabemos ABDARE. Pues ya está, estamos

427
00:33:11,970 --> 00:33:28,269
listos para probar. new class main. Tengo la clase main, pongo el chrome main y lo que hace este señor es decir

428
00:33:28,269 --> 00:33:35,609
antes tenía que hacer todo con arrays, pues ahora no. Ahora lo que digo es miListArray.

429
00:33:35,609 --> 00:33:55,609
mlat es igual al new miListaArr. Y ahora para añadir algo en esta lista mlat.add. Por ejemplo,

430
00:33:55,609 --> 00:34:05,210
gato. Esto estoy añadiendo un string. Un string es un object. Lo puedo añadir. Y luego puedo

431
00:34:05,210 --> 00:34:30,329
hacer mla.get , y esto por ejemplo guardarlo en un string, voilà, sí, eso. ¿Por qué esto?

432
00:34:30,329 --> 00:34:48,630
¿Por qué esto se enfada? Entonces, ¿por qué se enfada?

433
00:34:48,630 --> 00:34:55,260
porque mla.get

434
00:34:55,260 --> 00:34:57,559
devuelve un object

435
00:34:57,559 --> 00:35:03,889
devuelve un object

436
00:35:03,889 --> 00:35:07,190
yo puedo poner un string

437
00:35:07,190 --> 00:35:08,329
dentro de un object

438
00:35:08,329 --> 00:35:09,949
pero no un object dentro de un string

439
00:35:09,949 --> 00:35:12,550
porque string es un object

440
00:35:12,550 --> 00:35:13,889
pero object no es un string

441
00:35:13,889 --> 00:35:15,929
entonces

442
00:35:15,929 --> 00:35:18,449
necesito hacer un

443
00:35:18,449 --> 00:35:19,530
casting explícito

444
00:35:19,530 --> 00:35:28,170
lo que yo lo estoy haciendo porque lo sé vale porque me tiene una una string aquí en realidad

445
00:35:28,170 --> 00:35:32,289
esta cosa aquí es muy peligrosa porque aquí dentro puedo poner de todo mezclando de todo

446
00:35:32,289 --> 00:35:37,690
todo el cuidado como lo usáis para forzarlo aquí aquí dentro hay sólo string que tengo

447
00:35:37,690 --> 00:35:40,670
que hacer esa cosa de los tipos genéricos que por ahora no estoy aquí

448
00:35:40,670 --> 00:36:05,980
Si esto funciona, ahora funciona. Puedes escribir también, si hizo, la.cd. La creo. Escribo

449
00:36:05,980 --> 00:36:13,780
su tamaño, luego añado gato, escribo su tamaño otra vez, y luego busco un objeto y lo imprimo.

450
00:36:13,780 --> 00:36:28,250
¿Qué me tiene que imprimir? ¿Aquí qué me imprime? ¡Hola! ¡Cero! ¿Aquí qué me imprime? ¡Uno!

451
00:36:28,250 --> 00:36:45,880
¿Y aquí qué me imprime? Gato. Si todo funciona, aquí me imprime cero, aquí me imprime uno,

452
00:36:45,880 --> 00:36:52,460
aquí me imprime gato. Señores, ¿lo veis? ¿Lo entendéis? Aquí no es cuestión de desarrollar

453
00:36:52,460 --> 00:36:58,300
código, es de entender el código que he escrito yo. Si no me estáis siguiendo en lo que escribo

454
00:36:58,300 --> 00:37:09,119
pues tenemos un problema más serio de que no sabáis escribir código. Me pareceis dormidos hoy.

455
00:37:09,119 --> 00:37:19,329
Cero. ¿Por qué? Porque cuando exprime esto de aquí, va a MLA6, que es esta cosa de aquí,

456
00:37:19,329 --> 00:37:28,429
devuelve la longitud de la array, por ahora la array está vacío, cero. ¿Vale? Aquí, cero. Ahora

457
00:37:28,429 --> 00:37:36,530
llamo añade gato por lo tanto se va aquí y lo que hace es añadir gato se crea un array nuevo grande

458
00:37:36,530 --> 00:37:45,170
1 porque 0 más 1 es 1 recorre el antiguo que era vacío por lo tanto no lo recorre vale y en la

459
00:37:45,170 --> 00:37:50,570
posición primera la posición 0 pues añade el elemento que le ha pasado que era este string

460
00:37:50,570 --> 00:37:57,050
gato vale y luego hace que mi lista es igual al nuevo entonces borra la lista que tenía nueva y

461
00:37:57,050 --> 00:38:05,150
vieja y se queda con la nueva. Por lo tanto, cuando ahora le pido el tamaño tienes, estoy

462
00:38:05,150 --> 00:38:11,809
apuntando, o sea, lista apuntará al rey nuevo, entonces tiene tamaño 1, porque tiene una posición,

463
00:38:11,809 --> 00:38:20,269
por lo tanto me escribe este 1. Después me voy aquí y le digo, me vas a pillar en mi lista el

464
00:38:20,269 --> 00:38:27,610
el señor get, vale, perdón, el señor 0, es la única posición que tiene, posición 0, me

465
00:38:27,610 --> 00:38:33,070
pillará este objeto que había añadido allí, que es un string, por lo tanto, si yo lo tengo así,

466
00:38:33,070 --> 00:38:42,780
podría hacer una jugada así, mira, así, pillo este objeto, este objeto es un object, te lo pone aquí,

467
00:38:42,780 --> 00:38:56,360
y ahora te dice, escríbemelo por favor. ¿Qué me va a escribir ahora? Gato, ¿por qué? ¿Por qué

468
00:38:56,360 --> 00:39:11,880
Ese es un object, me escribe Gato, una palabra. Me encanta cuando estudiáis. Tenéis meses

469
00:39:11,880 --> 00:39:16,000
antes del próximo examen, entonces es bien que esperéis un poquito más antes de empezar

470
00:39:16,000 --> 00:39:32,219
a estudiar. ¿Por qué me escribe Gato? Y siendo ese un object, no me debería escribir

471
00:39:32,219 --> 00:39:34,280
object, arroba

472
00:39:34,280 --> 00:39:35,300
y un número raro.

473
00:39:37,019 --> 00:39:38,440
No, le he quitado el casting

474
00:39:38,440 --> 00:39:39,300
mientras dormías.

475
00:39:45,460 --> 00:39:46,559
En una palabra.

476
00:39:51,260 --> 00:39:51,780
Polimorfismo.

477
00:39:51,780 --> 00:39:52,960
Polimorfismo, mi palabra favorita.

478
00:39:53,260 --> 00:39:54,639
La vuestra, la palabra del mes.

479
00:39:55,280 --> 00:39:56,199
Ya era de enero.

480
00:39:56,980 --> 00:39:59,599
Muy bien.

481
00:39:59,719 --> 00:40:01,519
Por polimorfismo, porque él va a

482
00:40:01,519 --> 00:40:03,059
utilizar el toString

483
00:40:03,059 --> 00:40:05,480
No de la referencia

484
00:40:05,480 --> 00:40:07,739
Va a utilizar el toString

485
00:40:07,739 --> 00:40:09,559
Propio de la instancia

486
00:40:09,559 --> 00:40:11,280
Y esto es un string

487
00:40:11,280 --> 00:40:13,739
Por lo tanto utilizará el toString de string

488
00:40:13,739 --> 00:40:15,599
Y por lo tanto me lo escribe bonito

489
00:40:15,599 --> 00:40:20,119
Enhorabuena

490
00:40:20,119 --> 00:40:24,579
Enhorabuena

491
00:40:24,579 --> 00:40:25,780
Vamos, sigamos adelante

492
00:40:25,780 --> 00:40:27,039
Entonces, funciona

493
00:40:27,039 --> 00:40:29,840
Es más, yo puedo añadir otro objeto

494
00:40:29,840 --> 00:40:32,440
La.add

495
00:40:32,440 --> 00:40:37,559
voy, uso string porque es fácil de verlas, ¿vale?

496
00:40:37,619 --> 00:40:39,920
En realidad podría añadir lo que me da la gana,

497
00:40:40,039 --> 00:40:42,500
pero eso a lo mejor provoca daño, ¿vale?

498
00:40:42,780 --> 00:40:44,599
Y pongo perro, ¿vale?

499
00:40:44,719 --> 00:40:48,820
Entonces ahora yo puedo leer gato otra vez,

500
00:40:49,440 --> 00:40:50,800
o puedo leer perro,

501
00:40:50,800 --> 00:40:54,199
o puedo equivocarme.

502
00:40:54,559 --> 00:40:58,000
¿Qué escribe esto?

503
00:40:58,719 --> 00:41:03,250
Bueno, espérate, espérate.

504
00:41:03,489 --> 00:41:04,289
Hagámoslo así.

505
00:41:05,789 --> 00:41:06,349
Me he equivocado.

506
00:41:06,530 --> 00:41:16,929
Si me lo escribe directamente, ¿vale?

507
00:41:16,929 --> 00:41:22,929
Entonces puedo escribir cero, puedo escribir uno, puedo escribir dos, tres.

508
00:41:22,929 --> 00:41:32,800
¿Qué pone esto? Esta cosa aquí, ¿qué me escribe?

509
00:41:32,800 --> 00:41:34,800
Gato.

510
00:41:34,800 --> 00:41:37,800
Gato. ¿Esto qué me escribe?

511
00:41:37,800 --> 00:41:39,800
Perro.

512
00:41:39,800 --> 00:41:41,639
Perro. ¿Y esto que me escribe?

513
00:41:52,800 --> 00:41:54,239
Antes me escribía también nulo.

514
00:41:55,039 --> 00:41:55,940
Pero me escribe

515
00:41:55,940 --> 00:41:57,059
¿en qué color?

516
00:41:58,480 --> 00:41:58,960
Rojo.

517
00:41:59,860 --> 00:42:02,219
Que oye, ha habido un error. Vamos a ver si es verdad.

518
00:42:02,480 --> 00:42:02,760
Dale.

519
00:42:06,340 --> 00:42:08,300
Mira, este es el primer gato.

520
00:42:08,300 --> 00:42:10,000
Esta es la parte nueva. Gato

521
00:42:10,000 --> 00:42:12,159
es la respuesta de esto. Perro

522
00:42:12,159 --> 00:42:13,380
en la respuesta de este de aquí.

523
00:42:13,960 --> 00:42:15,820
Null en la respuesta de esto, porque

524
00:42:15,820 --> 00:42:18,039
este señor ha llevado el B null, ¿vale?

525
00:42:18,300 --> 00:42:19,900
Pero me escribe en

526
00:42:19,900 --> 00:42:20,559
error

527
00:42:20,559 --> 00:42:23,940
que aceso, no, no escribe

528
00:42:23,940 --> 00:42:25,900
como llueve, más que aceso

529
00:42:25,900 --> 00:42:27,340
a índice no válido,

530
00:42:27,780 --> 00:42:30,239
index 2, out of bound of length 2.

531
00:42:31,219 --> 00:42:31,420
¿Vale?

532
00:42:31,760 --> 00:42:33,719
Este de aquí es el

533
00:42:33,719 --> 00:42:35,960
mensaje que había escrito yo, y esto

534
00:42:35,960 --> 00:42:37,960
era el e.getMessage.

535
00:42:39,300 --> 00:42:39,820
¿Os acordáis?

536
00:42:42,659 --> 00:42:43,519
Escribe error,

537
00:42:43,539 --> 00:42:45,460
ojo, porque no lo está escribiendo en el mismo

538
00:42:45,460 --> 00:42:47,639
canal. Lo está escribiendo en dos canales

539
00:42:47,639 --> 00:42:48,239
distintos.

540
00:42:49,340 --> 00:42:51,659
Este de aquí es el system.out,

541
00:42:51,820 --> 00:42:53,760
este de aquí es el system.er.

542
00:42:54,900 --> 00:42:55,139
¿Vale?

543
00:42:55,380 --> 00:42:57,340
Y luego, normalmente van a la

544
00:42:57,340 --> 00:42:58,860
consola los dos, pero

545
00:42:58,860 --> 00:43:01,340
podría hacerlos ir

546
00:43:01,340 --> 00:43:02,400
a sitios distintos.

547
00:43:03,699 --> 00:43:04,840
Por ejemplo, a ficheros distintos.

548
00:43:06,139 --> 00:43:06,699
¡Dudas!

549
00:43:08,059 --> 00:43:09,199
O sea, mi sistema funciona.

550
00:43:09,340 --> 00:43:10,699
Fijaos, ahora

551
00:43:10,699 --> 00:43:12,719
lo que antes hacía

552
00:43:12,719 --> 00:43:15,480
y yo pongo, pilla la rey,

553
00:43:15,599 --> 00:43:17,380
exténdelo, cópialo todo,

554
00:43:17,539 --> 00:43:18,619
ahora pon uno más.

555
00:43:18,719 --> 00:43:20,059
Lo estoy haciendo así.

556
00:43:20,920 --> 00:43:23,840
Porque lo estoy haciendo,

557
00:43:24,340 --> 00:43:26,019
pero lo hace él por dentro.

558
00:43:27,280 --> 00:43:27,980
Lo hace él aquí.

559
00:43:29,500 --> 00:43:30,699
Y yo esto lo he implementado

560
00:43:30,699 --> 00:43:32,420
una vez y a partir de ahora

561
00:43:32,420 --> 00:43:34,599
solo uso esta cosa aquí y él me añade

562
00:43:34,599 --> 00:43:38,769
cosas, dudas,

563
00:43:39,530 --> 00:43:41,610
preguntas.

564
00:43:47,230 --> 00:43:47,510
Vale.

565
00:43:48,309 --> 00:43:48,949
Sigamos

566
00:43:48,949 --> 00:43:50,989
implementando mi lista

567
00:43:50,989 --> 00:43:52,909
array. ¿Vale? Con los otros

568
00:43:52,909 --> 00:43:54,550
métodos que tengo que implementar.

569
00:43:54,969 --> 00:43:56,309
Me queda para hacer el remove,

570
00:43:56,730 --> 00:43:58,489
me queda para hacer el busca,

571
00:43:58,789 --> 00:44:00,389
me queda para hacer el show.

572
00:44:05,920 --> 00:44:06,559
¿Cuál queréis hacer?

573
00:44:10,269 --> 00:44:10,789
Buscar.

574
00:44:12,969 --> 00:44:14,550
Entonces, ¿busca qué tiene que hacer?

575
00:44:14,550 --> 00:44:16,289
Tiene que recorrer

576
00:44:16,289 --> 00:44:18,829
mi array, encontrar

577
00:44:18,829 --> 00:44:20,530
cuando este

578
00:44:20,530 --> 00:44:22,210
elemento es igual al otro.

579
00:44:22,889 --> 00:44:24,389
¿Vale? Y cuando encuentra

580
00:44:24,389 --> 00:44:26,570
que es igual al otro, pues me devuelve

581
00:44:26,570 --> 00:44:27,989
la posición en la que está.

582
00:44:28,369 --> 00:44:30,289
Si no lo encuentra, me devuelve menos uno.

583
00:44:31,789 --> 00:44:32,230
Entonces,

584
00:44:32,670 --> 00:44:34,710
interposición es igual a menos uno.

585
00:44:37,090 --> 00:44:38,010
Y devuelvo posición.

586
00:44:40,150 --> 00:44:41,869
Ya. Si no lo encuentro,

587
00:44:42,090 --> 00:44:42,909
esto es lo que tiene que hacer.

588
00:44:43,650 --> 00:44:45,849
Si lo encuentro, vamos a ver cómo recorre

589
00:44:45,849 --> 00:44:46,409
una raíz.

590
00:44:50,369 --> 00:44:51,170
Muy bien.

591
00:44:52,550 --> 00:44:53,889
Int i es igual a

592
00:44:53,889 --> 00:44:55,530
cero i menor

593
00:44:55,530 --> 00:45:02,630
Porque lista.langueter y más más.

594
00:45:03,570 --> 00:45:04,289
¿Qué hago?

595
00:45:05,630 --> 00:45:06,090
Sí.

596
00:45:06,630 --> 00:45:07,929
Lengueter, adverso.

597
00:45:09,269 --> 00:45:09,730
Sí.

598
00:45:14,659 --> 00:45:15,980
Element de i.

599
00:45:16,400 --> 00:45:18,380
Element de i.

600
00:45:20,659 --> 00:45:22,519
Lista de i.

601
00:45:22,519 --> 00:45:23,980
Lista de i.

602
00:45:23,980 --> 00:45:24,039
Lista de i.

603
00:45:25,059 --> 00:45:25,900
Punto.

604
00:45:26,920 --> 00:45:27,800
Equals.

605
00:45:29,500 --> 00:45:29,659
Que.

606
00:45:29,659 --> 00:45:33,880
ELEMENT

607
00:45:33,880 --> 00:45:46,500
Y

608
00:45:46,500 --> 00:45:46,559
Y

609
00:45:46,559 --> 00:45:52,710
Y

610
00:46:02,659 --> 00:46:04,500
Pregunta

611
00:46:04,500 --> 00:46:06,400
¿Mejor esto

612
00:46:06,400 --> 00:46:09,619
o mejor esto?

613
00:46:12,460 --> 00:46:34,840
Hola, buenos días.

614
00:46:34,840 --> 00:46:40,219
En el de arriba no estaría gustando realmente el elemento de la lista,

615
00:46:40,400 --> 00:46:42,179
pero estaría gustando en otra lista, ¿no?

616
00:46:42,719 --> 00:46:44,179
No, exactamente lo mismo.

617
00:46:45,840 --> 00:46:50,280
En el de arriba sería, comparas el elemento que te deja algo constante

618
00:46:50,280 --> 00:46:52,300
con una lista que va a cambiar de posición.

619
00:46:53,280 --> 00:46:55,639
Entonces, ¿cuál es mejor?

620
00:46:56,280 --> 00:46:56,880
Hay diferencia.

621
00:46:56,880 --> 00:47:06,320
En uno yo tengo mi lista y digo, esto es igual a esto, no, esto es igual a esto, no, esto es igual a esto, y sigo.

622
00:47:06,320 --> 00:47:12,320
En el otro tengo mi lista y el objeto y digo, esto es igual a esto, no, esto es igual a esto.

623
00:47:12,320 --> 00:47:15,320
Hace lo mismo.

624
00:47:15,320 --> 00:47:24,369
¿Qué diferencia hay? No, hay...

625
00:47:24,369 --> 00:47:26,369
Está escrito distinto.

626
00:47:26,369 --> 00:47:30,369
Entonces, ¿qué implica?

627
00:47:30,369 --> 00:47:39,780
Hay diferencias sobre el punto donde puede saltar una Null Pointer Exception.

628
00:47:41,500 --> 00:47:47,719
Si yo lo hago así, esto me da Null Pointer Exception si esto es Null.

629
00:47:49,800 --> 00:47:56,280
Si yo te he hecho busca y entre paréntesis te he puesto un objeto Null, te saltaría una Null Pointer Exception.

630
00:47:56,280 --> 00:47:59,920
esto te saltaría

631
00:47:59,920 --> 00:48:01,079
en un point of exception

632
00:48:01,079 --> 00:48:04,019
si dentro de lista

633
00:48:04,019 --> 00:48:05,760
tú en algún momento

634
00:48:05,760 --> 00:48:08,079
has hecho una add de null

635
00:48:08,079 --> 00:48:11,719
entonces has añadido un objeto nuevo

636
00:48:11,719 --> 00:48:12,280
que es null

637
00:48:12,280 --> 00:48:16,519
¿entendéis la diferencia?

638
00:48:17,920 --> 00:48:20,179
entonces, para evitar eso

639
00:48:20,179 --> 00:48:21,760
tengo varias opciones

640
00:48:21,760 --> 00:48:24,059
podría comprobar

641
00:48:24,059 --> 00:48:26,059
cuando busco

642
00:48:26,059 --> 00:48:30,199
que el elemento no sea nul.

643
00:48:30,619 --> 00:48:31,820
O sea, que esto lo hago

644
00:48:31,820 --> 00:48:33,039
solo si el elemento no es nul.

645
00:48:33,199 --> 00:48:34,219
Si es nul, no lo busco.

646
00:48:34,760 --> 00:48:37,280
Podría hacer que cuando añado un elemento,

647
00:48:37,760 --> 00:48:38,860
solo lo añado

648
00:48:38,860 --> 00:48:40,719
si el elemento que me han dado no es nul.

649
00:48:41,719 --> 00:48:43,480
Esto me garantizaría

650
00:48:43,480 --> 00:48:45,519
que todos los elementos de la lista

651
00:48:45,519 --> 00:48:46,340
no son nul.

652
00:48:47,340 --> 00:48:48,960
Y entonces podría utilizar

653
00:48:48,960 --> 00:48:50,139
¿cuál de los dos?

654
00:48:51,679 --> 00:48:52,239
Seguramente.

655
00:48:53,599 --> 00:48:55,559
Si no hay nulos en mi lista,

656
00:48:55,719 --> 00:48:56,579
¿cuántos tengo aquí?

657
00:48:57,880 --> 00:49:07,440
Si yo garantizo que no puede haber null en la lista, esto es seguro, porque estoy llamando

658
00:49:07,440 --> 00:49:13,619
equals sobre un objeto que nunca será null, entonces me funciona así, me da igual que

659
00:49:13,619 --> 00:49:18,360
esto sea null, esto es null dirá, no son iguales, un objeto real con un null pues no

660
00:49:18,360 --> 00:49:24,219
son iguales, pero el objeto sobre el que lo estoy llamando es éste, entonces es éste

661
00:49:24,219 --> 00:49:33,719
que manda si es null pointer o no. Lo podemos hacer. Otra opción es meter todo esto en un

662
00:49:33,719 --> 00:49:53,139
triketch y si explota le digo muy bien, pues entonces no son iguales. No la he encontrado.

663
00:49:53,139 --> 00:50:13,139
A ver, opciones. Opción número A. Meto así y puedo o comprobar aquí, hace esto. Esta es una primera opción.

664
00:50:14,820 --> 00:50:18,980
Compruebo que si no es null, pues entonces lo puedo utilizar y lo compruebo en toda la lista.

665
00:50:18,980 --> 00:50:38,179
Otra opción. Las pongo todas. Esto lo aumento y hago la opción número dos.

666
00:50:38,179 --> 00:50:51,869
Opción número dos. No compruebo, mas digo prueba. Si explotas, quiere decir que cuando has hecho esta cosa aquí has explotado.

667
00:50:51,869 --> 00:51:06,079
Entonces, Capture Null Pointer Exception x pos es igual a menú.

668
00:51:14,800 --> 00:51:20,820
Si me devuelve menos uno, es que ha podido buscarlo, pero no lo ha encontrado.

669
00:51:21,460 --> 00:51:26,260
Si me devuelve menos dos, quiere decir que ha habido un error al buscar.

670
00:51:32,219 --> 00:51:32,619
¿Entiende?

671
00:51:35,179 --> 00:51:38,579
Esta cosa aquí me devuelve la posición del objeto buscado.

672
00:51:38,579 --> 00:51:41,360
Si lo encuentra me devolverá 3

673
00:51:41,360 --> 00:51:42,840
Está en posición 3

674
00:51:42,840 --> 00:51:44,159
Fenomenal, lo ha encontrado

675
00:51:44,159 --> 00:51:47,340
Si me devuelve menos 1 quiere decir que todo esto ha ido bien

676
00:51:47,340 --> 00:51:49,480
Nunca ha saltado una excepción

677
00:51:49,480 --> 00:51:52,360
Pero no lo ha encontrado

678
00:51:52,360 --> 00:51:54,460
Al no encontrarlo se ha quedado menos 1

679
00:51:54,460 --> 00:51:56,619
Si al entrar aquí

680
00:51:56,619 --> 00:51:58,739
Por ejemplo, el elemento era nul

681
00:51:58,739 --> 00:52:01,480
Por lo tanto, hacer esto ha hecho un nul pointer exception

682
00:52:01,480 --> 00:52:03,940
Pues entonces entrará aquí dentro

683
00:52:03,940 --> 00:52:06,159
Pondrá en posición menos 2

684
00:52:06,159 --> 00:52:07,099
En vez de menos 1

685
00:52:07,099 --> 00:52:08,000
Y me lo devuelve

686
00:52:08,000 --> 00:52:23,940
Entonces yo desde fuera, cuando llamo busca, puedo hacer un switch diciendo que si es menos uno, no existe, si es menos dos, ha habido un error, y en cualquier otro caso, está en esta posición.

687
00:52:26,269 --> 00:52:26,670
¿Entienden?

688
00:52:28,510 --> 00:52:28,909
¿Cultan?

689
00:52:33,119 --> 00:52:34,920
Esta es una segunda opción.

690
00:52:37,090 --> 00:52:38,070
Tercera opción.

691
00:52:38,070 --> 00:52:40,909
la tercera opción sería

692
00:52:40,909 --> 00:52:42,230
en vez de utilizar esto

693
00:52:42,230 --> 00:52:43,769
cambiar

694
00:52:43,769 --> 00:52:46,170
lista de i con element

695
00:52:46,170 --> 00:52:48,469
cambiarlos, pero entonces

696
00:52:48,469 --> 00:52:50,510
para que funcione debería

697
00:52:50,510 --> 00:52:52,329
hacer un cambio en el add

698
00:52:52,329 --> 00:52:54,809
debería poner que aquí

699
00:52:54,809 --> 00:52:56,849
no me pueda poner elementos

700
00:52:56,849 --> 00:52:58,409
vacíos, entonces

701
00:52:58,409 --> 00:53:01,030
esta cosa de aquí la hace

702
00:53:01,030 --> 00:53:03,050
solo si

703
00:53:03,050 --> 00:53:04,650
element

704
00:53:04,650 --> 00:53:05,769
es not null

705
00:53:05,769 --> 00:53:19,889
Pero has dicho, añade un elemento. Si es null, no te lo añado. Si no es null, pues lo añado.

706
00:53:19,889 --> 00:53:33,730
Fijaos que el elemento aquí dentro no lo uso, entonces aquí usar el try-catch no serviría de

707
00:53:33,730 --> 00:53:41,769
nada. Este código de aquí no lanza nunca una null pointer exception. No hago nunca element punto

708
00:53:41,769 --> 00:53:49,590
algo. Por lo tanto, hasta si es null, él funciona. Entonces, en este caso, necesito

709
00:53:49,590 --> 00:54:04,909
hacerlo así. Podría, pero si yo me he cerciorado que en la lista aquí no puede haber elementos

710
00:54:04,909 --> 00:54:11,150
null, entonces es inútil que lo compruebe. Entonces, lo que haría es, el tercer tipo,

711
00:54:11,150 --> 00:54:15,150
que está aquí. ¿Dónde está? ¿Dónde está? ¿Dónde está? ¿Dónde está? ¿Dónde está? ¿Dónde está?

712
00:54:15,150 --> 00:54:17,150
Me he borrado.

713
00:54:17,150 --> 00:54:19,150
Oh, esto me la...

714
00:54:19,150 --> 00:54:21,150
Va.

715
00:54:21,150 --> 00:54:23,150
El tercer

716
00:54:23,150 --> 00:54:25,150
ejemplo que podría poner aquí...

717
00:54:25,150 --> 00:54:29,360
Esto es sobre RAI.

718
00:54:29,360 --> 00:54:36,699
Va.

719
00:54:36,699 --> 00:54:38,699
El tercer ejemplo, que lo llamaré

720
00:54:38,699 --> 00:54:40,699
búscalos, ¿vale?

721
00:54:40,699 --> 00:54:42,699
En vez de utilizar esto,

722
00:54:42,699 --> 00:54:50,809
utilizo esto.

723
00:54:50,809 --> 00:54:52,809
Y como sé que esto no puede ser

724
00:54:52,809 --> 00:54:59,929
Nunca. No me hace falta comprobar que salte una null pointer exception.

725
00:54:59,929 --> 00:55:04,530
Este código de aquí nunca lanzará una null pointer exception.

726
00:55:04,530 --> 00:55:11,710
Porque yo me he cerciorado que aquí dentro sólo hay objetos no null y además esto es privado,

727
00:55:11,710 --> 00:55:18,050
entonces nadie puede haber entrado allí y haberme metido null saltándose el add.

728
00:55:18,050 --> 00:55:33,239
¿Dudas? Entonces, aquí tenemos tres opciones.

729
00:55:33,239 --> 00:55:42,860
una dos y tres me quedo con esta vale estar aquí existe busca 22 pero no es parte de la

730
00:55:42,860 --> 00:55:57,449
lista es un método nuevo que me he creado vale entonces qué más hago esto ya puede

731
00:55:57,449 --> 00:56:04,670
buscar vamos a ver si la búsqueda funciona vale entonces aquí yo puedo hacer si eso

732
00:56:04,670 --> 00:56:39,639
punto busca de gato. Me debería devolver cero. Si busco perro, me debería devolver uno. Si busco

733
00:56:39,639 --> 00:57:03,949
bocorrilo, me debería devolver menos uno. Busco gato, no. Busco perro. Fijaos que este señor a veces

734
00:57:03,949 --> 00:57:05,750
aparece antes, a veces aparece

735
00:57:05,750 --> 00:57:07,929
después. Porque estoy escribiendo

736
00:57:07,929 --> 00:57:09,869
en la console, pero con dos

737
00:57:09,869 --> 00:57:11,510
mecanismos de escritura distintos.

738
00:57:12,130 --> 00:57:13,849
Entonces a veces llega antes, a veces llega

739
00:57:13,849 --> 00:57:14,230
después.

740
00:57:19,590 --> 00:57:21,829
Mientras todo lo que escribo en system.out

741
00:57:21,829 --> 00:57:23,349
llegará ordenado,

742
00:57:23,809 --> 00:57:24,989
lo que escribo en out y en air

743
00:57:24,989 --> 00:57:27,489
pueden que se solapen. Son dos mecanismos distintos.

744
00:57:27,750 --> 00:57:29,329
A quien se ejecute antes

745
00:57:29,329 --> 00:57:30,590
es el que escribe antes.

746
00:57:31,730 --> 00:57:32,670
Forma loquito

747
00:57:32,670 --> 00:57:33,690
para no molestar.

748
00:57:35,289 --> 00:57:35,510
¿Sí?

749
00:57:36,750 --> 00:57:37,309
Ahí.

750
00:57:37,570 --> 00:57:44,570
Funciona perfectamente. Podría buscarlo con busca dos y funcionaría igual.

751
00:57:44,570 --> 00:57:51,349
Ahí.

752
00:57:51,349 --> 00:57:54,349
¿Dudas?

753
00:57:54,349 --> 00:58:03,349
Estos métodos que están decidiendo para las colecciones, ¿ya vienen decididos o los están creando otra vez para ir explicando lo que hacen las colecciones?

754
00:58:03,349 --> 00:58:06,349
¿Dónde estabas al principio de la clase?

755
00:58:06,349 --> 00:58:08,349
En casa lo vi.

756
00:58:08,349 --> 00:58:09,710
Esto se ha grabado, ¿eh?

757
00:58:10,710 --> 00:58:13,010
Se lo harán en contra de ti.

758
00:58:13,690 --> 00:58:13,949
Mira,

759
00:58:14,550 --> 00:58:17,010
me he creado una interfaz lista yo

760
00:58:17,010 --> 00:58:18,929
proponiendo

761
00:58:18,929 --> 00:58:20,809
cuáles son los mecanismos,

762
00:58:20,889 --> 00:58:23,110
los métodos más comunes

763
00:58:23,110 --> 00:58:25,150
para gestionar

764
00:58:25,150 --> 00:58:26,670
lo que hacemos con los arrays,

765
00:58:26,829 --> 00:58:29,210
de añadir algo en un array, quitar algo en un array,

766
00:58:29,610 --> 00:58:31,309
saber el tamaño del array,

767
00:58:31,570 --> 00:58:33,090
buscar algo dentro del array.

768
00:58:33,630 --> 00:58:35,329
Estos son los métodos básicos.

769
00:58:36,050 --> 00:58:36,909
Y con esto me he creado

770
00:58:36,909 --> 00:58:44,409
una interfaz lista. Luego me he creado una clase mía que implementa lista y hemos decidido

771
00:58:44,409 --> 00:58:56,829
implementar estos métodos usando por debajo un Array. En este caso de objetos.

772
00:58:56,829 --> 00:59:06,980
Entonces, hemos implementado luego el add, que es igual a añadir un elemento a un Array.

773
00:59:06,980 --> 00:59:10,260
Hemos implementado el size, que me devuelve el tamaño del array.

774
00:59:10,260 --> 00:59:14,300
Hemos implementado el busca, que me busca este objeto.

775
00:59:14,300 --> 00:59:19,900
Hemos implementado el get, que me pilla el objeto en posición y del array.

776
00:59:19,900 --> 00:59:22,639
Me queda para enfrentarlos.

777
00:59:22,639 --> 00:59:37,929
Una cosa que quiero que os fijéis, aquí estoy utilizando Equals, que Equals se utiliza

778
00:59:37,929 --> 00:59:44,369
de object, entonces esto debería dar false. Esto no debería funcionar.

779
00:59:44,369 --> 00:59:53,889
Estoy utilizando el equals, pero si la clase que estoy utilizando tiene una sobrescritura

780
00:59:53,889 --> 00:59:59,530
del equals, como es el caso de la string, no voy a utilizar el de object, que es su

781
00:59:59,530 --> 01:00:04,690
referencia, voy a utilizar el de la instancia, que es una string, por lo tanto él me está

782
01:00:04,690 --> 01:00:19,389
utilizando el equals entre strings y por eso no porque aquí son objetos que el

783
01:00:19,389 --> 01:00:26,130
ecuador y que no recase no es de la clase objeto entonces no lo puede

784
01:00:26,130 --> 01:00:30,210
utilizar no lo reconoce debería da un castellano a string o para poder

785
01:00:30,210 --> 01:00:48,849
dudas sigamos adelante vamos show que es más fácil como me tiene que escribir una representación de

786
01:00:48,849 --> 01:01:07,369
esta red fácil ahí yo lista uso mi clase arrays.toString para hacer una representación de eso

787
01:01:07,369 --> 01:01:20,079
que hace reír a alguno de vosotros, y a este punto lo devuelvo. Así que ahora puedo hacer

788
01:01:20,079 --> 01:01:45,280
siso la.show. Ahí lo tenemos. Vale. Entonces vamos ahora a utilizar el remove. Pues para el

789
01:01:45,280 --> 01:01:55,900
El remove tengo dos señores, tengo el removeElement y tengo el removePositions, empezamos por

790
01:01:55,900 --> 01:02:02,480
esto por obvias razones, entonces lo que tengo que hacer es, me han dicho quita la posición

791
01:02:02,480 --> 01:02:11,880
3, por lo tanto lo que tengo que hacer yo es recorrer el array, copiarlo directamente

792
01:02:11,880 --> 01:02:12,900
hasta la posición.

793
01:02:14,440 --> 01:02:16,219
Luego saltarme

794
01:02:16,219 --> 01:02:18,239
esta posición y empezar a copiar

795
01:02:18,239 --> 01:02:20,260
en diagonal. Esto también lo hemos

796
01:02:20,260 --> 01:02:21,179
hecho varias veces.

797
01:02:22,500 --> 01:02:22,940
Entonces

798
01:02:22,940 --> 01:02:25,380
object

799
01:02:25,380 --> 01:02:28,400
nuevo

800
01:02:28,400 --> 01:02:30,039
es igual a new

801
01:02:30,039 --> 01:02:32,280
object un poquito

802
01:02:32,280 --> 01:02:33,699
más pequeño de lista.

803
01:02:37,610 --> 01:02:38,090
Justo.

804
01:02:39,070 --> 01:02:41,050
Y ahora for int y es

805
01:02:41,050 --> 01:02:42,949
igual a cero y menor

806
01:02:42,949 --> 01:02:44,409
que posición

807
01:02:44,409 --> 01:02:46,050
y más más

808
01:02:46,050 --> 01:02:49,849
desde cero hasta posición

809
01:02:49,849 --> 01:02:51,949
copio directamente

810
01:02:51,949 --> 01:02:53,869
nuevo de y

811
01:02:53,869 --> 01:02:56,030
es igual a lista de y

812
01:02:56,030 --> 01:03:03,239
ahora he llegado a posición

813
01:03:03,239 --> 01:03:05,960
posición me la tengo que saltar

814
01:03:05,960 --> 01:03:08,039
en lista

815
01:03:08,039 --> 01:03:09,340
pero no en nuevo

816
01:03:09,340 --> 01:03:11,659
entonces empiezo otra vez

817
01:03:11,659 --> 01:03:14,360
for int y es igual a

818
01:03:14,360 --> 01:03:17,260
posición

819
01:03:17,260 --> 01:03:18,239
más uno

820
01:03:18,239 --> 01:03:23,630
y menor que lista.length

821
01:03:23,630 --> 01:03:25,329
y más más

822
01:03:25,329 --> 01:03:29,329
desde posición más uno

823
01:03:29,329 --> 01:03:31,090
la siguiente a la que no quería copiar

824
01:03:31,090 --> 01:03:31,969
hasta el fondo

825
01:03:31,969 --> 01:03:34,530
lo que hago es copiar de nuevo

826
01:03:34,530 --> 01:03:36,570
de y menos uno

827
01:03:36,570 --> 01:03:40,690
lo que hay en lista

828
01:03:40,690 --> 01:03:43,329
de y

829
01:03:43,329 --> 01:03:45,809
ahora estoy copiando en diagonal

830
01:03:45,809 --> 01:03:52,360
al final

831
01:03:52,360 --> 01:03:59,349
lista es igual a nueve

832
01:03:59,349 --> 01:03:59,829
y voilà

833
01:03:59,829 --> 01:04:28,030
eliminado la posición. A ver si funciona. MLA.remove 0. No, quito el perro. Perro. Se hizo MLA.shock.

834
01:04:28,030 --> 01:04:49,880
Ya está. Me ha quitado el perro. Ahora, esto ya lo hemos visto mil veces. Lo hemos hecho varias veces esta

835
01:04:49,880 --> 01:04:57,880
Menos que el add, o sea, menos que añadir a un array, pero sí que lo hemos visto al menos tres o cuatro veces.

836
01:04:57,880 --> 01:05:40,730
Esto, ¿cómo lo hago? Una línea. ¿Qué hace esto? Pues busca element, me busca la posición del elemento que quiero borrar.

837
01:05:40,730 --> 01:05:51,730
Entonces me devuelve tres. Y a este punto le digo, remueve tres usando este método.

838
01:05:51,730 --> 01:05:56,909
no me pongo a reescribir todo el código otra vez que si luego lo tengo que

839
01:05:56,909 --> 01:06:00,909
mejorar lo tengo en seis sitios distintos reutilizó lo que ya tengo

840
01:06:00,909 --> 01:06:10,510
ahora esto me expone algunos problemas que yo puedo hacer qué pasa si le pongo

841
01:06:10,510 --> 01:06:17,090
remove de menos uno de posición menos uno o de más o menos dos o menos cinco o

842
01:06:17,090 --> 01:06:20,110
27

843
01:06:20,110 --> 01:06:48,329
Hago el remove de la posición sólo si esa posición es válida.

844
01:06:48,329 --> 01:06:56,880
Entonces si este de aquí cuando luego lo busca no lo encuentra me dará menos uno

845
01:06:56,880 --> 01:07:01,260
entonces no lo remueve y si este de aquí cuando lo encuentra hace un error y me da

846
01:07:01,260 --> 01:07:08,179
porque le he pasado aquí nul entonces explota y me dará menos dos tampoco lo remueve.

847
01:07:08,179 --> 01:07:27,829
Pero no explota ni nada. Y ya está, tenemos implementada nuestra

848
01:07:27,829 --> 01:07:41,329
lista utilizando Arrays. Por debajo estoy manejando Arrays, pero sustancialmente por

849
01:07:41,329 --> 01:07:49,190
fuera yo aquí de Arrays no he visto nada. Y aquí ya puedo utilizar mis objetos añadiendo cosas,

850
01:07:49,190 --> 01:08:01,730
quitando cosas, haciendo cosas raras, y de array ya no tengo ni la remota idea. Lo he hecho una vez,

851
01:08:03,309 --> 01:08:13,349
me lo he aprendido, estoy listo, y ahora, a partir de ahora, simplemente importo mi lista array en

852
01:08:13,349 --> 01:08:19,890
mis nuevos proyectos y puedo olvidarme de la gestión de los arreos. Y repito, esto habríais

853
01:08:19,890 --> 01:08:28,109
podido hacerlo ya desde varias semanas. ¿Eso es lo que se le llamaría una librería?

854
01:08:31,720 --> 01:08:42,279
La librería es más bien una colección de clases estáticas o no estáticas relacionadas con

855
01:08:42,279 --> 01:08:48,279
con unos varios temas concretos, pero una sola cosa así no.

856
01:08:48,279 --> 01:08:53,279
Ahora, si tú tuvieras la implementación de una lista, la implementación de una cola,

857
01:08:53,279 --> 01:08:58,279
la implementación de una stack, la implementación de un árbol, la implementación de...

858
01:08:58,279 --> 01:09:01,279
y todos en un mismo paquete, pues eso podría ser una library.

859
01:09:01,279 --> 01:09:10,699
¿Dudas?

860
01:09:10,699 --> 01:09:17,699
¿Podría repetir otra vez lo que has dicho en el método remove? O sea, le pasas...

861
01:09:17,699 --> 01:09:27,699
Yo de removeTheElement lo que tiene que hacer es remover el primero. Nosotros lo hemos definido como removeElPrimero, ¿vale?

862
01:09:27,699 --> 01:09:37,699
Y yo tengo ya un método que es buscaElement, este, que lo que hace es te doy un elemento, te doy un objeto y me devuelve su...

863
01:09:37,699 --> 01:09:45,699
El primer objeto que tú me has pasado me devuelve su posición. Podría haber varios, yo podría poner tres gatos.

864
01:09:45,699 --> 01:09:50,140
pero tú me devuelves la posición del primero, así que lo hemos definido aquí.

865
01:09:50,140 --> 01:09:57,100
Cuando lo hemos definido, devuelve la posición del primer objeto, igual a element, ¿vale?

866
01:09:57,100 --> 01:10:02,800
Entonces, como yo ya tengo este método, si yo a este método hago busca de un element,

867
01:10:02,800 --> 01:10:08,199
me da la posición de ser, ¿vale? Entonces, con esta cosa de aquí,

868
01:10:08,199 --> 01:10:21,840
yo voy a recibir a cambio un int, que es positivo si lo ha encontrado o negativo si no lo ha encontrado.

869
01:10:22,979 --> 01:10:31,819
Y yo esto se lo paso como parámetro a remove, a este remove, porque este es remove de object y este es remove de int.

870
01:10:32,720 --> 01:10:38,460
Entonces él me va a comprobar y me dice si es una posición válida, entonces si me has pasado menos uno no hará nada, no remove nada.

871
01:10:38,460 --> 01:10:45,579
Pues si es una posición entre cero y el tamaño del array, pues entonces hazme todo el trabajo para quitarme esa posición.

872
01:10:48,319 --> 01:10:56,460
Primero en dos pasos, int posición remove es igual a busca.lm.

873
01:11:06,829 --> 01:11:14,399
Y aquí, si os queda más claro.

874
01:11:14,399 --> 01:11:17,079
con esto paso de aquí

875
01:11:17,079 --> 01:11:18,800
busco en qué posición

876
01:11:18,800 --> 01:11:21,079
está el elemento para quitarla

877
01:11:21,079 --> 01:11:23,079
y luego le digo, usa este otro

878
01:11:23,079 --> 01:11:24,560
método para quitar el otro

879
01:11:24,560 --> 01:11:28,779
eso también os

880
01:11:28,779 --> 01:11:30,979
dice una cosa, que es cuando

881
01:11:30,979 --> 01:11:33,060
tenéis que implementar varios métodos

882
01:11:33,060 --> 01:11:34,800
o varias versiones del mismo método

883
01:11:34,800 --> 01:11:37,199
cuidado con el orden con lo que implementáis

884
01:11:37,199 --> 01:11:38,920
porque si empezáis de aquí

885
01:11:38,920 --> 01:11:40,939
hacéis una

886
01:11:40,939 --> 01:11:42,979
parrafada de código, que luego tenéis

887
01:11:42,979 --> 01:11:43,899
que recopiar aquí

888
01:11:43,899 --> 01:11:47,439
porque removeObject

889
01:11:47,439 --> 01:11:50,460
puede usar removeInt

890
01:11:50,460 --> 01:11:53,560
pero removeInt no usa removeObject

891
01:11:53,560 --> 01:11:58,000
entonces allí tenéis que tener un poquito

892
01:11:58,000 --> 01:12:00,819
de por qué yo he implementado antes

893
01:12:00,819 --> 01:12:03,640
busca, si tú vas en orden

894
01:12:03,640 --> 01:12:06,460
pues aquí habrías implementado el busca

895
01:12:06,460 --> 01:12:09,159
habrías implementado el remove de la posición

896
01:12:09,159 --> 01:12:13,000
y ahora deberías reescribirlo otra vez, como mínimo copiarlo

897
01:12:13,000 --> 01:12:14,840
si tienes un puesto de espera

898
01:12:14,840 --> 01:12:16,720
pero como lo he hecho yo

899
01:12:16,720 --> 01:12:19,000
pues los he dividido y he escrito el código solo una vez

900
01:12:19,000 --> 01:12:20,380
y aquí he reutilizado el código

901
01:12:20,380 --> 01:12:23,100
entonces el remove the object me sale

902
01:12:23,100 --> 01:12:25,319
como una línea de código súper fácil

903
01:12:25,319 --> 01:12:34,250
además así se me ha quedado más

904
01:12:34,250 --> 01:12:36,029
divide tímpera porque esto remueve

905
01:12:36,029 --> 01:12:38,229
el otro busca, son dos ejercicios

906
01:12:38,229 --> 01:12:39,869
distintos más sencillitos

907
01:12:39,869 --> 01:12:42,210
esto al fin y al cabo lo que hace es

908
01:12:42,210 --> 01:12:44,310
busca y remueve, busco este

909
01:12:44,310 --> 01:12:52,229
objeto y luego lo remuevo. Entonces son dos pasos que yo podría, hasta si sólo tuviera este método

910
01:12:52,229 --> 01:12:58,350
de aquí sin este y sin el busca, pues yo me habría hecho dos métodos auxiliares, uno para buscar y

911
01:12:58,350 --> 01:13:22,109
uno para remover una posición, ¿eh? Dudas. Vale. Ahora. Control-C, control-U. MyLista,

912
01:13:22,109 --> 01:13:35,880
miLista. Esta es mi lista con objetos, ¿vale? Utiliza object, etcétera, etcétera. Ahora,

913
01:13:35,880 --> 01:13:46,340
Lo que no me gusta de object es que yo aquí he puesto, he quedado con mi lista y he empezado

914
01:13:46,340 --> 01:13:55,579
a poner cosas, lo comento, ahora tengo vacía, vale, puedo hacer MLA es igual, no, punto

915
01:13:55,579 --> 01:14:20,050
Vale, perfecto, he añadido gato, pero puedo hacer mla.addNewScanner, sin problema, porque

916
01:14:20,050 --> 01:14:23,329
aquí se añaden objetos.

917
01:14:23,329 --> 01:14:45,590
Ahora esto me puede dar problemas cuando yo digo oye me buscas perro, ah no, porque habrá

918
01:14:45,590 --> 01:15:00,949
hecho un ahora habrá utilizado yo vamos a ver por qué entonces nosotros tenemos por aquí el

919
01:15:00,949 --> 01:15:11,750
busca el busca lo que hace es utilizar elementos entonces ha utilizado el de string pero si no son

920
01:15:11,750 --> 01:15:18,289
la misma cosa no está comparando que no son el mismo a la misma clase de la primera línea si

921
01:15:18,289 --> 01:15:25,510
Si vosotros hacéis aquí un toString, un equals,

922
01:15:25,510 --> 01:15:33,020
search, crea un equals, que está aquí,

923
01:15:33,020 --> 01:15:37,020
veis, la primera cosa que busca es si son de la misma clase.

924
01:15:37,020 --> 01:15:40,520
O sea, una de las primeras cosas que busca es si son de clases distintas.

925
01:15:40,520 --> 01:15:46,859
Pues si son de clases distintas, pues no son iguales, son distintos.

926
01:15:46,859 --> 01:15:54,380
esto me salva de que estoy comparando un escáner y un string

927
01:15:54,380 --> 01:15:59,500
y no explota. Son clases distintas, son distintos, ya está, sigo adelante.

928
01:15:59,500 --> 01:16:10,680
Aún así puede ser feucho, puede ser feo, entre comillas, el gestionar

929
01:16:10,680 --> 01:16:18,880
un array que tenga dentro de todo. Una lista, una lista de objetos, de todo.

930
01:16:18,880 --> 01:16:26,619
entonces la cosa interesante podría ser intentar evitar que sean de cualquier

931
01:16:26,619 --> 01:16:31,479
cosa vale entonces tengo esta esta nueva versión de la lista

932
01:16:31,479 --> 01:16:36,880
y son estas de que son copias la copiado donde vamos a intentar ver oye mira más

933
01:16:36,880 --> 01:16:41,680
no puedo yo de alguna forma decirle oye mira no quiero objetos

934
01:16:41,680 --> 01:16:45,640
quiero un tipo

935
01:16:45,640 --> 01:16:48,460
Pero no quiero decir, oye, mira, esto tiene que ser string.

936
01:16:50,430 --> 01:16:53,329
Entonces ahora esto me funciona, pero no me funciona solo para string.

937
01:16:53,689 --> 01:16:57,170
Si ahora quiero hacerlo para coches, pues tengo que cambiar esto a coches.

938
01:16:58,010 --> 01:17:00,050
Quiero lo que sea, un tipo genérico.

939
01:17:06,699 --> 01:17:10,039
Esto me está diciendo, oye, cuando tú implementas la interfaz lista,

940
01:17:10,340 --> 01:17:12,220
dime para qué lo implementas.

941
01:17:15,020 --> 01:17:17,979
Si lo implementas para string, pues esto será string,

942
01:17:18,460 --> 01:17:21,119
esto será string, esto será string.

943
01:17:21,119 --> 01:17:29,319
Si tú lo implementas para coches, pues entonces esto será coche, coche, coche. Si lo implementas para gatos,

944
01:17:29,319 --> 01:17:43,220
pues esto será gato, gato, gato y gato. Ahora, cuando tú implementas lista, si yo no le digo nada, lista se

945
01:17:43,220 --> 01:17:55,880
mantiene por object. Y entonces aquí utilizo object. Si yo aquí le digo algo, pues ahora esta lista de

946
01:17:55,880 --> 01:18:03,260
aquí, en vez de ser object aquí, pues aquí le tengo que poner string. Aquí le tengo que poner string.

947
01:18:03,260 --> 01:18:10,760
Aquí le tengo que poner string. No, esto no, porque no es de larga. Aquí le tengo que poner string, ¿vale?

948
01:18:11,319 --> 01:18:21,199
Entonces, lo que me gustaría a mí es mantener también a este nivel una cosa de ese estilo.

949
01:18:21,199 --> 01:18:22,500
A ver si me lo pillo así.

950
01:18:24,260 --> 01:18:29,579
Yo te digo, cuando tú creas mi lista de array, me dices de qué tipo tienes.

951
01:18:30,399 --> 01:18:32,979
Y esto implementa una lista de ese tipo.

952
01:18:33,539 --> 01:18:39,159
Si tú me dices al crear la lista de array que es de string, pues esta que aquí será una lista de string.

953
01:18:40,460 --> 01:18:44,640
Cuando lo pones así, quiere decir que esto es un t.

954
01:18:47,680 --> 01:18:48,640
Esto es un t.

955
01:18:53,020 --> 01:18:54,100
Esto es un t.

956
01:18:54,100 --> 01:18:56,720
Esto no, porque buscador no es parte de la lista.

957
01:18:56,899 --> 01:19:04,899
Entonces este de aquí lo puedo quitar, este de aquí sí, y ya está.

958
01:19:06,680 --> 01:19:27,779
¿Vale? Además esto, esto se me enfado, porque no puedo crear arrays de tamaño, de tipo genérico.

959
01:19:28,140 --> 01:19:30,319
Tengo que hacer cosas distintas para poder hacer esto.

960
01:19:30,840 --> 01:19:32,460
Entonces esto sería un problema.

961
01:19:34,920 --> 01:19:36,439
No sé si aquí me lo podría pillar.

962
01:19:42,289 --> 01:19:47,890
Tengo que solucionar este problema aquí. Me dice, no puedes crear un generic array of t.

963
01:19:47,890 --> 01:19:51,430
Me tienes que decir cuando lo creas, me tienes que decir como sea.

964
01:19:51,430 --> 01:20:03,229
Entonces por ahora lo soluciona así. Pásamelo desde fuera.

965
01:20:06,659 --> 01:20:14,479
Cuando tú creas un MrArray, me pasas un array del tipo correcto y a partir de allí hago lo que me

966
01:20:14,479 --> 01:20:23,039
Creamelo tú, cuando la tienes que usar, me lo creas un array vacío y a partir de allí

967
01:20:23,039 --> 01:20:32,930
yo ya hago lo que tengo que hacer. Y a ver si aquí se molesta en alguna forma, ahora

968
01:20:32,930 --> 01:20:40,109
hay que revisar un poco todo porque esto también se ha de hacer, este de aquí, este de aquí

969
01:20:40,109 --> 01:20:55,420
es un problema. Esto de aquí, ahora hacerlo como object y luego hacer algo así. Lo creo con objetos,

970
01:20:55,420 --> 01:21:10,079
como puede estar todo en objetos, cuando voy a hacer aquí, hago un downcasting. Como tanto sé

971
01:21:10,079 --> 01:21:20,439
que estoy utilizando todos los elementos T, lo puedo hacer. ¿Lo veis esto? No puedo crear,

972
01:21:20,439 --> 01:21:39,380
en realidad este mismo truquillo lo puedo utilizar aquí. Te creo un new object, pero te digo que eres,

973
01:21:39,380 --> 01:22:01,020
esperando que esto no explote. Y lo mismo con estas otras cosas. Esto de aquí también, lista,

974
01:22:01,020 --> 01:22:14,880
creo un object y al final remove me da un t, una red de t, esto se queda igual, object,

975
01:22:14,880 --> 01:22:26,880
este buscador se me lo salto, este elemento sí debería funcionar, esto es t, y un t object que

976
01:22:26,880 --> 01:22:43,270
devuelve devolver y ya está con esto y un poco de suerte cuando yo creo mi lista yo le puedo

977
01:22:43,270 --> 01:22:56,210
decir que mi lista es una lista de streaming esta cosa de aquí me está forzando que esta

978
01:22:56,210 --> 01:23:05,210
lista de aquí ya no puedo añadirle un escáner. Si yo hago mla.add new ScannerSystem.in

979
01:23:05,210 --> 01:23:41,130
punto in, no importa, que era java punto útil, punto, no, java punto, lo hemos importado

980
01:23:41,130 --> 01:23:52,479
al otro lado, java punto útil, punto escándalo, no sé por qué ahora, no importa, bueno, ahí,

981
01:23:52,479 --> 01:23:59,560
veis que se enfada, porque me dice, oye mira, no, tú has definido que mi array es de tipo

982
01:23:59,560 --> 01:24:10,109
string. O sea, tú has asociado string a esta t de aquí. Entonces, ahora yo donde uso t,

983
01:24:10,109 --> 01:24:16,710
quiero un string. Y tú me estás diciendo, ponle un scanner. Y si te fijas, el add,

984
01:24:18,550 --> 01:24:24,810
el método add, pilla un elemento t. Y tú me has dicho que t string. Entonces no puedes añadir un

985
01:24:24,810 --> 01:24:38,609
un scan. Ahora, si yo le digo que esto es object, dicen encantado de la vida, añade los objetos que

986
01:24:38,609 --> 01:24:45,069
te da la gana. Scanner es un object, string es un object, lo puedes añadir. Entonces, aquí estaría

987
01:24:45,069 --> 01:24:50,069
en la misma situación de antes. Puedo añadir lo que me da la gana. No la he perdido la opción de

988
01:24:50,069 --> 01:24:58,890
poder hacer una lista con dentro de todo, pero tengo una opción más avanzada, que es que si te

989
01:24:58,890 --> 01:25:14,199
Con el esfuerzo a que sea string, ahora aquí dentro solo puedo poner string.

990
01:25:14,199 --> 01:25:20,199
Supero el código y luego lo puedo utilizar como me dé la gana.

991
01:25:20,199 --> 01:25:30,180
Si, eso, mla.show.

992
01:25:30,180 --> 01:25:39,130
Ah, esto va para el panel.

993
01:25:39,130 --> 01:25:44,130
Aquí tengo mi lista que funciona tranquilamente con string.

994
01:25:44,130 --> 01:25:48,130
Y ahora quiero hacer una lista de coches,

995
01:25:48,130 --> 01:26:03,130
mi lista array de coches. Solo puedes crear arrays del mismo tipo. Lo único que has hecho con T es que le das la opción de crear de varios tipos, pero no el array siempre va a ser del mismo tipo.

996
01:26:03,130 --> 01:26:17,130
Yo estoy haciendo un control diciendo que puedo crear listas que contengan dentro todos el mismo tipo. Pero eso no quita que pueda hacer listas con tipo mezclado.

997
01:26:17,130 --> 01:26:22,130
Si yo pongo object, puede meter dentro lo que te haga, lo he hecho.

998
01:26:22,130 --> 01:26:24,130
Claro, eso sería...

999
01:26:24,130 --> 01:26:30,130
Sustancialmente no lo estás limitando, estás diciendo, y aquí dentro quiero solo objetos.

1000
01:26:30,130 --> 01:26:39,130
Por lo tanto, como todos heredan de objetos, puedes poner un integer, puedes poner un sonoscanner, puedes poner una string, puedes poner un coche.

1001
01:26:39,130 --> 01:26:42,130
Y él te pillará todo diciendo, muy bien, estoy contento.

1002
01:26:42,130 --> 01:26:45,130
Si quisiera hacer uno de tipo primitivo, no existe.

1003
01:26:45,130 --> 01:26:57,170
Sí, porque tú aquí le pones integer y ahora tienes una lista de entero.

1004
01:26:59,170 --> 01:27:06,069
Porque en Java integer e int van de la manita. Y él hace muchos cambios entre integer e int. Pero

1005
01:27:06,069 --> 01:27:11,449
aquí estamos trabajando con tipos de objetos, entonces no le puedes poner aquí un tipo

1006
01:27:11,449 --> 01:27:16,569
primitivo pero si le pones integer es la misma cosa ahora él te dice no le va a poner y le puede

1007
01:27:16,569 --> 01:27:25,359
añadir 1 4 y 27 30 y esto funciona

1008
01:27:29,359 --> 01:27:34,739
porque está utilizando integer pero aquí yo no tengo a hacer new integer de 1 porque él

1009
01:27:34,739 --> 01:27:39,239
entiende que este 1 es un int pero que tú lo estás tratando como integer y lo hace en automático

1010
01:27:43,140 --> 01:27:58,149
Entonces, esto es una pincelada de tipos genéricos. Es mucho más complejo de esto los tipos genéricos, ¿vale?

1011
01:27:58,149 --> 01:28:03,710
Se pueden hacer cosas bastante complejas con los tipos genéricos, ¿vale?

1012
01:28:04,069 --> 01:28:13,449
Pero como primer inicio para entender un poquito para qué pueden servir, pues aquí lo tenemos, ¿vale?

1013
01:28:13,449 --> 01:28:15,149
hemos pasado desde tener

1014
01:28:15,149 --> 01:28:16,909
una lista de objetos que

1015
01:28:16,909 --> 01:28:19,470
me valía perfectamente

1016
01:28:19,470 --> 01:28:20,909
para hacer una lista de string

1017
01:28:20,909 --> 01:28:23,569
pero si alguien malintencionado

1018
01:28:23,569 --> 01:28:25,390
ponía un coche dentro de una lista de string

1019
01:28:25,390 --> 01:28:26,390
pues podía ponerlo

1020
01:28:26,390 --> 01:28:28,989
a tener un mecanismo para

1021
01:28:28,989 --> 01:28:31,069
no perder lo anterior

1022
01:28:31,069 --> 01:28:32,729
porque si yo hago una lista de objetos

1023
01:28:32,729 --> 01:28:35,470
si yo lo instancio como object

1024
01:28:35,470 --> 01:28:37,590
pues sigo en el mismo

1025
01:28:37,590 --> 01:28:39,630
caso anterior y puedo hacer lo que me da la gana

1026
01:28:39,630 --> 01:28:41,409
pero con esto

1027
01:28:41,409 --> 01:28:42,470
pues ya

1028
01:28:42,470 --> 01:28:45,189
Puedo hacer cosas más estrictas

1029
01:28:45,189 --> 01:28:46,229
Puedo decir string

1030
01:28:46,229 --> 01:28:47,090
Entonces vamos a string

1031
01:28:47,090 --> 01:28:48,569
Puedo poner aquí

1032
01:28:48,569 --> 01:28:51,010
Una clase

1033
01:28:51,010 --> 01:28:54,590
De la que luego hereden otras clases

1034
01:28:54,590 --> 01:28:56,829
Yo podría hacer una lista de personas

1035
01:28:56,829 --> 01:29:03,439
Y dentro poner profesores y alumnos

1036
01:29:03,439 --> 01:29:04,399
Eso no lo quiero

1037
01:29:04,399 --> 01:29:07,659
Es una herramienta para hacer las cosas

1038
01:29:07,659 --> 01:29:09,239
Más flexibles

1039
01:29:09,239 --> 01:29:10,359
¿Vale?

1040
01:29:10,720 --> 01:29:13,260
Aquí se enfadaba siempre un poco

1041
01:29:13,260 --> 01:29:15,380
Porque aquí estoy haciendo una cosa un poquito

1042
01:29:15,380 --> 01:29:28,170
peligrosa, pero… ¡Dudas hasta aquí!