1
00:00:00,870 --> 00:00:02,490
Hola y bienvenidos a esta elección.

2
00:00:02,490 --> 00:00:06,850
A continuación vamos a ver el tema de manejo de conexiones en Java están listos.

3
00:00:06,900 --> 00:00:07,380
Vamos

4
00:00:10,190 --> 00:00:16,520
bien abrimos nuestro Irem vamos a hacer cualquier proyecto que tengamos abierto damos clic derecho Claws

5
00:00:18,030 --> 00:00:19,700
y vamos a crear un nuevo proyecto.

6
00:00:19,920 --> 00:00:23,570
En fin Project y a la web Leuven y applications.

7
00:00:23,790 --> 00:00:30,840
Damos clic en Next y el nombre del proyecto se va a llamar manejo colecciones

8
00:00:36,850 --> 00:00:38,950
y lo depositamos en la ruta de cursos

9
00:00:41,420 --> 00:00:45,430
diagonal inversa aullaba agruparía cm x con G.M. globalmente.

10
00:00:45,470 --> 00:00:53,400
La versión 1.0 y dejamos el nombre del paquete vacío y damos fuguen finalizar bien como siguiente paso

11
00:00:53,400 --> 00:00:57,620
vamos a crear una clase para poner a prueba el concepto de colecciones.

12
00:00:57,780 --> 00:01:03,510
Así que sobre los paquetes vamos a crear una nueva clase damos clic derecho nuevo Java class el nombre

13
00:01:03,510 --> 00:01:08,340
de la clase se llama manejo colecciones y también el nombre del paquete se va a llamar igual manejo

14
00:01:08,760 --> 00:01:11,160
colecciones y damos fuguen finalizar

15
00:01:13,850 --> 00:01:15,230
quitamos estos comentarios

16
00:01:19,900 --> 00:01:25,920
y agregamos un método main bien con esto estamos listos para empezar a trabajar.

17
00:01:26,020 --> 00:01:33,010
Lo primero que vamos a hacer es definir una variable de tipo lista List es una interfase así que por

18
00:01:33,010 --> 00:01:40,250
un lado ya estamos poniendo en práctica el concepto de tipos interface declaramos una variable de tipo

19
00:01:40,250 --> 00:01:45,560
lista pero debido a que no podemos crear objetos de tipo interface entonces tenemos que utilizar una

20
00:01:45,560 --> 00:01:48,310
clase que implemente esta interfase.

21
00:01:48,350 --> 00:01:55,600
Una de las clases que implementa la interface list es la clase Array lista así que vamos a crear un

22
00:01:55,600 --> 00:02:03,870
nuevo objeto del tipo Array List importamos estas clases del paquete ya apunto y útil y debido a que

23
00:02:03,870 --> 00:02:09,960
vamos a utilizar varias clases de este paquete ponemos punto asterisco y se imparten todas las clases

24
00:02:09,960 --> 00:02:17,310
de este paquete y básicamente esta clase de Rairiz lo que permite es ir agregando elementos de manera

25
00:02:17,310 --> 00:02:19,380
dinámica a una lista.

26
00:02:19,470 --> 00:02:26,220
Además los agrega de manera ordenada vamos a poner a prueba esto utilizando nuestra variable en mi lista

27
00:02:27,830 --> 00:02:34,780
mandamos a llamar el método add y podemos ir agregando cualquier tipo de elemento por ejemplo los valores

28
00:02:34,780 --> 00:02:35,410
de 1

29
00:02:40,900 --> 00:02:44,020
y vamos agregando los de manera ordenada para que veamos que también.

30
00:02:44,110 --> 00:02:54,380
Así es como nos despliega el valor de tres etc. Pero si queremos agregar por ejemplo un elemento repetido

31
00:02:57,160 --> 00:02:58,480
vamos a ver que lo que sucede

32
00:03:02,120 --> 00:03:07,460
vamos a imprimir esta lista para ver qué sucede con este elemento repetido y además con el orden de

33
00:03:07,460 --> 00:03:12,160
cada uno de estos elementos vamos a crear un método llamado imprimir

34
00:03:16,190 --> 00:03:26,530
que va a ser privado de tipo Static Veidt y se llama imprimir y para imprimir debido a que no solamente

35
00:03:26,530 --> 00:03:32,200
vamos a utilizar este método para imprimir elementos de tipo listo sino que vamos a utilizar el tipo

36
00:03:32,200 --> 00:03:33,180
más genérico.

37
00:03:33,340 --> 00:03:38,980
En este caso también es una interfase ya que también las interfaces pueden manejar el concepto de herencia

38
00:03:39,580 --> 00:03:47,360
así que vamos a utilizar la interfase colección que es la interfase padre de todos los tipos interfaces

39
00:03:47,360 --> 00:03:49,400
que vamos a utilizar en este ejercicio.

40
00:03:49,730 --> 00:03:56,340
Cómo puede ser Lisset C.T o Mapp la variable se va a llamar colección y este tipo colección que es una

41
00:03:56,340 --> 00:04:02,580
interfase va a poder apuntar a todos los tipos que vamos a utilizar en esta lección como es el objeto

42
00:04:02,720 --> 00:04:09,270
raulista ya que este tipo Areliz implementa la interfaz de lista y a su vez la interfase Liz hereda

43
00:04:09,390 --> 00:04:15,210
de la interfase colección así que al tener esta relación de clases entonces es posible que el tipo colección

44
00:04:15,420 --> 00:04:21,150
apunte a objetos de tipo Analyst y como siguiente paso y tengamos cada uno de los elementos de la lista

45
00:04:25,820 --> 00:04:32,180
definimos la variable que va a recorrer cada uno de los elementos que es de tipo Object y posteriormente

46
00:04:32,180 --> 00:04:38,760
especificamos la colección que deseamos iterar e imprimimos cada uno de los elementos

47
00:04:44,760 --> 00:04:49,180
y al terminar de imprimir cada elemento imprimimos también un salto de línea ya que vamos a mandar a

48
00:04:49,180 --> 00:04:55,300
llamar varias veces este método y una vez que ya tenemos este método implementado vamos a mandarlo a

49
00:04:55,300 --> 00:05:02,860
llamar desde el método main y le pasamos la lista que hemos creado en este momento.

50
00:05:02,860 --> 00:05:07,480
Guardamos cambios y vamos a ejecutar un derecho Rombai

51
00:05:14,060 --> 00:05:21,090
y podemos observar que nos despliega cada uno de los elementos elemento con el valor de 1 2 3 y el elemento

52
00:05:21,090 --> 00:05:26,580
repetido en este caso podemos observar que lo pueda almacenar sin ningún problema y además también respetó

53
00:05:26,580 --> 00:05:31,890
el orden en el que agregamos cada uno de los elementos y en ese mismo orden es que despliega los elementos

54
00:05:32,070 --> 00:05:37,920
que hemos agregado podemos observar que en este caso utilizamos tipos enteros pero bien podríamos haber

55
00:05:37,920 --> 00:05:43,830
agregado cualquier tipo de elemento ya que si no especificamos otra cosa por default estamos agregando

56
00:05:43,830 --> 00:05:50,100
tipos obvie así que en lugar de por ejemplo de agregar un valor de 1 podríamos haber agregado la cadena

57
00:05:50,160 --> 00:05:57,360
de uno o guardamos cambios y ejecutamos y con eso estamos combinando elementos de tipo string con elementos

58
00:05:57,360 --> 00:06:03,160
de tipo integral así que se despliega el string y posteriormente los valores de tipo int.

59
00:06:03,820 --> 00:06:08,860
Así que en esa primera lección de colecciones podemos agregar cualquier tipo de dato ya que la colección

60
00:06:08,860 --> 00:06:14,380
por default almacena tipos Object como lo pudimos ver al momento de extraer cada uno de los elementos

61
00:06:14,890 --> 00:06:21,030
estamos extrayendo elementos de tipo obvie así que ese es nuestro primer tipo de dato el tipo listo.

62
00:06:21,160 --> 00:06:29,450
Ahora vamos a manejar el tipo set definimos una variable de tipo set utilizando la interface set definimos

63
00:06:29,450 --> 00:06:36,170
la variable llamada set y una de las clases que implementa esta interfaz de Set es la clase Asset

64
00:06:38,790 --> 00:06:44,380
existen más clases que implementa la interfaz de set pero esa es una de las más utilizadas y posteriormente

65
00:06:44,380 --> 00:06:47,600
lo que vamos a hacer es ir agregando también cada uno de los elementos.

66
00:06:47,650 --> 00:06:52,660
De igual manera podemos observar que recibe un objeto así que podemos agregar cualquier tipo de dato

67
00:06:52,990 --> 00:06:57,240
desde tipos primitivos hasta cualquier tipo obvie y vamos agregando valores.

68
00:06:57,250 --> 00:06:58,480
Por ejemplo el valor de 100

69
00:07:02,920 --> 00:07:03,790
200

70
00:07:10,330 --> 00:07:14,110
300 íbamos a agregar un elemento duplicado

71
00:07:21,730 --> 00:07:27,220
agregamos de nueva cuenta el valor de 300 y podemos observar que son tipos estrujan pero bien pudimos

72
00:07:27,220 --> 00:07:30,680
haber agregado cualquier otro tipo como tipos enteros.

73
00:07:30,940 --> 00:07:38,480
Bien vamos a poner entre comentarios imprimir esta lista para que únicamente tengamos la impresión del

74
00:07:38,480 --> 00:07:41,260
tipo set y finalmente mandamos a imprimir este set

75
00:07:45,450 --> 00:07:50,850
mandamos a imprimir el tipo de dato set que hemos creado podemos observar que podemos mandar a llamar

76
00:07:50,880 --> 00:07:56,620
el método de imprimir sin ningún problema debido a que la interface set hereda de la interfase Collection.

77
00:07:56,670 --> 00:08:01,440
Así que la interfase colección como es la interface padre de todas las interfaces de tipo colección

78
00:08:01,740 --> 00:08:07,930
entonces puede apuntar a objetos que implementan las interfaces hijas como en este caso HCP que implementa

79
00:08:07,930 --> 00:08:14,010
la interface C.T entonces colección puede apuntar a este tipo de objetos bien guardamos cambios y ejecutamos.

80
00:08:14,010 --> 00:08:21,610
Vamos a revisar y podemos observar que a diferencia de la lista en este caso no se agregó el elemento

81
00:08:21,610 --> 00:08:28,420
duplicado únicamente podemos observar tres elementos el valor de 100 200 y 300 y además también se respeta

82
00:08:28,420 --> 00:08:31,160
el orden en que agregamos cada uno de los elementos.

83
00:08:31,300 --> 00:08:36,810
Así que en este caso el elemento duplicado no se agrega.

84
00:08:36,900 --> 00:08:39,500
Esa es la diferencia entre una lista y un set.

85
00:08:39,720 --> 00:08:45,180
La lista puede agregar cualquier tipo de elemento y no revisa si hay elementos duplicados solamente

86
00:08:45,180 --> 00:08:50,850
conserva el orden en que se fueron agregando los elementos pero un set a diferencia de una lista no

87
00:08:50,850 --> 00:08:56,730
agrega elementos duplicados si mantiene el orden pero ya no podemos agregar elementos duplicados en

88
00:08:56,730 --> 00:09:02,190
automático los descarta así que esa es una de las diferencias más importantes cuando trabajamos este

89
00:09:02,190 --> 00:09:11,070
tipo de dato y por último vamos a manejar un mapa definimos una variable en mi mapa de tipo interface

90
00:09:11,070 --> 00:09:20,480
Map y una de las clases que implementa esa interface es la clase SMAP también podemos observar que ninguno

91
00:09:20,480 --> 00:09:26,090
de los casos anteriores hemos especificado cuántos elementos va a contener cada una de estas listas

92
00:09:28,900 --> 00:09:33,490
así que una de las características de lapida colección es que no es necesario indicar cuántos elementos

93
00:09:33,490 --> 00:09:39,100
va almacenar en automático podemos agregar cualquier cantidad de elementos a nuestras colecciones y

94
00:09:39,100 --> 00:09:44,410
un mapa a diferencia de una lista Adum set es que maneja el concepto de llave valor

95
00:09:48,210 --> 00:09:53,880
así que por un lado vamos a utilizar nuestro tipo mi mapa y en este caso ya no vamos a manejar el método

96
00:09:53,940 --> 00:09:59,880
APT sino que vamos a manejar el método put@ y podemos observar que este método recibe un objet como

97
00:09:59,880 --> 00:10:06,540
llave y también un objeto como valio así que vamos a especificar dos valores la llave y el valor asociado

98
00:10:06,600 --> 00:10:12,620
a la llave que vamos a poner la llave puede ser de cualquier tipo como en este caso nos está indicando

99
00:10:12,620 --> 00:10:16,550
que es un tipo Objet nosotros lo vamos a utilizar una cadena que es lo más común.

100
00:10:16,610 --> 00:10:25,430
Por ejemplo podemos especificar la llave valor 1 y la asociamos el valor por ejemplo la cadena de

101
00:10:29,630 --> 00:10:37,550
agregamos otro valor con la llave de valor 2 con el valor de Carla

102
00:10:40,910 --> 00:10:53,180
agregamos un tercer valor con la llave valor 3 y la asociamos el valor de Carlos a esta llave 3.

103
00:10:53,510 --> 00:10:57,750
Y si intentamos repetir algún elemento vamos a ver cómo se comporta

104
00:11:04,800 --> 00:11:13,440
agregamos la llave de valor 3 cuando el valor de Rosario ahora guardamos cambios y vamos a tratar de

105
00:11:13,440 --> 00:11:14,230
imprimirlo.

106
00:11:14,430 --> 00:11:19,770
Aquí la diferencia para imprimir un mapa es que no podemos mandar a imprimir directamente este mapa

107
00:11:20,070 --> 00:11:25,590
sino que tenemos que especificar que queremos imprimir ya sea las llaves o los valores asociados a cada

108
00:11:25,590 --> 00:11:26,760
una de las llaves.

109
00:11:26,760 --> 00:11:29,130
Así que en primer lugar vamos a imprimir todas las llaves

110
00:11:34,410 --> 00:11:39,390
así que para imprimir las llaves vamos a utilizar el siguiente método mandamos a llamar el método de

111
00:11:39,390 --> 00:11:40,260
imprimir.

112
00:11:40,260 --> 00:11:46,890
Utilizamos el tipo mi mapa pero vamos a solicitar únicamente las llaves y para imprimir cada una de

113
00:11:46,890 --> 00:11:48,370
las llaves mandamos a llamar.

114
00:11:48,390 --> 00:11:49,500
El método Kissed

115
00:11:52,350 --> 00:11:57,270
así que con este método nos va a regresar un set de cada una de las llaves que hemos agregado a este

116
00:11:57,270 --> 00:12:06,550
mapa así que guardamos cambios y ejecutamos vamos a poner entre comentarios esta impresión para que

117
00:12:06,550 --> 00:12:08,840
solamente se mande imprimir el mapa.

118
00:12:09,070 --> 00:12:19,480
Guardamos cambios ejecutamos y podemos llevar que se está imprimiendo el valor de 1 3 y 2 y en este

119
00:12:19,480 --> 00:12:22,010
caso podemos observar que no respeta el orden.

120
00:12:22,070 --> 00:12:28,330
él explica que esta información no respetó el orden en que fuimos agregando los elementos para imprimir

121
00:12:28,330 --> 00:12:30,940
los valores asociados a las llaves.

122
00:12:31,000 --> 00:12:39,270
Vamos a mandar a llamar el siguiente método imprimimos los valores volvemos a mandar a llamar el método

123
00:12:39,300 --> 00:12:39,920
imprimir.

124
00:12:42,190 --> 00:12:48,520
Pero para imprimir los valores mandamos a llamar el método valioso así que vamos a poner entre comentarios

125
00:12:48,710 --> 00:12:50,630
la impresión anterior.

126
00:12:50,630 --> 00:12:57,800
Guardamos cambios y ejecutamos y podemos llevar la impresión de cada uno de los elementos de los valores

127
00:12:58,100 --> 00:13:00,140
asociados a cada una de las llaves.

128
00:13:00,320 --> 00:13:01,430
Cómo es el valor de Juan.

129
00:13:01,460 --> 00:13:07,100
Rosario y Karla y también podemos ver que no se respeta ningún orden y además lo que hizo con el valor

130
00:13:07,100 --> 00:13:13,370
duplicado fue sustituir el valor ya que podemos observar que el primer valor que se agregó a la llave

131
00:13:13,520 --> 00:13:15,970
de valor 3 fue el nombre de Carlos.

132
00:13:16,340 --> 00:13:22,360
Pero el valor que realmente se está desplegando es el valor de Rosario así que el elemento duplicado

133
00:13:22,900 --> 00:13:27,880
sustituye al valor agregado previamente

134
00:13:31,150 --> 00:13:33,120
y esto lo podemos observar en la salida.

135
00:13:33,220 --> 00:13:38,170
No respeta ningún orden y además el valor de Carlos ya no se muestra únicamente tenemos los valores

136
00:13:38,170 --> 00:13:44,590
de Juan Rosario y Karla así que este valor duplicado sustituyó al valor de Carlos.

137
00:13:44,700 --> 00:13:50,740
Por lo tanto únicamente observamos el valor de Rosario y también si quisiéramos mandar a imprimir simplemente

138
00:13:50,770 --> 00:13:53,440
un valor asociado a una llave.

139
00:13:53,440 --> 00:13:54,890
Podemos hacer lo siguiente.

140
00:13:57,380 --> 00:14:05,230
Podemos mandar a llamar el método G.T del mapa especificamos la llave por ejemplo en este caso el valor

141
00:14:05,440 --> 00:14:10,780
de tres y esto nos va a regresar el valor asociado a esta llave lo mandamos a imprimir

142
00:14:15,020 --> 00:14:20,060
ponemos entre comentarios la impresión de los valores para que únicamente veamos lo que nos va a imprimir

143
00:14:20,090 --> 00:14:21,250
este valor 3.

144
00:14:21,350 --> 00:14:23,390
Al proporcionar esta llave valor 3

145
00:14:26,830 --> 00:14:32,550
y podemos observar que nos regresa el valor de Rosario así que con eso podemos extraer el valor asociado

146
00:14:32,760 --> 00:14:38,110
a una llave así que con esto hemos puesto en práctica el concepto de lápiz de colección.

147
00:14:38,330 --> 00:14:43,700
Sin embargo esta forma de utilizar las colecciones ya no es tan común al día de hoy ya que en este caso

148
00:14:43,700 --> 00:14:49,040
hemos visto que maneja tipos obvie lo que vamos a ver en la siguiente lección es utilizar los tipos

149
00:14:49,040 --> 00:14:54,110
genéricos para que no podamos agregar cualquier tipo de dato en nuestras colecciones sino que restringimos

150
00:14:54,110 --> 00:14:54,620
más.

151
00:14:54,620 --> 00:14:57,250
Qué tipo de dato podemos agregar a nuestra colección.

152
00:14:57,260 --> 00:15:01,380
Para eso vamos a ver a continuación el tema de colecciones genéricas.

153
00:15:01,400 --> 00:15:04,270
Eso es todo por esta elección y nos vemos en el siguiente video.

154
00:15:04,310 --> 00:15:04,940
Saludos.
