Saltar navegación

Implementacion Lista con Array - 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 2 de febrero de 2026 por Stefano C.

8 visualizaciones

Más información Transcripción

Descargar la transcripción

Entonces, nosotros hemos dicho que anteriormente, en noviembre o algo por el estilo, 00:00:00
hemos aprendido a utilizar los arrays. 00:00:06
Una de las características fundamentales de los arrays es que son estáticos, 00:00:09
que son, una vez creados, esas son las celdas que pueden contener, 00:00:12
y si yo quiero añadir o quitar algo, pues tengo que liarme con cosas complejas. 00:00:17
entonces ha llegado un momento en que nosotros decimos hoy mira para pero porque no simplificó 00:00:23
el utilizo de los arrays como los arrays a mí me molestan porque tengo que hacer siempre código 00:00:34
súper complejo vale para poder trabajar con los arrays porque no me los quito de encima 00:00:42
y tú dices, yo no sé cómo se hace. 00:00:49
Pues sí, sabes cómo se hace. 00:00:53
Vosotros tenéis todas las herramientas para quitaros lo de encima, 00:00:56
solo que no habéis conectado los puntos. 00:00:59
Tenéis el rotulador, tenéis los puntos, pero os falta hacer el dibujo. 00:01:03
Entonces hoy vamos a intentar hacerlo. 00:01:08
Entonces me he creado un nuevo proyecto con un package. 00:01:11
Aquí vamos a crear una interfaz, ¿vale? 00:01:16
Esta interfaz la llamamos, no sé, lista. 00:01:21
Estamos de acuerdo que en el mundo de los arrays, 00:01:26
nosotros principalmente por ahora lo hemos utilizado como una lista, ¿vale? 00:01:32
Yo tenía los alumnos, he puesto los alumnos en una lista que era mi array. 00:01:36
Yo tenía los coches, pues tenía un array de coches donde dentro ponía coches, 00:01:41
una lista de coches, ¿sí? 00:01:44
A veces lo he, como se dice, ordenado, a veces he buscado ahí dentro, he hecho cosas distintas, pero sustancialmente lo que he hecho es utilizarlo como una lista. 00:01:46
Existen otros tipos de estructuras de datos que veremos cuando veremos la teoría de esta parte, ¿vale? 00:01:58
Pero por ahora nosotros pensamos en una lista. 00:02:04
Entonces, cuando yo he usado mis fantásticos arrays en mis proyectos superdifíciles que 00:02:06
pueden ser una escuela, un taller o lo que sea, pues ¿qué operaciones necesitaba hacer 00:02:16
sobre estos arrays antes de recorrer un array? 00:02:24
Va, recorrer un array, ¿qué más? 00:02:34
Sí, es como lo relleno, añadiendo un elemento. Añadamos un elemento. Yo quiero que mi interfaz 00:02:40
lista, cuando yo creo una lista, este objeto mágico que voy a crear, que sustituirá los arrays, 00:03:02
pues tendrá la posibilidad de public void add para añadir a la lista una cosa nueva, ¿vale? 00:03:11
¿Add qué? Oiga, señores, os separo si seguís leyendo. ¿Qué queremos añadir? Element. ¿Y qué 00:03:21
tipo le doy a él? Ni idea. Si fuera un array de string, el elemento sería string. Si fuera 00:03:31
un array de coches, coche. Si fuera un array de gatos, gato. Entonces, ¿cómo hago? ¿Qué 00:03:51
hago aquí? ¡Voilá! Añado un objeto. ¿Gato es un objeto? Hola, buenos días. Clase de programación, 00:04:00
lunes, ya segunda hora. El hecho de no estar dormido porque primera hora ya no vale. ¿Sí? 00:04:18
¿Por qué uso object? Para hacerlo más genérico. ¿Vale? Esto me permite añadir lo que me da la 00:04:25
si no está perfecto vale esto molaría decir que si yo estoy utilizando una red string fuera string 00:04:35
donde de gato gatos mientras esta cosa aquí es un poquito peligrosa porque me permitiría añadir gato 00:04:45
string dentro del mismo a la misma cosa vale pero todavía nos falta saber utilizar bien los tipos 00:04:51
genéricos. Porque aquí lo que me encantaría ponerle tipo T. ¿Qué es tipo T? No lo sé. Ya lo veremos. 00:04:58
Pero podría hacer... Ahí. Ya he utilizado el tipo genérico. No estoy haciendo una lista cualquiera, 00:05:08
estoy haciendo una lista de objetos T que me tendrás que decir cuando lo creas y aquí añades 00:05:16
un elemento T. Pero como todavía no lo entendemos y estamos... ¿Qué es esto? Y añadimos 00:05:22
complejidad, pues por ahora vamos 00:05:27
así. ¿Vale? Pongo objetos. 00:05:29
¿Me podéis hacer un ejemplo 00:05:32
de un object? 00:05:33
¿Coches? ¿Qué más? 00:05:42
¿Gato? ¿Qué más? 00:05:45
¿Malo? 00:05:46
¿Entendéis que todas las clases que 00:05:48
he creado hasta ahora son object? 00:05:49
¿Sí? Porque 00:05:52
heredan de object directamente o 00:05:54
indirectamente. Por lo tanto, 00:05:56
si aquí pongo object, puedo poner cualquier cosa. 00:05:58
¿Sí? Entonces, 00:06:01
si me estoy diciendo, mira, 00:06:02
Quien implemente una lista, tiene que tener la posibilidad de añadir un objeto. 00:06:04
¿Cómo se hace? Me da igual. Lo tienes que saber tú, cómo se hace. 00:06:11
Pero cuando yo usaré tu clase que implementa esta interfaz, sé que puedes añadir un objeto a la lista. 00:06:19
¿Sí? ¿Qué más puede hacer una lista? 00:06:27
public void removeObjectElement, puede ser ¿no? Vamos con calma. ¿Esto qué hace? Pues me tiene que 00:06:30
buscar el objeto elemento y quitar. Podría hacerlo así, pero no. Cuidado, cuando yo uso esto yo tendré 00:06:52
que comprobar que el objeto element es igual al objeto que voy a borrar y borrarlo, cuando uso 00:07:17
esto, borro una posición concreta. Cuando uso esto, me expongo a la posibilidad que haya varias veces 00:07:25
el mismo objeto en la lista y si digo remueve el objeto, ¿qué quiere hacer? ¿Quiere remover el 00:07:35
el primero, quiere removerlos todos, ¿qué quiere hacer? Lo tengo que definir. Entonces, 00:07:41
esto nosotros usamos una versión list sencilla, pero si tuviera que hacerla una compleja, 00:07:52
una seria, debería plantearme estos problemas. Dejamos los dos, ¿por qué no? Sobrecargamos 00:07:59
que el remove se puede eliminar como elemento o como posición. 00:08:06
Más, ¿qué función tiene replace? 00:08:11
Porque replace al fin y al cabo podría ser remueve un objeto y pone otro. 00:08:25
Entonces, más o menos lo tengo, para no complicarme la vida, ¿vale? 00:08:31
Pero sí, cosas que podrían estar interesantes, es, ¿sabes?, dime el tamaño de la lista, public, 00:08:34
ah, bueno, y public object busca, public int, object busca, object, 00:08:47
¿Qué hará esta cosa aquí? 00:09:10
Busca a este señor 00:09:19
Y me devuelve 00:09:21
Su posición 00:09:22
Pero si hay más de un objeto 00:09:27
De este tipo, pues devolvamos esto 00:09:31
Si queremos 00:09:33
Y si no, asumamos que 00:09:39
El busca te dice 00:09:41
La posición del primer objeto 00:09:45
Igual a esto 00:09:47
El primer 00:09:49
Podría haber más, pero él te da el primero que encuentro, ¿si? 00:09:51
Y removeObject para nosotros remueve el primer objeto que se encuentre, ¿vale? 00:09:56
Me lo apunto, remueve el primer objeto igual a element, devuelve la posición del primer 00:10:02
objeto igual a elemento. ¿Sí? ¿Por qué? Porque he decidido yo hacerlo así, ¿vale? Para reducir la 00:10:19
complejidad de esta cosa, ¿sí? Porque si no, debería trabajar con me devuelve un array de 00:10:40
enteros y cosas por el estilo, ¿vale? En un punto más complejo. Entonces, por ahora, lo dejamos así, ¿vale? 00:10:46
también apunto aquí negativo si no lo encuentra. Entonces, si lo encuentra me devuelve la posición 00:10:53
del array allí dentro. La posición del elemento dentro de esta lista. Si en vez de no lo encuentra 00:11:07
me devolverá menos uno, por ejemplo. Entonces, menos uno quiere decir, mira, lo he buscado y no 00:11:15
la he encontrado. 00:11:19
Esto está claro. 00:11:22
Este de aquí creo que está claro también. 00:11:23
¿Dónde lo añade? ¿Al principio, al final, en el 00:11:25
medio? Ordenado. 00:11:27
Al final, claramente. 00:11:30
Lo decidimos nosotros. 00:11:36
¿Vale? No es necesario 00:11:38
saber... 00:11:39
Por ahora estamos creando nuestra 00:11:41
interfaz. Si tuviese una interfaz 00:11:43
ya creada, debería ir a mirar 00:11:45
oye, ¿qué hace? 00:11:47
A lo mejor yo quiero que la lista 00:11:49
mía sea ordenada. Entonces, 00:11:51
cuando lo añado, no lo puedo añadir al azar. 00:11:53
Tengo que añadirlo donde está de acá. 00:11:55
Entonces, no puedo 00:11:57
utilizar Object. Debería utilizar 00:11:59
Comparable. 00:12:01
Para poder estar seguro que 00:12:03
yo puedo añadir los objetos que te da la gana 00:12:05
siempre y cuando implemente Comparable. 00:12:07
Porque si tiene que estar ordenada, 00:12:09
pues tengo que poder compararlos entre ellos. 00:12:11
¿Verdad? 00:12:15
Pero eso no sería Sol en vez de A. 00:12:16
No lo sé. 00:12:18
Si tú quieres añadirlo desordenado 00:12:22
y luego ordenarlo, 00:12:24
sí, podría poner aquí otra cosa. Pero si tú asumes que tu lista siempre esté ordenada, 00:12:25
quiere decir que cuando añades un nuevo elemento no lo puedes ordenar desordenado 00:12:31
esperando a que alguien haga sort. Pues tú lo añades y automáticamente lo sorteas. 00:12:35
¿Queréis el sort? Esto es ya un poquito más complejo. Hablit int sort object. Pero esto 00:12:41
es un poquito más complicado porque nosotros estamos utilizando object entonces podría no 00:12:54
ser comparable, por lo tanto esto es un poco más complejo. Lo tenemos sencillo. Esta es una lista 00:12:58
muy sencilla. Añade, quita, dice el tamaño y busca si hay un objeto o no hay dentro. Si lo encuentra, 00:13:09
de paso me da también... Esto habría podido ponerlo como booleano. Dime si está o no. Contains. Pero 00:13:16
como ya que para saber si lo contiene 00:13:25
lo tengo que buscar, una vez que lo he encontrado, en vez de decir si lo contiene, pues te 00:13:29
devuelvo ya el número y tú sabes que menos uno es, no lo 00:13:33
contiene, cualquier otro número positivo, pues es el índice donde está. 00:13:37
¿Sí? Podríamos ahora añadir 00:13:42
una última cosa que es el public 00:13:45
object get int. 00:13:48
sigue. Esto me sirve para pillar los objetos de la lista. Los puedo pillar de uno en uno, 00:13:54
pero uno, dos, tres, entonces me pillaría el primero, el segundo, el tercero, o podría 00:14:03
buscar un objeto, me da el asistio tres, entonces si yo aquí le pongo tres y él me da el objeto 00:14:09
asociado. Sí? Buscar es como show? Buscar es como show. O sea, sería la misma definición? No lo sé. Show qué? Como mostrar. Pero mostrar, yo si leo un show, me mostraría el entero array. En mi opinión. Busca no lo enseña. Busca tiene igual de tres, que es la posición del objeto que estabas buscando. 00:14:15
¿Queréis un show? 00:14:42
Public 00:14:45
void 00:14:46
toString. ¿Cómo no? 00:14:48
Pero ya lo tiene, public string. 00:14:50
Ya lo tiene 00:14:53
porque cualquier 00:14:54
objeto que implemente esta lista 00:14:56
ya tiene el toString 00:14:58
de object. Por lo tanto, esto es un poco 00:15:00
inútil. 00:15:02
Pero 00:15:04
si quiero que 00:15:07
funcione, pues 00:15:10
imprime lista. 00:15:11
Lo que hace es imprimir la lista. Entonces, ¿qué estoy haciendo aquí? Yo estoy definiendo. 00:15:12
Yo hasta ahora estoy trabajando con los arrays. Odio los arrays porque son mis amigos. Si 00:15:27
seguís hablando y riendo os separo. Segundo aviso. Los arrays no me gustan porque son 00:15:33
complicados y cosas por el estilo pues quiero hacer una nueva entidad una nueva 00:15:44
clase que sea una lista y que cuando yo voy a trabajar con ella en vez de decir 00:15:50
oye mira pilla la red y hablo más grande de una posición de recorre lo llega al 00:15:56
final pone la cosa si es cuestión no yo le digo añade este elemento y él se 00:16:01
encarga yo digo tengo que quitar un elemento 00:16:06
vale, entonces recorre la array, busca dónde está 00:16:12
el elemento, quítalo, reduce la array 00:16:14
y cosas por el estilo, pues no lo quiero hacer más 00:16:16
vale, quiero que yo le diga, remuévelo 00:16:18
y él lo hace 00:16:20
¿ok? 00:16:21
pero para llegar a esto 00:16:24
tengo que hacer 00:16:26
lo de los arrays una última vez 00:16:28
¿vale? 00:16:30
entonces, vamos a verlo 00:16:33
esto se entiende, esto es 00:16:34
un contrato que me dice, para hacer 00:16:36
este nuevo elemento que nosotros hemos llamado 00:16:38
una lista, pues para hacer un objeto que sea una lista tiene que implementar 00:16:40
estos métodos de aquí. Podría añadir más. Podría decir 00:16:44
contains, podría decir remove, pero una 00:16:48
lista de objetos y que él remove a todos esos objetos que están 00:16:52
o añadir una lista y añadir 00:16:56
un array y él me añade todos los elementos de ese array. Puede hacer lo que me da 00:16:59
la gana. Pero esta es mi lista mágica. 00:17:04
¿Sí? Entonces, una vez que yo tengo la lista, tengo la idea de la lista, ahora tengo que hacer la implementación de la lista. 00:17:07
Y nosotros vamos a hacer dos implementaciones. 00:17:17
La primera implementación es la más fácil para vosotros porque estos métodos los habéis implementado ya 5.000 veces. 00:17:21
Me creo una nueva clase que llamaré miListaArray. 00:17:30
¿Vale? Esta clase 00:17:39
listarray 00:17:43
implements 00:17:44
listarray. 00:17:46
Se enfada porque dice no es posible 00:17:49
porque no tiene todos los métodos. 00:17:51
Venga, ponme los métodos. 00:17:54
Y no me da hoy 00:18:01
opciones. 00:18:02
Ahí. Esto me gusta. 00:18:10
¿Ok? Entonces 00:18:13
estos son todos los métodos 00:18:14
que tengo que 00:18:16
¿cómo se dice? 00:18:17
implementar aquí dentro 00:18:19
para que esto funcione. 00:18:23
¿Veis? Entonces empezamos. 00:18:25
Yo tengo ahora que imaginarme 00:18:27
cómo voy a implementar 00:18:29
esta lista. 00:18:31
Tengo que tener 00:18:33
algo por detrás, algo que luego 00:18:35
será escondido. 00:18:37
Pero 00:18:39
me sirve para implementar la funcionalidad 00:18:40
de esta lista por dentro. 00:18:43
¿Vale? Y nosotros 00:18:46
esta primera versión de lista 00:18:47
la vamos a implementar 00:18:50
con un array por dentro. 00:18:52
¿Vale? La última vez que usamos 00:18:54
los arrays, porque a partir de allí 00:18:56
usaré siempre mi lista array 00:18:57
en vez de un array. 00:18:59
Entonces, por 00:19:02
debajo, este señor tiene un array 00:19:04
object 00:19:06
y de aquí 00:19:07
lista 00:19:09
es igual 00:19:11
a new object 00:19:13
o podría hacerlo así 00:19:18
public 00:19:24
miListArray 00:19:26
voy a poner esto aquí 00:19:29
vale, entonces ya tengo un constructor 00:19:40
cuando yo creo miListArray 00:19:42
por dentro creo un array vacío 00:19:44
existe, no es null 00:19:46
pero no tiene ninguna 00:19:48
posición dentro 00:19:50
vamos a poderlo con esto 00:19:51
vale, entonces yo ahora tengo 00:19:53
que esconder este señor que no me gusta 00:19:56
porque es un array, utilizando 00:19:58
estos métodos. Empezamos de los más fáciles. Tengo un método size. ¿Quién me tendrá que devolver 00:20:00
size? ¿Tamaño de quién? ¿De qué array? No sabes escribir el código que me dice lo que estás 00:20:10
pensando. Tengo una lista, tengo que saber cuántos elementos hay en la lista. ¿Dónde estarán los 00:20:29
elementos. ¿Están en? Listo. ¿Lista? ¿Qué más? Yo miraré el tamaño del array y eso será cuántos 00:20:39
elementos están. Nada más crearlo tiene cero elementos porque no han añadido nada. Cuando 00:21:03
añadiré tres elementos pues habrá añadido al array tantas posiciones cuantas necesarias para 00:21:09
que contenga los tres elementos, entonces cuando pediré el tamaño de la red me dirá que son tres, 00:21:15
que son los tres elementos que tengo dentro. ¿Entiendes? En este caso, súper fácil. 00:21:19
Vamos a añadir un elemento. Entonces yo tengo este señor, que no sé cuánto grande es, 00:21:28
porque no sé si es la primera vez que hago el add o es la centésima vez que hago el add, 00:21:36
Pero me han dicho, oye, mira, a lista quiero que tú añadas este elemento. 00:21:41
¿Qué hago? 00:21:48
Aux. 00:21:53
New object. 00:22:02
New. 00:22:05
No, aux igual a new object con la longitud de lista más uno. 00:22:06
Así. 00:22:23
¿Qué es lo que más has dicho tú? 00:22:24
¿Dónde? 00:22:27
En lugar de los cuarenta y uno. 00:22:28
¿En lugar de lo falso? 00:22:30
¿Cómo? 00:22:40
¿Así? 00:22:44
Pregunto. 00:22:48
¿En serio, a febrero 00:22:50
vosotros no sabéis 00:22:52
todavía crear un array? 00:22:54
¿Cómo lo hago? 00:22:56
lo que hemos hecho 7000 veces me creo un array más grande 00:23:00
que el array anterior, ¿sí? 00:23:38
Es que es más curva que lista copia, ¿vale? 00:23:45
Además, no es una lista copia. 00:23:50
Es una copia, pero no es esto, entonces... 00:23:52
Vale, ¿y qué hago ahora? 00:23:55
Forinti es igual a cero y menor que lista.length y más más. 00:24:08
Esto lo hemos hecho 7000 veces. 00:24:15
Me encanta que me contesten dos personas. 00:24:18
Nuevo de i es igual a lista de i. 00:24:22
Cuando estoy aquí, ¿qué he hecho? 00:24:29
¿Qué tengo cuando estoy aquí? 00:24:33
Ahora estoy en este punto. 00:24:34
¿Qué tengo? 00:24:35
¿Cuántos objetos tengo? 00:24:39
Que están igual, ¿no? 00:24:45
¿Qué tengo? 00:24:46
¿Qué elementos? 00:24:51
¿Qué tengo cuando llego aquí? 00:24:53
Tienes dos elementos de lista dentro de... 00:24:57
Sí. 00:25:00
En este caso nada. 00:25:00
en este caso no lo sabemos 00:25:01
si fuera vacío 00:25:05
sí, pero si lo estoy llamando 00:25:07
la quinta vez, pues ya hay 5 00:25:08
no lo sé, es genérico 00:25:10
yo aquí tengo dos objetos 00:25:12
tengo lista 00:25:15
que es un array de n posiciones con n 00:25:16
objetos dentro 00:25:18
y luego tengo nuevo 00:25:19
que es un array de n más 1 00:25:22
posiciones con 00:25:25
n objetos dentro 00:25:26
que son los mismos de 00:25:28
lista. ¿Era claro? 00:25:30
Esto lo hemos visto 00:25:34
al menos cuatro o cinco veces. 00:25:34
Hemos hecho gestión 00:25:37
array que hace literalmente esta 00:25:38
cosa aquí. 00:25:40
La clase gestión array que hemos visto 00:25:43
tres o cuatro veces, pues hemos siempre 00:25:44
hecho esto. 00:25:46
¿Qué hago ahora? 00:25:48
Nueve. 00:25:50
Nueve. 00:25:52
Ocho. 00:25:54
Vista. 00:25:56
Igual. 00:25:58
He añadido el elemento que me han dicho para añadir al final de nuevo. 00:26:03
Contaos que en lista, lista.length, me daría array index out of bounds, 00:26:14
porque en un array de 5 posiciones, la posición 5 no está, es de 0 a 4, 00:26:22
pero en nuevo, que es un poquito más grande, sí está, y es la última posición. 00:26:29
Esto habría podido ponerlo como nuevo. .length-1. Mismo número. 00:26:35
¿Eh? 00:26:44
No, que me está poniendo el nuevo mal. 00:26:46
Sí. A lo mejor lo has declarado dentro de tu bloque. 00:26:48
¿Y ahora qué hago? 00:26:55
Ya está. Ya he implementado mi add. 00:26:59
Esto lo he escrito ahora 00:27:06
Y no lo volveré a escribir en mi vida 00:27:09
Porque a partir de ahora 00:27:12
Cuando uso mi array lista 00:27:14
Mi lista array o como se llame 00:27:16
Lo que hago es 00:27:18
Usar add 00:27:19
Para añadir algo 00:27:21
No tengo que pillar el array, extenderlo, ponerlo 00:27:22
Porque lo hace el debajo escondido 00:27:25
Sin que yo lo vea 00:27:28
Claro, esto es lo mismo 00:27:33
Porque os he dicho 00:27:37
Lo podíais haber hecho 00:27:38
Claro, esta cosa de aquí la podríais haber hecho tranquilamente. 00:27:40
De hecho, la hemos hecho. 00:27:44
La hemos hecho como estática, pero nosotros la podríamos hacer como un objeto. 00:27:48
Aquí dentro tengo mi array y este objeto me esconde el array. 00:27:53
De hecho, este array podría ser private. 00:27:57
Porque yo desde fuera ni me puedo enterar que existe. 00:28:01
Y yo trabajo con los métodos estos de aquí. 00:28:05
añade, remueve, y lo hace él por debajo. Él hace el trabajo. ¿Vale? Muy bien. Sizer sigue funcionando. 00:28:08
Podemos hacer esto, que es fácil. Object.getInt.y. ¿Qué hace esto? ¿Cómo lo implemento? Tiene que 00:28:19
devolver el elemento en posición y de mi lista. 00:28:31
Esto, si tú intentas acceder a algo que no existe, pues explotará una excepción. Si tú aquí le pones 00:28:34
100.000 y tienes solo tres objetos, pues él te dirá una null pointer exception, una array index 00:28:52
out of bound exception, que se causará a la hora de intentar acceder a la posición 100 de la array 00:28:58
Y este de aquí, cuando tienes dentro solo tres posiciones. 00:29:06
Pero si la usas bien, funciona. 00:29:11
¿Vale? 00:29:14
Si quieres evitar que explote, lo que podemos hacer es lo siguiente. 00:29:14
Object. 00:29:25
Object. 00:29:29
Es igual a null. 00:29:31
¿Vale? 00:29:34
Try object es igual a esto. 00:29:35
cart.exception o esto sería un array index out of bound exception. Creo que no me parece absolutamente nada. 00:29:44
Entonces, esta cosa de aquí me dice que, oye, mira, el objeto es nul. Intenta ponerle el elemento i de la lista. 00:30:09
Si lo consigues 00:30:43
Perfecto, ahora object es ese elemento 00:30:45
Y lo devuelves 00:30:47
Si no lo consigues 00:30:48
Esto daría un error 00:30:51
Y bloquearía el programa 00:30:52
Yo no quiero que tú bloquees el programa 00:30:54
Pero que tú te recuperes 00:30:56
No hagas nada 00:30:58
Y ahí llegues aquí 00:30:59
Y lo que hace es devolverme object con dentro 00:31:00
Y un null 00:31:03
Porque si aquí explota 00:31:08
Y no ejecuta esta cosa de aquí 00:31:13
pues aquí no hace nada 00:31:14
llega al object y el object dentro 00:31:17
tenía null, entonces 00:31:19
este método de aquí me devuelve 00:31:21
el objeto si el objeto 00:31:23
está en posición y si en vez 00:31:25
he pedido una posición que no es 00:31:27
me devolverá null 00:31:29
y luego cuando uso get puedo 00:31:30
decir, pilla get 00:31:35
este elemento aquí, si este elemento que has 00:31:37
pillado es null, pues entonces 00:31:39
el usuario no existe esta posición 00:31:41
y si no, haz lo que tienes que hacer 00:31:43
dudas hasta aquí 00:31:45
y así estamos repasando 00:31:49
también el 3G 00:31:52
y podría meter 00:31:53
un mensaje error 00:31:56
system.er 00:31:57
.println 00:31:59
acceso 00:32:02
índice no 00:32:09
válido 00:32:11
claro es que lo escribo en er 00:32:13
no en out 00:32:16
para que el usuario no se da cuenta, pero yo escribo en un log que alguien ha intentado acceder a una, ¿vale? 00:32:18
Y a lo mejor le puedo poner mase.getMessage, que es la descripción de esta explosión de acto. 00:32:25
Luego este de aquí lo puedo redireccionar en un fichero de log, entonces todos estos intentos de hacer una get que no funciona 00:32:43
me lo escribirá en un fichero y yo como administrador puedo ir al fichero y ver qué ha pasado, cuántos 00:32:50
usuarios han intentado acceder a elementos que no existen. Si me interesa, si no, no. 00:32:55
Dudas hasta aquí. ¿Vale? Entonces sabemos GETTARE y sabemos ABDARE. Pues ya está, estamos 00:33:04
listos para probar. new class main. Tengo la clase main, pongo el chrome main y lo que hace este señor es decir 00:33:11
antes tenía que hacer todo con arrays, pues ahora no. Ahora lo que digo es miListArray. 00:33:28
mlat es igual al new miListaArr. Y ahora para añadir algo en esta lista mlat.add. Por ejemplo, 00:33:35
gato. Esto estoy añadiendo un string. Un string es un object. Lo puedo añadir. Y luego puedo 00:33:55
hacer mla.get , y esto por ejemplo guardarlo en un string, voilà, sí, eso. ¿Por qué esto? 00:34:05
¿Por qué esto se enfada? Entonces, ¿por qué se enfada? 00:34:30
porque mla.get 00:34:48
devuelve un object 00:34:55
devuelve un object 00:34:57
yo puedo poner un string 00:35:03
dentro de un object 00:35:07
pero no un object dentro de un string 00:35:08
porque string es un object 00:35:09
pero object no es un string 00:35:12
entonces 00:35:13
necesito hacer un 00:35:15
casting explícito 00:35:18
lo que yo lo estoy haciendo porque lo sé vale porque me tiene una una string aquí en realidad 00:35:19
esta cosa aquí es muy peligrosa porque aquí dentro puedo poner de todo mezclando de todo 00:35:28
todo el cuidado como lo usáis para forzarlo aquí aquí dentro hay sólo string que tengo 00:35:32
que hacer esa cosa de los tipos genéricos que por ahora no estoy aquí 00:35:37
Si esto funciona, ahora funciona. Puedes escribir también, si hizo, la.cd. La creo. Escribo 00:35:40
su tamaño, luego añado gato, escribo su tamaño otra vez, y luego busco un objeto y lo imprimo. 00:36:05
¿Qué me tiene que imprimir? ¿Aquí qué me imprime? ¡Hola! ¡Cero! ¿Aquí qué me imprime? ¡Uno! 00:36:13
¿Y aquí qué me imprime? Gato. Si todo funciona, aquí me imprime cero, aquí me imprime uno, 00:36:28
aquí me imprime gato. Señores, ¿lo veis? ¿Lo entendéis? Aquí no es cuestión de desarrollar 00:36:45
código, es de entender el código que he escrito yo. Si no me estáis siguiendo en lo que escribo 00:36:52
pues tenemos un problema más serio de que no sabáis escribir código. Me pareceis dormidos hoy. 00:36:58
Cero. ¿Por qué? Porque cuando exprime esto de aquí, va a MLA6, que es esta cosa de aquí, 00:37:09
devuelve la longitud de la array, por ahora la array está vacío, cero. ¿Vale? Aquí, cero. Ahora 00:37:19
llamo añade gato por lo tanto se va aquí y lo que hace es añadir gato se crea un array nuevo grande 00:37:28
1 porque 0 más 1 es 1 recorre el antiguo que era vacío por lo tanto no lo recorre vale y en la 00:37:36
posición primera la posición 0 pues añade el elemento que le ha pasado que era este string 00:37:45
gato vale y luego hace que mi lista es igual al nuevo entonces borra la lista que tenía nueva y 00:37:50
vieja y se queda con la nueva. Por lo tanto, cuando ahora le pido el tamaño tienes, estoy 00:37:57
apuntando, o sea, lista apuntará al rey nuevo, entonces tiene tamaño 1, porque tiene una posición, 00:38:05
por lo tanto me escribe este 1. Después me voy aquí y le digo, me vas a pillar en mi lista el 00:38:11
el señor get, vale, perdón, el señor 0, es la única posición que tiene, posición 0, me 00:38:20
pillará este objeto que había añadido allí, que es un string, por lo tanto, si yo lo tengo así, 00:38:27
podría hacer una jugada así, mira, así, pillo este objeto, este objeto es un object, te lo pone aquí, 00:38:33
y ahora te dice, escríbemelo por favor. ¿Qué me va a escribir ahora? Gato, ¿por qué? ¿Por qué 00:38:42
Ese es un object, me escribe Gato, una palabra. Me encanta cuando estudiáis. Tenéis meses 00:38:56
antes del próximo examen, entonces es bien que esperéis un poquito más antes de empezar 00:39:11
a estudiar. ¿Por qué me escribe Gato? Y siendo ese un object, no me debería escribir 00:39:16
object, arroba 00:39:32
y un número raro. 00:39:34
No, le he quitado el casting 00:39:37
mientras dormías. 00:39:38
En una palabra. 00:39:45
Polimorfismo. 00:39:51
Polimorfismo, mi palabra favorita. 00:39:51
La vuestra, la palabra del mes. 00:39:53
Ya era de enero. 00:39:55
Muy bien. 00:39:56
Por polimorfismo, porque él va a 00:39:59
utilizar el toString 00:40:01
No de la referencia 00:40:03
Va a utilizar el toString 00:40:05
Propio de la instancia 00:40:07
Y esto es un string 00:40:09
Por lo tanto utilizará el toString de string 00:40:11
Y por lo tanto me lo escribe bonito 00:40:13
Enhorabuena 00:40:15
Enhorabuena 00:40:20
Vamos, sigamos adelante 00:40:24
Entonces, funciona 00:40:25
Es más, yo puedo añadir otro objeto 00:40:27
La.add 00:40:29
voy, uso string porque es fácil de verlas, ¿vale? 00:40:32
En realidad podría añadir lo que me da la gana, 00:40:37
pero eso a lo mejor provoca daño, ¿vale? 00:40:40
Y pongo perro, ¿vale? 00:40:42
Entonces ahora yo puedo leer gato otra vez, 00:40:44
o puedo leer perro, 00:40:49
o puedo equivocarme. 00:40:50
¿Qué escribe esto? 00:40:54
Bueno, espérate, espérate. 00:40:58
Hagámoslo así. 00:41:03
Me he equivocado. 00:41:05
Si me lo escribe directamente, ¿vale? 00:41:06
Entonces puedo escribir cero, puedo escribir uno, puedo escribir dos, tres. 00:41:16
¿Qué pone esto? Esta cosa aquí, ¿qué me escribe? 00:41:22
Gato. 00:41:32
Gato. ¿Esto qué me escribe? 00:41:34
Perro. 00:41:37
Perro. ¿Y esto que me escribe? 00:41:39
Antes me escribía también nulo. 00:41:52
Pero me escribe 00:41:55
¿en qué color? 00:41:55
Rojo. 00:41:58
Que oye, ha habido un error. Vamos a ver si es verdad. 00:41:59
Dale. 00:42:02
Mira, este es el primer gato. 00:42:06
Esta es la parte nueva. Gato 00:42:08
es la respuesta de esto. Perro 00:42:10
en la respuesta de este de aquí. 00:42:12
Null en la respuesta de esto, porque 00:42:13
este señor ha llevado el B null, ¿vale? 00:42:15
Pero me escribe en 00:42:18
error 00:42:19
que aceso, no, no escribe 00:42:20
como llueve, más que aceso 00:42:23
a índice no válido, 00:42:25
index 2, out of bound of length 2. 00:42:27
¿Vale? 00:42:31
Este de aquí es el 00:42:31
mensaje que había escrito yo, y esto 00:42:33
era el e.getMessage. 00:42:35
¿Os acordáis? 00:42:39
Escribe error, 00:42:42
ojo, porque no lo está escribiendo en el mismo 00:42:43
canal. Lo está escribiendo en dos canales 00:42:45
distintos. 00:42:47
Este de aquí es el system.out, 00:42:49
este de aquí es el system.er. 00:42:51
¿Vale? 00:42:54
Y luego, normalmente van a la 00:42:55
consola los dos, pero 00:42:57
podría hacerlos ir 00:42:58
a sitios distintos. 00:43:01
Por ejemplo, a ficheros distintos. 00:43:03
¡Dudas! 00:43:06
O sea, mi sistema funciona. 00:43:08
Fijaos, ahora 00:43:09
lo que antes hacía 00:43:10
y yo pongo, pilla la rey, 00:43:12
exténdelo, cópialo todo, 00:43:15
ahora pon uno más. 00:43:17
Lo estoy haciendo así. 00:43:18
Porque lo estoy haciendo, 00:43:20
pero lo hace él por dentro. 00:43:24
Lo hace él aquí. 00:43:27
Y yo esto lo he implementado 00:43:29
una vez y a partir de ahora 00:43:30
solo uso esta cosa aquí y él me añade 00:43:32
cosas, dudas, 00:43:34
preguntas. 00:43:39
Vale. 00:43:47
Sigamos 00:43:48
implementando mi lista 00:43:48
array. ¿Vale? Con los otros 00:43:50
métodos que tengo que implementar. 00:43:52
Me queda para hacer el remove, 00:43:54
me queda para hacer el busca, 00:43:56
me queda para hacer el show. 00:43:58
¿Cuál queréis hacer? 00:44:05
Buscar. 00:44:10
Entonces, ¿busca qué tiene que hacer? 00:44:12
Tiene que recorrer 00:44:14
mi array, encontrar 00:44:16
cuando este 00:44:18
elemento es igual al otro. 00:44:20
¿Vale? Y cuando encuentra 00:44:22
que es igual al otro, pues me devuelve 00:44:24
la posición en la que está. 00:44:26
Si no lo encuentra, me devuelve menos uno. 00:44:28
Entonces, 00:44:31
interposición es igual a menos uno. 00:44:32
Y devuelvo posición. 00:44:37
Ya. Si no lo encuentro, 00:44:40
esto es lo que tiene que hacer. 00:44:42
Si lo encuentro, vamos a ver cómo recorre 00:44:43
una raíz. 00:44:45
Muy bien. 00:44:50
Int i es igual a 00:44:52
cero i menor 00:44:53
Porque lista.langueter y más más. 00:44:55
¿Qué hago? 00:45:03
Sí. 00:45:05
Lengueter, adverso. 00:45:06
Sí. 00:45:09
Element de i. 00:45:14
Element de i. 00:45:16
Lista de i. 00:45:20
Lista de i. 00:45:22
Lista de i. 00:45:23
Punto. 00:45:25
Equals. 00:45:26
Que. 00:45:29
ELEMENT 00:45:29
Pregunta 00:46:02
¿Mejor esto 00:46:04
o mejor esto? 00:46:06
Hola, buenos días. 00:46:12
En el de arriba no estaría gustando realmente el elemento de la lista, 00:46:34
pero estaría gustando en otra lista, ¿no? 00:46:40
No, exactamente lo mismo. 00:46:42
En el de arriba sería, comparas el elemento que te deja algo constante 00:46:45
con una lista que va a cambiar de posición. 00:46:50
Entonces, ¿cuál es mejor? 00:46:53
Hay diferencia. 00:46:56
En uno yo tengo mi lista y digo, esto es igual a esto, no, esto es igual a esto, no, esto es igual a esto, y sigo. 00:46:56
En el otro tengo mi lista y el objeto y digo, esto es igual a esto, no, esto es igual a esto. 00:47:06
Hace lo mismo. 00:47:12
¿Qué diferencia hay? No, hay... 00:47:15
Está escrito distinto. 00:47:24
Entonces, ¿qué implica? 00:47:26
Hay diferencias sobre el punto donde puede saltar una Null Pointer Exception. 00:47:30
Si yo lo hago así, esto me da Null Pointer Exception si esto es Null. 00:47:41
Si yo te he hecho busca y entre paréntesis te he puesto un objeto Null, te saltaría una Null Pointer Exception. 00:47:49
esto te saltaría 00:47:56
en un point of exception 00:47:59
si dentro de lista 00:48:01
tú en algún momento 00:48:04
has hecho una add de null 00:48:05
entonces has añadido un objeto nuevo 00:48:08
que es null 00:48:11
¿entendéis la diferencia? 00:48:12
entonces, para evitar eso 00:48:17
tengo varias opciones 00:48:20
podría comprobar 00:48:21
cuando busco 00:48:24
que el elemento no sea nul. 00:48:26
O sea, que esto lo hago 00:48:30
solo si el elemento no es nul. 00:48:31
Si es nul, no lo busco. 00:48:33
Podría hacer que cuando añado un elemento, 00:48:34
solo lo añado 00:48:37
si el elemento que me han dado no es nul. 00:48:38
Esto me garantizaría 00:48:41
que todos los elementos de la lista 00:48:43
no son nul. 00:48:45
Y entonces podría utilizar 00:48:47
¿cuál de los dos? 00:48:48
Seguramente. 00:48:51
Si no hay nulos en mi lista, 00:48:53
¿cuántos tengo aquí? 00:48:55
Si yo garantizo que no puede haber null en la lista, esto es seguro, porque estoy llamando 00:48:57
equals sobre un objeto que nunca será null, entonces me funciona así, me da igual que 00:49:07
esto sea null, esto es null dirá, no son iguales, un objeto real con un null pues no 00:49:13
son iguales, pero el objeto sobre el que lo estoy llamando es éste, entonces es éste 00:49:18
que manda si es null pointer o no. Lo podemos hacer. Otra opción es meter todo esto en un 00:49:24
triketch y si explota le digo muy bien, pues entonces no son iguales. No la he encontrado. 00:49:33
A ver, opciones. Opción número A. Meto así y puedo o comprobar aquí, hace esto. Esta es una primera opción. 00:49:53
Compruebo que si no es null, pues entonces lo puedo utilizar y lo compruebo en toda la lista. 00:50:14
Otra opción. Las pongo todas. Esto lo aumento y hago la opción número dos. 00:50:18
Opción número dos. No compruebo, mas digo prueba. Si explotas, quiere decir que cuando has hecho esta cosa aquí has explotado. 00:50:38
Entonces, Capture Null Pointer Exception x pos es igual a menú. 00:50:51
Si me devuelve menos uno, es que ha podido buscarlo, pero no lo ha encontrado. 00:51:14
Si me devuelve menos dos, quiere decir que ha habido un error al buscar. 00:51:21
¿Entiende? 00:51:32
Esta cosa aquí me devuelve la posición del objeto buscado. 00:51:35
Si lo encuentra me devolverá 3 00:51:38
Está en posición 3 00:51:41
Fenomenal, lo ha encontrado 00:51:42
Si me devuelve menos 1 quiere decir que todo esto ha ido bien 00:51:44
Nunca ha saltado una excepción 00:51:47
Pero no lo ha encontrado 00:51:49
Al no encontrarlo se ha quedado menos 1 00:51:52
Si al entrar aquí 00:51:54
Por ejemplo, el elemento era nul 00:51:56
Por lo tanto, hacer esto ha hecho un nul pointer exception 00:51:58
Pues entonces entrará aquí dentro 00:52:01
Pondrá en posición menos 2 00:52:03
En vez de menos 1 00:52:06
Y me lo devuelve 00:52:07
Entonces yo desde fuera, cuando llamo busca, puedo hacer un switch diciendo que si es menos uno, no existe, si es menos dos, ha habido un error, y en cualquier otro caso, está en esta posición. 00:52:08
¿Entienden? 00:52:26
¿Cultan? 00:52:28
Esta es una segunda opción. 00:52:33
Tercera opción. 00:52:37
la tercera opción sería 00:52:38
en vez de utilizar esto 00:52:40
cambiar 00:52:42
lista de i con element 00:52:43
cambiarlos, pero entonces 00:52:46
para que funcione debería 00:52:48
hacer un cambio en el add 00:52:50
debería poner que aquí 00:52:52
no me pueda poner elementos 00:52:54
vacíos, entonces 00:52:56
esta cosa de aquí la hace 00:52:58
solo si 00:53:01
element 00:53:03
es not null 00:53:04
Pero has dicho, añade un elemento. Si es null, no te lo añado. Si no es null, pues lo añado. 00:53:05
Fijaos que el elemento aquí dentro no lo uso, entonces aquí usar el try-catch no serviría de 00:53:19
nada. Este código de aquí no lanza nunca una null pointer exception. No hago nunca element punto 00:53:33
algo. Por lo tanto, hasta si es null, él funciona. Entonces, en este caso, necesito 00:53:41
hacerlo así. Podría, pero si yo me he cerciorado que en la lista aquí no puede haber elementos 00:53:49
null, entonces es inútil que lo compruebe. Entonces, lo que haría es, el tercer tipo, 00:54:04
que está aquí. ¿Dónde está? ¿Dónde está? ¿Dónde está? ¿Dónde está? ¿Dónde está? ¿Dónde está? 00:54:11
Me he borrado. 00:54:15
Oh, esto me la... 00:54:17
Va. 00:54:19
El tercer 00:54:21
ejemplo que podría poner aquí... 00:54:23
Esto es sobre RAI. 00:54:25
Va. 00:54:29
El tercer ejemplo, que lo llamaré 00:54:36
búscalos, ¿vale? 00:54:38
En vez de utilizar esto, 00:54:40
utilizo esto. 00:54:42
Y como sé que esto no puede ser 00:54:50
Nunca. No me hace falta comprobar que salte una null pointer exception. 00:54:52
Este código de aquí nunca lanzará una null pointer exception. 00:54:59
Porque yo me he cerciorado que aquí dentro sólo hay objetos no null y además esto es privado, 00:55:04
entonces nadie puede haber entrado allí y haberme metido null saltándose el add. 00:55:11
¿Dudas? Entonces, aquí tenemos tres opciones. 00:55:18
una dos y tres me quedo con esta vale estar aquí existe busca 22 pero no es parte de la 00:55:33
lista es un método nuevo que me he creado vale entonces qué más hago esto ya puede 00:55:42
buscar vamos a ver si la búsqueda funciona vale entonces aquí yo puedo hacer si eso 00:55:57
punto busca de gato. Me debería devolver cero. Si busco perro, me debería devolver uno. Si busco 00:56:04
bocorrilo, me debería devolver menos uno. Busco gato, no. Busco perro. Fijaos que este señor a veces 00:56:39
aparece antes, a veces aparece 00:57:03
después. Porque estoy escribiendo 00:57:05
en la console, pero con dos 00:57:07
mecanismos de escritura distintos. 00:57:09
Entonces a veces llega antes, a veces llega 00:57:12
después. 00:57:13
Mientras todo lo que escribo en system.out 00:57:19
llegará ordenado, 00:57:21
lo que escribo en out y en air 00:57:23
pueden que se solapen. Son dos mecanismos distintos. 00:57:24
A quien se ejecute antes 00:57:27
es el que escribe antes. 00:57:29
Forma loquito 00:57:31
para no molestar. 00:57:32
¿Sí? 00:57:35
Ahí. 00:57:36
Funciona perfectamente. Podría buscarlo con busca dos y funcionaría igual. 00:57:37
Ahí. 00:57:44
¿Dudas? 00:57:51
Estos métodos que están decidiendo para las colecciones, ¿ya vienen decididos o los están creando otra vez para ir explicando lo que hacen las colecciones? 00:57:54
¿Dónde estabas al principio de la clase? 00:58:03
En casa lo vi. 00:58:06
Esto se ha grabado, ¿eh? 00:58:08
Se lo harán en contra de ti. 00:58:10
Mira, 00:58:13
me he creado una interfaz lista yo 00:58:14
proponiendo 00:58:17
cuáles son los mecanismos, 00:58:18
los métodos más comunes 00:58:20
para gestionar 00:58:23
lo que hacemos con los arrays, 00:58:25
de añadir algo en un array, quitar algo en un array, 00:58:26
saber el tamaño del array, 00:58:29
buscar algo dentro del array. 00:58:31
Estos son los métodos básicos. 00:58:33
Y con esto me he creado 00:58:36
una interfaz lista. Luego me he creado una clase mía que implementa lista y hemos decidido 00:58:36
implementar estos métodos usando por debajo un Array. En este caso de objetos. 00:58:44
Entonces, hemos implementado luego el add, que es igual a añadir un elemento a un Array. 00:58:56
Hemos implementado el size, que me devuelve el tamaño del array. 00:59:06
Hemos implementado el busca, que me busca este objeto. 00:59:10
Hemos implementado el get, que me pilla el objeto en posición y del array. 00:59:14
Me queda para enfrentarlos. 00:59:19
Una cosa que quiero que os fijéis, aquí estoy utilizando Equals, que Equals se utiliza 00:59:22
de object, entonces esto debería dar false. Esto no debería funcionar. 00:59:37
Estoy utilizando el equals, pero si la clase que estoy utilizando tiene una sobrescritura 00:59:44
del equals, como es el caso de la string, no voy a utilizar el de object, que es su 00:59:53
referencia, voy a utilizar el de la instancia, que es una string, por lo tanto él me está 00:59:59
utilizando el equals entre strings y por eso no porque aquí son objetos que el 01:00:04
ecuador y que no recase no es de la clase objeto entonces no lo puede 01:00:19
utilizar no lo reconoce debería da un castellano a string o para poder 01:00:26
dudas sigamos adelante vamos show que es más fácil como me tiene que escribir una representación de 01:00:30
esta red fácil ahí yo lista uso mi clase arrays.toString para hacer una representación de eso 01:00:48
que hace reír a alguno de vosotros, y a este punto lo devuelvo. Así que ahora puedo hacer 01:01:07
siso la.show. Ahí lo tenemos. Vale. Entonces vamos ahora a utilizar el remove. Pues para el 01:01:20
El remove tengo dos señores, tengo el removeElement y tengo el removePositions, empezamos por 01:01:45
esto por obvias razones, entonces lo que tengo que hacer es, me han dicho quita la posición 01:01:55
3, por lo tanto lo que tengo que hacer yo es recorrer el array, copiarlo directamente 01:02:02
hasta la posición. 01:02:11
Luego saltarme 01:02:14
esta posición y empezar a copiar 01:02:16
en diagonal. Esto también lo hemos 01:02:18
hecho varias veces. 01:02:20
Entonces 01:02:22
object 01:02:22
nuevo 01:02:25
es igual a new 01:02:28
object un poquito 01:02:30
más pequeño de lista. 01:02:32
Justo. 01:02:37
Y ahora for int y es 01:02:39
igual a cero y menor 01:02:41
que posición 01:02:42
y más más 01:02:44
desde cero hasta posición 01:02:46
copio directamente 01:02:49
nuevo de y 01:02:51
es igual a lista de y 01:02:53
ahora he llegado a posición 01:02:56
posición me la tengo que saltar 01:03:03
en lista 01:03:05
pero no en nuevo 01:03:08
entonces empiezo otra vez 01:03:09
for int y es igual a 01:03:11
posición 01:03:14
más uno 01:03:17
y menor que lista.length 01:03:18
y más más 01:03:23
desde posición más uno 01:03:25
la siguiente a la que no quería copiar 01:03:29
hasta el fondo 01:03:31
lo que hago es copiar de nuevo 01:03:31
de y menos uno 01:03:34
lo que hay en lista 01:03:36
de y 01:03:40
ahora estoy copiando en diagonal 01:03:43
al final 01:03:45
lista es igual a nueve 01:03:52
y voilà 01:03:59
eliminado la posición. A ver si funciona. MLA.remove 0. No, quito el perro. Perro. Se hizo MLA.shock. 01:03:59
Ya está. Me ha quitado el perro. Ahora, esto ya lo hemos visto mil veces. Lo hemos hecho varias veces esta 01:04:28
Menos que el add, o sea, menos que añadir a un array, pero sí que lo hemos visto al menos tres o cuatro veces. 01:04:49
Esto, ¿cómo lo hago? Una línea. ¿Qué hace esto? Pues busca element, me busca la posición del elemento que quiero borrar. 01:04:57
Entonces me devuelve tres. Y a este punto le digo, remueve tres usando este método. 01:05:40
no me pongo a reescribir todo el código otra vez que si luego lo tengo que 01:05:51
mejorar lo tengo en seis sitios distintos reutilizó lo que ya tengo 01:05:56
ahora esto me expone algunos problemas que yo puedo hacer qué pasa si le pongo 01:06:00
remove de menos uno de posición menos uno o de más o menos dos o menos cinco o 01:06:10
Hago el remove de la posición sólo si esa posición es válida. 01:06:20
Entonces si este de aquí cuando luego lo busca no lo encuentra me dará menos uno 01:06:48
entonces no lo remueve y si este de aquí cuando lo encuentra hace un error y me da 01:06:56
porque le he pasado aquí nul entonces explota y me dará menos dos tampoco lo remueve. 01:07:01
Pero no explota ni nada. Y ya está, tenemos implementada nuestra 01:07:08
lista utilizando Arrays. Por debajo estoy manejando Arrays, pero sustancialmente por 01:07:27
fuera yo aquí de Arrays no he visto nada. Y aquí ya puedo utilizar mis objetos añadiendo cosas, 01:07:41
quitando cosas, haciendo cosas raras, y de array ya no tengo ni la remota idea. Lo he hecho una vez, 01:07:49
me lo he aprendido, estoy listo, y ahora, a partir de ahora, simplemente importo mi lista array en 01:08:03
mis nuevos proyectos y puedo olvidarme de la gestión de los arreos. Y repito, esto habríais 01:08:13
podido hacerlo ya desde varias semanas. ¿Eso es lo que se le llamaría una librería? 01:08:19
La librería es más bien una colección de clases estáticas o no estáticas relacionadas con 01:08:31
con unos varios temas concretos, pero una sola cosa así no. 01:08:42
Ahora, si tú tuvieras la implementación de una lista, la implementación de una cola, 01:08:48
la implementación de una stack, la implementación de un árbol, la implementación de... 01:08:53
y todos en un mismo paquete, pues eso podría ser una library. 01:08:58
¿Dudas? 01:09:01
¿Podría repetir otra vez lo que has dicho en el método remove? O sea, le pasas... 01:09:10
Yo de removeTheElement lo que tiene que hacer es remover el primero. Nosotros lo hemos definido como removeElPrimero, ¿vale? 01:09:17
Y yo tengo ya un método que es buscaElement, este, que lo que hace es te doy un elemento, te doy un objeto y me devuelve su... 01:09:27
El primer objeto que tú me has pasado me devuelve su posición. Podría haber varios, yo podría poner tres gatos. 01:09:37
pero tú me devuelves la posición del primero, así que lo hemos definido aquí. 01:09:45
Cuando lo hemos definido, devuelve la posición del primer objeto, igual a element, ¿vale? 01:09:50
Entonces, como yo ya tengo este método, si yo a este método hago busca de un element, 01:09:57
me da la posición de ser, ¿vale? Entonces, con esta cosa de aquí, 01:10:02
yo voy a recibir a cambio un int, que es positivo si lo ha encontrado o negativo si no lo ha encontrado. 01:10:08
Y yo esto se lo paso como parámetro a remove, a este remove, porque este es remove de object y este es remove de int. 01:10:22
Entonces él me va a comprobar y me dice si es una posición válida, entonces si me has pasado menos uno no hará nada, no remove nada. 01:10:32
Pues si es una posición entre cero y el tamaño del array, pues entonces hazme todo el trabajo para quitarme esa posición. 01:10:38
Primero en dos pasos, int posición remove es igual a busca.lm. 01:10:48
Y aquí, si os queda más claro. 01:11:06
con esto paso de aquí 01:11:14
busco en qué posición 01:11:17
está el elemento para quitarla 01:11:18
y luego le digo, usa este otro 01:11:21
método para quitar el otro 01:11:23
eso también os 01:11:24
dice una cosa, que es cuando 01:11:28
tenéis que implementar varios métodos 01:11:30
o varias versiones del mismo método 01:11:33
cuidado con el orden con lo que implementáis 01:11:34
porque si empezáis de aquí 01:11:37
hacéis una 01:11:38
parrafada de código, que luego tenéis 01:11:40
que recopiar aquí 01:11:42
porque removeObject 01:11:43
puede usar removeInt 01:11:47
pero removeInt no usa removeObject 01:11:50
entonces allí tenéis que tener un poquito 01:11:53
de por qué yo he implementado antes 01:11:58
busca, si tú vas en orden 01:12:00
pues aquí habrías implementado el busca 01:12:03
habrías implementado el remove de la posición 01:12:06
y ahora deberías reescribirlo otra vez, como mínimo copiarlo 01:12:09
si tienes un puesto de espera 01:12:13
pero como lo he hecho yo 01:12:14
pues los he dividido y he escrito el código solo una vez 01:12:16
y aquí he reutilizado el código 01:12:19
entonces el remove the object me sale 01:12:20
como una línea de código súper fácil 01:12:23
además así se me ha quedado más 01:12:25
divide tímpera porque esto remueve 01:12:34
el otro busca, son dos ejercicios 01:12:36
distintos más sencillitos 01:12:38
esto al fin y al cabo lo que hace es 01:12:39
busca y remueve, busco este 01:12:42
objeto y luego lo remuevo. Entonces son dos pasos que yo podría, hasta si sólo tuviera este método 01:12:44
de aquí sin este y sin el busca, pues yo me habría hecho dos métodos auxiliares, uno para buscar y 01:12:52
uno para remover una posición, ¿eh? Dudas. Vale. Ahora. Control-C, control-U. MyLista, 01:12:58
miLista. Esta es mi lista con objetos, ¿vale? Utiliza object, etcétera, etcétera. Ahora, 01:13:22
Lo que no me gusta de object es que yo aquí he puesto, he quedado con mi lista y he empezado 01:13:35
a poner cosas, lo comento, ahora tengo vacía, vale, puedo hacer MLA es igual, no, punto 01:13:46
Vale, perfecto, he añadido gato, pero puedo hacer mla.addNewScanner, sin problema, porque 01:13:55
aquí se añaden objetos. 01:14:20
Ahora esto me puede dar problemas cuando yo digo oye me buscas perro, ah no, porque habrá 01:14:23
hecho un ahora habrá utilizado yo vamos a ver por qué entonces nosotros tenemos por aquí el 01:14:45
busca el busca lo que hace es utilizar elementos entonces ha utilizado el de string pero si no son 01:15:00
la misma cosa no está comparando que no son el mismo a la misma clase de la primera línea si 01:15:11
Si vosotros hacéis aquí un toString, un equals, 01:15:18
search, crea un equals, que está aquí, 01:15:25
veis, la primera cosa que busca es si son de la misma clase. 01:15:33
O sea, una de las primeras cosas que busca es si son de clases distintas. 01:15:37
Pues si son de clases distintas, pues no son iguales, son distintos. 01:15:40
esto me salva de que estoy comparando un escáner y un string 01:15:46
y no explota. Son clases distintas, son distintos, ya está, sigo adelante. 01:15:54
Aún así puede ser feucho, puede ser feo, entre comillas, el gestionar 01:15:59
un array que tenga dentro de todo. Una lista, una lista de objetos, de todo. 01:16:10
entonces la cosa interesante podría ser intentar evitar que sean de cualquier 01:16:18
cosa vale entonces tengo esta esta nueva versión de la lista 01:16:26
y son estas de que son copias la copiado donde vamos a intentar ver oye mira más 01:16:31
no puedo yo de alguna forma decirle oye mira no quiero objetos 01:16:36
quiero un tipo 01:16:41
Pero no quiero decir, oye, mira, esto tiene que ser string. 01:16:45
Entonces ahora esto me funciona, pero no me funciona solo para string. 01:16:50
Si ahora quiero hacerlo para coches, pues tengo que cambiar esto a coches. 01:16:53
Quiero lo que sea, un tipo genérico. 01:16:58
Esto me está diciendo, oye, cuando tú implementas la interfaz lista, 01:17:06
dime para qué lo implementas. 01:17:10
Si lo implementas para string, pues esto será string, 01:17:15
esto será string, esto será string. 01:17:18
Si tú lo implementas para coches, pues entonces esto será coche, coche, coche. Si lo implementas para gatos, 01:17:21
pues esto será gato, gato, gato y gato. Ahora, cuando tú implementas lista, si yo no le digo nada, lista se 01:17:29
mantiene por object. Y entonces aquí utilizo object. Si yo aquí le digo algo, pues ahora esta lista de 01:17:43
aquí, en vez de ser object aquí, pues aquí le tengo que poner string. Aquí le tengo que poner string. 01:17:55
Aquí le tengo que poner string. No, esto no, porque no es de larga. Aquí le tengo que poner string, ¿vale? 01:18:03
Entonces, lo que me gustaría a mí es mantener también a este nivel una cosa de ese estilo. 01:18:11
A ver si me lo pillo así. 01:18:21
Yo te digo, cuando tú creas mi lista de array, me dices de qué tipo tienes. 01:18:24
Y esto implementa una lista de ese tipo. 01:18:30
Si tú me dices al crear la lista de array que es de string, pues esta que aquí será una lista de string. 01:18:33
Cuando lo pones así, quiere decir que esto es un t. 01:18:40
Esto es un t. 01:18:47
Esto es un t. 01:18:53
Esto no, porque buscador no es parte de la lista. 01:18:54
Entonces este de aquí lo puedo quitar, este de aquí sí, y ya está. 01:18:56
¿Vale? Además esto, esto se me enfado, porque no puedo crear arrays de tamaño, de tipo genérico. 01:19:06
Tengo que hacer cosas distintas para poder hacer esto. 01:19:28
Entonces esto sería un problema. 01:19:30
No sé si aquí me lo podría pillar. 01:19:34
Tengo que solucionar este problema aquí. Me dice, no puedes crear un generic array of t. 01:19:42
Me tienes que decir cuando lo creas, me tienes que decir como sea. 01:19:47
Entonces por ahora lo soluciona así. Pásamelo desde fuera. 01:19:51
Cuando tú creas un MrArray, me pasas un array del tipo correcto y a partir de allí hago lo que me 01:20:06
Creamelo tú, cuando la tienes que usar, me lo creas un array vacío y a partir de allí 01:20:14
yo ya hago lo que tengo que hacer. Y a ver si aquí se molesta en alguna forma, ahora 01:20:23
hay que revisar un poco todo porque esto también se ha de hacer, este de aquí, este de aquí 01:20:32
es un problema. Esto de aquí, ahora hacerlo como object y luego hacer algo así. Lo creo con objetos, 01:20:40
como puede estar todo en objetos, cuando voy a hacer aquí, hago un downcasting. Como tanto sé 01:20:55
que estoy utilizando todos los elementos T, lo puedo hacer. ¿Lo veis esto? No puedo crear, 01:21:10
en realidad este mismo truquillo lo puedo utilizar aquí. Te creo un new object, pero te digo que eres, 01:21:20
esperando que esto no explote. Y lo mismo con estas otras cosas. Esto de aquí también, lista, 01:21:39
creo un object y al final remove me da un t, una red de t, esto se queda igual, object, 01:22:01
este buscador se me lo salto, este elemento sí debería funcionar, esto es t, y un t object que 01:22:14
devuelve devolver y ya está con esto y un poco de suerte cuando yo creo mi lista yo le puedo 01:22:26
decir que mi lista es una lista de streaming esta cosa de aquí me está forzando que esta 01:22:43
lista de aquí ya no puedo añadirle un escáner. Si yo hago mla.add new ScannerSystem.in 01:22:56
punto in, no importa, que era java punto útil, punto, no, java punto, lo hemos importado 01:23:05
al otro lado, java punto útil, punto escándalo, no sé por qué ahora, no importa, bueno, ahí, 01:23:41
veis que se enfada, porque me dice, oye mira, no, tú has definido que mi array es de tipo 01:23:52
string. O sea, tú has asociado string a esta t de aquí. Entonces, ahora yo donde uso t, 01:23:59
quiero un string. Y tú me estás diciendo, ponle un scanner. Y si te fijas, el add, 01:24:10
el método add, pilla un elemento t. Y tú me has dicho que t string. Entonces no puedes añadir un 01:24:18
un scan. Ahora, si yo le digo que esto es object, dicen encantado de la vida, añade los objetos que 01:24:24
te da la gana. Scanner es un object, string es un object, lo puedes añadir. Entonces, aquí estaría 01:24:38
en la misma situación de antes. Puedo añadir lo que me da la gana. No la he perdido la opción de 01:24:45
poder hacer una lista con dentro de todo, pero tengo una opción más avanzada, que es que si te 01:24:50
Con el esfuerzo a que sea string, ahora aquí dentro solo puedo poner string. 01:24:58
Supero el código y luego lo puedo utilizar como me dé la gana. 01:25:14
Si, eso, mla.show. 01:25:20
Ah, esto va para el panel. 01:25:30
Aquí tengo mi lista que funciona tranquilamente con string. 01:25:39
Y ahora quiero hacer una lista de coches, 01:25:44
mi lista array de coches. Solo puedes crear arrays del mismo tipo. Lo único que has hecho con T es que le das la opción de crear de varios tipos, pero no el array siempre va a ser del mismo tipo. 01:25:48
Yo estoy haciendo un control diciendo que puedo crear listas que contengan dentro todos el mismo tipo. Pero eso no quita que pueda hacer listas con tipo mezclado. 01:26:03
Si yo pongo object, puede meter dentro lo que te haga, lo he hecho. 01:26:17
Claro, eso sería... 01:26:22
Sustancialmente no lo estás limitando, estás diciendo, y aquí dentro quiero solo objetos. 01:26:24
Por lo tanto, como todos heredan de objetos, puedes poner un integer, puedes poner un sonoscanner, puedes poner una string, puedes poner un coche. 01:26:30
Y él te pillará todo diciendo, muy bien, estoy contento. 01:26:39
Si quisiera hacer uno de tipo primitivo, no existe. 01:26:42
Sí, porque tú aquí le pones integer y ahora tienes una lista de entero. 01:26:45
Porque en Java integer e int van de la manita. Y él hace muchos cambios entre integer e int. Pero 01:26:59
aquí estamos trabajando con tipos de objetos, entonces no le puedes poner aquí un tipo 01:27:06
primitivo pero si le pones integer es la misma cosa ahora él te dice no le va a poner y le puede 01:27:11
añadir 1 4 y 27 30 y esto funciona 01:27:16
porque está utilizando integer pero aquí yo no tengo a hacer new integer de 1 porque él 01:27:29
entiende que este 1 es un int pero que tú lo estás tratando como integer y lo hace en automático 01:27:34
Entonces, esto es una pincelada de tipos genéricos. Es mucho más complejo de esto los tipos genéricos, ¿vale? 01:27:43
Se pueden hacer cosas bastante complejas con los tipos genéricos, ¿vale? 01:27:58
Pero como primer inicio para entender un poquito para qué pueden servir, pues aquí lo tenemos, ¿vale? 01:28:04
hemos pasado desde tener 01:28:13
una lista de objetos que 01:28:15
me valía perfectamente 01:28:16
para hacer una lista de string 01:28:19
pero si alguien malintencionado 01:28:20
ponía un coche dentro de una lista de string 01:28:23
pues podía ponerlo 01:28:25
a tener un mecanismo para 01:28:26
no perder lo anterior 01:28:28
porque si yo hago una lista de objetos 01:28:31
si yo lo instancio como object 01:28:32
pues sigo en el mismo 01:28:35
caso anterior y puedo hacer lo que me da la gana 01:28:37
pero con esto 01:28:39
pues ya 01:28:41
Puedo hacer cosas más estrictas 01:28:42
Puedo decir string 01:28:45
Entonces vamos a string 01:28:46
Puedo poner aquí 01:28:47
Una clase 01:28:48
De la que luego hereden otras clases 01:28:51
Yo podría hacer una lista de personas 01:28:54
Y dentro poner profesores y alumnos 01:28:56
Eso no lo quiero 01:29:03
Es una herramienta para hacer las cosas 01:29:04
Más flexibles 01:29:07
¿Vale? 01:29:09
Aquí se enfadaba siempre un poco 01:29:10
Porque aquí estoy haciendo una cosa un poquito 01:29:13
peligrosa, pero… ¡Dudas hasta aquí! 01:29:15
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:
8
Fecha:
2 de febrero de 2026 - 11:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 29′ 30″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
750.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid