Saltar navegación

20250128 Colecciones_1 - Contenido educativo

Ajuste de pantalla

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

Subido el 29 de enero de 2025 por Raquel G.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues hemos dicho que íbamos a empezar ya por fin 00:00:00
esto que se llama colecciones. 00:00:06
¿Vale? 00:00:14
Vale. 00:00:16
Bueno, pues en una aplicación 00:00:18
en una aplicación informática 00:00:21
siempre es imprescindible trabajar con datos. 00:00:27
Eso lo tenemos clarísimo. Y los datos tienen que estar en variables de la aplicación. Y eso también lo tenemos clarísimo. Que los datos tienen que estar en variables de la aplicación. A ver si el micrófono está bien porque el otro día no se oía nada. Vale. En datos de la aplicación. 00:00:31
entonces si son 3, 4 datos 00:00:52
3 números, 4 cadenas 00:00:55
en programas muy sencillitos 00:00:57
tenemos nuestras variables para guardarlos 00:00:58
pero normalmente una aplicación 00:01:01
trabaja con 00:01:03
volúmenes de datos grandotes 00:01:04
pues un montón de usuarios 00:01:06
un montón de DNIs 00:01:08
un montón de objetos 00:01:10
factura 00:01:12
trabaja con un montón de datos 00:01:14
normalmente volcados en una base de datos 00:01:16
pero eso ya es otro tema 00:01:19
Bueno, pues entonces para trabajar con un volumen de datos grande, las variables primitivas ya sabemos que no se adaptan, entonces usábamos Arrays y ya está. 00:01:20
Y es lo único que hemos usado porque no teníamos otra cosa. 00:01:30
Y sabemos que un Array es una estructura que es esto, tal cual. 00:01:32
Un montón de datos que están ahí en filita y la ventaja que tienen, la ventaja maravillosa que tienen, es que se les puede acceder a través de la posición. 00:01:41
¿Vale? A través de la posición. 00:01:51
Y ese acceso es rapidísimo, es inmediato. 00:01:53
Una vez que el array ya está creado en memoria, su espacio, 00:01:56
el acceso a través de la posición es muy rápido. 00:02:00
¿Vale? En términos de rendimiento, me refiero. 00:02:04
Y esto es lo único que hay y lo único que existe para guardar muchos datos en memoria. 00:02:07
Un array que los tiene todos así a mogollón, uno tras otro, 00:02:13
y la posibilidad de acceso a través de un índice. 00:02:16
¿Vale? Y no hay nada más 00:02:19
Entonces, está claro 00:02:22
Que aunque tiene esa 00:02:25
Rapidez de acceso a través del índice 00:02:27
Tiene la pega que nos hemos encontrado 00:02:29
Todo el rato y que hemos sufrido 00:02:31
Que una vez que uno ha decidido 00:02:32
Usar un array de 30 posiciones 00:02:35
O 40 o 50 00:02:37
El array es de 30 posiciones 00:02:39
O 40 o 50 00:02:41
Es imposible decidir 00:02:43
Ay no, espera, que quiero ahora tener más 00:02:44
Ah, lo hago más grande 00:02:46
Uy, me están sobrando un montón 00:02:47
pues corto esto, no, eso no se puede hacer 00:02:49
entonces es poco eficiente 00:02:52
en términos de aprovechamiento de la memoria 00:02:54
claro 00:02:56
vale, pero es lo único que hay 00:02:57
es que no hay otra cosa 00:03:00
bueno, pues entonces, ¿qué es lo que 00:03:00
se ha incorporado a través de Java 2 00:03:04
las primeras versiones y luego después? 00:03:06
pues hacer por código, programar 00:03:08
estructuras 00:03:10
apoyadas sobre 00:03:12
lo único que hay, que son 00:03:14
en términos de almacenamiento, me refiero 00:03:16
las variables primitivas 00:03:18
y los arrays 00:03:21
que apoyándose sobre eso 00:03:23
programen, simulen 00:03:25
una forma de funcionamiento que sea más cómodo 00:03:27
pero está todo programado 00:03:30
por encima 00:03:32
como vamos a programar nosotros ahora 00:03:33
entonces 00:03:36
eso como se hace todo el rato 00:03:37
usar esas otras 00:03:39
programar esas otras estructuras 00:03:41
que son más cómodas a la hora de usar 00:03:43
pues ya directamente 00:03:45
se hacen unas clases 00:03:47
que te ofrecen métodos que tú los usas 00:03:48
y ya está simulado 00:03:51
ese comportamiento. El comportamiento 00:03:52
en realidad de estructura 00:03:55
dinámica. Vale, a ver. 00:03:57
Que me explico un poco mal. 00:03:59
Lo que está claro es que 00:04:01
nosotros solamente 00:04:02
en Java solamente provee de 00:04:05
la posibilidad de declarar variables 00:04:07
primitivas y arrays. 00:04:09
Y bueno, y variables objeto. 00:04:11
Claro, variables objeto. O sea, variables 00:04:13
en general sueltas, variables sueltas 00:04:15
sean primitivas o objetos, variables sueltas 00:04:17
y arrays, y ya está, y no provee de nada más 00:04:19
vale, el problema 00:04:21
del array es que es estático 00:04:23
lo que hemos dicho, de que una vez declarado 00:04:25
30 con 40 de ahí no se mueve 00:04:27
y eso es incómodo 00:04:29
a la hora de usarlo 00:04:31
es incómodo porque si me aparecen 00:04:32
20 usuarios nuevos 00:04:34
no tengo espacio para ellos 00:04:37
o si de repente empieza ya 00:04:38
una forma de trabajo en la cual 00:04:41
solamente trabajo 00:04:42
con 10, pues todo lo que tenía 00:04:45
reservado no vale, entonces es incómodo 00:04:47
bueno, pues entonces 00:04:49
se programa 00:04:51
y esto ya es por programa, por encima 00:04:53
otras estructuras, que son las que 00:04:55
se llaman estructuras dinámicas 00:04:57
y dinámicas 00:05:00
¿por qué? porque simulan 00:05:09
que todo está simulado 00:05:11
el efecto de un array 00:05:12
que crece 00:05:15
según media milagana, se encoge 00:05:17
según media milagana, etcétera, simulan 00:05:19
eso, pero lo simulan por programa 00:05:21
entonces 00:05:22
una vez que esa clase ya está hecha 00:05:25
y simula ese comportamiento 00:05:28
yo me limito a usarla 00:05:29
y entonces a nivel de código 00:05:31
a nivel de uso 00:05:33
es mucho más fácil 00:05:36
el desarrollo me va a quedar mucho más cómodo 00:05:38
lo que hay por debajo 00:05:40
sigue siendo pesado 00:05:41
lo que hay por debajo sigue siendo un array 00:05:43
que está haciéndose, deshaciéndose 00:05:45
todo eso, pero eso ya lo ha programado 00:05:47
alguien y me da a mí los métodos 00:05:49
para que yo simule que estoy metiendo algo nuevo 00:05:51
y que la raya del suelo se ha agrandado 00:05:54
o que estoy sacando y que la raya del suelo se ha encogido. 00:05:56
Por eso se les llaman estructuras dinámicas, 00:05:59
porque son estructuras de almacenamiento 00:06:02
que simulan o dan a entender 00:06:04
que efectivamente se están adaptando en cada momento 00:06:11
al volumen de datos que yo tengo. 00:06:15
Cuando tengo este dato, este volumen, se adaptan y son así. 00:06:16
cuando meto más volumen de datos 00:06:20
se van agrandando, algo que la RAI no hace 00:06:22
pues estas estructuras son clases 00:06:24
que ya están hechas y que nosotros usamos 00:06:26
que a través de métodos muy sencillos 00:06:28
añadir, borrar 00:06:31
etcétera 00:06:33
pues simulan ese comportamiento 00:06:34
entonces son muy cómodas de usar 00:06:37
pero por debajo está la programación 00:06:38
de toda la vida, por debajo está eso 00:06:41
entonces 00:06:43
en estructuras dinámicas 00:06:45
hay 00:06:46
vamos a tener que desglosarlas 00:06:47
una por una, porque hay matices 00:06:50
de funcionamiento muy distintos entre 00:06:52
unas y otras, y eso implica 00:06:54
que algunas se adaptan 00:06:56
mejor a unas situaciones que otras. Entonces, tenemos 00:06:58
que poder seleccionar en cada situación 00:07:00
qué estructura dinámica se adapta 00:07:02
mejor. Bueno, pues estructuras dinámicas 00:07:04
hay muchos 00:07:06
tipos, que se dividen en 00:07:08
tres grandes grupos. 00:07:14
Tres grandes grupos. 00:07:16
Las listas, 00:07:18
los conjuntos 00:07:19
y los mapas 00:07:25
lo que 00:07:28
también se suele llamar 00:07:30
en programación diccionarios 00:07:32
son tres tipos 00:07:34
de estructuras dinámicas que hay, listas 00:07:39
conjuntos y diccionarios 00:07:41
vale, entonces esto 00:07:43
el que lo diseñó 00:07:45
e hizo las clases para que 00:07:47
luego nosotros las usáramos 00:07:49
pues por supuesto hizo un diseño 00:07:51
basándose en herencia y en interfaces 00:07:53
por supuesto 00:07:55
entonces pues 00:07:56
existe una cosa 00:07:58
que es la interfaz 00:08:01
colección 00:08:03
esta si tal cual 00:08:04
que es una interfaz 00:08:06
que tiene los métodos básicos de 00:08:08
meter en la colección, borrar de la colección 00:08:10
y poquito más 00:08:12
y esta interfaz 00:08:13
tiene una implementación 00:08:15
concreta 00:08:19
que es list 00:08:20
que es la implementación 00:08:21
que ya adapta 00:08:25
el funcionamiento al de las listas 00:08:27
que ya veremos cuál es 00:08:29
y tiene una implementación que es 00:08:30
set 00:08:33
que esa implementación ya particulariza 00:08:34
estos métodos de añadir 00:08:37
meter, sacar y borrar 00:08:39
los particulariza al funcionamiento 00:08:40
concreto de los conjuntos 00:08:43
porque las listas y los conjuntos 00:08:45
funcionan internamente de forma distinta 00:08:47
o sea, todo esto vale 00:08:49
para meter y sacar y tener 00:08:51
y guardado, no vale para nada más que para eso 00:08:53
para meter cosas y tenerlas ahí guardaditas 00:08:55
y sacarlas y consultarlas 00:08:57
todo eso solo vale para eso 00:09:00
para almacenar datos, son estructuras de almacenamiento 00:09:01
solo vale para almacenar 00:09:04
pero claro, como el almacenamiento 00:09:05
el diseño del almacenamiento es una parte 00:09:08
tan importante 00:09:10
en un código, porque de ahí depende 00:09:11
que el código tenga más o menos rendimientos 00:09:14
sea más fácil de programar, sea más fácil de ampliar 00:09:15
como es, el almacenamiento 00:09:18
es tan crítico, por eso hay tantas posibilidades 00:09:20
hay tantas 00:09:22
una de ellas es el array, ya está 00:09:23
pero aparte del array están todas estas 00:09:25
que funcionan de forma distinta 00:09:27
bueno, pues todas esas 00:09:29
son las diferentes clases que están 00:09:32
programadas en una arquitectura 00:09:34
de herencia de este tipo 00:09:36
repito, collection 00:09:38
una interfaz con los métodos básicos 00:09:39
de meter, sacar, pero ahora ya 00:09:41
las listas 00:09:44
implementan esos métodos de una manera 00:09:45
concreta, pero siguen siendo 00:09:48
los mismos métodos, meter y sacar y consultar 00:09:50
los conjuntos implementan 00:09:52
esos métodos de otra manera concreta 00:09:54
pero siguen siendo mismos métodos, meter, consultar 00:09:56
sacar y ya está 00:09:59
los mapas no eran de colección, son otra 00:09:59
interfaz aparte 00:10:02
que se llama map 00:10:05
entonces list, set 00:10:05
y map, que no era de colección 00:10:08
son tres implementaciones 00:10:10
concretas 00:10:13
para meter, sacar y guardar 00:10:14
datos en algún lado 00:10:17
eso es lo que es 00:10:18
Y luego, a su vez, las listas tienen variantes en función de cómo se haga internamente. Las listas tienen el ArrayList, que es una implementación concreta de List, porque List sigue siendo una clase abstracta. 00:10:20
de esta, que ya te implementa 00:10:53
de una manera muy concreta cómo hacer 00:10:55
el meter, sacar y consultar. 00:10:57
De una forma muy concreta. 00:10:59
Pero tiene otra. 00:11:02
Tiene otra implementación 00:11:04
que es la Linked List. 00:11:06
Entonces, estas ya sí que son 00:11:12
dos implementaciones concretas, 00:11:13
dos cosas que podemos instanciar 00:11:15
y usar para guardar cosas a mogollón. 00:11:17
Esta es una 00:11:21
y esta es otra. Y las dos se usan 00:11:21
igual porque solamente valen 00:11:23
para eso, para meter y sacar, las dos se usan 00:11:25
igual, lo que pasa es que 00:11:27
por dentro están construidas 00:11:29
de forma distinta 00:11:32
y eso tiene implicaciones en cuanto a rendimiento 00:11:32
para cuál, en qué situaciones se adapta 00:11:36
mejor esta, en cuál se adapta mejor esta 00:11:37
que tendremos que saber distinguir 00:11:39
¿vale? 00:11:41
¿vale? y ¿por qué hay dos? 00:11:43
list y set 00:11:46
bueno, pues hay dos 00:11:46
porque las listas están pensadas 00:11:49
para que en la cajita 00:11:52
de listas 00:11:53
pensad que las colecciones 00:11:54
son cajas, no son más que esto 00:12:01
las colecciones son una caja 00:12:04
para meter cosas, igual que era una raíz 00:12:05
una caja, ¿vale? 00:12:08
pues las listas, tanto esta 00:12:10
como esta, son una implementación 00:12:12
concreta de la caja 00:12:14
una implementación concreta 00:12:15
de la caja, en la que 00:12:18
las cosas que metemos en la caja 00:12:20
tienen una posición 00:12:22
¿vale? luego la lista 00:12:23
es una implementación en la cual 00:12:27
yo meto algo en la caja 00:12:29
pero lo meto en una posición siempre 00:12:31
luego la lista sería 00:12:33
una cajita con posiciones 00:12:35
y yo meto en la posición 00:12:37
y puedo recuperar por posición 00:12:38
puedo decir, oye, recupérame 00:12:41
la que pusiste en la posición 4 00:12:43
conceptualmente es igual que un array 00:12:45
en un array todo lo que metemos tiene una posición 00:12:48
pues en una lista 00:12:51
todo lo que metemos tiene una posición 00:12:53
¿vale? 00:12:54
entonces 00:12:56
lo que caracteriza la lista 00:12:59
es que puedes meter dos cosas iguales 00:13:03
en realidad, porque van a ser 00:13:05
distinguibles por la posición 00:13:07
¿verdad? imagínate que es una 00:13:09
lista en la que yo voy a meter caracteres 00:13:11
letras 00:13:13
pues podría meter esto 00:13:14
y pueden coexistir dos X 00:13:16
perfectamente, pueden coexistir dos 00:13:19
porque una iría en esta posición 00:13:21
y otra iría en esta 00:13:23
luego en una lista 00:13:24
las cosas que meto 00:13:26
se caracterizan por supuesto por su valor 00:13:27
lo que tiene, la letra X 00:13:29
pero también se caracterizan 00:13:31
por la posición en la que están 00:13:33
desde el momento en el que las meto en la lista 00:13:36
vale 00:13:37
sin embargo eso 00:13:40
el llevar un registro 00:13:41
del orden o de la posición 00:13:44
en la que se han metido las cosas en la lista 00:13:46
requiere pues programarlo 00:13:47
y tiene sus complejidades 00:13:49
de programación 00:13:52
pues los sets están pensados 00:13:52
para situaciones en las cuales 00:13:55
eso me da igual 00:13:58
¿qué es un set? pues un set es 00:13:58
una implementación de esta cajita 00:14:01
un set es un conjunto 00:14:03
una implementación de esta cajita 00:14:05
en la que no hay ningún tipo de orden 00:14:07
las cosas se meten 00:14:09
en cualquier sitio 00:14:12
donde caen 00:14:14
luego esto por dentro 00:14:14
es más fácil de programar 00:14:17
que esto porque no hay que llevar un registro 00:14:20
de la posición en la que ha caído la cosa 00:14:22
aquí en un conjunto 00:14:24
si yo meto caracteres 00:14:26
el problema que tengo es que 00:14:27
la X no la puedo meter dos veces 00:14:30
¿vale? si yo 00:14:32
metiera otra X aquí 00:14:34
estas clases 00:14:35
están pensadas para 00:14:38
no aceptar esa X, porque ya hay una 00:14:39
entonces como ya hay una 00:14:42
esa otra X en la caja 00:14:44
no se distinguiría de esta 00:14:45
no se distinguiría, no puede haber aquí otra X 00:14:48
entonces ¿cómo distingues esta de esta? 00:14:50
Si no tienen posición, están ahí las dos a mogollón. 00:14:52
No podrías distinguir cuál es la primera X que metiste y la segunda. 00:14:55
Serían indistinguibles. 00:14:58
Entonces, las clases set están programadas y pensadas para que tú no puedas meter duplicados. 00:14:59
Y cuando intentas meter en una caja un elemento igual a otro que ya está igual, 00:15:06
pues entonces el conjunto simplemente no lo mete. 00:15:15
No lo mete y ya está. 00:15:17
¿vale? no se pueden meter en un set 00:15:18
elementos duplicados 00:15:20
pues esa es la 00:15:22
principal diferencia entre list y set 00:15:24
y por eso hay dos tipos de colecciones 00:15:27
tan distintas, porque en esta 00:15:29
la cajita tiene posiciones 00:15:31
con lo cual puedo meter duplicados 00:15:32
es decir, dos cosas 00:15:35
puedo meter dos cosas iguales 00:15:36
y en esta nunca puede haber 00:15:38
dos cosas iguales, porque el conjunto 00:15:41
nunca te habría dejado meter una cosa 00:15:43
igual a otra que ya está 00:15:45
entonces, en función de lo que tú estés programando 00:15:46
lo que estés desarrollando, cuál sea tu modelo de datos 00:15:49
qué es lo que estés haciendo 00:15:51
pues te puede valer un set o no 00:15:52
si tú necesitas que sí están duplicados 00:15:55
un segundo Inés, dime 00:15:57
¿qué diferencia es con un array? 00:15:59
a ver, un array es lo que es 00:16:03
es una estructura nativa, por decirlo así de Java 00:16:05
¿vale? que tiene las características 00:16:07
que conocemos, que es tú la declaras 00:16:09
tiene un tamaño fijo que ya 00:16:11
no se puede cambiar 00:16:13
y se accede a sus posiciones por Ingrid. 00:16:14
Vale, entonces una lista 00:16:17
que puede haber varias 00:16:19
variantes, es una estructura 00:16:21
de programación que se programa 00:16:23
de hecho vamos a hacerlas las dos, 00:16:25
vamos a programar nosotros, 00:16:27
se programa de tal manera que te 00:16:29
ofrece unos métodos que 00:16:31
te facilitan la inserción y el recuperar 00:16:33
de los datos. Entonces tú te olvidas 00:16:35
el problema del array 00:16:38
de que si quieres meter un dato nuevo 00:16:41
que no te cabe, todo eso que hemos hecho 00:16:43
de hacer un array con una posición más 00:16:45
meterlo extra 00:16:46
sustituir el 00:16:48
viejo con el nuevo, todo eso 00:16:51
que hemos estado haciendo todo el rato 00:16:53
la lista te lo enmascara 00:16:54
y te ofrece un método, añade 00:16:56
tú llamas al método, añade 00:16:59
y ya por dentro hace todo lo que haga falta 00:17:00
¿vale? o sea, una lista es como 00:17:03
una especie de 00:17:05
enmascarar un array 00:17:05
para usarlo, para que te aparente 00:17:08
a ti que es dinámico 00:17:11
para que tú veas que es dinámico. 00:17:12
Eso que yo he dicho en particular es una 00:17:15
ArrayList. Lo que pasa es que luego 00:17:16
está la LinkedList, que también simula 00:17:18
eso, pero no partiendo de un Array, 00:17:20
partiendo de otra cosa mucho más chula. 00:17:22
Pero simula eso también. 00:17:24
¿Vale? 00:17:26
Entonces, lo que estamos ahora un poco... 00:17:28
Te digo que si en un set 00:17:31
que no tiene posiciones, metes dos objetos 00:17:32
que son de diferente tiempo, una de sus 00:17:34
propiedades, sí puede, pero se tiene 00:17:36
diferencia. Claro, a ver. 00:17:38
El set decide 00:17:40
si lo que tú le das es igual 00:17:42
que algo que ya esté, llamando 00:17:44
al método equals. 00:17:46
Claro, de ahí la importancia de equals. 00:17:48
O sea, si tú le tienes puesto un método equals para que te diga 00:17:50
el nombre, tiene que ser el nombre distinto 00:17:52
en concreto. Aunque las otras características 00:17:54
le darían igual. Efectivamente. 00:17:56
Ahora ya, cuando usamos colecciones para 00:17:58
guardar datos, la implementación 00:18:00
de equals ahora ya sí que es fundamental. 00:18:02
Porque las colecciones, 00:18:04
los conjuntos en particular, cuando tú le metas 00:18:06
un dato, va a decir, a ver, 00:18:08
hay uno igual, y para ver si hay uno 00:18:10
igual es equals. Java no tiene otra forma 00:18:12
de ver si un objeto es igual a otro. 00:18:14
Y ese equals está definido como tú quieras. 00:18:15
No había la importancia de los equals antes porque 00:18:17
si tú lo quieres realista, aunque sean iguales... 00:18:19
Claro, pues equals es fundamental 00:18:21
para cualquier estructura de programación 00:18:23
que necesite saber si algo es igual a otro. 00:18:25
Y el conjunto necesita saber 00:18:27
si algo es igual a otro 00:18:30
para decidir si lo mete o no lo mete, por ejemplo. 00:18:31
Es esto lo que tú decías. 00:18:34
Y ese equals ya estará programado como tú hayas querido. 00:18:35
Que no lo has programado. 00:18:38
Será el equals de object. 00:18:40
Porque es el heredado. 00:18:42
Y el equals de object define 00:18:43
que un objeto es igual a otro 00:18:45
si la dirección de memoria es la misma. 00:18:47
Luego, si tú no 00:18:50
sobreescribieras un método 00:18:52
igual, si no hubiera tus clases... 00:18:54
Pues que todos los objetos idénticos 00:18:55
están con la dirección de memoria distinta. 00:18:55
Claro, el set los cogería. 00:18:57
Los cogería todos, porque para él son distintos. 00:18:58
Porque están en direcciones de memoria distintas. 00:19:01
Pero normalmente, eso no es lo que tú quieres hacer. 00:19:03
Porque la aplicación pierde su sentido. 00:19:06
¿Vale? 00:19:08
Tú quieres que la aplicación tenga sentido 00:19:09
y que si dos objetos sean iguales 00:19:10
en virtud de N, I y D, lo que tú seas, 00:19:12
pues que la aplicación lo sepa. 00:19:15
Claro, la clave primaria 00:19:17
tiene un sentido real 00:19:18
y es que dos cosas sean la misma. 00:19:20
Entonces tienes que simularla con el equal. 00:19:22
Si no, la aplicación no tiene sentido. 00:19:24
Claro, y 00:19:27
quien te dice las colecciones, 00:19:28
hay muchas otras clases que necesitan saber 00:19:30
si algo es igual que otra cosa. 00:19:32
Entonces tú lo tienes que proveer con el equal. 00:19:35
Porque si no lo provees con el equal, 00:19:37
se ha perdido el sentido todo. 00:19:38
vale 00:19:39
entonces 00:19:40
estos son los dos tipos esenciales 00:19:42
de colecciones que heredan 00:19:46
de esta, de colección 00:19:48
y luego aparte yo he mencionado para que tengamos ya 00:19:49
los tres conceptos que tenemos 00:19:52
que ver, los mapas 00:19:54
que son los diccionarios 00:19:55
la particularidad que tienen los mapas 00:19:58
es que también valen 00:20:00
para guardar datos, como todo 00:20:01
para guardar datos, pero los mapas 00:20:03
guardan los datos siempre en forma 00:20:05
de pares, una clave 00:20:08
y un valor 00:20:10
una clave y un valor 00:20:10
en las listas y los conjuntos 00:20:13
se guarda el dato tal cual 00:20:16
un dato, otro dato, otro dato, otro dato 00:20:17
en los mapas 00:20:20
tú guardas el dato 00:20:21
siempre asociado a una clave 00:20:23
y tú metes el par 00:20:25
por eso se llaman diccionarios 00:20:27
porque un diccionario es un montonazo 00:20:29
de pares 00:20:32
nombre de palabra, significado 00:20:33
nombre de palabra, significado 00:20:35
Eso es un diccionario, ¿no? ¿Vuestra generación todavía ha visto un diccionario alguna vez? ¿Un papel? ¿Un preso? 00:20:37
Bueno, pues eso es un diccionario, un conjunto de pares, término, significado, término, significado, término, significado, pues el mapa reproduce esa idea, un conjunto de pares, clave, contenido de la clave, clave, contenido de la clave. 00:20:46
existe esa estructura programada 00:21:04
porque está programada, no es que exista 00:21:06
como el array que existe por ciencia infusa 00:21:08
existe esta estructura 00:21:10
porque en muchas situaciones 00:21:12
es interesante 00:21:14
que cada dato 00:21:16
tenga asociado una clave única 00:21:18
porque nos va a facilitar 00:21:20
normalmente el recuperar los datos 00:21:22
es más fácil recuperar por clave 00:21:24
que recuperar por contenido 00:21:25
el diccionario, si es útil 00:21:27
es precisamente porque está organizado de esa manera 00:21:30
término, significado 00:21:32
y los términos ordenados alfabéticamente 00:21:34
entonces tú rápidamente en un diccionario 00:21:37
encuentras el significado que buscas 00:21:39
porque vas buscando por término 00:21:41
pues entonces 00:21:43
a veces una estructura 00:21:44
map con un montón de términos, clave, valor 00:21:46
te facilita encontrar rápidamente 00:21:48
un valor, porque tú vas 00:21:50
a la clave 00:21:52
y todo eso está programado por dentro 00:21:53
y nosotros nos vamos a limitar a aprender a usar 00:21:57
estas dos de aquí 00:21:58
el ArrayList y el LinkedList y que las vamos a programar 00:22:01
porque tenéis que 00:22:03
pues tenéis que saber aprender a programar 00:22:04
y los conjuntos y los mapas 00:22:07
ya vamos a aprender a usarlos 00:22:09
vale, de listas 00:22:11
ya hemos dicho 00:22:13
que hay dos implementaciones concretas 00:22:14
el ArrayList 00:22:17
y el LinkedList 00:22:18
y de conjuntos 00:22:20
hay tres, el HashSet 00:22:25
una pequeña variante 00:22:27
del HashSet que es el Linked 00:22:32
HashSet 00:22:33
y el 00:22:35
tree set 00:22:37
¿en qué se diferencian entre ellas? 00:22:38
en cómo están programadas por dentro 00:22:42
¿vale? 00:22:44
en cómo están programadas por dentro 00:22:48
y en función de cómo están programadas por dentro 00:22:49
pues os repito, son más útiles para unas cosas 00:22:51
o para otras, o más que útiles pegan más 00:22:54
para unas cosas que para otras 00:22:56
entonces hay que entender bien un hash set por dentro 00:22:57
cómo está programado 00:23:00
un tree set por dentro cómo está programado 00:23:01
porque a veces el tree set 00:23:03
tiene muy buen rendimiento para algunas cosas 00:23:04
pero para otras no, entonces si pagas que no 00:23:07
pues a lo mejor no tienes que hacer, entonces depende de la 00:23:09
aplicación, pues interesa más coger 00:23:11
una que otra, sabiendo 00:23:13
que cualesquiera de ellas 00:23:15
son set 00:23:17
luego tiene esta particularidad 00:23:18
que no admiten duplicados 00:23:21
¿vale? y cualquiera 00:23:23
de estas son listas, luego tiene esa 00:23:25
particularidad, que todo en la cajita va 00:23:27
en una posición 00:23:29
y los mapas lo que he dicho 00:23:30
¿vale? 00:23:33
vale 00:23:36
Pues a ver, la que nos va a ser 00:23:36
Facilísimo de hacer 00:23:39
Es el ArrayList porque lo hemos estado usando 00:23:40
Todo el rato, hemos estado todo el rato metiendo en el Array 00:23:43
Cosas y sacando cosas del Array 00:23:45
Pues ahora ya vamos a darle un cuerpo 00:23:46
De clase, para usarla 00:23:49
Rápidamente 00:23:51
Y luego el LinkedList 00:23:52
Venga, hala 00:23:54
A ver 00:24:30
Venga, pues siempre que empezamos 00:24:34
algo, como nos estamos 00:24:35
todo el rato apoyando en lo 00:24:37
de siempre, porque hay que usarlo todo 00:24:39
hasta ahora, todo, no podemos obviar nada 00:24:41
de lo que hemos visto, pues de nuevo 00:24:43
aprovechad 00:24:45
los que estáis así tambaleandos 00:24:46
para volver 00:24:49
trabajar lo mismo, no hay otra vez 00:24:53
pues venga, vamos a 00:24:55
hacernos un proyecto 00:24:57
mis colecciones 00:25:00
porque van a ser las colecciones 00:25:02
nuestras que nos va a dar la gana 00:25:03
hacer a nosotros 00:25:05
que luego vamos a exportar a Ujar 00:25:06
y las vamos a usar como si fueran colecciones 00:25:09
para que ya tienes el ArrayList 00:25:11
y el LinkedInList, que van a ser esto 00:25:17
pero un poquito 00:25:19
mejor hecho, bueno mejor no 00:25:20
con más 00:25:23
venga pues ya está 00:25:24
a ver 00:25:26
Venga 00:25:35
A ver, Gels 00:25:38
¿Qué? 00:25:41
Sí, sí, sí 00:25:53
Te vamos a llevar a un sitio muy bonito 00:25:55
Con gente vestida de blanco 00:25:58
Sí, no te asustes 00:25:59
Vas a estar muy a gusto allí 00:26:02
Las paredes son blanditas 00:26:04
A ver, igual te ponen un chaleco un poquito incómodo 00:26:08
Pero te acostumbras 00:26:13
Según Brian, ¿no? 00:26:14
Venga, pues vamos a hacernos un paquete 00:26:22
Lista 00:26:24
Venga, listas 00:26:26
Porque aquí vamos a meter 00:26:29
Pues venga 00:26:30
vamos a hacernos nosotros 00:26:33
nuestra propia 00:26:37
nuestra propia clase 00:26:39
ArrayList 00:26:41
la que nos ven de Java 00:26:42
pues no, la vamos a hacer nosotros que somos malistos 00:26:43
venga 00:26:47
la vamos a llamar miArrayList 00:26:47
para no repetir el nombre 00:26:53
bueno, pues que va a ser esta clase 00:26:56
esta clase 00:27:03
esta clase está pensada 00:27:05
para que los objetos 00:27:06
que pertenecen a 00:27:09
a ella, guarden 00:27:11
dentro un montón de datos 00:27:13
de forma que 00:27:15
podamos nosotros 00:27:16
meter, sacar y consultar 00:27:18
de forma sencilla 00:27:21
y que nos sea completamente 00:27:22
transparente como 00:27:25
hace por dentro lo de meter, sacar, 00:27:27
consultar. Entonces, esta clase la idea es que nos ofrezca 00:27:29
datos, perdón, que nos ofrezca 00:27:31
métodos, por ejemplo, como este. 00:27:33
A ver, como tenemos que decidir 00:27:35
con qué tipo de datos vamos a trabajar, 00:27:37
porque todavía no hemos dado el salto 00:27:39
a tipo genérico que le vamos a dar 00:27:41
ya mismo, en cuanto tengamos 00:27:43
esta clase ya la damos a genérico 00:27:45
tenemos que decidir un tipo 00:27:47
de dato para ella, vamos a hacer esta primera 00:27:49
versión que guarde 00:27:51
cadenas, stream 00:27:53
venga, pues 00:27:59
entonces, esta clase 00:28:01
va a servir para guardar un montón de 00:28:03
cadenas dentro y además nos va 00:28:05
a dar datos para fácilmente 00:28:07
meter cadenas y sacar, nos va a dar 00:28:09
métodos, jolines, luego sería 00:28:11
maravilloso que esta clase 00:28:13
tuviera un 00:28:15
método que fuera este 00:28:17
donde yo le paso 00:28:19
un string 00:28:21
y lo mete en esa 00:28:22
estructura 00:28:27
porque si lo ofrecen, si ofrecen 00:28:27
este método, ya metí una 00:28:31
cadena nueva, y sería maravilloso 00:28:33
si tuviera un método 00:28:35
que yo le llamo get 00:28:37
por ejemplo le doy una posición y me devuelve la cadena en esa posición, magnífico, y sería genial si esta clase tiene un método que fuera borrar, por ejemplo, yo le doy una posición y me borra el elemento en esa posición, me lo saca de la lista, 00:28:38
Y sería también estupendo, por ejemplo, si tuviera un método que fuera tamaño y me devolviera el tamaño de la lista para ya saber cuántos elementos hay. 00:29:09
Si hay siete cadenas, ocho cadenas, nueve cadenas. 00:29:23
¿El punto led de quién? 00:29:29
Bueno, llámale el led si quieres, pero el led es de una RAI. 00:29:32
Vale, entonces. 00:29:35
Vale. 00:29:37
entonces yo lo que quiero es hacer una clase 00:29:38
para meter un montón de datos dentro 00:29:40
y que me ofrezca estos datos 00:29:42
y que me ofrezca estos métodos 00:29:45
porque yo lo único que quiero hacer con ese mogollón 00:29:46
de datos es meter datos 00:29:49
consultar datos por posición 00:29:51
eliminar datos por posición 00:29:52
y cuantos datos hay 00:29:55
porque claro si yo voy a recorrer 00:29:56
la colección pues la tendré que recorrer 00:29:59
a lo largo de su tamaño, maravilloso 00:30:01
claro pero nos falta algo esencial 00:30:03
que es 00:30:05
oye, pero ¿dónde los va a guardar? 00:30:06
hemos dicho que esta clase 00:30:10
me va a servir para guardar dentro 00:30:11
un montón de datos, un montón de cadenas 00:30:12
¿dónde los va a guardar? internamente 00:30:14
los va a guardar en algún sitio 00:30:16
muy bien, venga, pues internamente 00:30:17
pero nosotros no nos enteramos y nos da igual 00:30:20
internamente que los guarde 00:30:23
en un array 00:30:25
que inicialmente puede ser un array vacío 00:30:25
voy, voy, voy 00:30:29
voy, voy, ya 00:30:36
vale, pues entonces 00:30:37
mi clase, mi ArrayList 00:30:42
al que le va a usar 00:30:44
le da lo mismo, al que la va a usar 00:30:46
le da igual, no le importa 00:30:49
pero la clase, mi ArrayList 00:30:50
ella por dentro va a guardar 00:30:52
todos los datos en un Array y se va a limitar 00:30:54
a ofrecer unos métodos 00:30:57
para que la gente meta y saca 00:30:58
bueno, pues entonces el de añadir 00:31:00
ya lo sabemos programar 00:31:03
si el usuario 00:31:05
me pasa un dato. 00:31:07
¿Cómo lo meto en el array? Pues la misma 00:31:08
historia de siempre, que estamos hartos 00:31:10
ya de lo mismo. Nos hacemos 00:31:13
un auxiliar con una posición 00:31:15
más que 00:31:16
el datos en el que quiero meter. 00:31:18
Hacemos un 00:31:32
for en el que copio 00:31:32
todo lo que hay 00:31:34
en el array antiguo, que es datos, 00:31:39
en el nuevo. 00:31:42
Una vez que ese for ha terminado, 00:31:53
en la posición extra de auxiliar, 00:31:55
que es la de aux.lenc-1 00:31:57
copio el dato nuevo 00:32:03
y una vez que ya tengo mi aux completito 00:32:05
con los datos antiguos y el extra 00:32:09
sobre escribo datos 00:32:12
con el nuevo 00:32:15
pues genial 00:32:17
el método recuperar por posición 00:32:28
este es muchísimo más fácil 00:32:33
el método recuperar por posición 00:32:35
es tan fácil como este 00:32:37
Se la pasas por parámetro 00:32:39
O sea, cuando tú uses el método 00:32:50
Dices, dame el de la posición tal 00:32:52
Size 00:32:54
Bueno, size facilísimo también 00:32:59
Devuelvo esto 00:33:01
Ya está 00:33:05
Me dice error de compilación 00:33:05
Porque length 00:33:12
Me lo devuelve en tipo long 00:33:13
Y yo aquí he puesto int 00:33:15
Y entonces estoy yéndome 00:33:17
De un dato long a un int 00:33:20
Podría perder información 00:33:22
Bueno, voy a cambiar el size para que me devuelva un long 00:33:24
Y así 00:33:26
Y así no hago el casting y hago nada 00:33:27
Ahora, vale 00:33:30
Nada, o sea que datos.led 00:33:34
Me devuelve el tamaño de la array en long 00:33:43
Y por eso he puesto que me devuelva un long 00:33:46
Pero ya está, nada más 00:33:48
da igual, que más te da 00:33:49
vas a tener tú a raíz 00:33:56
de más de 2 elevado a 00:33:57
pues si 00:34:01
entonces es un chulo 00:34:04
y un listo de mierda 00:34:05
pues le pones long 00:34:07
y si tienes 2 elevado a 63 00:34:09
más de eso, que le pones 00:34:12
otro más 00:34:13
venga, remove 00:34:14
que me preguntaste 00:34:18
es que no, imagino que te diría 00:34:21
que lo tienes que construir tú por programa 00:34:28
claro, combinando varios 00:34:30
y haciendo multiplicaciones por dos 00:34:32
para llevar la parte a 00:34:33
construir otro por programa 00:34:35
como tipo de dato en sí 00:34:36
claro 00:34:38
eso 00:34:40
igual que estamos construyendo aquí 00:34:43
pues construir un tipo de dato que tuviera 00:34:45
parte una, parte dos 00:34:47
Y a ofrecer tú los métodos 00:34:48
Que fuera a guardar 00:34:51
Y a llevarte 00:34:52
Vale, entonces remove por posición 00:34:53
Si habríais a hacerlo, pues sí 00:34:58
Habría que hacer un auxiliar con una posición menos 00:35:00
¿Verdad? 00:35:02
Datos.length 00:35:15
Menos uno, uno con una posición menos 00:35:18
Hasta la posición 00:35:20
A borrar, copiamos los que había 00:35:22
Y luego copiamos con una de adelanto 00:35:24
entonces ahora 00:35:26
mientras i sea igual a 0 00:35:27
mientras i sea menor 00:35:31
que la posición que 00:35:33
no voy a copiar 00:35:35
que me voy a saltar 00:35:36
incrementando i 00:35:38
pues copiamos 00:35:40
en aux de i 00:35:41
copiamos datos de i 00:35:43
y ahora ya nos falta copiar 00:35:47
la segunda parte 00:35:51
la que va desde 00:35:52
pos más 1 00:35:54
Ah, perdón 00:35:56
Vale 00:36:01
Ahora nos faltaría copiar 00:36:07
La que va 00:36:11
Desde pos más uno 00:36:12
Porque la pos nos la saltamos 00:36:15
Desde pos más uno 00:36:17
Mientras 00:36:20
Eh, perdón 00:36:21
Si, pos más uno 00:36:23
Mientras i sea menor 00:36:25
que datos.length 00:36:26
incrementando 00:36:29
y, vale 00:36:31
pues aquí hay que copiarla 00:36:35
en una inferior 00:36:38
de la y, porque i va por dentro de la aux 00:36:40
porque aux va por detrás 00:36:42
vale, y una vez que tenemos el aux construido 00:36:43
datos 00:36:54
igual a aux 00:36:56
vale, pues ahora ya hemos metido en una 00:36:57
clase nuestra, que podemos llamar 00:37:11
colección, y además porque lo es 00:37:13
en una clase nuestra la posibilidad de 00:37:14
instanciar objetos para guardar un montón de datos y simular un comportamiento dinámico. 00:37:17
Por ejemplo, ahora nos hacemos un paquete con mi main que hace cosas. 00:37:23
Venga, una clase main para hacer cositas. 00:37:43
Bueno, pues resulta que esta aplicación mía va a trabajar con un montón de nombres. 00:37:52
Un montón de nombres que pide por teclado o como sea. 00:37:57
Entonces, voy a meterle lo de leer por teclado. 00:38:01
Para que sea más cómodo, en el classpad le añado el jar. 00:38:05
A ver, está aquí, ¿qué es lo que falta? 00:38:26
Pedro, ¿qué es lo que falta? 00:38:28
Bueno, pues entonces, esta clase a mí me la han dado, ya ni siquiera tengo acceso a su código. 00:38:47
La puedo haber importado con un jar, me la han dado exportada en un jar, yo la he importado 00:38:55
Y no tengo ni código ni tengo nada 00:38:59
Pero sé que tengo una clase en mi ArrayList 00:39:00
Que puedo instanciar 00:39:03
Pues venga 00:39:04
Por ejemplo 00:39:06
Queremos un montón de nombres 00:39:12
Pues todos estos nombres 00:39:14
En lugar de crear un Array 00:39:16
Para ellos 00:39:18
Yo me creo 00:39:19
Una estructura, un objeto 00:39:22
Mi ArrayList 00:39:24
Vale 00:39:25
Importo 00:39:41
vale, entonces me he creado 00:39:43
un objeto de esa clase 00:39:47
¿este objeto para qué vale? 00:39:49
pues yo sé que vale, porque en la ayuda 00:39:51
que me han dado de la clase, que me he importado con el 00:39:53
jar, lo que sea, en la ayuda 00:39:55
he visto que vale para meter un montón de 00:39:57
nombres, con add, recuperar, lo que sea 00:39:59
pues yo me creo esta estructura 00:40:01
entonces esto es 00:40:03
una instancia concreta 00:40:04
de mi ArrayList, de la colección 00:40:07
que yo me he programado, que vale para 00:40:09
meter un montón de nombres 00:40:11
vale, y yo repito 00:40:12
como esté hecha por dentro me da igual, sé que vale 00:40:15
para guardar nombres, bueno pues por ejemplo 00:40:17
suponer que le vamos a pedir 00:40:18
en un bucle a un usuario 00:40:20
que meta nombres 00:40:22
todo el rato 00:40:25
por ejemplo yo que sé, pues 10 nombres 00:40:25
vamos a suponer que 00:40:28
un programa que mete 10 nombres 00:40:30
y luego los muestra, ya está, vamos a hacer eso 00:40:33
venga, pues vamos a meter 10 nombres 00:40:35
luego un bucle que ejecutamos 00:40:39
10 veces 00:40:41
y ahora le decimos 00:40:41
nombre 00:40:45
ahora leemos el nombre 00:40:51
y ahora este nombre 00:40:57
se va a la caja 00:41:05
no se va a un array 00:41:07
que yo construí, nada, se va a la caja 00:41:09
nombres, porque nombres es una caja 00:41:11
una colección, y como se va a la caja 00:41:13
pues a través de su método add 00:41:15
que acabo de programar, ala, ya está en la caja 00:41:18
como está hecha por dentro de esa caja 00:41:21
me da igual, yo sé que llamo al método 00:41:25
add y el nombre 00:41:26
se va a esa cajita nombres 00:41:28
que acabo de crear 00:41:30
de esta clase 00:41:32
ya está, me da igual 00:41:33
los detalles 00:41:36
entonces yo desde fuera 00:41:37
veo como voy 00:41:41
metiendo, voy metiendo, luego la caja se va 00:41:43
agrandando, pero es una lista dinámica, yo voy metiendo 00:41:44
nombres, voy metiendo nombres y ya está, en este caso 10 00:41:46
como si fueran 100, como si fueran 50 00:41:48
esto es simplemente una caja para meter 00:41:50
nombres 00:41:52
venga a suponer que ya hemos metido la caja 00:41:53
ahora vamos a mostrarlos 00:41:56
podría ser cualquier otra cosa la que queramos hacer 00:41:57
pero vamos a mostrarlos 00:42:03
vale pues yo sé que esta cajita 00:42:04
mía nombres tiene un método get 00:42:07
para devolverme 00:42:09
el de cada posición si a mi me da la gana 00:42:11
bueno de hecho 00:42:13
en lugar de mostrarlos todos vamos a hacer una cosa 00:42:15
mostramos el primero 00:42:16
introducido pues como mostramos 00:42:18
el primero introducido como va a salir 00:42:20
pues nombres 00:42:22
punto get 00:42:24
de 0 00:42:26
entonces yo aquí me olvido 00:42:28
de la implementación interna que es un array 00:42:33
tengo un get que me saca el que yo quiera 00:42:35
vamos a mostrar el último 00:42:36
pues el último 00:42:39
sería 00:42:51
el noveno en este caso 00:42:53
vale resulta que queremos 00:42:56
eliminar 00:42:58
el que está en la posición 3 00:42:58
por ejemplo 00:43:02
eliminamos 00:43:02
posición 00:43:06
bueno, pues yo sé que hay un método 00:43:09
de esa cajita que me acabo 00:43:12
de construir nombres 00:43:14
sé que hay un método que es remove 00:43:15
que le paso una posición y me elimina 00:43:18
ese, pues magnífico 00:43:20
voy a mostrar ahora los que tengo 00:43:22
todos, pues voy a recorrer 00:43:26
voy a recorrer 00:43:28
mi colección 00:43:30
desde igual a 0, metéis a menor que igual 00:43:31
que el tamaño que tenga la colección 00:43:33
el tamaño que tenga la colección, sé cuál es 00:43:35
Porque he programado un método size 00:43:37
Entonces, como he programado este método 00:43:39
El tamaño de la colección sé cuál es 00:43:42
Que ahora mismo será uno menos 00:43:44
Porque he hecho un remove 00:43:45
Y ahora vamos a mostrar todos y cada uno 00:43:46
De los que están en esas posiciones 00:43:56
Uy, nombres get 00:43:57
Bueno, pues esto es mucho más cómodo de usar 00:44:01
Que cualquier array 00:44:11
Tengo mi add para añadir 00:44:12
Cuando a mí me dé la gana meter uno nuevo en la caja 00:44:16
mi remove para eliminar el que yo quiera 00:44:18
en la posición que quiera 00:44:21
un método de consulta por posición 00:44:22
y podría poner muchos más métodos 00:44:24
para hacer cosas con lo que hay ahí 00:44:27
pero bueno, esto es para ver la idea 00:44:29
de lo que es una colección 00:44:30
pues esto es una colección 00:44:32
de verdad 00:44:35
de todas las que hay 00:44:37
esto es una clase como esta que hemos hecho 00:44:38
que mediante sus variables 00:44:41
internas te provee 00:44:43
de una posibilidad de guardar muchas cosas 00:44:45
dentro y te provee de 00:44:47
métodos para meterlos, sacarlos y consultarlos. 00:44:49
Es una colección. 00:44:51
Con lo cual, tú la usas 00:44:53
instanciando la colección. 00:44:55
La usas 00:44:59
instanciando la colección y la usas 00:44:59
como se usan las colecciones, 00:45:01
que se usan para meter, sacar y consultar 00:45:03
y punto, pelota. 00:45:06
¿Y cómo está hecha por dentro? Te da igual. 00:45:07
¿Cómo añade? Me da lo mismo. Yo añado 00:45:09
y se acabó. ¿Cómo recupera? 00:45:11
Me da igual cómo recupere. Yo recupero 00:45:13
y se acabó. ¿Cómo borra? Me da igual. 00:45:15
yo borro y se acabó, dime 00:45:17
el tamaño porque así 00:45:19
la he programado yo, yo me he hecho un método 00:45:24
size aquí que te 00:45:26
devuelve el tamaño 00:45:28
de los datos 00:45:30
entonces size te da el tamaño de los datos 00:45:32
por eso el size es imprescindible 00:45:34
para recorrer esa colección 00:45:37
claro, pero por eso he hecho 00:45:38
el método size 00:45:44
aquí nombres nunca le haría lenz 00:45:45
claro, es el método 00:45:47
de hecho es que el array este 00:45:49
es privado. Que exista este 00:45:52
array, el usuario de la colección 00:45:54
no tiene ni idea de que este array existe. Es su forma 00:45:56
interna de guardar esos datos. 00:45:58
Tú desde fuera 00:46:01
añade, desde fuera 00:46:01
llamas a los métodos y ya está. 00:46:04
¿Vale? Entonces, 00:46:07
lo que pasa es que nosotros hemos hecho esto 00:46:09
muy alegremente. Aquí pueden salir un punto de interés 00:46:12
y de todo, porque no estamos viendo los casos particulares 00:46:14
borrar uno y le das una posición 00:46:17
que no exista, entonces 00:46:20
yo he hecho los métodos sin verificar 00:46:22
por ejemplo el get 00:46:25
habría que verificar que 00:46:26
pos está comprendido 00:46:28
entre 0 y el tamaño 00:46:30
del array menos 1 porque si no esto me va a dar 00:46:32
un array in this bound exception 00:46:34
pero a ver, mi idea ahora es que 00:46:35
entendáis la filosofía de las colecciones 00:46:38
que es una clase que 00:46:40
internamente te ofrece 00:46:42
espacio de almacenamiento 00:46:44
y te ofrece 00:46:46
una forma de acceder a ese espacio 00:46:48
de almacenamiento, ese espacio 00:46:50
de almacenamiento como está 00:46:52
hecho, si está con una array, si está con una lista 00:46:54
enlazada, como veremos luego 00:46:56
es lo de menos, entonces vamos a hacer 00:46:58
este main, a ver si 00:47:00
pero voy a ponerlos con 00:47:01
con mensajitos 00:47:04
para enterarnos bien de los 00:47:06
a ver 00:47:08
el primero, voy a poner 00:47:10
ahí para liarnos 00:47:13
el primero 00:47:15
aquí ponemos 00:47:16
el segundo 00:47:19
voy a poner aquí 00:47:24
el segundo no, perdón 00:47:27
el último 00:47:28
voy a poner aquí 00:47:30
eliminamos 00:47:36
el que está en posición 3 00:47:42
y ahora voy a poner aquí 00:47:46
los que quedan 00:47:49
vale, a ver si así 00:47:56
podemos, entendemos mejor 00:47:58
la salida y 00:48:00
A ver qué ocurre 00:48:01
Venga, ejecutamos esto 00:48:03
Vale, ha metido cadena de texto 00:48:09
Pues 00:48:10
Tenía que haber puesto 5 00:48:12
Vale 00:48:16
Entonces yo he metido mis 10 cadenas de texto 00:48:23
El primero, este, efectivamente 00:48:26
El último que metí 00:48:28
Este, efectivamente 00:48:30
Vamos a eliminar la posición 3 00:48:31
Que la posición 3 00:48:33
Era el DD 00:48:36
No, el DD no, ese es el 2 00:48:37
el FF, vamos a ver 00:48:39
si el FF lo he eliminado 00:48:42
pues sí, el FF lo he eliminado 00:48:43
¿vale? 00:48:45
luego yo 00:48:48
desde fuera 00:48:49
y como usuario 00:48:50
desde fuera me he limitado a 00:48:52
crear mi caja 00:48:55
instanciar el objeto 00:48:57
crear mi caja con el tipo de dato 00:48:59
del que yo dispongo 00:49:01
creo mi caja y la uso metiendo y sacando 00:49:02
y ya está 00:49:05
a mí el site me devuelve feo 00:49:06
Habiendo guardado previamente 00:49:08
Y los añade realmente 00:49:17
Claro, es que si pone 0 00:49:25
Es que no los está añadiendo 00:49:28
A ver si te va a faltar esto de sobreescribir datos por aus 00:49:29
Bueno, necesitéis parar un momentito 00:49:32
Vamos a aprovechar la parada 00:49:42
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
21
Fecha:
29 de enero de 2025 - 13:02
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 45″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
833.31 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid