Saltar navegación

20250203 Estructuras dinámicas - 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 3 de febrero de 2025 por Stefano C.

17 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto si habláis me estáis autorizando a poder grabar vuestra voz 00:00:00
Entonces hoy la primera cosa que vamos a ver es un poco el concepto de estructuras dinámicas en general 00:00:08
Una estructura dinámica es una colección de datos que puede variar su tamaño en tiempo de ejecución 00:00:14
Ya lo hemos hablado varias veces de esto, hay dos tiempos, uno en tiempo de compilación y uno en tiempo de ejecución, más o menos 00:00:23
El tiempo de compilación es cuando tú estás programando, entonces vas a compilar tu código y te sale un fichero .class con dentro bytecode que luego la Java Virtual Machine interpretará porque se interpreta. 00:00:29
¿Vale? Os acordaos que Java es mitad compilado, mitad interpretado, principalmente interpretado por la Java Hector Machine. 00:00:45
Entonces, estos dos tiempos son distintos en el sentido que hay cosas que se pueden hacer cuando todavía el programa no se ha ejecutado, 00:00:55
pero hay otras cosas que no, que hasta que el programa no se ejecute no sé qué va a pasar. 00:01:03
¿Vale? Cuando yo leo un número por teclado, ¿vale? Y digo, vale, dame tu edad. Yo sé que va a leer un número, pero hasta que no lo ejecute, no sé si el usuario se va a equivocar y en vez de ponerme un número me pone gato. ¿Vale? En ese caso explotaría y no sé qué va a pasar porque todavía no hemos visto la gestión de excepciones. 00:01:08
aquí es un poquito lo mismo vale y nosotros conocemos los arrays vale los arrays son una 00:01:30
estructura que son una colección de datos sí o no ahora el tamaño de los arrays cuando se decide 00:01:38
normalmente el tiempo de compilación sí ahora podría hacer cosas un poquito distintas vale en 00:01:47
Yo podría pedirte un número, tú pones 7, y yo te hago un array de 7 posiciones. 00:02:00
Pues eso sería a tiempo de ejecución. 00:02:05
Pero todo lo que hago con el array, crearlo, cuando yo lo creo, le tendré que decir, 00:02:08
new array, no sé qué, y entre paréntesis le pongo un tamaño. 00:02:13
Ese es su tamaño, fijo. 00:02:17
Cuando yo le doy ese numerito de allí, la memoria, o sea, la digital machine, 00:02:20
irá a la memoria, pillará un trozo 00:02:25
de memoria y dirá, esto es mi array 00:02:28
y ese trozo, el tamaño de ese trozo 00:02:31
no lo va a cambiar en la vida, la única cosa que yo puedo hacer 00:02:34
para cambiar eso, es crear un nuevo array 00:02:37
¿si? por eso se dice 00:02:39
que es estático, una vez definido el array, una vez creado 00:02:43
pues así está, sin embargo 00:02:46
yo quiero crear estructuras que puedan 00:02:49
modificar su tamaño 00:02:51
mientras la estoy utilizando 00:02:53
o sea que si yo soy una escuela 00:02:56
y estoy dando de alta de alumnos 00:02:57
y ahora tengo 30 alumnos, pues ahora 00:02:59
puedo añadir otros 100 alumnos 00:03:01
y no pasa nada 00:03:03
es siempre la misma estructura que se va 00:03:04
haciendo más grande 00:03:07
está claro que luego por debajo, dependiendo de cómo 00:03:09
está hecha y de cómo está implementada 00:03:11
podría hacer cosas distintas 00:03:13
si nosotros la hemos implementado con un array 00:03:15
pues llegará un momento que el array 00:03:17
estará lleno y entonces 00:03:19
tendré que crear una red más grande 00:03:21
y volcar todo, etc 00:03:23
pero si por ejemplo pensáis a como 00:03:25
hemos implementado la linked list 00:03:27
pues la linked list no necesita 00:03:29
eso, añado más 100 usuarios 00:03:31
pues son 100 objetos nuevos que creo 00:03:33
enlazados entre ellos, ya está 00:03:35
entonces la diferencia 00:03:37
fundamental sería que una vez 00:03:43
definido el tamaño del array 00:03:45
esto no se puede modificar 00:03:47
en tiempo de jugación, se puede crear un nuevo array 00:03:48
pero no modificar el array que tenemos, mientras una estructura 00:03:51
dinámica permite modificar dinámicamente 00:03:53
el número de objetos que puede almacenar 00:03:55
hasta una 00:03:57
virtualmente 00:03:59
infinito, pero claramente 00:04:01
en informática no existe nada que sea 00:04:02
infinito, ¿vale? porque siempre tenemos 00:04:05
límites grandes de memoria 00:04:07
y cosas por el estilo, mientras que 00:04:09
tenga memoria puedo crear nuevos objetos 00:04:11
si creo demasiados objetos 00:04:13
pues llegará un momento en que mi ordenador no puede 00:04:15
Entonces, colapsará. Dentro de las estructuras dinámicas que podemos tener, hay varios tipos, ¿vale? Aquí estamos todavía, no hemos llegado a Java propiamente, ¿vale? Estos son más bien teoría genérica de las estructuras dinámicas. Luego pasaremos a Java y veremos Java, cosa que nos ofrece, ¿vale? 00:04:17
Dentro de las estructuras dinámicas en general, que luego tú puedes implementar en el lenguaje que tú quieras, están las listas, las colas, las pilas y los árboles. 00:04:43
¿Hay otros? Sí. Estas son las más básicas. 00:04:53
Listas. Una lista es una estructura dinámica que permite almacenar un objeto y tener un modo para poder acceder al siguiente elemento de la lista. 00:04:59
¿Cómo es este modo? No me interesa. Depende de cómo implemento la lista. En el linked list acceder al siguiente es con su campo siguiente. En el array list acceder al siguiente es cambiar el numerito del array. 00:05:08
pero dependiendo de cómo tú lo implementes 00:05:24
tendrás un modo para 00:05:27
sustancialmente recorrer esta lista 00:05:29
tendrás un inicio 00:05:31
tendrá una serie de objetos 00:05:33
que están enlazados de alguna 00:05:35
forma entre ellos, repito, como objetos 00:05:37
o porque están en un array o 00:05:39
por otro método que tú te inventes 00:05:41
en la lista el orden de los objetos 00:05:43
la escritura es importante 00:05:45
es una lista, cuando yo voy a meterlos 00:05:47
aquí hay un cierto 00:05:49
orden 00:05:51
que no necesariamente es el orden de inserción, pero sustancialmente, ¿por qué pensáis que es importante el orden en una lista? 00:05:53
¿Por qué el orden tiene algo que ver con la lista? 00:06:05
Porque la lista siempre inicia desde el inicio, inicia desde el objeto primero. 00:06:13
Entonces, si yo pongo un objeto al final de la lista, encontrarlo me costará siempre más que el primero de la lista, por ejemplo. 00:06:17
Entonces, dependiendo de lo que quiero hacer con estos objetos, pues puede ser que la lista no sea la mejor opción, o puede ser simplemente que en vez de ordinarlos con el orden de inserción, 00:06:27
o sea, el primero que inserto lo pongo primero, el segundo, segundo, tercero, tercero, pues a lo mejor me compensa crear otro tipo de orden, ¿vale? 00:06:40
Como por ejemplo, yo doy una prioridad a mis objetos y los objetos con prioridad más alta se pondrán antes de los objetos con prioridad más baja, ¿vale? 00:06:50
Una característica de la lista es que se pueden insertar nuevos objetos donde quiera, ¿vale? 00:07:04
normalmente nosotros por ejemplo hemos hecho que se añade al final una opción que se añaden o al 00:07:10
final o al principio vale pero en teoría la lista debería darme la posibilidad de decir 00:07:16
encércame esto en posición 3 esto me permite hacer listas ordenadas yo podría insertar un 00:07:22
nuevo objeto y esto por ejemplo como hemos dicho con un campo prioridad y él me lo va a poner 00:07:30
primero o último depende como quiero yo pero dejé entre que aquellos objetos que tengan la misma 00:07:35
prioridad entonces si yo inserto un prioridad 2 por ejemplo y esto tiene prioridad 1 será 00:07:43
seguramente después de esto esto tiene primero uno después después de esto esto ya tiene problema 00:07:49
prioridad 2 pues sólo inserto aquí o lo inserto después dependiendo de cómo quiero hacerlo pero 00:07:54
seguramente antes de todos aquellos que tienen prioridad 3. 00:08:00
¿Cómo implementaríais vosotros un concepto de prioridad? 00:08:04
¿Cómo podríamos hacer nosotros que insertamos un objeto y él elige dónde ponerlo? 00:08:11
¿Ese no es un string? 00:08:23
Pero si no sabemos qué objeto es, ¿por qué tiene un número? 00:08:32
¿Qué haríais vosotros para que yo pueda saber si este objeto va antes o después? 00:08:36
¿Eso no lo hemos visto? 00:08:55
Exacto, un método por ejemplo interesante podría ser la interfaz comparable 00:09:02
Como la interfaz comparable me permite comparar dos objetos y saber si es mayor o menor 00:09:06
Yo podría decir, defino dentro de mi lista los objetos, los defino con comparable 00:09:13
Entonces implemento el método compareTo 00:09:18
Y cuando voy a insertar un elemento 00:09:21
Para poderlo insertar lo voy a comparar con todos los elementos 00:09:24
Y digo, ¿es más grande o más pequeño que este de aquí? 00:09:28
Si este es más pequeño lo dejo primero 00:09:32
¿Este es más grande o más pequeño? 00:09:33
Este es más grande, pues entonces va aquí 00:09:35
Para que siempre me quede ordenada la lista 00:09:36
De menor a mayor o de mayor a menor 00:09:40
Dependiendo de cómo lo podáis hacer, ¿vale? 00:09:41
Al recorrer la lista lo haré desde el inicio hasta el final, ¿vale? 00:09:44
Esta es una cosa importante de las listas, que normalmente hay el punto de acceso inicial y desde aquí tendré un mecanismo, como hemos dicho, para mirar el siguiente, para mirar el siguiente, para mirar el siguiente. 00:09:48
Entonces, hay listas, hay implementaciones de listas que me permiten un poquito evitar esto. 00:10:01
Como por ejemplo, la lista implementada como array permite acceder donde te da la gana. 00:10:07
Yo puedo decir, acceder a la posición 7, y él accederá directamente a la posición 7 de la array, y entonces me evito de saltar uno por uno. 00:10:12
Pero, por ejemplo, la lista implementada como un linked list no me permite hacer esto. 00:10:20
Tengo que insertar en el primero, entrar en el primero, y luego ir al segundo, y del segundo al tercero, del tercero al cuarto, hasta llegar al 7. 00:10:24
Dudas. 00:10:32
Las colas son parecidas a las listas, pero tienen una política fifo. 00:10:36
First in, first out. 00:10:43
O sea, el primero que tú has insertado tiene que ser el primer objeto que tú quites, ¿vale? 00:10:44
Esta es una fila, es una cola del supermercado, es una cola de una ventanilla, una cosa de ese estilo, ¿vale? 00:10:54
El primero que llega será el primero que será atendido. 00:11:01
Si yo implemento una cola, sustancialmente podría implementarla con un array, podría implementarla con una linked list que hemos visto, 00:11:05
Pero cuando voy a hacer la GET y la ADD, la que añade un elemento y la que pilla un elemento, cuando hago ADD siempre lo añadiré al final de la cola y cuando hago el GET siempre pillaré el objeto más viejo según orden de inserción. 00:11:12
inserción. ¿Podría cambiar yo a hacer una cola especial, que es una cola de prioridad, por ejemplo, 00:11:31
en el que se ordenan, pero no se ordenan según el orden de inserción, sino se ordenan según un orden 00:11:38
distinto, un orden de prioridad, un orden alfabético, un orden de numerito de 1 a 10, qué sé yo, pues sí lo 00:11:46
puedo hacer. Serían colas especiales. Normalmente la cola, así cuando lo pienso en general, debería 00:11:52
ser que los primeros insertados son los primeros que se salen que salen de la cola si esto por 00:12:00
ejemplo se puede utilizar para si yo tengo un programa que tiene que procesar alumnos y hacer 00:12:06
algo con ellos ellos lo que tengo otro programita o algo por estilo que va añadiendo a la cola los 00:12:16
alumnos que tiene que hacer y de vez en cuando el programa va a mirar vale voy a procesar uno 00:12:21
de estos alumnos a ver cuál le toca le toca este de aquí que es el primero vale lo procesa y hace 00:12:26
lo que tenga en una cola siempre tengo una cabeza este de aquí normalmente es el primer elemento que 00:12:31
voy a sacar o sea el más viejo el primero que ha insertado entonces cuando yo inserto simplemente 00:12:41
la cabeza la mueva aquí cuando yo remuevo perdón cuando yo pillo este objeto y digo dame el objeto 00:12:47
esto se remueve, la cabeza se mueve al siguiente 00:12:53
objeto que se vuelve la cabeza de la cola 00:12:55
¿sí? 00:12:57
¿judas? 00:12:59
¿se entiende más o menos? 00:13:01
la pila 00:13:03
es al revés, por distinta 00:13:05
es LIFO 00:13:07
last in, first out 00:13:08
¿vale? 00:13:11
el último que he insertado 00:13:12
es el primero que quito 00:13:14
¿sí? 00:13:16
por ejemplo 00:13:19
las llamadas a métodos 00:13:20
dentro de la Java Virtual Machine 00:13:22
se implementan como una pila 00:13:25
porque tú tienes el método main 00:13:28
dentro del método main llamas el 00:13:29
añade alumno 00:13:32
dentro del añade alumno llamas el 00:13:33
cambianombre 00:13:35
el primero que acaba será 00:13:36
cambianombre, entonces cuando acabo 00:13:39
cambianombre vuelvo 00:13:41
no al primero 00:13:43
a main 00:13:45
pero vuelvo a 00:13:47
añade alumno 00:13:50
Entonces estoy haciendo como una cola, ¿vale? Una pila, perdón. La primera, la base de la pila sería el main, por encima de la pila pongo el agrega alumnos, por encima el llama nombre. 00:13:51
Cuando acaba llama nombre y quito llama nombre de esta pila de ejecución, pues lo que tengo por debajo sería agregar alumno. 00:14:04
Cuando acabo de agregar alumno vuelvo al main, ¿vale? Esto es como se hacen normalmente las llamadas de métodos en Java o en cualquier lenguaje de programación más o menos. 00:14:12
¿Habéis visto alguna vez el juego de la Torre de Hanoi? 00:14:21
Hanoi, no sois informáticos. 00:14:29
Torre de Hanoi. 00:14:36
¿Eh? ¿Este aquí? ¿Eh? ¿Sí? ¿Os suena? 00:14:39
¿Tocos aquí? 00:14:43
Vale, es que, sustancialmente, tenéis todos los anillos en un palo 00:14:48
y tenéis que volver a... tenéis que conseguir ponerlos aquí, 00:14:52
pero solo podéis mover el palo de arriba 00:14:55
o sea, el anillo de arriba 00:14:58
pues esto es una pseudopila 00:14:59
¿sí? 00:15:01
porque yo no puedo mover el de abajo 00:15:03
tengo que mover esto, que es el último 00:15:05
que he metido dentro 00:15:07
¿sí? bueno, esto es un programa 00:15:08
típico 00:15:13
de, o sea, programar 00:15:14
un programa que te hace todas las 00:15:17
monsas para mover esto aquí 00:15:19
es un programa típico 00:15:20
de la informática 00:15:22
sigo, entonces 00:15:24
Entonces, estos al fin y al cabo son todos parecidos a listas, son cosas que tú añades los objetos y los objetos se van, hay un punto de acceso y se van añadiendo uno tras otro y hay una forma para ir de uno a otro, ¿vale? 00:15:27
Pero, mientras una lista es simplemente una lista como la lista de la compra, la cola tiene esta particularidad de que no puedes pillar el que te da la gana, 00:15:41
Tienes que pillar solo el más viejo que has insertado o según tu política de ancianidad. 00:15:51
Y la pila, en vez, es que el último que has insertado es el primero que quitarás. 00:15:59
Finalmente está el concepto de árbol. 00:16:07
En informática hablamos de árbol cuando vemos un grafo acíclico parecido a este de aquí. 00:16:09
Un grafo son nodos conectados con conexiones aristas, creo que lo llamáis, entre ellos. 00:16:19
Cuando un árbol no tiene nunca ciclos, o sea, si yo conecto estos dos puntitos de aquí entre ellos, 00:16:28
pues entonces no sería un árbol. 00:16:37
Y tiene la característica de que normalmente un nodo tiene un solo progenitor y tiene cuantos hijos tiene. 00:16:39
entonces, si os fijáis 00:16:46
esto tiene un solo padre, madre 00:16:49
o lo que más os dé la gana 00:16:51
pero puede tener varios hijos 00:16:52
entonces 00:16:55
se crea un árbol porque esto es el 00:16:57
nodo raíz y estas son las 00:16:59
hojas, lo veis el árbol 00:17:01
al revés 00:17:03
nosotros lo hemos llamado nodo 00:17:04
si tú haces un árbol 00:17:21
con un solo hijo 00:17:23
o un solo padre, pues te viene una lista 00:17:25
al fin y al cabo, la ventaja de este 00:17:27
aquí es que un nodo puede tener varios 00:17:29
¿para qué sirven estos? pues hay algunos tipos 00:17:31
de problemas que si lo miramos como 00:17:35
árboles, esto mejora muchísimo 00:17:38
con respecto a si lo miramos como lista 00:17:41
la lista es lineal, el árbol es 00:17:44
una estructura que no es lineal, tiene varias 00:17:47
diramaciones, tiene más complejidad 00:17:50
en términos de figura, por ejemplo 00:17:53
un uso típico es para ordenar 00:17:55
Yo aquí tengo un objeto que vale no sé cuánto. El siguiente objeto que inserto, lo inserto como su hijo, pero lo inserto a la izquierda si su valor es menor y a la derecha si su valor es mayor. 00:17:58
De esta forma me va distribuyendo y buscar luego los objetos es más rápido, porque por ejemplo, imaginaos que esto sea 5. 00:18:13
Si yo estoy buscando el objeto 7, puedo descartar automáticamente todos estos, porque los que estarán allí serán a la izquierda del 5, entonces valdrán menos de 5. 00:18:22
Voy aquí, me encuentro 9, pues puedo descartarme todo lo que está a la derecha, porque esto será menor que el 5. 00:18:33
Esto se llama árbol binario de búsqueda 00:18:40
Y tiene la particularidad que solo puede tener dos hijos 00:18:44
O mayor o menor 00:18:51
O sea que esto no podría ser porque aquí tiene tres 00:18:51
Es para hacer un ejemplo de 00:18:54
Hay algunos problemas que si utilizado como árbol 00:18:57
Pues funciona mucho mejor que si hago una cosa lineal 00:19:00
si no 00:19:04
porque aquí estamos hablando de una estructura de datos 00:19:15
y estamos hablando de algoritmo de ordenación 00:19:19
y depende de cuál 00:19:22
la ventaja es que 00:19:23
si tú cuando vas a ordenar los datos 00:19:27
en vez de guardarlos en un array 00:19:31
y luego buscar en un array con el método que sea 00:19:33
lo guardas en un árbol de búsqueda binario 00:19:35
y esta tiene algunas características 00:19:38
pues llega a ver, luego la búsqueda es mucho mejor que buscar en un array, pero sí, o ordenarlo. 00:19:40
Claramente, si yo aquí me invento un método que digo cuando inserto uno tengo que mirar si es mayor 00:19:50
o menor que esto y ponerlo a la izquierda o a la derecha, insertar un nuevo nodo va a ser más complejo 00:19:58
que antes, antes era, oye, añádelo, ya está, ahora en vez de, no, pillo, voy a mirar el primo nodo, si 00:20:03
Si el primer nodo es mayor, entonces voy a mirar esto. 00:20:09
Si el primer nodo es mayor, voy a mirar esto. 00:20:11
Y voy a buscar dónde tiene que estar. 00:20:13
Entonces se complica, por ejemplo, la inserción a ventaja de que luego después la búsqueda es mucho mejor. 00:20:16
Pero es un ejemplo. 00:20:23
El árbol como estructura es esto, ¿vale? 00:20:25
Y luego se pueden hacer muchas cosas con ellos. 00:20:29
Cuando hablamos de árbol, el nodo hoja es un nodo que no tiene descendentes. 00:20:32
Un nodo interior es un nodo que no es hoja. Un nodo raíz es el primero que no tiene progenitores. El nivel de árbol es cuántas generaciones tiene el árbol. Por ejemplo, ¿qué nivel tiene este? Cuatro. Una, dos, tres y cuatro. 00:20:36
el grado de un nodo es 00:20:56
¿cuántos hijos tiene ese nodo? 00:21:03
¿qué grado tiene este nodo? 00:21:05
el grado de un árbol es el máximo 00:21:08
de los nodos de un árbol 00:21:12
entonces en este caso 00:21:14
¿qué grado tiene este árbol? 00:21:16
el máximo 00:21:22
el máximo de los nodos de un árbol 00:21:25
¿vale? 00:21:28
es el grado máximo 00:21:30
Este de aquí, como tiene un nodo con tres hijos, pues el grado es 3, porque entre todos sus nodos, él tiene 3, ¿vale? 00:21:31
Un árbol binario de búsqueda debería tener grado 2, ¿sí? 00:21:42
Porque no puede tener un nodo con más de dos hijos, ¿sí? 00:21:49
¿Dudas hasta aquí? 00:21:57
vale, entonces 00:21:58
ahora que tenemos un poquito la idea 00:22:00
de la tipo de colecciones 00:22:03
dinámicas, que se puede hacer 00:22:05
que cosas hay por allí, vamos a ver 00:22:06
Java que nos ofrece, vale 00:22:09
Java implementa una serie 00:22:10
de estructuras dinámicas que extienden 00:22:13
la interface collection 00:22:15
vale, o sea que el punto 00:22:16
más alto en realidad es uno por arriba, pero bueno 00:22:19
la idea de cuando me pongo con 00:22:20
estructuras dinámicas, tengo un 00:22:23
interfaz que se llama collection 00:22:24
que me define algunas herramientas, algunos métodos que tienen que implementar todas las colecciones que hay. 00:22:26
Si voy a mirar Collection, esta es una interfaz y lo que me dice es que cualquier interfaz que quiera hacer Collection 00:22:44
tiene que poder añadir un elemento, remover todos los elementos 00:22:53
de la conexión, buscar un objeto, o sea, decirme si este objeto 00:22:58
está o no en la colección, decirme, no lo sé, si está vacía 00:23:02
la colección, decirme si... quitar un elemento concreto, 00:23:08
decirme el tamaño de cuántos elementos hay, bla, bla, bla, 00:23:14
más otras cosillas. Entonces, cualquier collection 00:23:17
que yo creé en Java 00:23:21
tiene que haber implementado todos estos métodos de aquí 00:23:24
esto quiere decir que una cualquier collection 00:23:27
permite utilizar estos métodos 00:23:29
las colecciones representan un grupo de objetos 00:23:33
denominados elementos 00:23:37
podemos encontrar diversos tipos de colecciones 00:23:39
según si esos elementos están ordenados 00:23:42
si se permiten las repeticiones de los elementos, etc. 00:23:45
cada una de las collections que veremos ahora 00:23:48
son implementaciones que difieren 00:23:50
un poquito una de la otra, con características 00:23:52
un poquito distintas. Luego habrá más 00:23:55
de las que vemos nosotros, pero nosotros 00:23:57
veremos las principales. 00:23:59
Es el tipo más genérico en 00:24:01
cuanto a que se refiere 00:24:03
a cualquier tipo que contenga 00:24:04
un grupo de elementos. O sea, que esto es 00:24:06
no te dice 00:24:09
qué es, no te dice cómo funciona, 00:24:10
no te dice si es una lista, una 00:24:13
cola, un árbol, te dice si es una colección 00:24:14
de datos. Es 00:24:17
muy muy genérico. Luego, dependiendo de cómo lo 00:24:18
implementas tú tendrá una función u otra porque él te dice tú tienes que añadir y tienes que poder 00:24:20
quitar pero no te está diciendo cómo hacerlo si tú decides por ejemplo que añade siempre delante 00:24:28
y quita siempre del fondo estás haciendo una cola pero si en vez de estar hablando y haciendo lo 00:24:35
que no sé que escucharéis entonces si yo lo que hago es que la collection me dice tiene la de 00:24:49
tiene la remove, y yo digo que cuando hace la add la añade siempre al principio de 00:24:58
mi estructura y que cuando hago la remove quita siempre la última de la 00:25:02
estructura, lo que estoy haciendo es una cola, porque el primero que inserto al 00:25:06
principio y removo al final, entonces el del final será siempre el más viejo, si? 00:25:11
es una cola al revés, en cierto sentido, si? que se puede hacer si se inserta delante y 00:25:15
se quita al final en vez de insertar al final y sacar delante, siempre una cola 00:25:22
en esta interfaz encontramos una serie de métodos 00:25:27
que nos servirán para hacerlo 00:25:38
esta es la estructura general de todo lo que vamos a ver 00:25:39
a partir de ahora 00:25:45
aquí está collection 00:25:46
en realidad collection 00:25:49
extiende o hereda 00:25:51
da iterable 00:25:54
¿Sí? Entonces, lo que empieza toda esta estructura es iterable 00:25:57
Iterable es un concepto de algo, un conjunto de cosas sobre el que yo puedo ir a iterar 00:26:02
O sea, que yo puedo ir a mirar de uno en uno 00:26:12
¿Sí? Y a partir de este concepto de no sé qué es, pero sé que puedo ir a mirarlo de uno en uno 00:26:15
Me hago una colección. ¿Qué es una colección? Pues un conjunto de datos 00:26:22
No un conjunto, un grupo de datos 00:26:26
¿Vale? Un grupo de objetos 00:26:28
Sobre el que yo podré hacer 00:26:30
Una iteración 00:26:32
O sea, que tengo 10 objetos 00:26:34
Puedo pillar el primero, luego el segundo, luego el tercero 00:26:36
Luego el cuarto, hasta que los he mirado todos 00:26:38
¿Por qué? Porque cualquier collection 00:26:40
Es iterable 00:26:42
¿Se entiende? 00:26:43
Esto es una ventaja porque me da la posibilidad 00:26:47
De sustancialmente cualquier 00:26:49
Colección, tener un 00:26:51
Mecanismo para poder decir 00:26:53
Dame todos sus objetos 00:26:55
uno por uno, ahora 00:26:57
si será una cola me los dará ordenado 00:26:59
del primero al último, si es una pila me dará 00:27:01
last in, last out 00:27:03
last in, first out, si es 00:27:04
un árbol me lo dará de otra forma 00:27:07
como 00:27:09
se hace no me interesa 00:27:11
depende de la implementación 00:27:13
yo sé que se puede hacer 00:27:14
yo sé que hay un mecanismo para poder ir a 00:27:16
mirar uno por uno todos los 00:27:19
elementos 00:27:21
¿se entiende? 00:27:21
a partir de collection 00:27:25
se crean tres interfaces, que son list, queue y set. 00:27:26
Lista es una lista, queue es una cola, set es un conjunto. 00:27:35
La diferencia fundamental entre list, queue y set es que aquí se pueden repetir los datos, 00:27:42
o sea, yo puedo poner el mismo alumno diez veces, mientras aquí los datos son únicos. 00:27:49
Si yo he añadido un alumno concreto, no puedo añadir otra vez el mismo alumno o un alumno equivalente. 00:27:56
¿Cuándo dos alumnos son equivalentes? 00:28:06
¿Cuándo dos objetos son equivalentes? 00:28:15
Cuando el equals entre estos dos objetos es de true. 00:28:24
Luego tú, si no has definido el equals, será el igual igual, entonces serán iguales sólo cuando son el mismo objeto. 00:28:28
si en vez tú has sobre escrito el equal 00:28:35
si has dicho que tengan el mismo DNI 00:28:37
cuando dos objetos hasta distintos 00:28:39
dos instancias distintas tengan el mismo DNI 00:28:42
para ti serán lo mismo 00:28:45
entonces en una lista se pondrían una y otra vez 00:28:46
en un set se pondría una sola vez 00:28:49
cuando tú intentaras poner otra vez 00:28:51
el mismo alumno con el mismo DNI 00:28:54
te diría, no está 00:28:57
entonces en el set es muy importante 00:28:59
la definición del equal 00:29:02
lo volveremos a ver 00:29:04
entonces 00:29:07
la lista son las listas 00:29:09
la que hemos hablado ahora, la queue son las colas 00:29:11
los sets son los conjuntos, esta particularidad 00:29:13
de que es un conjunto que no se puede repetir 00:29:15
los elementos 00:29:17
también en lista queue 00:29:18
el orden tiene sentido 00:29:21
en un set no 00:29:23
el conjunto es 00:29:24
yo pongo ahí elementos 00:29:27
pero el orden con que los he metido 00:29:28
no me interesa 00:29:31
Él hará lo que quiere, lo reorganizará, no necesariamente se ha insertado antes esto y luego esto, cuando los voy a leer lo encuentro en esta orden. Él lo moverá como mejor le da para que sea lo más eficiente posible. 00:29:34
Si quiero y me interesa que el orden sea importante y que quiera respetarlo, no uso un set, uso un list. 00:29:50
dentro de list que hay 00:29:59
hay ArrayList 00:30:06
de que os suena ArrayList 00:30:08
de que podría ser un ArrayList 00:30:09
una lista cuya implementación 00:30:11
está hecha con 00:30:17
Arrays, o sea mi lista 00:30:18
lo que hemos hecho el miércoles 00:30:21
pues eso se llama ArrayList en Java 00:30:23
y luego está 00:30:25
LinkedList, que será LinkedList 00:30:28
lo del viernes 00:30:31
¿vale? o sea que lo que nosotros 00:30:34
hemos hecho, formada 00:30:37
simplificada, sin optimizar nada 00:30:38
y feo como poca cosa en este multiverso 00:30:40
alguien se ha metido a hacerlo 00:30:42
bonito, bien 00:30:45
hecho, seguro 00:30:47
y con 00:30:48
¿cómo se dice? 00:30:50
con algo de eficiencia 00:30:53
y me ha creado dos listas 00:30:54
que ya existen, o sea dos 00:30:56
clases que ya existen, fijaos que 00:30:58
los verdes son clases, yo puedo crear objetos 00:31:00
RList o crear objetos LinkedList 00:31:02
y heredarán 00:31:05
todo lo que puedan hacer la lista, todo lo que 00:31:06
puedan hacer las colecciones y todo lo que puedan hacer 00:31:09
los iterables y por lo tanto 00:31:11
los podré utilizar para guardar 00:31:13
allí objetos y hacer lo que me dé la gana 00:31:15
¿se entiende? 00:31:17
vale 00:31:20
¿qué más cosas hay? hay vector 00:31:20
¿vale? vector es 00:31:23
parecido a una lista 00:31:25
¿vale? la ventaja que tiene vector 00:31:26
es que está 00:31:29
sincronizado 00:31:30
¿Qué quiere decir? 00:31:32
Segundo de DAM 00:31:36
¿Vale? 00:31:37
Programación de servicios 00:31:39
Y procesos 00:31:41
Vosotros ahora estáis trabajando con un solo hilo 00:31:42
De ejecución, le dais a un play 00:31:45
Y se va 00:31:46
Todas las 00:31:47
¿Cómo se dice? 00:31:49
Los comandos de Java que habéis puesto, uno detrás de otro 00:31:52
Se acabó 00:31:54
En segundo de DAM 00:31:56
Se aprende a programar con procesos 00:31:58
Eso quiere decir que la misma 00:32:00
o con threads 00:32:01
¿vale? hilos 00:32:03
un mismo proceso cuando se arranca 00:32:04
en vez de tener un único hilo de ejecución 00:32:08
tiene varios hilos de ejecución 00:32:10
que trabajan a la vez 00:32:12
mientras uno está haciendo una cosa 00:32:13
otro está haciendo otra cosa, para que entendáis 00:32:15
el word 00:32:17
cuando tú tienes el word, ¿qué puedes hacer 00:32:19
con el word? escribir 00:32:22
pero mientras tú escribes, ¿qué te hace el word? 00:32:25
sí, por otra cosa 00:32:34
pero lo que hace en particular es que si tú 00:32:35
escribes sin acentos, ¿qué te hace? Te lo pones rojo. ¿Y quién lo está haciendo eso? Pues otra 00:32:38
tarea, ¿vale? Otro hilo. Tú tienes dos hilos a la vez, uno que está pendiente de ti, de lo que 00:32:46
escribes, y otro hilo que está pendiente de cuando tú has escrito una palabra, ir a buscar en un 00:32:52
diccionario si esta palabra está escrita bien y si está escrita mal, marcarla de rojo. Estas dos 00:32:57
cosas se hacen a la vez. Son dos tareas que se hacen a la vez. ¿Vale? Para hacer un ejemplo 00:33:02
de multitarea. Pues cuando hay multitarea, hay un problema serio en el escribir en la 00:33:08
misma variable. Porque si yo me meto a escribir en esta variable y mientras estoy escribiendo 00:33:17
en esta variable viene otro y empieza a escribir en la misma variable, llega un momento en 00:33:21
que este trozo de memoria tiene una parte escrita por mí y una parte escrita por el 00:33:26
otro. Entonces, lo que está escrito no es ni mi dato ni el dato del otro. Es una mezcla 00:33:30
de los dos. Y si a alguien se le ocurre en ese momento ir a leer, tiene lo que se llama 00:33:35
una race condition, una condición de carrera o una inconsistencia de memoria. Y por lo 00:33:41
tanto, no funciona. Pues vector tiene sistemas internos para poder evitar esto. Si alguien 00:33:49
toca un vector, otro 00:33:58
thread no lo puede tocar. 00:34:00
¿Sí? 00:34:03
A nosotros no nos 00:34:05
interesa para nada. En un futuro 00:34:06
podría interesarnos. ¿Cuál es 00:34:08
la desventaja del 00:34:10
vector? Es que es más lento. 00:34:12
Para hacer esta comprobación 00:34:15
de, oye, mira, alguien me está 00:34:16
utilizando, porque si alguien me está utilizando, nadie 00:34:18
más me puede utilizar, pues esa 00:34:20
comprobación lo ralentiza. 00:34:22
Entonces una relista es más rápido 00:34:24
con vector, pero en términos 00:34:26
de utilizo, una relista con vector 00:34:28
serían muy muy parecidos 00:34:30
cambian poco o nada 00:34:31
hasta el menos segundo de dam 00:34:33
ahora, de vector 00:34:35
puedo heredar 00:34:38
una clase, que es la clase 00:34:40
stack, que en inglés 00:34:42
quiere decir, no, eso es 00:34:44
heap, stack 00:34:48
es pila, tu stack es 00:34:52
pila 00:34:55
esta es la implementación de la pila 00:34:56
esta pila 00:35:00
esta pila pila duda vale luego está la interfaz que no es una lista es una interfaz aparte se 00:35:01
parece vale pero es un poquito distinta porque la lista yo puedo hacer como lo que me da la gana la 00:35:14
que en vez es una una cola vale de este es una lista este es una cola vale o sea la lista no 00:35:19
necesariamente puede insertar en el medio puede hacer un poquito de más de 00:35:29
caos la cola no la cola inserto por un lado y pillo por el otro vale entonces 00:35:33
cuando hago la que la implementación que tengo de que es priority que priority que 00:35:38
es una cola de prioridad es lo que decíamos antes yo tengo que definir 00:35:45
dentro de los objetos una cierta prioridad la definiré probablemente con 00:35:49
un comparable vale y una vez que yo sé cuál es la prioridad como se calcula la 00:35:55
prioridad de un objeto cuando lo inserto dentro de una prioridad y que se 00:36:00
insertará allá donde tiene que estar como como como prioridad entonces donde 00:36:04
sale la cola que lo que tienen mayor prioridad serán los primeros que salen 00:36:11
vale no es un exactamente un puesto en fest out 00:36:17
Pero es un first-in, first-out con prioridad. 00:36:21
Y luego está una versión de la Q que es la DEC. 00:36:24
Esta está Double Ended Q. 00:36:29
La coda con doble extremidades, finales, qué sé yo. 00:36:33
Que, sustancialmente, en esta de aquí, que está la ArrayDec, 00:36:39
que fijaos que hace una mezcla rara así, 00:36:42
pues esta de aquí, de la ArrayDec, permite, 00:36:46
es una cola en el que se puede insertar 00:36:48
o quitar desde los dos extremos 00:36:51
entonces la puedo ver como por aquí 00:36:53
o por aquí, a la vez 00:36:57
¿para qué sirve? eso ya no lo sé, pero existe 00:36:58
lado set 00:37:01
hemos dicho que un set tiene la característica 00:37:05
de que no se pueden repetir los elementos 00:37:07
allí dentro y el orden 00:37:08
se pierde aquí, el orden no 00:37:11
tiene mucho sentido, el orden de inserción 00:37:13
esto es 00:37:15
Y aquí hay dos posibles implementaciones que son LashSet y LinkedLashSet. 00:37:16
El LashSet es una de las estructuras dinámicas más rápidas que haya. 00:37:25
es una de las implementaciones más veloz 00:37:35
a la hora de insertar y quitar 00:37:40
y encontrar objetos dentro de la colección 00:37:43
entonces siempre que podamos 00:37:47
y que esto sea, pues H7 sería una buena solución 00:37:51
ahora luego hablaremos de ese 00:37:56
la link de H7 es parecida a esta 00:37:58
solo que por dentro utiliza 00:38:00
un sistema enlazado parecido a la linked list 00:38:02
y finalmente está el sorted set 00:38:06
que es como un set pero en el que cuando insertas las cosas 00:38:09
no van al azar sino que van ordenadas y tienes el 00:38:14
triset que es un poco parecido a lo que decíamos antes 00:38:18
o sea que es un árbol que pero cuando inserto las cosas los ordeno 00:38:22
poniéndolo en el subárbol derecho o izquierdo dependiendo de si es 00:38:25
mayor o menor en base a la comparación del objeto que estoy insertando con el 00:38:30
objeto nodo esto es presentación general vale luego ahora haremos ejemplitos y 00:38:35
problemas y cosas por el estilo para ver cómo se usan aquí vale entonces la 00:38:43
interfaz collection las operaciones más importante puede añadir puede decir el 00:38:47
tamaño puedo iterar sobre esta colección o sea ir a mirar de uno en uno puedo 00:38:51
saber si un objeto 00:38:56
existe y puedo quitar un 00:38:58
objeto. ¿Vale? Esto es lo que me permite 00:39:00
Collection, que grosso modo 00:39:02
si lo pensáis, es la lista que hemos 00:39:04
hecho nosotros. La interfaz que hicimos nosotros 00:39:06
era esta. 00:39:08
¿Sí? Interfaz que desciende de Collection 00:39:10
está Set, que serían los conjuntos. 00:39:14
Los conjuntos son grupos de elementos en 00:39:16
los que no se admiten elementos 00:39:18
repetidos. ¿Vale? Para saber si 00:39:20
un elemento es repetido, se usa 00:39:22
Equals y HashCode. 00:39:24
¿Vale? Estos dos señores 00:39:26
me permiten saber si dos son iguales o si dos caen en el mismo hash. 00:39:28
¿Qué es un hash? 00:39:34
Paint. 00:39:36
¿Vale? 00:39:38
El hash es una función que me pilla un número infinito de x 00:39:38
y me lo mapea en un número finito de valores y. 00:39:49
Es una categorización. 00:40:00
¿Vale? 00:40:04
Por ejemplo, yo podría decir, hacer una función que me pilla un número y me dice si es par o impar. 00:40:04
Esta es una función ash, porque pilla un cualquier número, entonces tengo infinitos números, 00:40:16
y me lo maspea en dos categorías, o es par o es impar. 00:40:25
Si esto lo llamo 0 y esto lo llamo 1 00:40:30
Por ejemplo 00:40:36
Pues yo tengo una función que me da 00:40:37
Cualquier número, infinitos números 00:40:39
Me lo mapea o en la categoría 0 00:40:42
O en la categoría 1 00:40:44
¿Se entiende? 00:40:45
Podría hacer otra función 00:40:49
Que pilla esto 00:40:51
Y me lo pone en 8 posibles categorías 00:40:54
Entonces yo te doy el 37 00:40:58
El hace magia 00:41:03
Y me saca que es la categoría 3 00:41:04
Vale, perfecto, el 37 va aquí 00:41:07
El 37 va en esta categoría 00:41:09
Ahora te doy el 42 00:41:10
Hace magia, el 42 va aquí 00:41:12
Ahora te doy el 96 00:41:15
Y resulta que el 96 después de haber hecho magia 00:41:18
Pues va aquí también 00:41:21
Porque claro 00:41:22
Puede haber distintos números 00:41:24
Que caigan en la misma categoría 00:41:27
Porque el número de categoría es infinito 00:41:28
El número es infinito 00:41:30
Entonces esto pasará seguramente 00:41:32
¿Se entiende? 00:41:34
se entiende que es una función hash 00:41:37
entonces, ¿para qué me sirve? 00:41:39
así, a grandes rasgos 00:41:46
tampoco me quiero meter 00:41:48
porque aquí tengo un número 00:41:49
infinito de posibles objetos 00:41:52
y yo quiero 00:41:53
crearme una estructura en la que 00:41:57
tenga, por ejemplo, son pocas 00:41:59
pero, cuatro posibles categorías 00:42:02
y luego a partir de aquí 00:42:04
hago una cola 00:42:05
de estas cuatro categorías 00:42:07
¿sí? 00:42:09
Entonces, cuando tú pillas el primer número, el primer número cae en esta categoría, lo pongo aquí, A. 00:42:10
Tú pillas el segundo número, el segundo número cae en esta categoría aquí, lo pongo aquí, B. 00:42:17
El tercer número cae también aquí, pues lo pongo aquí, C. 00:42:24
El cuarto cae aquí, D. 00:42:30
El quinto aquí, E. 00:42:33
El sexto aquí, F. 00:42:35
El sexto aquí, F, G. 00:42:37
Veis que yo, ¿cuántos números he insertado? 00:42:39
¿Cuántos he insertado? 00:42:42
Dos, cuatro, seis, siete cosas 00:42:42
Si ahora los voy a buscar 00:42:44
¿Cuántas operaciones máximo tardo? 00:42:46
Si ahora busco F 00:42:56
¿Cuántas operaciones tardo? 00:42:57
Dos 00:43:05
Porque yo diría F cae en esta categoría 00:43:05
Y ya puedo excluir todas las otras categorías 00:43:08
Y entonces entraría aquí y lo compro 00:43:11
¿Es esto o no? 00:43:14
¿Es esto sí? 00:43:15
He insertado siete objetos 00:43:19
en una lista normal. Tendría a, b, c, d, f, g, y para encontrar f debería comprobar 00:43:20
es esto, no es esto, no es esto, no es esto, no es esto, no es esto, sí. Sin embargo, 00:43:33
ahora en dos pasos lo he hecho. Si la función h está bien hecha, mejora un mogollón este 00:43:38
tipo de problemas? Si la función h está hecha mal, pues entonces no. ¿Cuándo una 00:43:48
función h está mal hecha? No. Cuando todas, todos los números o la mayoría de los números 00:43:55
caen en una misma categoría. Función h, si el número es cero va en la categoría 00:44:11
uno, si hay otro número, va en la categoría dos. Es una función hash. Sí, está categorizando 00:44:19
números infinitos en dos categorías solas. Solo que todos los números van en la categoría 00:44:26
dos, excepto el cero que va en la categoría uno. Es pésima como función hash. ¿Sí? 00:44:31
Otro ejemplo de función hash. Pongamos que yo tengo un strings, ¿vale? Tengo un conjunto 00:44:39
de strings que me dan palabras 00:44:54
y cosas por el estilo, y yo quiero estas palabras 00:44:55
guardarlas y luego en un futuro 00:44:57
ir a buscarlas 00:44:59
y las quiero buscar de una forma eficiente 00:45:02
lo que podría hacer por ejemplo es 00:45:04
crearme, no sé cuántas son 00:45:05
21, 21 categorías 00:45:09
¿cuántas letras tenéis en vuestro 00:45:11
alfabeto? 00:45:15
¿eh? 27 00:45:17
que italiano es 21 00:45:21
Bueno, me creo una categoría por cada letra, más una categoría comodín para todos los demás, por si algo no es una letra. 00:45:25
Y ahora, cuando pillo una string, miro la primera letra de esta string y la pongo en su categoría en base a la primera letra. 00:45:35
Si empieza por A, la pongo en esta. Si empieza por B, la pongo en esta. Si empieza por C, la pongo en esta. 00:45:42
Y si no empieza por ninguna letra del alfabeto, la pongo en la última. 00:45:47
Entonces, si me llegan muchas palabras, las voy separando en estas categorías aquí. 00:45:54
Y luego, cuando voy a buscar, solo tendré que buscar entre las palabras que empiezan con la misma letra. 00:45:59
Todas las otras las puedo descartar. 00:46:05
¿Se entiende? 00:46:09
¿Entiende la idea que está la base del hash, del función hash? 00:46:11
Ahora, hacer una función hash hecha bien es complejo. 00:46:15
Es tarea de matemáticos. 00:46:22
¿Cuántos matemáticos hay aquí? 00:46:25
Bueno, a lo mejor alguien hay. 00:46:28
Pero como nosotros no sabemos hacerla, nosotros la hacemos con botón derecho, créame el hash. 00:46:32
Yo tengo que saber cuándo la tengo que hacer, pero cuando la tengo que hacer, que me la haga él. 00:46:40
¿Se entiende? 00:46:47
Entonces, en un conjunto, cuando voy a comparar, como no puedo repetir los elementos, 00:46:49
vale, el equals y el hashcode me sirven para comprobar si son iguales, vale, tened en cuenta que dos elementos iguales tienen que tener el mismo hashcode, pero puede ser que elementos distintos tengan el mismo hashcode, si, 00:46:56
los números pares 00:47:18
el 4 y el 8 00:47:21
tienen el mismo hashcode 00:47:23
pero no son iguales 00:47:24
pero normalmente está 00:47:27
esto set o las set 00:47:28
lo que hace es comprobar antes 00:47:30
el hashcode que es más fácil normalmente 00:47:32
si el hashcode es 00:47:35
correcto, es el mismo 00:47:36
va a comprobar que efectivamente 00:47:39
sean iguales, si el hashcode ya es 00:47:40
distinto pues ya fuera 00:47:43
esto implica que cuando yo como 00:47:44
programador implemento equals 00:47:46
y hashcode, tengo que hacer que respeten 00:47:48
estas cosas, o sea que 00:47:51
dos que tengan el mismo equals 00:47:52
tienen que tener el mismo hashcode 00:47:54
por eso se lo hago hacer 00:47:56
al eclipse 00:48:00
las listas, este tipo de 00:48:01
colecciones se refiere a las listas 00:48:04
en las que los elementos de la conexión tienen un 00:48:06
orden, existe una 00:48:08
secuencia de elementos, en ella 00:48:10
cada elemento estará en una determinada posición 00:48:12
índice de la lista 00:48:14
Entonces en las listas tienen un orden 00:48:15
Este es el primero, el segundo, el tercer elemento 00:48:19
Cuarto elemento, y yo le puedo decir 00:48:21
Píllame el séptimo elemento 00:48:22
Sea como array o sea como 00:48:24
Lista enlazada 00:48:27
Y la Q, la cola 00:48:28
Este tipo de colección 00:48:31
Esta diferencia es una lista de elementos 00:48:33
Que sigue el patrón 00:48:35
First in, first out, o sea, parecida a una lista 00:48:37
Pero que yo 00:48:39
No puedo pillar lo que me da la gana e insertar donde me da la gana 00:48:40
¿Vale? Tengo que seguir 00:48:43
el FIFO 00:48:45
la interfaz list 00:48:46
os recuerdo que hereda 00:48:49
de collection, entonces hace todo lo que tiene 00:48:51
que hacer collection, pero añade algunas 00:48:53
cosillas, permite 00:48:55
elementos duplicados 00:48:57
y aparte de lo que hereda 00:48:59
de collection, puede manipular el elemento 00:49:01
en función de su posición de la lista, le puedo 00:49:03
decir, píllame el tercer elemento 00:49:05
o ponme esto en el cuarto sitio 00:49:07
¿vale? 00:49:09
búsqueda de elemento, puede buscar 00:49:11
un elemento concreto en la lista y devuelve 00:49:13
su posición 00:49:15
búscame este señor 00:49:15
y si lo encuentras te dice 00:49:19
está en posición 7, y ahora tú puedes ir 00:49:21
a la posición 7 y pillarlo si quieres 00:49:23
o remover la posición 7 00:49:24
o hacer lo que quieras con la posición 7 00:49:27
iterar sobre el elemento 00:49:29
la lista 00:49:31
permite mejorar un poco el iterador 00:49:33
de collection, o sea, collection 00:49:35
tiene un iterador genérico 00:49:37
este de aquí permite hacer el iterador 00:49:39
propio de lista 00:49:41
el rango de operaciones 00:49:42
vale, permite hacer ciertas operaciones 00:49:44
sobre bloques 00:49:46
en plan, en vez de añádeme esto 00:49:48
y ahora añádeme esto, ahora añádeme esto 00:49:50
te puede decir, añádeme toda esta colección 00:49:52
te paso una colección y me la 00:49:55
añades a mi lista 00:49:56
pero bueno 00:49:57
aquí hay ArrayList, LinkedList 00:49:59
y una comparativa entre ArrayList 00:50:05
y LinkedList, lo dejamos 00:50:06
por ahora aquí, al nivel de 00:50:08
teoría, porque si no es 00:50:10
mucho, lo que vamos a hacer 00:50:12
es un ejemplo usando estas 00:50:14
cosas de aquí y mañana 00:50:16
lo retomamos y vemos la 00:50:18
diferencia y cosas por el estilo y seguimos un poquito 00:50:20
¿vale? 00:50:22
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
17
Fecha:
3 de febrero de 2025 - 14:32
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
50′ 28″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
118.52 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid