Saltar navegación

20241029 ProgrEstruct-Arrays_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 30 de octubre de 2024 por Raquel G.

23 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, pues vamos a continuar 00:00:00
porque estáis así a medias 00:00:04
nos falta un montón de cosas 00:00:07
concentración 00:00:10
bueno, pues entonces 00:00:13
tenemos clarísimo que nuestras aplicaciones 00:00:17
trabajan con datos, eso está claro 00:00:20
trabajan con datos 00:00:22
entonces, nosotros 00:00:23
hemos tenido que decidir cuando hemos arrancado 00:00:28
nuestros programas y nuestras aplicaciones 00:00:30
esos datos a donde 00:00:33
iban a ir 00:00:34
entonces en nuestro caso iban a 00:00:35
variables 00:00:38
primitivas 00:00:39
iban pues a lo mejor a una 00:00:42
variable n o a lo mejor a 2 00:00:44
si teníamos una cadena de texto 00:00:47
pues conocíamos un tipo que era 00:00:50
un pelín más sofisticado que los tipos 00:00:52
primitivos que era el string 00:00:54
para guardar una cadena de texto 00:00:56
pero eso es lo único 00:00:59
que conocemos para guardar datos 00:01:01
variables sueltas 00:01:03
de los tipos de datos primitivos 00:01:05
variables sueltas 00:01:07
o variables string 00:01:08
y en todo caso son variables sueltas 00:01:10
entonces si una aplicación 00:01:12
tiene que conservar 00:01:15
mil datos 00:01:17
pues tenemos que declararnos 00:01:18
mil de estos 00:01:20
con lo que conocemos hasta ahora 00:01:21
lógicamente 00:01:24
eso no es operativo y no es lo que vamos a hacer 00:01:25
entonces 00:01:28
hay situaciones en las cuales va a ser 00:01:30
necesario guardar muchísimo de algo 00:01:32
¿no? muchísimo 00:01:34
por ejemplo 00:01:35
¿recordáis 00:01:37
la... el ejercicio 00:01:39
que hicimos el otro día 00:01:42
de sacar cifras decimales 00:01:43
hicimos un ejercicio de sacar cifras decimales 00:01:45
en el que íbamos haciendo 00:01:48
un bucle de este estilo 00:01:50
mientras el 00:01:51
cociente sea mayor 00:01:54
que cero. 00:01:55
Hacíamos 00:02:01
muéstrame 00:02:01
esta cifra decimal 00:02:05
y ahora ya 00:02:10
x igual a x entre 00:02:13
10. 00:02:15
Este era el programita para mostrar 00:02:17
las cifras decimales de x, ¿verdad? 00:02:19
Entonces, primero nos mostraba 00:02:22
las unidades, luego ya 00:02:24
nos quedábamos 00:02:27
con el cociente, volvíamos 00:02:29
arriba y al hacer el resto 00:02:30
de nuevo de ese cociente 00:02:32
nos mostraba las decenas 00:02:34
nos quedábamos con el cociente 00:02:36
al volver a hacer el resto 00:02:38
con 10, nos mostraba las centenas 00:02:40
es el ejercicio que hicimos, ¿no? 00:02:42
¿sí o no? 00:02:44
entonces, vale, estaba bien, lo que pasa es que 00:02:46
bueno, que si x era 00:02:48
315 00:02:51
pues no había tutía, esto funcionaba 00:02:54
primero me muestra el 5 00:02:57
luego ya cociente 31 00:02:58
resto de dividir 31 00:03:00
pues el 1, cociente 3 00:03:02
resto de dividir 3 00:03:05
el 3, cociente ya 0 00:03:06
no volvía a entrar, así funcionaba 00:03:08
nos sacaba 5, 1, 3 00:03:10
entonces si hubiéramos querido cambiar este programa 00:03:11
para que me mostrara 00:03:15
primero el 3, luego 1, luego el 5 00:03:16
pues no podíamos 00:03:18
porque no podemos adivinar el futuro 00:03:20
yo las iba mostrando según me iban llegando 00:03:21
¿verdad? según me iban llegando 00:03:24
las iba mostrando 00:03:26
entonces hombre, podríais decir 00:03:27
hombre, no pasa nada, tú habilítate 00:03:29
tres variables 00:03:31
n1, n2 y n3 00:03:32
y en lugar de mostrarlo 00:03:35
pues ve guardando 00:03:37
si estoy en la primera iteración, guarda en n1 00:03:39
pero si estás en la segunda 00:03:41
iteración, guarda en n2 00:03:43
si estás en la tercera, guarda en n3 00:03:45
menudo rollo 00:03:47
menudo rollo 00:03:48
primero, porque tengo aquí 00:03:51
que distinguir en qué iteración estoy 00:03:53
para decidir si guardo en N1 este numerito 00:03:55
o lo guardo en N2 o lo guardo en N3 00:03:57
eso primero, que es un pollo 00:03:59
y segundo, ¿cómo generalizo esto 00:04:01
a cualquier tamaño? 00:04:03
no lo puedo generalizar a cualquier tamaño 00:04:05
es imposible 00:04:07
entonces con lo que sabemos hasta ahora 00:04:08
no podríamos hacer este programa 00:04:11
de mostrar las cifras decimales 00:04:13
pero en orden inverso al que me van llegando 00:04:15
bueno, pues 00:04:17
si tuviéramos una especie de caja 00:04:19
en la que 00:04:21
pudiéramos irlas guardando, según me llegan, 00:04:23
es decir, en lugar de mostrarla, yo la guardo. 00:04:25
Vale. 00:04:28
Ahora esta, en lugar de mostrarla, yo la guardo. 00:04:29
Ahora esta, en lugar de 00:04:32
mostrarla, yo la guardo. 00:04:33
¿Vale? Y así las que me van llegando. 00:04:36
Una caja de un tamaño muy grandote. 00:04:37
Pues si yo pudiera irlo guardando 00:04:40
en una caja, con casillas, 00:04:41
¿no? En una tablita, 00:04:44
pues cuando ya este bucle ha terminado, 00:04:46
lo que hago es, como las tengo todas 00:04:47
aquí guardadas, 00:04:49
pues las voy sacando 00:04:50
de la caja al revés, empiezo 00:04:54
en lugar de empezar desde aquí, empiezo desde aquí 00:04:55
como están todas guardadas 00:04:57
bueno, pues este es un ejemplo 00:04:58
entonces 00:05:01
el array es esto 00:05:03
esto es un array 00:05:05
¿vale? ¿qué es un array? 00:05:07
un array es una estructura 00:05:11
una variable, un array es una variable 00:05:13
en realidad, es una variable, pero ¿qué me permite 00:05:15
esa variable? guardar muchos 00:05:17
datos del mismo tipo 00:05:19
por ejemplo, en este caso me vendría estupendo 00:05:20
una variable que me permite 00:05:23
guardar muchos datos 00:05:25
numéricos 00:05:27
yo los voy metiendo ahí y ya está 00:05:28
pues esto es un array 00:05:32
luego es un tipo nuevo de dato 00:05:41
ya tenemos 00:05:43
tenéis el cambio de clase, el recreo para hablar 00:05:47
vale 00:05:52
he estado pensando en una forma 00:05:53
yo creo que se podría hacer 00:05:57
y por demostrarlo al revés 00:05:58
yo creo que se podría hacer también 00:06:01
en vez de 00:06:02
o sea, hacer las operaciones de otra manera 00:06:06
claro, para que sea al revés 00:06:09
sí, lo que pasa es que 00:06:11
para cualquier tipo de edad, para cualquier longitud 00:06:12
yo creo que sí 00:06:15
hombre, a ver, tendrías que contar las cifras 00:06:19
sí, por un lado 00:06:21
Entonces, una vez que cuentas las cifras, como ya sabes 00:06:22
la cantidad de veces que tienes que hacerlo, puedes 00:06:24
hacer un follow. O sea, puedes hacer, sí. 00:06:26
Como si tienes 00:06:29
siete cifras, tienes que hacerlo siete veces. 00:06:30
Lo vas sacando y lo vas haciendo. 00:06:32
Ya, pero bueno. 00:06:34
La idea es otra, ¿no? 00:06:36
La idea es enseñar. 00:06:37
Efectivamente. Esto es una motivación 00:06:40
para decir que hay situaciones 00:06:42
en las cuales nos viene bien 00:06:44
poder guardar a la vez muchos datos 00:06:46
del mismo tipo. ¿Vale? 00:06:47
Muchos. 50, 100, 00:06:50
200, hasta ahora 00:06:51
guardar 50, 100, 200 00:06:53
exige que yo haga 00:06:55
50 variables 00:06:57
100 variables, no es operativo 00:06:59
bueno, pues un array ¿qué es? 00:07:02
un array es un nuevo tipo de datos 00:07:04
¿vale? entonces ya conocemos 00:07:05
los 8 tipos de datos primitivos 00:07:08
by, short, in, long, etc, etc 00:07:09
y el state, conocemos esos 00:07:12
y ahora vamos a conocer un nuevo tipo 00:07:14
de datos, bueno pues este tipo 00:07:16
de datos me permite 00:07:18
guardar un montón de valores 00:07:19
a la vez del mismo tipo 00:07:22
luego es un tipo de dato complejo 00:07:24
¿Vale? Luego es una caja 00:07:28
donde puedo guardar yo un montón 00:07:55
de elementos, un montón de elementos 00:07:57
del mismo tipo 00:07:59
¿Vale? ¿Qué ventaja tiene? Que la caja 00:08:00
recibe un único nombre, es decir 00:08:03
es una única variable, la caja entera es una única 00:08:05
variable con su nombre 00:08:07
y a partir de ese nombre ya veremos cómo yo puedo 00:08:08
ir sacando todos y cada uno de los elementos 00:08:11
según la posición 00:08:13
luego el array físicamente 00:08:15
es esto 00:08:18
recibe un nombre, un único nombre, el que a mí me dé la gana 00:08:19
pues números, por ejemplo 00:08:25
y ahora, bajo este 00:08:27
nombre, números, se esconde 00:08:30
todo este conjunto de elementos 00:08:32
y yo podré acceder 00:08:34
a ellos por separado 00:08:36
por suposición 00:08:38
luego los tengo todos juntos, bajo un único 00:08:39
nombre 00:08:43
que si yo los declaro así por 00:08:43
separado es un rollo, claro, n1, n2 00:08:46
cada uno tiene su nombre 00:08:48
pero podría estos tres números 00:08:50
meterlos en un único array de tres 00:08:52
ese array 00:08:55
recibe un único nombre 00:08:57
luego solo tengo una variable con un nombrecito 00:08:58
y ahora 00:09:00
por posición ya puedo 00:09:01
decidir cuál saco, si el primero, el segundo 00:09:04
luego el array es una 00:09:06
estructura que tiene orden 00:09:08
es decir, tiene posiciones 00:09:10
la primera sería la cero 00:09:12
la uno, la dos 00:09:15
así hasta la última que yo haya decidido que tengo 00:09:16
luego esto es físicamente 00:09:19
se le da un nombre 00:09:22
tiene posiciones 00:09:24
empezando desde la cero 00:09:25
y lo que va adentro 00:09:27
son los elementos 00:09:29
el elemento que a mí me dé la gana 00:09:30
del tipo de dato 00:09:32
que he decidido para el array 00:09:34
entonces situaciones en las que identifique 00:09:35
que me viene bien tener un montón de datos guardados 00:09:38
del mismo tipo a la vez 00:09:41
pues pongo un array 00:09:42
aquí por ejemplo podría haber venido bien 00:09:43
oye, pues en lugar de irlos mostrando 00:09:46
ve guardándolos 00:09:49
en posiciones consecutivas de un array 00:09:50
este en lugar de mostrarlo a la 0 00:09:52
este en lugar de mostrarlo 00:09:54
a la 1, este siguiente 00:09:57
en lugar de mostrarlo a la 2, ve guardándolos 00:09:58
en lugar de mostrarlos 00:10:00
y ahora ya, cuando ya he terminado el bucle 00:10:01
muestro ese array al revés y listo 00:10:04
y ya tendría las cifras 00:10:06
desde esta hasta esta porque estoy mostrando al revés 00:10:08
por ejemplo 00:10:10
bueno, pues entonces ya sabiendo lo que es 00:10:11
y para que es interesante 00:10:15
vamos a ver cómo se declara 00:10:17
cómo se declara para utilizarlo en mi programa 00:10:19
vale, pues primero 00:10:21
tenemos que decidir qué tipo de 00:10:30
dato va a ir dentro 00:10:32
porque todos tienen que ser iguales, o son todos números 00:10:33
o son todos 00:10:37
cadenas, o son todos double 00:10:38
pero lo que hay dentro, todos los 00:10:40
elementos tienen que ser del mismo tipo, todos 00:10:42
del mismo, vale 00:10:44
luego con lo de la herencia y con todo eso 00:10:46
ya esto se puede matizar, pero ahora mismo 00:10:48
con lo que sabemos, todos del mismo tipo 00:10:50
bueno, pues por ejemplo, vamos a crear 00:10:52
un array 00:10:54
de números enteros 00:10:55
pues entonces 00:10:57
ponemos int 00:10:59
vale, pero para 00:11:02
he decidido el nombre, pues venga, voy a meter 00:11:04
ahí números, pues números 00:11:06
vale, ahora para indicar que 00:11:07
esto es un array, no 00:11:12
una variable número suelta 00:11:14
una única variable suelta, para indicar 00:11:17
que es un array, tenemos que 00:11:18
poner estos corchetes abriendo 00:11:20
y cerrando. 00:11:22
Acabáramos. 00:11:25
Entonces, con estos corchetes abriendo y cerrando, 00:11:26
esto ya es 00:11:29
un array de números enteros. 00:11:30
¿Vale? 00:11:33
Luego, esto 00:11:34
es una 00:11:36
única variable entera, 00:11:38
n, una variable entera, 00:11:40
que se llama n para guardar solo un 00:11:42
entero, y sin embargo 00:11:44
números es otra cosa. 00:11:46
números es otra cosa 00:11:48
vamos a ver qué es números 00:11:50
cómo se construye 00:11:54
porque efectivamente diríais, vale, pero ¿cuántos puedo meter? 00:11:55
bueno, pues con esta declaración 00:11:59
de aquí, con ir números 00:12:01
hacia paloseco 00:12:02
lo único que 00:12:03
hemos hecho 00:12:06
es declarar esta variable 00:12:07
números 00:12:10
que en lo que realmente 00:12:10
tiene dentro es una dirección 00:12:13
de memoria que va 00:12:16
apuntar a la verdadera 00:12:18
tablita 00:12:20
con las posiciones 00:12:20
pero números como tal 00:12:23
es la dirección de memoria sin más 00:12:25
luego un array es un objeto exactamente 00:12:27
igual que era un string, cuando declarábamos 00:12:29
un string ya dijimos en su momento 00:12:32
aunque lo estamos usando igual que cualquier 00:12:34
tipo, que sepamos 00:12:36
que ese en realidad 00:12:38
es una dirección de memoria 00:12:39
que nos lleva 00:12:42
a la parte 00:12:43
de la memoria RAM donde estén los datos 00:12:46
la cadena 00:12:48
físicamente es esto 00:12:49
aunque para nosotros a ese 00:12:52
le podíamos agregar 00:12:54
inicializar con hola tranquilamente 00:12:55
como si fuera un dato 00:12:58
un tipo de dato normal 00:12:59
primitivo 00:13:01
pero string dijimos cuidado que string 00:13:02
aunque ahora mismo para el uso que hacemos 00:13:05
no tiene implicaciones 00:13:08
esto es un tipo de dato objeto 00:13:09
lo que realmente tiene dentro es la dirección 00:13:11
que lleva a donde está 00:13:14
realmente el contenido, que en este 00:13:16
caso son un montón de caracteres. 00:13:18
Bueno, pues el array 00:13:21
igual. El array es un objeto 00:13:22
también. Luego, al ser 00:13:24
un objeto, números, 00:13:26
lo que realmente es 00:13:28
una dirección de memoria 00:13:32
que me lleva al espacio 00:13:33
ya de memoria donde van a estar 00:13:36
esos elementos. 00:13:38
Bueno, pues cuando yo lo declaraba así 00:13:41
sin hacer nada, ¿a qué espacio me lleva 00:13:42
y qué tamaño tiene 00:13:44
y que me lleva a la nada 00:13:45
porque todavía no he creado ese espacio 00:13:47
me lleva a la nada 00:13:49
si yo intento usar este array 00:13:52
para meter cosas en él 00:13:54
me va a decir 00:13:55
nada, error 00:13:57
porque todavía no está creado el espacio 00:13:58
en ese momento 00:14:02
a donde estará apuntando es a una cosa que se llama null 00:14:03
¿vale? 00:14:06
null es una palabra 00:14:08
que ya la podemos incorporar 00:14:09
es una palabra reservada de Java 00:14:11
que significa espacio de memoria 00:14:13
que no está habilitado, en el que no hay nada 00:14:16
espacio de memoria en el que no hay nada 00:14:18
con lo cual este array números 00:14:20
recién declarado así tal cual 00:14:22
me está llevando a la nada 00:14:24
a lo que Java llama null 00:14:25
entonces si intentáramos usarlo 00:14:27
para guardar algo, tal y como se usa 00:14:30
nos saldría 00:14:32
en letras rojas 00:14:34
esta excepción 00:14:35
null pointer 00:14:36
exception 00:14:40
Que diría, oye, ojo 00:14:42
Estás intentando acceder a la nada 00:14:44
En la nada no puedes guardar cosas 00:14:47
No puedes hacer nada 00:14:49
Te diría eso, null pointer exception 00:14:50
Vale, entonces 00:14:53
Lo que tenemos que hacer para poder usar ya realmente 00:14:55
Este array números 00:14:59
El siguiente paso 00:15:01
Es crear físicamente el espacio en memoria 00:15:02
Crearlo 00:15:05
Para que esto deje de apuntar a null 00:15:05
Y empiece a apuntar de algún sitio 00:15:09
Vale, ¿cómo se crea el espacio en memoria? 00:15:11
pues con el operador new 00:15:14
como se crean los objetos 00:15:19
porque esto es un objeto, se crean con new 00:15:24
aunque ahora mismo 00:15:26
entonces 00:15:27
igual que scanner se creaba con new 00:15:30
porque era un objeto, pues el array también 00:15:33
porque es un objeto, new 00:15:34
el tipo primitivo, el tipo del que 00:15:36
pertenece y aquí 00:15:38
la cantidad de posiciones 00:15:40
que queremos darle, ahí es donde 00:15:42
decidimos cuantas posiciones 00:15:44
quiero que tenga 00:15:46
10, pues ahí tenemos 00:15:48
por el 10, eso no se puede quedar vacío 00:15:50
tiene que tener 00:15:52
las 90 posiciones que queremos, no se puede quedar vacío 00:15:54
entonces cuando 00:15:56
ya hemos instanciado 00:15:58
esto, new in 10 00:15:59
pues ahora ya aparece automáticamente 00:16:02
aquí 00:16:04
la tablita 00:16:05
con 10 posiciones 00:16:13
¿no se puede poner algo con infinito o algo así? 00:16:15
¿cómo vas a crear una de infinitas posiciones? 00:16:22
¿qué ordenador tiene una RAM infinita? 00:16:25
lo que podrías 00:16:26
es decir 00:16:29
lo que uno diría, a ver 00:16:30
lo dejo por definir 00:16:32
y luego según voy usándolo 00:16:34
que se vaya agrandando 00:16:36
pero eso lo tendrías 00:16:38
que programar 00:16:40
y eso son ya otra cosa 00:16:41
es el array 00:16:44
esto es lo que hay 00:16:46
esto es lo único que hay para guardar 00:16:49
varios del mismo tipo, lo que viene de serie 00:16:50
cualquier otra cosa hay que programarla 00:16:52
¿vale? 00:16:55
ya vienen programadas algunas estructuras 00:16:56
que ya veremos para facilitar 00:17:00
el uso, pero esto 00:17:01
es una estructura de datos 00:17:04
que es estática 00:17:06
desde el momento en que tú le has dado el tamaño 00:17:07
y se lo tienes que dar, no hay alternativa 00:17:10
se lo tienes que dar 00:17:12
esta tabla se queda valiendo 10 00:17:13
y se va a quedar valiendo 10 para siempre jamás 00:17:15
no puede 00:17:18
cambiar de tamaño 00:17:20
a ver, que tú en un momento dado haces esto 00:17:21
Números igual a new int 3 00:17:24
Pues entonces, ¿qué ocurre? 00:17:30
Que esta desaparece 00:17:33
Esta desaparece 00:17:35
La que tenías antes desaparece 00:17:37
Se crea una nueva con 3 00:17:39
Y ahora números empieza a apuntar a esta 00:17:41
Pero esta la has tirado a la basura con todos sus datos 00:17:45
Con todos los valores dentro 00:17:49
No, no, no, no, no es que se acorde y se quede con los tres primeros 00:17:49
esta se fue a la basura 00:17:54
porque la hemos sobrescrito 00:17:55
con esta otra que se queda limpia de nuevas 00:17:58
claro 00:18:00
o sea 00:18:02
esta la he puesto como si fuera encima de esta 00:18:04
en realidad no es que la haya pisado 00:18:06
es que he creado otra nueva 00:18:08
números, empieza a apuntar 00:18:09
a esta dirección 00:18:13
y a esta pobre que le ha pasado 00:18:14
que se ha quedado sin nadie que le apunte 00:18:16
pero sigue ahí en memoria 00:18:18
Nando Guerra, sigue ahí en memoria 00:18:20
pero ¿qué ocurre? que nadie la está apuntando 00:18:22
con lo cual es imposible 00:18:25
ir a ella, es imposible 00:18:27
porque no hay ninguna variable que la apunte 00:18:29
entonces diríais 00:18:31
pues se va llenando la memoria RAM 00:18:33
de cosas que se han quedado ahí 00:18:36
pues sí, se va llenando 00:18:37
pero afortunadamente la máquina virtual 00:18:39
de Java tiene un proceso 00:18:41
que es el recolector de basura 00:18:42
tiene un proceso que está continuamente 00:18:44
despertándose 00:18:55
e identificando qué estructuras 00:18:56
se han quedado sin nadie que les apunte 00:18:58
porque las que se han quedado sin nadie 00:19:00
que les apunte, es imposible 00:19:02
recuperarlas, no se puede recuperar 00:19:04
esa memoria otra vez, o sea, esa dirección 00:19:06
porque ya no hay ninguna variable que la tenga 00:19:08
pues el recolector de basura 00:19:10
periódicamente, todas esas variables 00:19:12
que se han quedado sin nadie 00:19:14
que les apunte, a la basura 00:19:16
por ejemplo, un segundito 00:19:17
un segundito y ahora 00:19:20
el recolector de basura también 00:19:21
actuaría, imaginaos que 00:19:24
hacemos esto, tenemos aquí 00:19:26
una cadena 00:19:30
igual a ola, por ejemplo 00:19:31
y ahora 00:19:34
yo hago cad 00:19:36
esto para nosotros 00:19:37
y no nos preocupa 00:19:43
como lo hace por dentro, para nosotros es que cadena 00:19:45
pasa de tener este texto 00:19:47
a tener este y ya está y trabajamos con eso 00:19:49
y lo que pase por debajo nos da igual 00:19:51
pero físicamente ¿qué está pasando? 00:19:53
pues que cad era 00:19:55
la dirección de memoria 00:19:57
de una porción de memoria 00:19:59
donde ponía hola 00:20:01
si ahora hacemos esto 00:20:02
ahora otra porción de memoria 00:20:04
donde pone adiós se habilita 00:20:07
y Kat empieza a apuntar a ella 00:20:08
y esta pobre porción de memoria 00:20:10
en la que ponía hola se ha quedado vacía 00:20:13
sin que nadie la referencie 00:20:15
con lo cual 00:20:16
es imposible recuperar 00:20:18
esta porción de memoria porque nadie la referencia 00:20:21
es imposible por código acceder a ella 00:20:23
luego el recolector de basura 00:20:25
está todo el rato borrando cosas 00:20:27
cada vez que un objeto 00:20:28
y ahora mismo tenemos ejemplos solamente 00:20:30
de dos tipos de objetos, los string 00:20:33
y los arrays, cada vez que 00:20:35
sobrescribimos un objeto 00:20:37
como aquí, lo estamos sobrescribiendo 00:20:39
con otro valor, o como aquí 00:20:41
lo estamos escribiendo con otro 00:20:43
el objeto antiguo se queda ahí suelto 00:20:44
y la referencia esta 00:20:47
empieza a apuntar al nuevo 00:20:49
no hay manera 00:20:50
entonces el recolector de basura va eliminando 00:20:52
Para todo eso que se va quedando sin referencia 00:20:55
Si supieras la memoria 00:20:57
Real de eso 00:20:59
No podrías recuperarla 00:21:02
Es que no la sabes 00:21:03
Tú no puedes 00:21:05
Es decir, tú podrías 00:21:06
Claro, antes de haber hecho esto 00:21:09
Haber guardado esto en un auxiliar 00:21:11
Pero si lo has guardado en un auxiliar 00:21:13
Ya está apuntado con una variable 00:21:14
Entonces el recolector de basura no lo elimina 00:21:16
Elimina solo la memoria que se ha quedado 00:21:19
Sin apuntar 00:21:21
Por nadie 00:21:23
Un segundito, tú ibas a preguntar algo 00:21:24
Imagínate si en vez de poner el número 10 00:21:26
Pusiera, o sea, si me ganara una variable 00:21:29
In, le pongo el nombre que sea 00:21:32
También, también 00:21:33
O sea, sí, lo que importa es que aquí 00:21:34
En última instancia hay un número entero 00:21:37
Me da igual que lo pongas a capón o que sea un número 00:21:38
O que pongas una variable 00:21:41
Que tiene un número entero dentro, da igual 00:21:43
Con que haya aquí un número entero es suficiente 00:21:44
Si lo cambias a flow, a método 00:21:46
¿Te acepta un decimario? 00:21:49
a ver, pero si lo cambias 00:21:51
a float todo, tienes que declararla 00:21:54
de nuevas 00:21:56
o sea, esta tal y como está declarada 00:21:57
solo puede guardar enteros 00:22:00
si tú quieres un array de float 00:22:02
pues entonces 00:22:04
tendrás que hacer 00:22:06
esto, claro 00:22:07
float 00:22:10
esto y aquí el nombrecito 00:22:12
que sea 00:22:14
y ya tienes un array para guardar float 00:22:15
vale 00:22:18
claro, new flow app 00:22:19
el tamaño que quieras 00:22:23
entonces declarar una array siempre es 00:22:24
aquí pones el tipo al que tú quieres 00:22:26
que pertenezcan los elementos que van dentro 00:22:29
todo es el mismo, van a ser 00:22:31
los cochetes 00:22:33
claro, y aquí el nombre 00:22:35
que tú le quieres dar a esa variable 00:22:37
como de costumbre, el nombre lo más explicativo posible 00:22:38
y ahora, para que se cree 00:22:41
el espacio de verdad, porque si no el espacio 00:22:43
no se crea, para que se cree 00:22:45
hay que hacer new el mismo tipo de dato 00:22:47
de la declaración 00:22:50
y el tamaño que sea 00:22:51
esto un número entero siempre porque es el número de posiciones 00:22:53
¿vale? esto tiene que ser 00:22:56
el número de posiciones del array 00:22:57
¿vale? entonces esto lo podemos 00:22:59
poner pues aquí seguido a la vez que 00:23:09
lo creamos y inicializamos 00:23:11
y ya está 00:23:12
son 10 pasos pero empiezan del 0 al 9 00:23:14
entonces, claro, la posición 00:23:17
es del 0 al 9 00:23:19
ahora cuando lo recorramos veremos como luego el contenido 00:23:21
el que sea, el que uno meta 00:23:24
inicialmente el array 00:23:25
no tiene nada, pero es imposible no tener nada 00:23:27
entonces por defecto la máquina virtual 00:23:29
lo va a poner a cero 00:23:31
pero luego la aplicación no cuenta con ello 00:23:32
la aplicación nos diría 00:23:35
está sin inicializar 00:23:37
se puede meter en guays 00:23:38
es una variable más, puedes hacer con ella lo que quieras 00:23:40
entonces puedo hacer infinitos 00:23:43
números 00:23:45
yo creo que se puede hacer infinito 00:23:46
con esto 00:23:49
el infinito no existe 00:23:50
desde ya siento defraudarte 00:23:53
pero no existe 00:23:55
bueno a ver 00:23:56
tienes razón que existe 00:24:02
el infinito y se 00:24:05
trabaja en topología 00:24:07
obviamente y de los límites 00:24:09
las derivadas, todo eso 00:24:11
pero estamos hablando en el mundo matemático 00:24:12
que es un constructo axiomático 00:24:14
entonces ahí sí 00:24:16
pero es que en las matemáticas sigue sus reglas 00:24:18
entonces en las reglas de la física 00:24:21
que es las nuestras 00:24:23
el infinito no existe 00:24:24
lo siento mucho 00:24:26
ni en el universo 00:24:27
si quieren 00:24:29
se supone que es finito 00:24:30
ya han medido hasta el tamaño y todo 00:24:36
hay como un límite 00:24:38
que es lo máximo que podemos llegar a medir 00:24:40
pero no significa que no haya más 00:24:43
simplemente que es el máximo que podemos llegar a medir 00:24:44
porque la luz que ha llegado desde ahí 00:24:47
es un limbo 00:24:49
Ya, ya, ya, pero ¿qué te hace pensar 00:24:52
que eso se extienda hasta el infinito? 00:24:54
¿Cómo decir que te hace pensar que existe Dios? 00:24:56
Es lo mismo, tú puedes creer en el infinito 00:24:58
y no creer, pero no hay señales de eso. 00:24:59
En vez de creer en alguien 00:25:02
si es creer en el infinito, no creer en el infinito. 00:25:04
Claro que... 00:25:06
¿Y si el infinito es nuestro Dios? 00:25:07
El infinito es nuestro Dios. 00:25:11
Ah, yo lo he gustado mucho. 00:25:12
¿Puede ser? 00:25:13
Bueno, en programación no existe. 00:25:16
Ok. 00:25:18
¿Y cuando llamas a esa variable? 00:25:18
¿Tú puedes especificarle 00:25:22
qué es lo que quieres 00:25:24
que utilice? 00:25:27
¿Cómo que es lo que quieres que utilice? 00:25:29
Tú cuando llamas a esa variable 00:25:30
para acceder 00:25:33
a los datos. 00:25:35
¿Tú les puedes especificar la posición 00:25:36
que quieres que utilice? 00:25:39
Claro, es que si no, no nos valdría para nada. 00:25:40
La idea es poder usar las posiciones 00:25:43
independientes. 00:25:45
Cuando yo quiera acceder a esta o esta 00:25:46
vamos a ver ahora ya cómo acceder al array 00:25:48
Para darle valores, para recuperarlo 00:25:51
¿Vale? 00:25:52
Entonces, con esto, dime 00:25:54
Ya por preguntar 00:25:56
Al lado de los cachetes de lindos 00:25:59
¿No puedes especificar ahí las posiciones que quieres? 00:26:00
Ahí se pone lo que hay 00:26:03
Nada, nada, así, tal cual 00:26:06
No puedes poner nada, no debes poner nada 00:26:08
Y el otro 00:26:10
Aquí tienes que poner algo 00:26:12
Obligatorio, no lo puedes dejar vacío 00:26:14
Obligatorio, vale 00:26:16
También se admite como sintaxis 00:26:17
poner los corchetes después del nombre 00:26:20
de la variable 00:26:23
también se admite como sintaxis 00:26:24
esto, porque así se hacía 00:26:27
antiguamente en C 00:26:29
pero a mí esta 00:26:30
esta sintaxis 00:26:33
que también se admite, me parece 00:26:34
muy fea, para mí 00:26:36
es como si el nombre de la variable tuviera corchetes 00:26:38
no me gusta esta sintaxis, aunque se admite 00:26:41
me gusta más decir 00:26:42
la variable se llama números 00:26:44
¿y de qué tipo es? 00:26:46
de este, de Array 00:26:48
me parece mucho más claro 00:26:50
y es la genuina 00:26:52
de Java, pero se admite la otra 00:26:54
bueno, por tradición del pasado 00:26:56
pero para qué 00:26:57
para qué me lo quieres hacer raro 00:27:00
si me lo puedes hacer bien, no lo entiendo 00:27:02
y si soy raro, ¿qué pasa? 00:27:04
pues te vas 00:27:06
pues si eres raro te normalizamos en un repás 00:27:07
no pasa nada 00:27:09
cosas más raras hemos hecho 00:27:11
¿como cuáles? 00:27:13
cuenta propio, cuenta 00:27:16
que no, que luego os asustáis rápido 00:27:17
anécdota, anécdota del año pasado 00:27:21
bueno, el año pasado 00:27:23
si estaban aquí los del año pasado 00:27:25
de años 00:27:26
el pasado queda en el pasado 00:27:27
que no, vamos a centrarnos en esto 00:27:31
venga 00:27:35
buen intento pero no 00:27:36
¿cuánto es el máximo que puedes poner 00:27:39
de número de tamaño de la cuenta? 00:27:42
no está limitado 00:27:45
a ver, tanto como te quepa 00:27:46
en una variable 00:27:49
porque si no te va a desbordar 00:27:50
pero si pones dos variables 00:27:52
bueno, claro 00:27:54
aquí hay que pasarlo en un número entero 00:27:55
si tú le pasas este número entero 00:27:58
y te pasas de lo que cabe 00:28:01
te va a decir, oye, que no me cabe tanto en un número entero 00:28:03
ya, ya, ya 00:28:05
bueno, en el array, es que como no vas a poder declarar 00:28:06
no va a poder existir 00:28:13
El máximo value de lint 00:28:15
caben 10 máximos values. 00:28:17
Ah, sí, sí, sí. 00:28:19
A ver, dime. 00:28:22
¿Cómo era para escoger el elemento justo? 00:28:22
Ahora, ahora, que no lo hemos hecho todavía. 00:28:25
Porque no tengo que preguntar. 00:28:27
Es que no nos ha dado tiempo. 00:28:29
Una pregunta. A ver, tú metes un 00:28:30
máximo. 00:28:32
Y vas metiendo cifras 00:28:35
en ese máximo. 00:28:37
¿Cómo que metes un máximo? 00:28:38
Tú metes 10. 00:28:39
Y metes 10 00:28:43
si tú ahora lo haces 5 00:28:45
esos valores 00:28:47
desaparecen 00:28:48
se borran 00:28:50
cuando estabas pensando en otra cosa 00:28:53
es cuando lo hemos dicho 00:28:56
en fin 00:28:58
bueno, pues como declararlo y crearlo 00:29:03
ya está, ¿no? 00:29:06
vale, pues después de declararlo 00:29:13
tenemos esta cosa tan mona 00:29:15
¿Habéis visto qué bonito? 00:29:18
Lo único mono que vamos a ver en la matita 00:29:25
Oye, haz el favor, ¿eh? 00:29:27
Todo es bonito 00:29:30
Venga, a ver 00:29:31
Ahora ya podemos usarla para guardar cosas 00:29:37
Que es para la que la hemos declarado 00:29:40
Si no, ¿pa' qué cojones nos sirve? 00:29:42
bueno, pues cada 00:29:45
posición tiene asociada 00:29:53
una posición, efectivamente 00:29:55
entonces, las podemos 00:29:57
usar por libre, por separado 00:29:59
que yo quiero guardar en la primera posición 00:30:01
el 7 00:30:03
pues así 00:30:05
el número de la RAI 00:30:07
el nombre de la RAI, perdón 00:30:09
si yo pongo 00:30:11
el nombre del array y entre corchetes 00:30:19
una posición 00:30:21
por ejemplo esta 00:30:23
me estoy refiriendo 00:30:25
a esta 00:30:27
y esto ya es como si fuera una variable más 00:30:28
bueno pues por ejemplo que hago esto 00:30:31
pues ya está 00:30:33
a la posición 3 del array números 00:30:35
le asigno el 7 00:30:37
bueno pues ya está 00:30:38
que ahora hago esto otro 00:30:40
números 0 00:30:43
Igual a números 3 00:30:49
Esto ya es como variables sueltas 00:30:54
En realidad 00:30:56
Si pones los cortetes solos 00:30:57
Igual a tal, te lo añade al siguiente 00:30:58
Que haya, al siguiente hueco libre 00:31:00
¿Cómo? 00:31:02
Si pusiera números, en vez de indicarle posición 00:31:04
Te dejas vacío 00:31:06
No puedes dejarlo vacío 00:31:07
Y no puedes hacer que te vayan añadiendo a la array 00:31:09
Uno tras otro 00:31:11
Por programa sí, o sea, esto no puedes dejarlo vacío 00:31:13
Entonces ahora ya lo que tú quieras hacer 00:31:16
Ya lo podemos hacer con bucles, lo que sea 00:31:18
Ahora mismo simplemente lo que estamos 00:31:19
indicando es que ahora ya cada 00:31:21
posición en realidad es como 00:31:23
si fuera una variable independiente unas de otras 00:31:25
y sus nombres son, esta será 00:31:27
números 0, números 00:31:29
1, números 2 00:31:32
¿vale? entonces operamos 00:31:33
lo que queramos, lo de arriba pues sería 00:31:36
meter el 7 aquí 00:31:38
esta sería a la variable 00:31:39
número 0 que es esta 00:31:42
asígnale números 3 00:31:43
que tiene 7, pues estaríamos 00:31:46
haciendo esto y ya está y lo podemos 00:31:48
trabajar así. Bueno, pues 00:31:49
¿qué hemos ganado respecto a hacer n1 00:31:51
n2, n3? Pues que 00:31:54
ahora las variables 00:31:55
su nombre se diferencia por el numerito 00:31:57
entero que pongamos aquí. Pues si 00:31:59
ponemos un contador que se 00:32:01
vaya incrementando, por ejemplo 00:32:03
podemos hacer un barrido por 00:32:05
todo el array, cosa que no podríamos 00:32:07
hacer si las variables están sueltas 00:32:10
n1, n2, n3 00:32:11
pero ahora son n0, n1 00:32:13
n2, entonces 00:32:16
por ejemplo 00:32:17
Vamos a asignar un 1 00:32:18
A todos los valores del array 00:32:22
Obviamente podríamos hacer esto 00:32:24
Pero que es un rollo, ¿no? 00:32:27
¿Puedo hacer un array de arrays? 00:32:27
Sí, sí, sí 00:32:30
Ahora ya lo... 00:32:30
Un array de millones de arrays 00:32:32
Vale, a ver 00:32:35
Vamos a poner a 1 00:32:40
Todas las posiciones del array 00:32:41
Podríamos hacerlo así, ¿verdad? 00:32:43
Y una por una 00:32:45
Podríamos ir una por una 00:32:46
n0, n1, n2 00:32:48
pero entonces sí que no hemos ganado nada 00:32:50
no hemos ganado nada respecto a usarlo 00:32:51
como variables sueltas 00:32:54
no habríamos ganado nada 00:32:56
luego es una tontería hacer un array 00:33:02
para luego trabajar con él igual que 00:33:03
trabajamos con variables sueltas, es una tontería 00:33:06
luego no lo haríamos así 00:33:08
nos aprovechamos de 00:33:09
esto de aquí dentro 00:33:11
nos aprovechamos de esto de aquí dentro 00:33:13
y ahora ya 00:33:15
el bucle que más se adapta 00:33:17
para trabajar con for 00:33:20
perdón, para trabajar con a raíz es el for 00:33:21
porque tiene dentro una variable 00:33:24
índice que yo puedo poner 00:33:26
entonces 00:33:27
esto mismo 00:33:31
sería mucho mejor hacerlo así 00:33:33
claro 00:33:35
entonces este for se ejecuta 00:33:47
para igual a 0, para igual a 1 00:33:49
para igual a 2, pues yo me aprovecho 00:33:51
y está ahí que vaya siendo 00:33:53
los sucesivos índices 00:33:55
las sucesivas posiciones, me aprovecho de eso 00:33:57
y ahora ya 00:34:00
solamente con una única 00:34:03
sentencia for, estoy haciendo 00:34:06
n0 igual a 1, n0 igual a 2 00:34:08
n0 igual a 3 00:34:10
en este tema nos quedaremos un ratito 00:34:10
porque quiero decir, esto tiene chicha 00:34:12
bueno, claro, ahora ahí se pueden hacer 00:34:15
ya muchísimas cosas y claro, tenemos un listado 00:34:16
de nuestros ejercicios para practicar 00:34:18
no digo que 00:34:20
nos dejes un tiempo 00:34:22
a asimilarlo 00:34:24
Que sí, hombre, que sí, que sí, que sí. 00:34:25
No os asustéis. Tranquilos. 00:34:27
Vale. 00:34:30
Pero realmente 00:34:34
esto es todo. 00:34:35
Lo que pasa es que ahora hay que 00:34:37
saber programar para hacer 00:34:39
los algoritmos con los clientes. 00:34:41
Ya sabemos todo y ya sabemos programar. 00:34:44
Pues de programación estructurada lo sabéis 00:34:45
todo. 00:34:47
Lo sabéis estructurado. 00:34:48
Lo que pasa es que estamos en... 00:34:50
Nos falta programación. 00:34:52
Vamos a trabajar. 00:34:53
No, hablamos de estructurada 00:34:54
Pero orientada a objetos 00:34:57
Bueno, te falta mucha información 00:34:57
Vale, pues esto es 00:34:59
El for es el bucle 00:35:03
El bucle ideal 00:35:06
Para recorrer las posiciones de un array 00:35:09
Porque este mismo i 00:35:12
Que solemos poner dentro 00:35:13
Lo usamos para ir barriendo 00:35:15
Bueno, puesto n debería haber puesto números 00:35:17
Debería haber puesto números, ¿no? 00:35:19
Que es el nombre del array 00:35:20
para que no quede tan feo 00:35:21
vamos a ponerlo así 00:35:23
y así no parece que me he equivocado 00:35:25
que no parezca 00:35:28
que me he equivocado 00:35:32
así 00:35:33
¿vale? 00:35:34
entonces ya está, respondiendo a tu pregunta 00:35:37
pues a las posiciones sueltas 00:35:39
tú accedes con el índice 00:35:41
¿que estás accediendo todas en fin una tras otra? 00:35:42
sí, imaginaos que queremos 00:35:45
acceder solamente a las pares 00:35:47
pues hombre, pongamos aquí 00:35:49
y más igual 2, por ejemplo 00:35:51
ponemos y más igual 2 00:35:54
y estamos haciendo solo las pares 00:35:56
a 0, a 2, a 4 00:35:57
ya uno juega con esto y hace lo que quiera 00:35:59
dime 00:36:02
en este ejemplo estoy poniendo 00:36:02
uno en todas, pero cada uno 00:36:08
hace lo que le da la gana, lo que necesite 00:36:10
a lo mejor puedes saber 00:36:12
introduzca valor, lo lees 00:36:14
y se lo asignas a esa 00:36:16
entonces cada posición del array tendrá la que 00:36:17
se haya metido por teclado 00:36:20
lo que sea que te hayan dicho 00:36:21
entonces los arrays es una forma cómoda 00:36:23
de manejar un montón de variables 00:36:25
del mismo tipo, porque tú te declaras 00:36:27
una única variable array con el 00:36:29
tamaño que te dé la gana 00:36:31
y luego recorrerla para 00:36:32
hacer cosas, para 00:36:35
rellenarla, para ver los valores 00:36:36
que tiene, pues es mucho 00:36:39
más sencillo, con variables sueltas 00:36:41
sería una locura 00:36:43
¿vale? aquí lo único 00:36:44
claro, cuidado, si uno 00:36:51
trata de acceder a una posición del array 00:36:53
para lo cual no hay valor, imaginaos que 00:36:55
hacemos n de 10 00:36:57
igual a 7 00:37:00
por ejemplo, la máquina 00:37:02
virtual, claro, se va a la posición 10 00:37:03
y ya no la tiene, porque tiene 00:37:06
de la acera la 9, pues automáticamente 00:37:07
saldría una excepción 00:37:10
a raíz 00:37:11
y de 00:37:14
¿Puedes darle a la raíz n 00:37:15
el tamaño i? 00:37:18
¿Eh? 00:37:23
¿Eh? 00:37:24
Vale, entonces 00:37:26
un segundito 00:37:27
id quedándoos con los nombres de las excepciones 00:37:30
si de repente vuestro programa 00:37:32
se ha parado y ha salido en rojo 00:37:34
y os dice 00:37:36
Array in the sound of monosception, ¿qué os está diciendo? 00:37:37
vete corriendo donde hayas recorrido 00:37:41
un array, porque en algún momento 00:37:42
le has dado una posición que no existe 00:37:44
entonces tú dices 00:37:46
ah, este error va por ahí, te vas 00:37:48
como cuando nos salía el string 00:37:49
out of monosception 00:37:52
uy, cuidado, se ha hecho un charar 00:37:53
de una posición que no está 00:37:55
vale, pues lo mismo 00:37:57
si puedes crear, por ejemplo 00:37:59
la n la creas dentro del port 00:38:01
y le das 00:38:03
tamaño y 00:38:04
pero entonces estarías creando muchos arrays 00:38:06
o sea, te lo estaría volando cada vez 00:38:08
claro, a ver, con esto estarías creando 00:38:10
si tú puedes hacer esto siempre 00:38:13
que quieras, el tema es que quieres 00:38:15
aquí estarías creando uno de cero posiciones 00:38:17
que puedes, un array de cero se puede 00:38:19
otro de uno, pero arrays distintos 00:38:21
y cada vez sobre escribiendo 00:38:23
la anterior, cae sobre escribiendo 00:38:25
la anterior. Yo quería que 00:38:27
me guardase tantas posiciones como recorriese 00:38:28
ahí, en el mismo array, pero 00:38:31
sabiendo, sin saber la cantidad 00:38:33
de posiciones que va a recorrer ahí. 00:38:35
O sea, siempre se tiene que saber 00:38:38
qué cantidad va a usar toda la cantidad. Cuando tú declaras un array 00:38:39
tienes que, de partida, decirle 00:38:41
el tamaño, y ese ya se 00:38:43
queda para siempre. 00:38:45
Tú puedes crearte otro nuevo 00:38:47
pisando el que había, pero pisas los datos también, 00:38:49
lo pisas todo. 00:38:51
O sea, el tamaño nunca puede ser 00:38:53
Sí, lo puedes meter por escáner 00:38:54
Guardar una variable y ponerlo aquí 00:39:00
Pero ahora ya se va a quedar para ese valor siempre 00:39:02
El array se va a quedar para ese valor siempre 00:39:04
Si vuelves a hacer un newIn 00:39:06
Con otro valor 00:39:10
Este array desaparece y se crea uno nuevo limpio 00:39:11
¿Y si editas el valor que ya estaba? 00:39:14
¿Cómo que si editas? 00:39:16
Lo has puesto en un principio en newIn 10 00:39:17
Ahora, en vez de poner 10 00:39:20
Te confundes por lo que se haya 00:39:22
un dato 2 y poner 12 00:39:24
en ese mismo 00:39:26
yoing poner 12 00:39:28
bueno, pues será 12 00:39:30
pero se caerían los datos juntos 00:39:31
se quitarían los datos, no me imagino 00:39:33
sí, seguro 00:39:36
o sea, crearía uno nuevo con 12 00:39:37
y el otro a la basura 00:39:40
o sea, que no te puedes arrepentir 00:39:42
bueno, pero tienes que hacer las cosas bien 00:39:43
es que yo he de hacerlas bien 00:39:46
entonces, esto es una estructura estática 00:39:47
que se llama 00:39:50
estática porque no se puede mover 00:39:51
pero nosotros la vamos a hacer dinámica 00:39:53
para moverse 00:39:57
porque lo podemos hacer con lo que sabemos 00:39:59
sabemos hacer prácticamente todo 00:40:02
imaginaos 00:40:04
que hemos cambiado de idea 00:40:06
y digo, ay, que ahora el usuario 00:40:07
me dice que quiere un numerito más 00:40:10
pues uno podría 00:40:12
crear un array con una posición 00:40:14
más de las que tiene esto 00:40:16
copiar este en el antiguo 00:40:17
y luego sobre escribirlo, o sea, todo 00:40:20
podemos hacer todo lo que queramos 00:40:22
todo, ¿vale? Lo iremos incorporando 00:40:23
en los ejercicios. 00:40:26
Vale, antes de parar, un segundo. 00:40:27
Sí. 00:40:30
Por favor. 00:40:31
Por favor. 00:40:32
¿Tiene una cavitaria? 00:40:34
Porque le hemos dicho a los dos. 00:40:39
Yo veo 00:40:41
hay mucha sincronización. 00:40:42
Bueno. 00:40:44
Venga, venga, venga. 00:40:48
Vamos a irnos más tarde 00:40:50
por vuestra culpa. 00:40:52
si accedéis a una posición que no existe 00:40:52
va a salir esto de aquí 00:41:02
luego es típico 00:41:03
que uno ponga aquí un numerito 00:41:05
y a lo mejor no lo haya mirado bien 00:41:07
y no sea el que ha puesto aquí 00:41:09
entonces si el que has puesto aquí es mayor 00:41:11
que el que has puesto aquí 00:41:14
cuando el force salga por abajo 00:41:15
te va a decir el de la urban exception 00:41:17
para el programa no sé qué 00:41:19
entonces, ¿qué ocurre? 00:41:20
yo he dicho que esto es un objeto 00:41:23
entonces los objetos 00:41:25
pueden llamar a cosas 00:41:28
igual que una cadena 00:41:29
stream podría llamar 00:41:31
a len 00:41:33
y esto nos decía 00:41:34
cuántos caracteres tenía 00:41:37
pues el array 00:41:39
por ser un objeto, con el operador punto 00:41:41
también puede llamar a cosas, esa suerte tenemos 00:41:43
bueno, pues en particular 00:41:45
este array n 00:41:47
puede llamar a una cosa 00:41:48
que se llama length 00:41:51
que te dice el tamaño 00:41:52
con el que tú lo has declarado 00:41:56
claro, claro 00:41:57
en teoría ya lo sabes 00:41:58
hombre 00:41:59
sí, a ver 00:42:00
pero si te vas a mirar mil líneas más arriba 00:42:04
vale 00:42:07
y aparte 00:42:09
si te lo han pasado por parámetro 00:42:10
entonces cada vez usamos un programa 00:42:12
pero si te han pasado la raíz por parámetro 00:42:14
es imposible, puedes saber, porque lo ha declarado 00:42:16
otro programa, entonces ahí es imprescindible 00:42:18
que se puede declarar desde otra clase y usarlo 00:42:20
exacto, entonces ahí es imprescindible 00:42:22
ahora mismo como lo tenemos todo en el mismo código 00:42:24
con mirar arriba y ya está 00:42:26
¿vale? un segundito, entonces 00:42:28
lo ideal, pero este es sin paréntesis 00:42:30
el de sin es con paréntesis 00:42:32
y este es sin, el de los arrays es sin 00:42:34
entonces ponemos esto aquí 00:42:36
y mucho más seguro 00:42:38
nos evita más problemas, dime 00:42:40
hay una forma de leer absolutamente 00:42:42
todos los números que ha puesto cada vez 00:42:44
con un for 00:42:45
con un for y pones el system out 00:42:48
o el numerito i 00:42:50
vale, pues venga, paramos aquí 00:42:51
un ratico 00:42:54
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:
23
Fecha:
30 de octubre de 2024 - 17:04
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 01″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.46

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid