Saltar navegación

20250211 RepasoColecciones_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 11 de febrero de 2025 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

pues esta es nuestra 00:00:00
entidad, vamos a ponerle 00:00:03
un constructor 00:00:05
con todo 00:00:06
y sin nada 00:00:09
muy bien 00:00:11
si tuviera además una propiedad 00:00:12
que fuera colección de algo 00:00:15
que fuera una colección 00:00:17
pues normalmente 00:00:19
se hacen constructores 00:00:21
sin incluir la colección 00:00:23
porque esa propiedad se suele inicializar 00:00:25
cuando ya está instancia el objeto 00:00:27
Pero bueno 00:00:29
Nada, olvida lo que he dicho 00:00:29
Pero qué cosas, estoy haciendo una 00:00:33
Venga 00:00:38
Constructor sin parámetros 00:00:42
Getty set 00:00:44
Punto pelota, y ahora una pequeña revisión 00:00:46
De todas las colecciones que hemos visto 00:00:48
E incorporando el tree set y el 00:00:50
Tree map 00:00:52
¿Vale? Para tener una revisión de todas 00:00:54
Y de cómo funcionan, para que las entendáis 00:00:56
Y nos vamos a quedar 00:00:58
muy a gusto 00:01:00
y nos vamos a ir muy satisfechos 00:01:01
todos 00:01:09
vale, esta es la entidad que vamos a meter en nuestras 00:01:09
cajitas, en nuestras colecciones 00:01:12
venga, pues a ver 00:01:14
las colecciones 00:01:15
recordad 00:01:18
así no vemos nada, vale 00:01:19
vale 00:01:22
vale, recordad que 00:01:28
las colecciones heredan 00:01:33
de una superclase suprema 00:01:35
que es Collection 00:01:37
¿vale? que es una interfaz 00:01:38
que ofrece unos 00:01:41
métodos básicos 00:01:43
que tienen que implementar todas las colecciones 00:01:44
que los métodos básicos ¿cuáles son? 00:01:47
pues meter en la colección 00:01:49
eliminar de la colección 00:01:51
y poco más 00:01:54
ofrece unos métodos básicos 00:01:55
entonces quien quiera ser una colección 00:01:56
tiene que implementar esta 00:01:58
interfaz dando 00:02:00
ya un comportamiento concreto. 00:02:03
Vale. Pues entonces, 00:02:05
aquí distinguimos que había dos 00:02:06
filosofías de colecciones. 00:02:08
Dos filosofías de colecciones. 00:02:10
Que son 00:02:13
las listas 00:02:14
y los conjuntos. 00:02:16
Estas son dos filosofías de colecciones. 00:02:20
Y las dos implementan colección. 00:02:23
¿Vale? Recordad 00:02:25
que lo que tienen todas en común, eso sí, 00:02:27
es que son dinámicas. 00:02:29
Dinámicas significa 00:02:31
que inicialmente cuando esa colección se instancia no tiene espacio para nada. 00:02:32
El espacio se va generando según vamos metiendo elementos, ¿vale? 00:02:37
Esa es la motivación de que existan, precisamente, ese comportamiento dinámico 00:02:43
que es el que no tiene el array. 00:02:49
El array haces tu caja con las posiciones y ahí se queda, ¿vale? 00:02:51
Bueno, pues con la motivación de generar una caja inicialmente sin espacio y pum, pum, pum, se va abriendo, se va más metiendo con esa motivación, se crean estas colecciones que, repito, heredan todas de la superclase colección. 00:02:55
Dos filosofías de construcción, dos filosofías de construcción, las listas y los conjuntos. Las listas, las listas ya sabemos por qué se caracterizan. Las listas se caracterizan porque cada objeto, cada objeto en la lista, cada objeto de la lista tiene una posición asociada y esa es la diferencia entre listas y conjuntos. 00:03:13
Y no hay otras 00:03:46
Lo que pasa es que eso luego tiene implicaciones 00:03:47
En cómo funcionan y en cómo se usan 00:03:50
Claro 00:03:52
Bueno, si tú no necesitas 00:03:53
Los objetos no 00:04:00
Tienen 00:04:04
Posición 00:04:06
Asociada 00:04:08
¿Vale? Esta es la diferencia fundamental 00:04:09
Entonces 00:04:12
¿Qué ocurre? 00:04:17
Que el llevar un registro de la posición en la que cae un elemento 00:04:19
implica pues cierta complejidad a la hora de programarlo. 00:04:23
Entonces, si realmente uno necesita almacenar las cosas 00:04:28
y el orden, la posición en la que ha caído cada cosa le da igual, 00:04:31
pues ¿para qué va a usar una lista? 00:04:35
Usa un conjunto. 00:04:37
Porque computacionalmente a la hora de ejecutarse todos los métodos que hay por debajo, 00:04:39
pues va a tardar menos, va a ser más eficiente. 00:04:43
porque no hay que llevar ese registro de las posiciones 00:04:46
que no lo llevamos nosotros, lo lleva la propia colección en sus métodos 00:04:50
que están programados, pero tiene una carga por debajo 00:04:53
vale, entonces 00:04:56
que en las listas cada objeto tenga una posición 00:04:58
implica automáticamente 00:05:02
esto, ¿verdad? 00:05:05
implica que puede haber duplicados 00:05:07
puede estar 00:05:09
el mismo objeto 00:05:16
varias veces 00:05:20
pero en diferentes posiciones 00:05:23
claro 00:05:27
en un mapa de 00:05:28
ahora el mapa 00:05:31
lo vemos después, pero en diferentes 00:05:34
posiciones, vale, en diferentes 00:05:35
posiciones 00:05:37
vale 00:05:38
sin embargo 00:05:39
en los conjuntos 00:05:43
uy, aquí no se me ha puesto la flecha gorda, que pena 00:05:45
ah, sí, ahora sí 00:05:49
Esto está mal expresado. 00:05:52
Sí, pero vamos, que esto es una esquemita para ir guiando. 00:06:16
Bueno, vale. 00:06:21
Y aquí es donde nos viene. 00:06:30
¿Pero qué es esto de el mismo objeto? 00:06:32
Ahora en nuestro ejemplo de pedidos. 00:06:36
¿Qué significa el mismo pedido? 00:06:38
Pues no lo sé. 00:06:41
Es algo que de nuevo decidimos nosotros. 00:06:42
¿Vale? 00:06:45
Para nosotros la idea de el mismo pedido, pedido igual a otro, lo tenemos que imponer nosotros desde fuera. 00:06:45
Porque la aplicación Java, la máquina virtual de Java, la aplicación no tiene ningún criterio sobre qué significa un pedido igual a otro. 00:06:55
Si nosotros no se lo damos ese criterio, ya sabemos cuál es el criterio de ser igual para Java por defecto. 00:07:04
Que es ser el mismo, estar en la misma dirección de memoria, el mismito. 00:07:11
¿Vale? Entonces 00:07:15
vámonos aquí. 00:07:17
Vale. 00:07:21
Vamos a hacernos aquí 00:07:24
un main, nuestro main 00:07:25
de pruebas para 00:07:27
poner todo esto, ¿verdad? 00:07:28
Entonces, esta clase 00:07:31
o al menos la 00:07:33
primera hora y media 00:07:35
va a ser un poco para tontos. 00:07:36
Espero que eso no os ofenda. 00:07:39
Porque estoy diciendo 00:07:47
Viedades que deberíais saber y deberíais decir 00:07:56
Otra vez lo mismo mil veces 00:07:59
Vale 00:08:00
Efectivamente, vale, entonces 00:08:01
Pedido P1 00:08:08
Entonces todas estas cosas 00:08:11
Por favor, si todo esto 00:08:12
Todo este repaso de hoy 00:08:14
Y todo esto lo tenéis clarísimo y lo sabéis aplicar en los ejercicios que hagamos jueves, viernes, incluso lunes que tenemos clase. 00:08:16
Pues deberíais hacer bien el examen. Es que yo no sé qué más necesitáis. 00:08:25
Aparte de un trasplante de cerebro. 00:08:28
Se están consiguiendo los primeros trasplantes de cerebro. 00:08:32
¿En serio? 00:08:36
Eso sí que me... Hombre, si hay zonas de cerebro. 00:08:37
Querían intentar trasplantar cabeza. 00:08:43
A ver, pedido, tenemos descripción, código, gomas, descripción, código, precio, 3,4 y fecha. 00:08:44
No, pero esta vez no va a ser así. 00:09:13
y mi promesa tiene el valor 00:09:16
que tienen las promesas 00:09:19
de las mujeres o de los profes 00:09:20
y la combinación de ambas ya 00:09:23
oye, la de mi padre era peor 00:09:25
siempre tenía la frase de prometer hasta meter 00:09:27
y cuando lo has metido a olvidar lo prometido 00:09:29
pues exactamente, esa es la idea 00:09:31
todos los padres del universo 00:09:32
venga, a ver 00:09:35
entonces 00:09:37
hablando estamos, recordad que estamos 00:09:38
en este concepto, el mismo 00:09:41
ahora, lógicamente 00:09:43
Todo el mundo, obviamente, sabe decirme que me muestra esto, ¿verdad? Obviamente, ¿no? Esto es un programa, todo el mundo sabe que me muestra esto, ¿verdad? ¿Qué me va a salir? ¿Me va a salir true? 00:09:45
me sale un falso como una casa 00:10:06
a esto voy, no puede ser 00:10:10
que a día de hoy me digáis true 00:10:12
porque entonces todo esto de colecciones 00:10:14
ya no vale para nada, ni lo de herencia 00:10:16
ni lo de nada 00:10:18
y luego decís 00:10:19
que Rosa se pone nerviosa 00:10:24
ya, pero es que 00:10:26
lo único que tienen que hacer para orientarse es 00:10:32
en casa, revisarlo 00:10:34
William, solo verte levantar la mano 00:10:36
es que me cago de miedo 00:10:39
así que 00:10:40
piénsate lo que vas a preguntar 00:10:42
no es el javasql, es javautil 00:10:45
vale 00:10:55
entonces, por dios, que me digáis 00:10:56
que esto no va a salir true a estas alturas 00:10:58
ya, pero vale 00:11:01
pero yo no lo he hecho 00:11:04
entonces todo el mundo tiene claro que esto sale 00:11:05
falso porque esta es una instancia 00:11:07
que está en una posición de memoria 00:11:09
esta es otra que está en otra posición de memoria 00:11:11
me da igual que los contenidos sean iguales 00:11:13
dos instancias, dos posiciones de memoria 00:11:16
con lo cual estos son 00:11:18
objetos distintos 00:11:19
claro, estos objetos cabrían 00:11:20
si yo meto los dos 00:11:24
en un set, entrarían los dos 00:11:25
claro que entrarían los dos perfectamente 00:11:27
porque son objetos distintos 00:11:29
y eso es lo que me dice aquí 00:11:30
la máquina virtual me dice son distintos 00:11:33
Pero en las aplicaciones tenemos que darle un sentido real y si estos pedidos tienen mismas propiedades es que son el mismo, me da igual que haya varias copias en la aplicación, son el mismo. 00:11:35
luego, vamos a darle ya un sentido real 00:11:46
entonces lo que nunca se nos olvida 00:11:50
es irnos a nuestra clase pedido 00:11:51
y decir, oye tú 00:11:54
te voy a hacer aquí un criterio de igualdad 00:11:55
implementándote 00:11:58
estoy idiota 00:12:01
ya, pero 00:12:07
no, pero no me lo imaginaba 00:12:11
Vale. 00:12:17
Venga. 00:12:19
Vale, entonces, nuestro criterio, 00:12:22
a esto ya lo decidimos, 00:12:25
hablándolo con el que nos ha pedido la aplicación. 00:12:26
Pues, hombre, el ID, para eso hay un ID. 00:12:28
Pues, nada, hasco de equals con el ID. 00:12:31
¿Vale? 00:12:33
¡Hala! 00:12:35
Ahora ya sí, todo el mundo me sabe decir 00:12:36
que esto, lógicamente, 00:12:39
si vuelvo a ejecutar este mismo código, 00:12:41
ahora sí que sale true. 00:12:43
Sale true, aunque yo ponga aquí bolis, 00:12:45
con muchas eses, ahora ya todo el mundo 00:12:48
sabe decirme que esto claro que va a salir true 00:12:50
¿vale? 00:12:52
bueno 00:12:56
hasta aquí hemos llegado ¿no? 00:12:56
todo esto venía a cuento de que 00:12:58
significa mismo objeto 00:13:00
o distinto objeto 00:13:02
¿vale? bueno está claro 00:13:03
vale, pues entonces esta es la diferencia 00:13:06
entre listas y conjuntos 00:13:08
ahora ya, dentro de las listas 00:13:10
que admiten posición 00:13:12
hay dos implementaciones 00:13:13
distintas 00:13:16
vale, dos implementaciones 00:13:17
vale, pues nos vamos 00:13:19
ahora con las listas 00:13:21
las listas 00:13:23
las listas son implementaciones 00:13:27
lógicamente 00:13:29
de list 00:13:30
y hay dos implementaciones 00:13:31
entre las cuales podemos 00:13:37
elegir, está esta 00:13:39
y esta otra 00:13:42
vale 00:13:44
y las dos son listas 00:13:47
luego las dos meten los elementos 00:13:49
en una posición en concreto 00:13:51
y las dos me permiten recuperar por posición 00:13:53
todo eso 00:13:56
que a mí ese comportamiento me interesa 00:13:57
porque yo quiero tener 00:13:59
cada elemento en una posición 00:14:01
porque me facilita la vida 00:14:03
pues 00:14:05
uso una lista y se acabó 00:14:07
vale, me la puede 00:14:10
ya, es que tú eres 00:14:11
el adorador de los Arrays 00:14:14
pero alguna vez tendrás que superar la fase Array 00:14:15
Sí, a ver, pero lo que es cierto 00:14:18
es que con un array tú tienes el control 00:14:30
de todo y siempre tener el control 00:14:31
va a conducir a programas computacionalmente 00:14:33
mejores 00:14:35
Es como que me preocupo ya de cómo está funcionando 00:14:36
Claro, todo esto 00:14:39
y todas las capas, de aquí a 00:14:41
segundo, bueno, y en segundo sobre todo 00:14:43
las capas que irán cayendo 00:14:45
entre otras, que si JBC, que si 00:14:47
no sé, Bernate, que si Spring, que si 00:14:49
Patatín. Todas las capas se van poniendo una sobre otra. 00:14:51
Y Bernate es más importante. 00:14:53
Sí. Y Spring, que va por encima 00:14:55
también. Pues todas esas capas 00:14:57
que vamos poniendo, pa, pa, pa, pa, pa. 00:14:59
Su único objetivo es que sea 00:15:00
más fácil desarrollar. Pero en 00:15:03
todas pierdes el control de la aplicación 00:15:05
y todas las cargas computacionalmente. 00:15:06
Que es justo lo que a ti no te gusta. Pero están 00:15:08
todas orientadas a eso. A facilitar el desarrollo. 00:15:11
Porque como ahora el problema no es tanto 00:15:13
la velocidad de los CPUs. 00:15:14
Pero vamos a tener programadores buenos. 00:15:17
Vais a ser los mejores gracias a que vais a conocer 00:15:18
Todas esas herramientas 00:15:22
Ay William 00:15:23
No me tiene muy nerviosa 00:15:24
A ver este año hay muchos 00:15:29
Porque hay muchos con pendientes de primero 00:15:33
De con programación pendiente 00:15:34
Eso no va a volver a ocurrir 00:15:36
Porque este año solo podéis pasar ya 00:15:39
Los que no tengáis 00:15:41
Quien suspenda la programación ya no puede pasar 00:15:42
Se va a quedar en primero sí o sí 00:15:45
Entonces, ¿cuántos habrá en segundo? 00:15:46
Pues dime, ¿cuántos vais a aprobar en programación? 00:15:47
Esos serán los que estéis en segundo. 00:15:48
Claro, a ver, es que no va a ocurrir 00:15:52
que apruebes una y suspendas la otra, 00:15:54
porque el examen que hacemos te evalúa a los dos. 00:15:55
¿Vale? 00:15:59
Entonces, estaréis en segundo los que aprobéis aquí programación, 00:15:59
porque entiendo que los que aprobéis programación, 00:16:02
sí, porque aunque suspendierais bases de datos, 00:16:04
que es la otra que igual se puede suspender, 00:16:06
se puede pasar a segundo con bases de datos. 00:16:08
Esperemos que no. 00:16:12
¿Vale? 00:16:14
hombre, a ver 00:16:16
no lo sé, o sea, cuántos han sido 00:16:21
si tu pregunta es cuántos han sido 00:16:24
el menor número de alumnos que he tenido 00:16:25
aprobados de programación en junio 00:16:27
pues al final siempre se levanta la mano 00:16:29
y 10 alumnos 00:16:31
yo creo que 8 00:16:33
alumnos es lo mínimo que he tenido aprobados en junio 00:16:35
después de ordinaria y extraordinaria 00:16:38
es lo menos, que normalmente tengo alguno más 00:16:39
pero este año no te va a pasar tampoco 00:16:41
Venga 00:16:44
A ver 00:16:51
Vale 00:16:52
¿Por qué no os puede a vosotros 00:16:54
Ahora en particular de cara al examen 00:16:59
¿Qué es lo que más os importa ahora 00:17:01
De cara al examen? 00:17:03
Silencio 00:17:05
Ahora mismo 00:17:06
No os vamos a evaluar para que decidáis 00:17:08
¿Qué colección elijo? 00:17:11
¿Un lis, un set? 00:17:12
No, os vamos a decir 00:17:13
hazme un list con no sé qué, hazme un set 00:17:14
entonces ahora mismo de lo que vamos a evaluar 00:17:16
es que sepáis usarlas 00:17:18
¿vale? que las uséis bien 00:17:20
no tanto, ¿qué colección 00:17:22
elegirías? que no sé qué, pero aún así tenéis criterios 00:17:25
suficientes para elegirlo, ¿vale? dime 00:17:27
si por ejemplo te dicen que use 00:17:28
un headset, por ejemplo 00:17:30
y yo no he usado 00:17:32
pues está jodido, ya está 00:17:33
una red y si uso un link 00:17:36
pues tenés un cero, si yo te he puesto un ejercicio 00:17:38
y te dije usar un headset y me lo haces 00:17:40
con un triset, pues no vale 00:17:42
no vale 00:17:44
y no vale nada 00:17:45
pues seguramente 00:17:47
claro 00:17:49
por ejemplo 00:17:50
claro, a ver, te ibas a preguntar algo 00:17:54
vale, a ver 00:17:57
por ejemplo, pero tenéis criterio suficiente 00:18:00
para saber cómo elegirlo 00:18:03
o sea, una lista, por supuesto, es cuando me interesa la posición 00:18:05
y cuando me puede interesar una posición 00:18:07
por ejemplo, cuando el orden 00:18:09
sea algo interesante 00:18:11
en mi aplicación 00:18:13
claro, pues por ejemplo 00:18:14
imagínate que yo quiero 00:18:17
tener aquí los pedidos 00:18:18
ordenados por 00:18:20
por lo que sea, por descripción 00:18:22
por lo que sea, entonces la lista 00:18:25
al ser una fila, porque no deja de ser una fila 00:18:26
en la lista, el sentido 00:18:29
lo del orden tiene un sentido 00:18:30
no, pero tú ordenas 00:18:32
como te da la gana, una cosa es 00:18:35
claro, en la lista son todos en fila 00:18:36
con lo cual hay un orden 00:18:39
en la propia lista 00:18:41
por el hecho de que no tiene una posición 00:18:43
entonces, tú tienes ya la ventaja 00:18:44
de que la iteración la puedes 00:18:47
hacer en ese orden 00:18:49
entonces, tiene sentido ahí plantearse 00:18:49
cosas como, oye 00:18:52
voy ahora a cambiar los elementos 00:18:54
de la lista y ponerlos ordenados 00:18:57
por orden de 00:18:58
alfabético de nombre o de descripción 00:19:00
pues nada, los tienes ahí cambiaditos 00:19:02
que para eso está el método sort 00:19:04
que alguna vez usamos 00:19:07
que ahora vamos a usar otra vez para verlo 00:19:08
hay listas y un método de sort, ¿no? 00:19:11
Justo. Entonces, el orden, 00:19:12
cuestiones relacionadas con el orden de la fila 00:19:15
tienen sentido en una lista, en un set, ¿no? 00:19:17
Ahí no hay ningún orden en un set, porque están todos a mogollón. 00:19:19
Entonces, cuando 00:19:22
cosas como, ideas como 00:19:23
tener las cosas ordenadas 00:19:25
importe a tu aplicación, 00:19:26
pues dices, hombre, pues un list. 00:19:29
Un list porque en mi aplicación tener las 00:19:31
cosas ordenadas me puede interesar para la 00:19:33
funcionalidad tal, por ejemplo. 00:19:35
Pero si a mí tener las cosas 00:19:37
ordenadas en filita 00:19:39
me da igual 00:19:41
realmente, pues entonces 00:19:42
uso un set y ya está. 00:19:44
¿Vale? Eso en cuanto a 00:19:47
criterios de... 00:19:49
¿Vale? 00:19:51
La lista 00:19:54
también, ¿qué ventaja tiene? 00:19:56
Hombre, que tú puedes recuperar 00:19:58
por posición. Imagínate 00:20:00
que tienes la lista ordenada por ID 00:20:02
y tienes un, dos, tres, cuatro y cinco. 00:20:04
Y dices, oye, quiero el cinco. Pues dices 00:20:06
Get, el de posición 5, y ya lo tienes 00:20:08
Entonces, el que los elementos en la lista 00:20:10
Estén uno detrás de otro, cada uno con un numerito 00:20:13
Que yo soy el 0, yo soy el 1, yo soy el 2 00:20:15
En orden, puede facilitarte 00:20:16
Algunas cosas, en función de las 00:20:19
Funcionalidades que tú tengas que hacer 00:20:21
Entre ellas, esto que digo 00:20:22
Tener un orden, para que luego al recorrer 00:20:24
Tengas tú un listado en orden 00:20:26
O recuperar por posición, si es que sabes 00:20:27
En qué posición está el que te interesa 00:20:31
Entonces, ese tipo de cosas, si importan 00:20:32
En tu aplicación 00:20:35
por la naturaleza de los objetos 00:20:36
con los que trabajas, 00:20:39
pues genial, coges un list y ya está. 00:20:41
Si eso no importa nada y da lo mismo, 00:20:42
pues coges un set, todos ahí y se acabó. 00:20:44
Vale, pues entonces, 00:20:47
listas. 00:20:49
Listas hemos decidido, aquí tienen un orden, 00:20:50
nos importa. Implementaciones, ArrayList y LinkList. 00:20:52
Las dos se usan 00:20:55
exactamente igual. 00:20:57
Diferencias, 00:21:00
cómo funcionan por dentro. 00:21:01
Nada más, ArrayList, ya sabemos que los elementos están en un Array 00:21:02
y el ArrayList se encarga de hacer sus 00:21:05
hechos y desechos. Y el LinkedList 00:21:07
es la lista enlazada que hemos programado. 00:21:09
Pero funcionan igual. Entonces, ahora ya 00:21:11
en mi main de pruebas este. 00:21:13
¿Vale? Espera, lo voy a poner 00:21:19
un método aparte. 00:21:21
Prueba listas. 00:21:31
¿Vale? Pues yo me quiero hacer una lista 00:21:33
de pedidos. Repito, 00:21:34
yo me puedo 00:21:38
hacer esto. ¿Vale? 00:21:39
¿Cómo le gusta usar la lista? 00:21:41
Sí, es una manía 00:21:42
¿Es bueno o malo? 00:21:45
Es bueno y malo 00:21:47
En este caso es bueno 00:21:49
Porque 00:21:51
De list a write list 00:21:51
Hay solo un salto 00:21:55
No tiene mucho 00:21:56
Pero 00:21:58
Sí, porque si yo pongo aquí 00:21:59
Ahora incidimos en ello 00:22:04
Pero vamos de nuevo a lo de genérico 00:22:06
Cada vez que me acuerdo que William me lo preguntó ayer 00:22:08
Me vuelvo a poner nerviosa 00:22:10
A ver, podemos hacerlo así, ¿vale? Ya sabemos la implicación que tiene, ¿verdad? Sin parametrizar que en pedidos puedo meter lo que me dé la gana. Puedo meter un numerito si quiero. No está pensada esta lista para meter numeritos, está pensada para meter objetos pedidos. 00:22:11
sí, ya vale 00:22:31
pero si yo quiero una lista 00:22:35
de pedidos 00:22:37
normalmente yo organizo los datos 00:22:38
de manera un poquito homogénea 00:22:41
no todos a mogollón 00:22:43
en el mismo sitio, es como las bases de datos 00:22:44
tú no haces una tabla 00:22:47
con un montón de campos y ahí hay registros 00:22:49
pero a este registro le interesan estos campos 00:22:51
no, te haces un diseño de base 00:22:53
de datos lo más desacoplado posible 00:22:55
cada tablita significa su cosa 00:22:57
pues aquí es lo mismo, tú te haces tus colecciones 00:22:59
y cada colección es para un tipo 00:23:01
de objetos, porque si no lo haces así 00:23:03
te sale un galimatías de aplicación 00:23:05
entonces no es este el uso que solemos 00:23:07
hacer, sino parametrizando la lista 00:23:09
y diciendo, eh ojo 00:23:11
que yo lo que quiero es guardar pedidos 00:23:13
y para eso hago esto 00:23:15
vale, repito 00:23:17
aquí lo mismo 00:23:19
puedo poner la super clase 00:23:21
y si pongo la super clase 00:23:24
y a mí me da la gana de repente cambiar 00:23:26
porque digo, uy, espérate, ahora me interesa 00:23:28
más una linked list 00:23:30
pues cambio 00:23:31
y no pasa nada 00:23:33
no pasa nada, ¿vale? 00:23:35
pero si aquí 00:23:39
he comprometido 00:23:40
ya el tipo 00:23:42
y ahora decido que cambio 00:23:43
y digo, no, me interesa más instanciar 00:23:46
un array list, pues tengo que venirme aquí 00:23:48
a cambiar 00:23:50
aquí en este caso está en la misma línea, no es mucho trabajo 00:23:50
pero podríamos estar en otra situación 00:23:54
y es que estoy en el parámetro 00:23:56
de un método 00:23:59
y le estoy pasando de otro sitio 00:23:59
entonces yo cambio 00:24:03
la instancia que le paso y me tengo que ir a la declaración 00:24:05
del método para cambiar 00:24:07
el tipo de dato que está en el método 00:24:09
entonces cuando es un parámetro de un método 00:24:11
cuando es un parámetro de un método 00:24:13
aquí sí que tiene especial trascendencia 00:24:15
ponerlo como la super clase 00:24:17
porque 00:24:21
a saber quién me va a llamar y de dónde 00:24:22
a lo mejor a uno le interesa pasarme una release 00:24:24
que a lo mejor a otro le interesa pasarme un linked list 00:24:27
es que no lo sé, porque quienes me van a llamar a mí 00:24:29
a saber dónde están 00:24:31
claro, si el método es independiente te da igual 00:24:32
claro, entonces 00:24:34
a la hora de hacer parámetros de los métodos 00:24:35
aquí sí, cuanto más super clase 00:24:39
seas, mejor 00:24:41
porque más les dejas a cualquiera 00:24:42
les dejas a los array list llamarte 00:24:45
les dejas a los linked list 00:24:47
pero si yo en parámetro del método 00:24:48
solo pongo esto, solo dejo 00:24:50
llamarme a los que hayan instanciado 00:24:52
como linked list, con lo cual 00:24:54
entonces aquí es donde puede tener más trascendencia 00:24:56
si lo declaras como parámetro de método 00:24:59
¿vale? pero aquí 00:25:01
en este caso que estamos declarando a la vez que 00:25:03
instanciamos donde estamos en la misma línea 00:25:05
pero bueno, como yo efectivamente tengo 00:25:06
esa manía de siempre 00:25:09
declarar como superclase e instanciar 00:25:10
como subclase, claro 00:25:13
¿cuál es el problema de declarar 00:25:16
como superclase e instanciar 00:25:18
como subclase? 00:25:20
que luego el compilador cuando yo llamo a métodos 00:25:22
solo me 00:25:24
permite llamar a los métodos de la 00:25:26
superclase. 00:25:28
Pero es que en list están 00:25:30
todos los que están en ArrayList 00:25:31
y LinkedList 00:25:34
incorpora algunos. Que entonces ahí sí que 00:25:36
tendría un problema, pero eso lo vemos ahora después. 00:25:38
¿Vale? Bueno, pues entonces 00:25:40
aquí, repito, me da 00:25:41
igual. Voy a 00:25:44
hacer de hecho dos 00:25:46
una con LinkedList 00:25:47
y otra con Array. ¿Vale? 00:25:50
Pedidos uno, 00:25:53
pedidos dos. ¿Vale? 00:25:54
Y para ver bien los métodos distintos de una y otra, las voy a instanciar como la suya. 00:25:56
Las voy a instanciar como la suya. 00:26:07
En el examen es que da igual como lo hagáis. 00:26:08
Vale, pues entonces, ¿a qué me da igual usar esta colección que esta? 00:26:11
Me da igual a efectos de uso. 00:26:16
Porque la voy a usar igual, porque valen para lo mismo. 00:26:19
Y aquí se trata simplemente de ver los métodos que me ofrece y ya está. 00:26:22
Y yo ya elijo lo que quiero hacer. 00:26:25
¿Pero por qué no? 00:26:31
A ver, y si no, ¿cómo vais a ver esto de aquí 00:26:33
si no pongo la lupa? 00:26:35
Hombre, 00:26:37
para esto hace falta la lupa. 00:26:39
Vale, entonces, me da igual 00:26:42
que sea ArrayList que LinkedList. 00:26:43
La mayoría de los métodos 00:26:46
son comunes. 00:26:47
Entonces, ahora estoy en ArrayList en particular. 00:26:49
ArrayList puedo añadir 00:26:52
un objeto entero. Eso ya lo sabemos, 00:26:53
por supuesto. Puedo añadirlo 00:26:55
en una posición. 00:26:57
Si no lo añado en una posición 00:26:58
Sabéis que se añade 00:27:01
Después del último añadido 00:27:02
Primero el 0, luego el 1, luego el 2 00:27:04
Puedo añadir con add all 00:27:06
Otra colección enterita que yo tenga 00:27:08
Y se añaden todos, uno detrás del otro 00:27:10
¿Verdad? 00:27:13
Es decir 00:27:14
Si añades en una posición ya ocupada 00:27:15
El método de añadir te desplaza 00:27:17
Sí, te desplaza 00:27:20
Hacia atrás 00:27:21
Entonces, por ejemplo 00:27:22
El método de esto es ver la descripción 00:27:25
De lo que me hace cada uno 00:27:27
si yo hago add all 00:27:28
y le doy otra colección 00:27:31
que puede ser incluso un set, puede ser 00:27:33
cualquier colección, pues coge 00:27:34
los elementos de esa colección, los va cogiendo 00:27:36
uno tras otro y los va 00:27:38
metiendo uno tras otro 00:27:40
en la lista, entonces ya está 00:27:42
se trata de ver los métodos que tiene 00:27:44
en este caso ArrayList que es el que estamos mirando 00:27:46
y son 00:27:49
esos, no hay mucho 00:27:50
no hay mucho 00:27:52
aquí que 00:27:55
que rascar 00:27:56
pues añadir, añadir de golpe 00:27:57
añadir muchos de golpe 00:28:02
cualquier colección 00:28:03
pero en medio, en una posición 00:28:04
con lo cual se irán hacia atrás los que estaban en esa posición 00:28:07
pero entonces se pierde 00:28:10
no se pierde, se desplazan hacia atrás 00:28:11
de todas formas las explicaciones siempre 00:28:13
están aquí 00:28:15
entonces, mira a ver, desplaza 00:28:17
el elemento en esa posición 00:28:19
¿vale? 00:28:21
¿Para qué lo quieres poner en español? 00:28:23
¿Para qué lo quieres poner en español? 00:28:25
Pues creas tú el método 00:28:27
A ver, te lo traduces 00:28:29
Pero vamos, quien no entienda 00:28:31
Inglés hoy en día 00:28:33
No, yo no digo por mí, digo por los demás 00:28:34
Claro 00:28:36
Vale 00:28:36
Añadir el primero 00:28:40
Añadir el último 00:28:44
Añadir el último es 00:28:46
Es el mismo método 00:28:47
Barrer, limpiar la colección 00:28:48
Y tirar a la basura 00:28:53
Hacer un clon de ese objeto 00:28:54
Bueno, es que este será de objeto, da igual 00:28:56
Este 00:28:57
Interesante 00:28:59
El contains 00:29:01
Método interesante 00:29:02
¿Vale? 00:29:05
Le pasas un objeto 00:29:07
Y te dice si existe un objeto 00:29:08
Igual a ese en la colección 00:29:11
¿Vale? 00:29:13
No, porque un equal sería 00:29:20
Para verse una colección 00:29:21
Es igual a otra, ¿no? 00:29:23
Esto es para ver si dentro 00:29:24
este es un método con things de la colección 00:29:26
es decir 00:29:28
vamos a 00:29:29
claro, pasa por cada uno y en cuanto 00:29:30
encuentre uno que es igual 00:29:33
por ejemplo, en pedidos 1 00:29:34
vamos a añadir un nuevo pedido 00:29:37
vamos a añadir este pedido 00:29:39
de aquí 00:29:41
vale 00:29:42
por ejemplo 00:29:48
vale, claro 00:29:51
por ejemplo, añadimos un nuevo pedido 00:29:56
este de aquí, ahora 00:29:58
¿qué hace este 00:30:00
método? pedidos 00:30:02
1.contains 00:30:05
y ahora yo le tengo 00:30:07
que pasar un objeto pedido 00:30:08
pues por ejemplo, voy a crear un objeto 00:30:10
pedido por aquí, otro 00:30:12
pedido p 00:30:13
igual a 00:30:16
new pedido 00:30:18
le voy a poner 00:30:19
menos el id 00:30:22
todo lo demás 00:30:24
cualquier cosa 00:30:25
vale, este es el nuevo pedido 00:30:27
que acabo de crear, con id1 00:30:30
lo demás, y ahora 00:30:32
si hacemos esto 00:30:34
si hacemos esto, ya sabemos todos 00:30:37
que nos va a salir 00:30:45
true, porque 00:30:46
pedidos1 contiene 00:30:49
un pedido al menos 00:30:51
1 al menos igual que p 00:30:53
porque recordad que la igualdad 00:30:55
la hemos implementado aquí 00:30:57
y es por el id 00:30:59
y este id es el mismo que este 00:31:00
vale, si no hubiéramos 00:31:02
implementado el jasco de equals 00:31:05
pues saldría falso, lógicamente 00:31:07
aquí me sale true 00:31:09
espérate que 00:31:11
algo me falta por aquí 00:31:12
donde tengo aquí 00:31:15
el, ah 00:31:19
vale 00:31:20
prueba listas 00:31:21
ahí 00:31:24
vale, a ver 00:31:27
esto ya lo voy a comentar 00:31:31
vale, pues aquí tenemos claro que si ejecutamos 00:31:33
esto, me sale true 00:31:41
está claro 00:31:42
pero si hubiéramos comentado 00:31:43
si esto no lo tuviéramos 00:31:47
este equals 00:31:49
no lo tuviéramos, porque la lista 00:31:51
tanto Raylist como LinkedList 00:31:52
solo tiran de equals 00:31:54
solo, me da igual, para ver la igualdad 00:31:56
solo, el hashcode como si no existiera 00:31:59
le da lo mismo 00:32:01
vale, entonces si este equals no existiera 00:32:01
por id 00:32:05
vale, que es como comprueba por id si este 00:32:06
equals no existiera 00:32:08
y yo ahora hago esto de aquí, pues lógicamente 00:32:09
me sale false como era de esperar, porque no hay 00:32:12
un pedido igual a este 00:32:14
porque la igualdad es la dirección de memoria 00:32:15
y la dirección de memoria de p, no es la dirección de memoria 00:32:18
del que está en la lista 00:32:20
claro, vale 00:32:21
entonces, importante 00:32:23
la igualdad 00:32:26
en las clases list, array list 00:32:27
linked list, se hace solo 00:32:30
basada en el equal, solo, el hash code 00:32:32
no sobra 00:32:34
vale, pues el contains 00:32:35
todo esto venía a cuento, de que más métodos 00:32:38
interesante tiene list, array list 00:32:40
en este caso, pues contains 00:32:42
que ya lo tenemos claro, contains 00:32:53
all es lo mismo, pero le pasas 00:32:55
una colección entera de objetos, y te dice 00:32:57
si contiene objetos iguales 00:32:59
al menos uno igual 00:33:01
a todos y cada uno de ellos 00:33:03
aquí, bueno, es 00:33:05
get 00:33:07
¿vale? 00:33:11
get, este es el que 00:33:16
está en listas que no está en conjuntos 00:33:18
que es recuperar por posición 00:33:20
¿vale? 00:33:22
¿qué me permite el get? 00:33:24
pues iterar con un for de índice 00:33:26
el get, este get por posición es el que no 00:33:28
está en conjuntos, entonces 00:33:30
vamos a suponer 00:33:32
que yo aquí en pedidos le vamos 00:33:34
a meter 00:33:36
un par de ellos por lo menos 00:33:36
este 00:33:40
vale 00:33:49
entonces podemos iterar 00:33:51
como si fuera casi un array con un for de índice 00:33:53
desde igual a 0 00:33:56
mientras si sea menor que 00:33:57
pedidos 00:33:59
1.6 que es el método 00:34:01
para el tamaño de una colección 00:34:03
incrementando y 00:34:05
pues ahora ya 00:34:06
puedo mostrar 00:34:08
pues lo que quiera 00:34:11
pues pedidos 1.get 00:34:12
de y 00:34:15
porque el get es el que me saca por posición 00:34:17
y aquí pues lo que 00:34:19
yo quiera mostrar, como no tengo un toString 00:34:21
pues bueno, voy a mostrar la descripción 00:34:23
por ejemplo 00:34:25
vale, entonces 00:34:26
esto me permite hacer un recorrido 00:34:28
con for de índice y que ventaja tiene 00:34:31
pues que me puedo parar, no tengo por qué recorrer 00:34:34
la entera, puedo empezar en lugar de encero 00:34:37
en la posición que yo quiera, puedo acabar antes 00:34:39
el recorrer con índice 00:34:42
me permite elegir 00:34:44
mi recorrido, si lo hago por toda la colección 00:34:45
lo hago en parte, etcétera 00:34:48
vale 00:34:50
aquí pues efectivamente 00:34:50
recorremos y aquí lo tenemos 00:34:54
los dos 00:34:55
vale 00:34:56
pero también puedo recorrer con un for each 00:34:58
como los arrays 00:35:01
y en ese caso pues recorrería así 00:35:03
para cada pedido 00:35:05
pedidos 00:35:10
pues ped 00:35:12
punto de descripción 00:35:19
vale 00:35:22
entonces también puedo recorrerla con un for each 00:35:22
pero si la recorro con un for each 00:35:26
tengo el problema 00:35:28
que ya tenemos de los for each 00:35:30
que aquí no puedo elegir 00:35:31
donde empiezo y donde acabo el recorrido 00:35:34
se hace al completo 00:35:36
no como aquí que yo puedo elegir 00:35:38
con el índice, se hace al completo 00:35:40
vale 00:35:41
pero el recorrido lo hago igualmente 00:35:43
y como veis además en el orden al que inserté 00:35:45
lógicamente porque tienen orden 00:35:48
¿vale? 00:35:49
métodos 00:36:01
más métodos de ArrayList 00:36:01
que nos interesen 00:36:04
porque no se trata de verlos todos 00:36:09
lógicamente, pues eso ya lo podéis ver vosotros 00:36:11
pues 00:36:13
bien, te hemos visto recorrer 00:36:16
sácame el primero 00:36:19
sácame el último, estos son heredados de 00:36:21
object, nada, este 00:36:23
interesante también 00:36:25
te devuelve en qué posición está el primer objeto que encuentre igual a otro, ¿vale? 00:36:27
El index of también es interesante, ¿vale? 00:36:36
Index of, por ejemplo, si nosotros usamos el index of aquí, 00:36:42
por ejemplo, vamos a hacernos este pedido P que ya lo tenemos. 00:36:48
Si yo ahora llamo a pedido y le digo, oye, index of P, 00:36:51
p pues que me va a mostrar esto que me va a devolver lo vamos a mostrar lo que me devuelve 00:36:57
pues me va a devolver y voy a mostrar la primera posición en la que ha encontrado dentro de esta 00:37:09
colección un objeto igual a este según el criterio de igualdad en mi caso p tiene índice 1 luego me 00:37:16
ha de volver la posición 0 porque es donde he insertado yo el objeto con índice 1 lo 00:37:24
insertado el primero, luego está en la 0 00:37:29
¿vale? 00:37:31
entonces me va a devolver 0 cuando ejecute 00:37:33
esto 00:37:35
y aquí está el 0 00:37:36
¿vale? si 00:37:39
un segundín 00:37:40
si aquí ap un segundo 00:37:43
lo cambiara por 00:37:45
justo 00:37:46
claro, cuando lleguemos a la r 00:37:49
si lo vuelvo a 1 00:37:50
¿por qué le he puesto el de índice 2? pues 00:37:53
el de índice 2 te lo he encontrado en la posición 1 00:37:55
entonces todas estas cosas relacionadas con las posiciones 00:37:57
nos pueden facilitar 00:37:59
la vida 00:38:02
si usamos vistas 00:38:03
y en conjuntos todo esto no está 00:38:05
todos los metros relacionados con posiciones en conjuntos no está 00:38:07
al final te da igual la posición porque borras 00:38:09
primero que tengas el criterio de igualdad y ya está 00:38:11
ya pero al no tener 00:38:13
la ayuda de la posición 00:38:16
tienes que iterar 00:38:17
aquí una vez que has encontrado la posición 00:38:18
el elemento puedes con él borrarlo 00:38:21
lo que quieras 00:38:23
no porque tienes el 00:38:23
IndexOf, por ejemplo. 00:38:27
Claro. 00:38:29
Eso sí. 00:38:31
Pero estamos hablando de que... 00:38:33
Sí, pero tú de nuevo siempre estás 00:38:34
en lo que hace por dentro. 00:38:35
Estamos hablando de facilidad de código. 00:38:37
Si por dentro son galimatías todas. 00:38:39
Vamos a... 00:38:42
¿Qué te facilita la escritura de código? 00:38:43
Nada más. 00:38:45
¿Vale? Nada más. 00:38:46
Tú ibas a preguntar algo. 00:38:47
IndexOf, 00:38:52
tú le pasas un objeto 00:38:53
y te devuelve 00:38:55
la primera posición en la que 00:38:56
encuentra un objeto igual a este 00:38:58
en esta colección. 00:39:01
Bueno, porque yo ahora he hecho 00:39:06
una segunda prueba en la que le he puesto 00:39:07
el 2 00:39:09
a pedido. Entonces, 00:39:09
la posición 2, o sea, el pedido 00:39:13
con índice 2, lo he encontrado 00:39:15
en la posición 1, porque es el segundo que metí. 00:39:17
O sea, este está en la 00:39:20
posición 0 y este en la posición... 00:39:21
Eso. Vale. 00:39:23
Entonces, el tener la posibilidad de jugar con las posiciones, pues es la que, por ejemplo, nos permite, ¿vale? 00:39:25
Index of, ¿vale? 00:39:41
El index of me devuelve la primera posición, dime. 00:39:45
A ver, sí, saber programar con ellas. 00:39:58
En general. 00:40:01
Todo, salvo no te vamos a evaluar de que seleccione esto una u otra 00:40:03
en función de criterios de diseño de mi aplicación. 00:40:09
Pero todo lo demás sí. 00:40:12
Todo lo demás, usarles correctamente, 00:40:15
decidir qué métodos tienes que usar para conseguir lo que quieras, 00:40:18
programar con ellas. 00:40:21
¿Vale? 00:40:23
Vale, a ver. 00:40:24
Seguimos con los métodos. 00:40:27
index of te devuelve la primera 00:40:31
posición, pero 00:40:34
laxt iterator, esto lo vamos a dejar por ahora 00:40:36
bueno, y SEMTI está claro, si la colección tiene elementos 00:40:38
o está vacía 00:40:41
la primera colección que cumpla 00:40:41
laxt index of te devuelve 00:40:43
index te devuelve el primero 00:40:47
en el que ha encontrado igualdad, pues laxt 00:40:48
index of te devuelve el último que ha encontrado igual 00:40:50
de los iterator nos olvidamos 00:40:53
por ahora, porque 00:40:55
andamos escasitos de tiempo 00:40:56
ahora cuando al final se nos da tiempo 00:40:58
Vale 00:41:00
Entonces el tema de los índices 00:41:02
Nos ahorra el tema del borrar 00:41:04
En una colección 00:41:06
Al menos yo no lo veo aquí 00:41:11
Pero tú puedes hacer unos sucesivos 00:41:13
Claro 00:41:16
Tú te metes en un while y vas 00:41:17
While get, while get, while get 00:41:19
Y vas sacando 00:41:21
Vale, remove 00:41:22
Pues borras por posición 00:41:24
Esto no lo tendrías en un set, lógicamente 00:41:25
Porque en un set no hay posición 00:41:28
El remove está sobrecargado 00:41:29
Puedes borrar diciendo 00:41:32
Bórrame el de posición 3 00:41:33
O puedes borrar pasando en un objeto 00:41:35
Son dos versiones distintas 00:41:37
Claro, si tú le dices 00:41:39
Bórrame este objeto 00:41:41
Te borra el primero que encuentre 00:41:43
Igual a ese, pero solo el primero 00:41:46
¿Vale? 00:41:48
Es decir 00:41:50
Si sabes la posición, sí 00:41:50
Si quieres, claro, depende de lo que tú quieras hacer 00:41:55
Por ejemplo 00:41:58
Vamos a ver lo de los borrados ahora 00:41:59
Por ejemplo, vamos a meter el primer objeto 00:42:02
Este de aquí, lo vamos a meter dos veces 00:42:04
En la posición 0 00:42:06
Y en la posición 2 00:42:09
El mismo objeto con el mismo índice 00:42:10
Ha metido dos veces 00:42:12
Entonces, y ahora 00:42:13
Este objeto P 00:42:15
Le vamos a dar uno 00:42:16
Vale, a ver 00:42:19
Atentos a esto 00:42:21
Vale, mi objeto P tiene el índice 1 00:42:22
Luego es igual al primero 00:42:26
y al tercero, es igual de posición 0 00:42:27
y al de posición, vale, pues vamos 00:42:30
a mandárselo a borrar 00:42:32
vamos a decir, pedidos1.remove 00:42:33
y ahora después de haberlo 00:42:37
borrado, vamos a volver a iterar 00:42:40
para recorrer la colección, a ver que tiene 00:42:41
habrá borrado 00:42:43
solo el primero 00:42:46
la colección 00:42:47
tenía bolis, gomas, bolis 00:42:54
y después del borrado 00:42:56
ha borrado solo el primero, ha borrado 00:42:57
el primero que se ha encontrado 00:43:00
igual, este remove 00:43:02
borra 00:43:04
solo el primero, vale 00:43:06
lo que pasa es que, si tú los quieres borrar 00:43:14
todos, tienes que meterlo en un bucle 00:43:16
pero tiene la deferencia 00:43:18
de devolverte 00:43:19
un boolean, como valor de control 00:43:23
que tú puedes usar o no, claro, que es true 00:43:25
si ha borrado alguno 00:43:27
o false y no encontró ninguno 00:43:28
entonces, esto es tan fácil 00:43:30
como hacer esto 00:43:33
bucle hasta que se haga. Justo. Esto es tan fácil 00:43:34
como hacer esto. Terminado. 00:43:36
Claro, porque ya te hace el bucle. 00:43:41
Claro. A ver, tú haces un while 00:43:43
y como condición 00:43:45
pones esto. Entonces, esto en el momento de 00:43:47
evaluarse ya se va a borrar. 00:43:49
Y te da a devolver true si borró uno. 00:43:51
Si borró uno, significa que 00:43:54
podría haber más. Entonces, 00:43:55
el while vuelve otra vez y te vuelve 00:43:57
a hacer el remove. Si te 00:43:59
vuelve a devolver true es porque borró uno. 00:44:01
Entonces, tú quieres que lo siga haciendo. 00:44:03
cuando ya haga un remove y te devuelva 00:44:05
falso porque ya no encontró ninguno 00:44:07
es que ya no hay más 00:44:09
entonces como este while no tiene cuerpo 00:44:10
este while en realidad es como 00:44:13
si yo lo dejara así 00:44:15
pues cuando un while se queda sin cuerpo 00:44:16
podéis cambiar esto por punto y coma 00:44:19
que queda más bonito, unas llaves vacías quedan muy feas 00:44:21
¿vale? 00:44:23
¿pero para qué quieres poner un break si no te hace ninguna falta? 00:44:27
es horrible 00:44:31
A ver 00:44:33
Y puedo poner 00:44:37
Pues yo que sé 00:44:39
Una imagen de Felipe González fumando 00:44:40
Lo que queráis 00:44:43
Pero para qué 00:44:44
Vale, entonces 00:44:45
Las llaves vacías 00:44:50
Las podéis utilizar por un punto y coma 00:44:52
Vale, luego este while 00:44:54
Lo habéis entendido, ¿verdad? 00:44:56
no lo pillo pero da igual 00:44:58
vale 00:45:03
sí, sí, lo he pillado 00:45:05
vale 00:45:07
no, no me cuentes más 00:45:10
porque hemos ido hasta 00:45:13
vale, habéis entendido que el ponerlo 00:45:14
en un while me permite borrarlos 00:45:17
todos uno tras otro, porque si yo no lo meto 00:45:19
en un while, me borra el primero que 00:45:21
encuentre y se acabó, vale 00:45:23
entonces 00:45:24
en un set 00:45:26
si esto fuera un set 00:45:28
yo podría ponerlo aquí en un while 00:45:31
pero es absurdo porque en un set 00:45:32
solo va a haber un objeto igual a p 00:45:34
solo va a haber uno 00:45:35
entonces da igual la cantidad de veces que haga yo remove 00:45:36
en un set solo hay un objeto como mucho igual 00:45:39
puede haber uno o ninguno 00:45:42
lo puedo meter en un while pero se va a ejecutar una vez como mucho 00:45:43
¿vale? 00:45:45
pero no tiene sentido 00:45:47
entonces en un do while 00:45:48
efectivamente y con un break dentro 00:45:49
el break es lo que necesitamos 00:45:54
y poquitos métodos más tenemos que nos interesen 00:45:56
de la ArrayList 00:46:04
borrar 00:46:04
esto es programación funcional, lo olvidamos 00:46:09
si está vacía la colección 00:46:12
si no tiene elementos 00:46:16
sin ser nulo 00:46:17
claro 00:46:18
claro 00:46:19
Sí, sí, sí. 00:46:21
Qué triste 00:46:53
Sí, que podías 00:46:59
Ese método lo que tiene dentro es 00:47:02
Un size igual a cero, es lo mismo 00:47:03
Pero bueno, hay muchos métodos 00:47:05
Un montón, que son redundantes 00:47:08
Pero para que tengas tú posibilidades de hacer las cosas más bonitas 00:47:10
No, no le pasas nada 00:47:12
Clone te hace otro objeto 00:47:18
Idéntico a ese 00:47:20
En otra dirección te hace un clone 00:47:21
O sea, no le pasas ningún parámetro 00:47:23
Te hace un clone 00:47:24
Al que llama al método clone 00:47:26
Al que tú le pasas, no, al que llama al método 00:47:29
O sea, pedidos1.clone 00:47:31
Te devuelve un ArrayList 00:47:34
Copia idéntico al que llamó a clone 00:47:36
Claro, claro, pero tienes que guardar 00:47:38
Bueno, si no 00:47:39
Lo has perdido, claro, lógicamente 00:47:41
Como todos los métodos que te devuelven cosas 00:47:43
Claro, vale, entonces 00:47:44
Pues nada, ahí vamos aquí con el remove 00:47:47
Remove 00:47:49
Por índice, remove por objeto 00:47:51
Puedes borrar de golpe 00:47:53
Sí, sí, sí 00:47:54
Vale, Remusol 00:47:57
Pues le pasas una colección 00:48:00
Y te borra la primera copia 00:48:02
Que encuentra igual a todos y cada uno 00:48:04
De ellos 00:48:06
Te borra el primero 00:48:07
Te borra el último 00:48:09
¿Vale? Esto es programación funcional 00:48:11
Entonces pasa 00:48:15
¿Eh? 00:48:15
Reversed te da la vuelta 00:48:18
Retour 00:48:19
vale, te da la vuelta 00:48:21
y que otro 00:48:26
podemos sacar 00:48:42
para no perdernos 00:48:44
por ejemplo, el tuarray 00:48:45
puede ser interesante en un momento dado 00:48:47
el tuarray puede ser interesante 00:48:50
que es, te coges a lista 00:48:52
y te la pasas en un array 00:48:53
y te lo devuelve como array 00:48:56
claro, entonces que tú ya 00:48:57
que yo no quiero lista, yo arrays 00:49:00
es interesante, ¿vale? 00:49:02
el tuarray, y de todos estos métodos 00:49:04
pues con los que hemos visto y si habéis entendido 00:49:06
bien como se usan 00:49:08
pues es que poco más se puede hacer con listas 00:49:10
¿vale? 00:49:12
¿no puedes entrar en el método de revés y tal vez como funciona internamente? 00:49:13
ahora entramos si queréis 00:49:17
a ver 00:49:18
Sí, porque como uso un auxilio... 00:49:19
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:
12
Fecha:
11 de febrero de 2025 - 17:00
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 21″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
220.07 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid