Saltar navegación

Arrays1 - 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 4 de noviembre de 2025 por Stefano C.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase que es sobre arrays, por lo tanto, si habláis, me autorizáis a grabar vuestra voz en el vídeo, ¿vale? 00:00:00
Ok, hoy vamos a introducir un nuevo elemento, ¿vale? 00:00:09
Otra pieza de la LEGO para construir fantásticos programas y sistemas súper complejos, que son los arrays. 00:00:13
Los arrays estarán con nosotros por un buen rato, ¿vale? 00:00:21
En un futuro lo sustituiremos con otra categoría que son las colecciones, que también nos darán unos cuantos dolores de cabeza, pero por ahora estas serán nuestras colecciones de datos, ¿vale? 00:00:25
Nosotros hasta ahora hemos utilizado variables. Sabemos que es una variable, sabemos las características de una variable, sabemos que tiene un tipo, un nombre y un valor actual, que es normalmente un literal del tipo de datos. 00:00:38
muy bien 00:00:53
solo que 00:00:53
las variables 00:00:57
tienen algunas limitaciones 00:00:59
nosotros hemos empezado a ver 00:01:01
por favor quita el móvil 00:01:03
hemos empezado a ver 00:01:04
algunas limitaciones 00:01:06
de las variables 00:01:08
cuando hemos empezado a hacer 00:01:10
oye mira, leeme 50 variables 00:01:12
leeme 50 números 00:01:15
y luego haz algo 00:01:17
porque la 00:01:18
solución nuestra era 00:01:19
o poner 50 variables, ¿vale? 00:01:22
Cosa que no... no, no. 00:01:25
O no utilizar los numeritos que me ponen, ¿vale? 00:01:29
Y hacer una acumulación, ¿vale? 00:01:34
Cuando nosotros hemos hecho estos ejercicios de calcular la media de los números que ponían por teclado, 00:01:36
nosotros no nos recordábamos los números. 00:01:42
Nos recordábamos sólo cuántos números se habían insertado y la suma de todos los números. 00:01:46
Si pero al final el ejercicio decía, vale, ahora reescríbeme todos los números que te he dado, 00:01:52
pues allí habríamos tenido algún problema, ¿vale? 00:01:58
Habríamos podido intentar, en cierto sentido, hacer trampa y colocarlos en una string, ¿vale? 00:02:00
Lo he añadido allí, pero si luego te dice, Filipe, ahora úsamelo, 00:02:09
súmbame uno de todos los números que te he dado, pues ya allí tenemos un problema, ¿vale? 00:02:12
Los arrays solucionan estos problemas. 00:02:17
¿Qué es un array? Vamos a ver. 00:02:19
un array 00:02:20
de java es una estructura 00:02:22
de datos que nos permite almacenar un conjunto 00:02:25
de datos del mismo tipo 00:02:27
es una variable 00:02:28
¿vale? pero 00:02:30
en vez de tener una sola 00:02:32
casillita en el que pongo 00:02:34
un valor, tiene muchas 00:02:36
casillitas 00:02:39
y puedo poner en cada una de estas casillitas 00:02:40
un valor distinto 00:02:43
del mismo tipo 00:02:44
si es un array de enteros, todos los 00:02:46
O sea, las casillitas tendrán un entero. 00:02:49
Si es un array de string, todas las casillitas tendrán un string. 00:02:51
Pero en vez de un solo literal, puedo almacenar allí varios literales. 00:02:54
¿Cuántos? ¿Cuántos yo diga? 00:03:00
Yo digo, quiero un array de siete posiciones, 00:03:02
pues ahora tengo una multivariable, una variable múltiple, 00:03:05
que tiene un solo nombre, pero tiene dentro siete celdas 00:03:09
en las que puedo almacenar siete valores del tipo del array. 00:03:13
Si tengo un array de enteros y le digo, tu tamaño es 10, 00:03:19
pues ahora tengo esta variable, sustancialmente, 00:03:23
y ahora veremos cómo se usa, 00:03:26
en la que tiene 10 compartimentos, 00:03:27
en cada compartimento puedo guardar un enter. 00:03:30
Cuidado. 00:03:33
Ya está, mañana examino. 00:03:35
El tamaño de los arrays se declara en un primer momento 00:03:37
y no puede cambiar en tiempo de ejecución. 00:03:41
Este es el problema grande de los arrays. 00:03:45
¿Vale? Cuando tú dices 00:03:47
Este array es de tamaño 7 00:03:49
Pues este array es de tamaño 7 00:03:50
¿Puede cambiar de tamaño? No 00:03:52
Tiene 7 celdas y así es 00:03:54
Veremos que hay una técnica 00:03:57
Arcana 00:03:59
Nono nivel ¿Vale? 00:04:02
Que permite en tiempo 00:04:05
De ejecución, pillar un array y hacerlo 00:04:07
Más grande, pero no es 00:04:09
Que hago más grande el array 00:04:11
Es que creo un array nuevo más grande 00:04:12
Y me lo cojo 00:04:15
en general tened en cuenta que 00:04:15
en Java un array 00:04:20
tiene su tamaño y ese es el tamaño 00:04:22
que tiene, vale, se acabó 00:04:24
si queréis una cosa dinámica, o sea 00:04:26
algo que tú puedes añadir un objeto 00:04:28
y ha añadido 10 y ahora, oh, se me ocurre 00:04:30
añadir uno más y añades uno más 00:04:32
pues con los arrays 00:04:34
hay cosas más avanzadas 00:04:35
que se llaman las colecciones, que veremos 00:04:39
que si te permiten hacer esto 00:04:40
que son estructuras de datos dinámicas 00:04:42
Pero esta de aquí, no 00:04:44
¿Vale? 00:04:46
¿Cómo se declara un array? 00:04:48
¿Vale? Con esta estructura de aquí 00:04:50
Tipo, símbolos raros 00:04:52
Nombre del array 00:04:55
Punto y coma, como una variable 00:04:56
¿Vale? Int 00:04:58
Edad, solo que además 00:05:00
De int edad, le pones estos 00:05:02
Simbolitos de aquí que te hacen decir 00:05:04
Mira, tú no eres una variable normal 00:05:06
Eres un array 00:05:08
¿Sí? 00:05:09
Entonces, por ejemplo, int 00:05:12
bla bla bla, no sé qué son estos 00:05:13
paréntesis cuadras, corchetes 00:05:15
int corchetes mi array de int 00:05:17
pues esta es una variable 00:05:20
que se llama mi array de int 00:05:22
que tiene como tipo 00:05:23
array de entero 00:05:25
entonces aquí dentro 00:05:27
no me esperaré de encontrar 00:05:31
un solo, una sola celda 00:05:33
con un valor, no una colección 00:05:35
de enteros, varios enteros 00:05:37
string corchetes mi array 00:05:40
string, la misma cosa, solo que 00:05:43
dentro tendrá varias celdas, todavía 00:05:45
no sé cuánto. Esto es equivalente a 00:05:47
cuando nosotros vimos 00:05:49
las declaraciones 00:05:50
y había int x, punto 00:05:53
y coma. Y todavía no habíamos 00:05:55
puesto ningún dato dentro. 00:05:57
Estamos a ese nivel de ahí. Ahora vemos 00:05:59
cómo lo inicializamos. 00:06:01
¿Habéis visto alguna regla? 00:06:05
String args. 00:06:07
Public static void 00:06:13
de string args, string corchete args. 00:06:15
Args es un array de string, ¿vale? 00:06:18
Desde el primer día estáis usando arrays 00:06:21
y no lo sabéis. 00:06:23
¿Sí? Vale. 00:06:25
Inicialización, ¿vale? 00:06:27
Nombre de array, que sería el que he usado aquí, 00:06:29
es igual a new tipo tamaño, ¿vale? 00:06:33
O sea, por ejemplo, mi array de int, 00:06:38
que era de tipo int corchetes, 00:06:40
pues será mi array de int es igual a 00:06:43
new int corchete 20 00:06:44
corchete. ¿Vale? 00:06:47
¿Qué quiere decir esto? Que sustancialmente 00:06:48
voy a crear 00:06:51
un espacio en memoria 00:06:51
que puede contener 20 00:06:54
enteros. ¿Vale? 00:06:56
Y lo referenciaré, 00:06:59
me... 00:07:00
lo voy a encontrar, voy a 00:07:02
llegar a ese espacio 00:07:04
usando la palabra 00:07:06
mi array de int. ¿Vale? Antes 00:07:08
cuando yo hacía int data es igual 00:07:10
la 9 yo tenía un espacio en memoria para llegar a ese espacio de memoria utilizaba edad vale edad 00:07:12
del el nombre de ese espacio era un una representación simbólica de ese dato luego 00:07:19
ese dato podía cambiar a 10 puede cambiar 12 pero yo siempre en mi programa lo me referenciaba este 00:07:31
a ese dato como edad. 00:07:37
Me da igual el valor que tiene en ese 00:07:39
momento. El valor se irá a pescar 00:07:41
en el momento en que estoy 00:07:43
ejecutando mi programa, iré 00:07:45
a ese espacio de memoria y veré que hay 00:07:47
almacenado ahí dentro. 00:07:48
Aquí la misma cosa, solo que en vez de tener 00:07:50
una celda sola, tendré 00:07:53
en este caso 20 celdas. 00:07:55
De esta 00:07:58
línea de aquí, es la siguiente, 00:07:58
mi array de strings igual a mi string de 15. 00:08:00
15 celdas que contienen 00:08:03
cada una, un string de cada una. De estas dos líneas, o tres si queréis, 00:08:05
puedo deducir algo sobre los arrays. ¿Qué los arrays son? Exacto, objetos. ¿Os acordáis que 00:08:11
nosotros hemos visto el new pocas veces? ¿Cuándo habéis visto el new? En el escáner. Y nosotros decimos, 00:08:29
escáner es un objeto, es una cosa rara, que nosotros todavía no usamos los objetos, no 00:08:36
No sabemos qué son, pero cuando yo hago New Scanner, lo que estoy haciendo es crear una nueva estancia de este objeto. 00:08:41
Y luego lo uso, que es una caja negra para mí, que tiene metoditos, tiene funciones, 00:08:47
que cuando la llamo me permite leer de teclado. 00:08:52
¿Cómo funciona? No tengo ni idea, pero sé que funciona así. 00:08:54
Aquí vuelvo a reutilizar el New. 00:08:57
El New es la palabra mágica que sustancialmente instancia objetos, crea objetos. 00:08:59
Entonces, el hecho de que aquí, al hacer el array, esté utilizando la palabra new, me da una pista de que, en realidad, dentro, este señor no es una variable de tipo primitivo. 00:09:06
Esta aquí es algo más complejo. 00:09:22
Eso. 00:09:25
Si os acordáis, breve paréntesis, si os acordáis, los tipos primitivos, 00:09:26
Cuando yo tenía int x, esto que es igual a 4, esto me creaba en un espacio de memoria una variable que se llamaba x de tipo int y aquí dentro me ponía el valor. 00:09:39
Esto vale por todos los tipos primitivos. 00:09:59
Sin embargo, lo vimos, no me acuerdo exactamente por qué contexto, en string o probablemente cosa por el estilo. 00:10:02
Cuando lo que yo estoy utilizando no son tipos primitivos, 00:10:08
más son objetos, ¿vale? 00:10:13
La cosa era un poquito distinta. 00:10:15
Yo tenía un tipo, por ejemplo, string, tenía un valor, edad, 00:10:17
pero lo que encontraba aquí no era el valor real. 00:10:27
El valor real se creaba por otro lado, en el heap, 00:10:33
que es una zona de memoria 00:10:37
¿vale? donde se creaba 00:10:41
el objeto string ¿vale? 00:10:43
este es un objeto string con dentro 00:10:45
hola 00:10:47
y aquí lo que tenía era una 00:10:47
dirección, un código, una 00:10:51
cosa rara que me apuntaba 00:10:53
a este bloque 00:10:55
aquí 00:10:57
era la razón de por qué cuando uso el igual igual 00:10:57
no me funciona 00:11:01
porque el igual igual está comprobando esta 00:11:02
cosa de aquí con otra y no 00:11:05
si son el mismo objeto 00:11:07
Pues el array es algo parecido. Mi array será de este tipo de aquí, no de este tipo de aquí. 00:11:08
No tengo yo aquí los valores. Esto tendré un puntero, una referencia a una zona de memoria 00:11:22
donde dentro habrá mis celdas, 4, 10, 20, cuantas haya creado, 00:11:30
y en cada una de estas celdas tendré un objeto del tipo que he utilizado. 00:11:38
O sea, este int, pues aquí tendré entero, entero, entero, entero, entero. 00:11:44
String, string, string, string, string, string. 00:11:50
Un pero es otro string. 00:11:53
¿Se entiende? 00:11:55
¿Dudas? 00:11:57
Estas celdas van numeradas, ¿vale? 00:11:59
Cero, uno, dos, tres, cuatro. 00:12:02
Sí. 00:12:07
Si yo en un array tengo una lista de frames, ¿no sería una lista de objetos dentro de objetos? 00:12:08
En vez que el que tengo aquí, tendría cosas como estas que apuntan a varios otros objetos. 00:12:14
Pero prácticamente no lo veo. 00:12:23
Con int, con tipo primitivo, que es más fácil de entender, 00:12:26
la idea es que en cada uno de estos aquí podré poner un entero 00:12:29
y cada una de estas celdas tiene un índice. 00:12:33
0, 1, 2, 3, 4. 00:12:36
¿Vale? Esto sería un array de cuántas posiciones? 00:12:37
Cinco. 00:12:41
Cinco. Siempre los arrays van de cero 00:12:42
a número de posiciones menos uno. 00:12:43
¿Sí? ¿No recuerda algo? 00:12:45
For. 00:12:48
¿O la for? 00:12:50
¿Vale? ¿Os acordáis que el for bonito 00:12:51
empezaba en cero y acababa en n menos uno? 00:12:53
O sea, en menor que n. 00:12:55
Perfecto para una 00:12:57
cosa de ese estilo. Lo veremos. ¿Vale? 00:12:59
Y entonces, yo tengo el nombre 00:13:01
arr, ¿vale? 00:13:03
Arr es el array. 00:13:05
Y cuando accedo a R, le tendré que decir, 00:13:06
oye, mira, accede a la estructura R en posición 3. 00:13:09
Entonces estaré accediendo a esta cosa de aquí. 00:13:13
O a la estructura R en posición 0. 00:13:16
Entonces estaré accediendo a esta celda. 00:13:20
Closso. 00:13:23
¿Sí? 00:13:24
Volvamos aquí. 00:13:25
Entonces, con esto yo creo un array de 20 posiciones. 00:13:27
Con esto creo un array de 15. 00:13:30
¿Sí? 00:13:32
claramente, se pueden hacer a la vez 00:13:32
o sea, yo puedo hacer int corchetes 00:13:36
mi array de int es igual a new int de 20 00:13:39
todo en una línea 00:13:42
ningún problema 00:13:44
¿cómo se asignan los valores a sus celdas? 00:13:46
o sea, yo he creado 20 celdas, ¿cómo accedo a una? 00:13:50
el nombre del array, corchete el número de la celda 00:13:52
cerro corchete, igual valor 00:13:56
por ejemplo, mi array int de 0 es igual a 16 00:13:57
lo que hace es llegar a mi array de int 00:14:02
que tiene 20 posibles celdas 00:14:05
accede a la celda 0 00:14:07
y allí dentro le pone el valor 16 00:14:09
¿entiendes? 00:14:11
bueno, si 00:14:16
lo hago gráficamente 00:14:16
nosotros tenemos nuestro array 00:14:18
que son 20 posiciones 00:14:21
¿vale? 00:14:24
entonces yo tendré 00:14:25
un array 00:14:26
un array 00:14:32
¿vale? y aquí tengo 00:14:34
varias posiciones. La primera posición, esto es ART. ART tiene un valor que apunta a esta 00:14:37
estructura aquí. Cuando entro en ART llego a esta estructura. Y esta estructura tiene 20 celdas y 00:14:47
cada una de estas celdas tiene un numerito. Entonces este es el numerito 0, este es el 00:14:54
numerito 1, 2, bla, bla, bla, bla, bla, bla, hasta las últimas dos, que son las 18 y las 19. 00:14:58
Porque de 0 a 19, 20 posiciones. Ahora, si yo hago ar corchetes de 0 corchete es igual a 16, 00:15:05
esto me está diciendo, vete a ar, vale, estoy aquí, llego a esta cosa. Aquí tengo 20 posiciones en 00:15:21
el que puede escribir? Pues usa la posición 0, o sea, esta. Y aquí dentro guardas el 16. 00:15:27
O sea, que yo pongo 16 aquí dentro. Si yo hiciera R de 19 es igual a 7. Muy bien. 00:15:36
Para complicar 00:16:00
¿Vale? 00:16:03
Si yo hiciera 00:16:03
De R 00:16:05
De 19 00:16:08
Es igual a 4 00:16:11
¿Qué haría? 00:16:16
Ahí 00:16:19
¿Y tú ya el 7 por el 4? 00:16:24
¿Has pedido R? 00:16:30
¿En qué posición? 00:16:34
¿Qué hay aquí dentro? 00:16:35
Entonces esto vale 7. 00:16:39
Entonces accedería a R de 7 00:16:41
y allí dentro pondría un 4. 00:16:43
Entonces en la posición 7 00:16:46
pondría un 4. 00:16:48
Esto es complejo. 00:16:52
Era para... 00:16:53
Olvidaoslo. 00:16:54
Explota. Ahora llegamos. 00:16:59
A mí me gusta decir que cuando el programa no funciona explota, ¿vale? 00:17:05
Porque os llamo vuestra atención, vosotros estáis acostumbrados a explosiones, ¿vale? 00:17:13
No lo digáis ni en el examen ni con otros profesores, 00:17:17
que el año pasado me echaban la bronca porque vosotros, en otras categorías de alumnos, 00:17:24
en otros exámenes escritos ponían esto no funciona porque explota. 00:17:30
Pues no, no explota nada. 00:17:34
Es una forma de verlo. 00:17:36
¿No estás enseñando a hacer explotar cosas? 00:17:39
¡Cabrón! 00:17:41
¡Vale! 00:17:44
Entonces, por ejemplo, 00:17:46
mi array de string de 0 00:17:48
es igual a Pepe. 00:17:50
¿Vale? 00:17:53
Pondrá Pepe dentro de esta cosa. 00:17:53
Esto me hace pensar. 00:17:56
Vale, entonces, 00:17:58
hay también una forma de hacer 00:18:01
todo el 1 la creación de un array vale se puede crear así de esta forma de aquí vale no siempre 00:18:02
es es funcional pero a veces puede servir vale esta cosa de aquí veis con corchetes cosas y 00:18:10
crearía una ley de cuántas posiciones tres posiciones en la posición 0 pondría 1 en la 00:18:17
posición 1 pondría menos 2 en la posición 2 pondría 3 en este caso no 00:18:24
Pero hay veces que esto no se puede usar. 00:18:32
Imagínate ejercicio. 00:18:37
El usuario me dice un número 00:18:38
y yo luego pillo ese número de datos y hago algo. 00:18:41
Yo te pongo 19, tú tienes que poner 19 datos más. 00:18:45
Yo te pongo 5, tú pones 5 datos más. 00:18:50
Pues tengo que crear un array de las posiciones que me da el usuario. 00:18:52
Esto no lo puedo usar. 00:18:55
Lo tengo que usar aquí, así. 00:18:56
Y aquí ponerle el número que me ha dado uso. 00:18:59
Haremos ejemplo. Variables índice, ¿vale? Una de las ventajas de los array es que se puede acceder a cada compartimento utilizando un número entero, un intervalo, o sea que la celda está numerada. 00:19:02
Si este número no es literal, sino variable, en vez de utilizar el numerito le puedo poner una variable allí dentro y entonces puedo cambiar luego el valor de la variable y él accederá a la casilla correspondiente. 00:19:17
¿Se entiende lo que quiero decir? 00:19:39
O sea que hasta aquí está accediendo a un número concreto, 00:19:40
a un literal, a 19, a 7, a 45, 00:19:45
pero yo puedo acceder a A. 00:19:47
¿Vale? 00:19:49
Es un poco este ejemplo que ya os he hecho yo. 00:19:49
¿Vale? 00:19:53
Aquí, en vez de poner un número, os he puesto una variable, 00:19:53
que además era una ley. 00:19:56
¿Vale? 00:19:58
Entonces, ahora llegamos allí cuando hacemos los ejemplos. 00:19:58
Esto en particular me suena mucho a esta I, 00:20:04
que esta i es 00:20:08
un for. 00:20:10
Entonces, si yo tengo un for que la i va 00:20:12
de 0 a el tamaño 00:20:14
de la rey menos 1, 00:20:16
pues lo que me está haciendo es recorrerme 00:20:18
la rey, ir en todas las celdas 00:20:20
de la rey y pillar el número 00:20:22
o meter un número o hacer algo 00:20:24
con cada una de las celdas. 00:20:26
¿Eh? 00:20:28
Muy bien. 00:20:28
¡Chica! 00:20:32
¡Ejemplo! 00:20:33
Entonces, aquí tengo esta 00:20:35
cosa de aquí que hace esta cosa aquí la primera línea que hace no me imprime nada que hace esta 00:20:37
primera línea de la primera línea del menino señores como sois sí claro 00:20:50
de siete posiciones el lunes en qué posición está el hacer el lunes esta posición 0 martes 00:21:11
en posición 1 miércoles en posición 2 lo veis sí claro para todos y entonces si esto está claro 00:21:22
que escribe esta maravillosa cosa aquí sí que es más que escribe en pantalla primer día de la 00:21:31
semana lunes y el último es domingo y un remedio es 00:21:45
dudas cuidado con que hay tres es miércoles no 00:22:00
vale pero 1 2 3 9 vale lo que decías tú antes vale qué pasa si yo digo ah muy bien ahora voy 00:22:05
a acceder a 6 vale fijaos que aquí he quitado 1 y tengo 1 2 3 4 5 6 días aquí dentro entonces es 00:22:17
es un array de seis posiciones 00:22:27
que van del cero al cinco. 00:22:28
Y aquí intento acceder en día seis. 00:22:31
¿Vale? 00:22:34
Pues me salta la que se llama una excepción. 00:22:35
Exception. 00:22:38
¿Vale? 00:22:39
En Java, los errores, 00:22:40
hay varios tipos de errores, 00:22:43
lo veremos cuando hablemos de las excepciones, 00:22:44
pero los errores estándar, digamos, de Java 00:22:46
son lo que se llaman excepciones. 00:22:49
Son mensajes que te manda la Java Virtual Machine 00:22:51
para decir, aquí ha pasado algo. 00:22:56
Aquí hay una excepción 00:22:59
en el normal 00:23:00
funcionamiento del programa. 00:23:02
¿Vale? Y tú puedes decir, oye, 00:23:04
pillo esta excepción y hago algo con ella. 00:23:06
O puedes decir, no hago nada, y dejar 00:23:08
que explote todo mi programa. ¿Vale? 00:23:10
En este caso, 00:23:12
cada una de estas excepciones tiene un nombre, 00:23:14
tiene un tipo, tiene una 00:23:16
descripción en un cierto sentido. 00:23:17
Esta de aquí es la 00:23:20
array index 00:23:22
out of bounds exception. 00:23:24
¿Vale? 00:23:27
Excepción de índice 00:23:27
fuera de los límites de un array. 00:23:29
Está bastante claro que es. 00:23:32
¿Vale? 00:23:33
Si tú tienes 6 posiciones 00:23:34
y accedes a la posición 6, 00:23:36
la posición 6 no existe 00:23:38
y por lo tanto te dice 00:23:39
que te has extralimitado 00:23:40
de las celdas del array. 00:23:42
También si le pusiera menos 1 00:23:45
me daría array index out of bounds 00:23:47
porque los bounds son entre 0 y 5. 00:23:49
¿No se ve? 00:23:55
no se lee 00:23:55
o sea, si empiezan 00:23:56
de sábado a viernes 00:23:59
en vez de lunes va a terminar 00:24:01
no se lee menos uno menos cuatro 00:24:03
es posible que en algunos 00:24:06
otros lenguajes hagan cosas raras 00:24:09
pero en principio no, ¿vale? 00:24:11
estas son, las celdas tienen su numerito 00:24:13
0, 1, 2, 3, 4 y esas son 00:24:15
si llegas a 6 explotas 00:24:17
si llegas a menos uno explotas 00:24:19
si llegas a 30 veces explotas también 00:24:20
¿sí? ¿dudas? 00:24:22
No, porque es quitado el domingo. 00:24:25
¡Cuidado! 00:24:32
Hay una flecha muy grande roja 00:24:37
que te hace... ¡Cuidado! 00:24:40
Si hubiese el domingo, 00:24:47
el día 6 es el mismo 00:24:49
programa que antes, 00:24:51
que ponía día 6, pero lo que he hecho 00:24:55
es quitarle el domingo. 00:24:57
Y entonces, claro, ya el domingo no existe, 00:24:58
desexplora. 00:25:00
¿Ya es? ¿Dudas? 00:25:02
Vale. 00:25:06
¿Qué es esto? 00:25:08
Vale. 00:25:10
Cosillas que tienen los array. 00:25:12
Length. Cuidado. 00:25:14
Nosotros hemos ya visto un length. 00:25:16
El length que hemos visto 00:25:18
nosotros es una función 00:25:20
de la clase string. 00:25:22
Y por lo tanto se escribe length 00:25:24
con paréntesis. 00:25:25
Este length no es 00:25:28
una función, es un 00:25:30
atributo 00:25:32
de esta clase, en un cierto sentido. 00:25:34
Es una variable. Y se escribe 00:25:36
sin paréntesis. 00:25:37
¿Vale? Eclipse os lo 00:25:39
dice. Tú lo escribes con 00:25:42
paréntesis y te dice, no, no lo tengo. 00:25:44
Pero si es sin paréntesis en una string, te dice, 00:25:45
no, esto no existe. Pero te tienes que 00:25:48
recordar que una con paréntesis es una 00:25:50
sin, donde está el error. 00:25:51
Luego Eclipse os dará una mano 00:25:53
en marcar que lo habéis escrito mal. 00:25:55
¿Vale? Entonces, si yo tengo 00:25:58
char array esté aquí, array es igual a new char bla bla bla 00:25:59
for int i es igual a cero i menor que array punto length i más más 00:26:03
system punto auto punto println array de i que haces esta maravilla de la naturaleza 00:26:09
que utilizareis cincuenta mil veces a partir de hoy 00:26:14
va a imprimir 00:26:17
el contenido de las celdas 00:26:32
desde la celda 0 00:26:35
hasta la celda 9 00:26:37
de este array 00:26:39
no de 0 al 9 00:26:41
va a imprimir el contenido de la celda 00:26:44
ahora, como yo no he puesto nada en esta celda 00:26:46
¿qué hay cuando 00:26:49
que pilla un int 00:26:51
si yo no le pongo nada 00:26:52
int si no lo inicializo 00:26:56
vale 0 00:27:00
por lo tanto esto me escriberá 00:27:01
10 ceros 00:27:03
0 0 0 0 0 0 0 00:27:04
10 veces 00:27:07
¿si? 00:27:08
¿yes? 00:27:11
esto es 00:27:12
la base 00:27:14
la fórmula básica 00:27:16
para recorrer un array 00:27:18
Mi array tiene no sé cuántas posiciones 00:27:20
Empiezo desde la primera 00:27:24
Y hasta las últimas 00:27:25
Lo que hago es acceder a la array 00:27:27
Y a ver si hay allí dentro 00:27:29
Escribirlo en pantalla 00:27:30
Pues esta cosa 00:27:31
¿Se entiende? 00:27:32
Voy a correr un array 00:27:37
Vale, misma cosa 00:27:39
Entonces, si yo tengo mi días 00:27:40
Lunes, domingo, miércoles, jueves, viernes 00:27:42
Fijaos, aquí perdí otro día 00:27:44
Porque cada vez que hago este ejercicio 00:27:46
Perdo un día más 00:27:47
Y luego le digo, int x es igual a 0, que no sé para qué sirve, for int y es igual a 0 y menor de días punto length, fijaos, sin parentesitas, y más más, y luego digo, x es igual a y más 1, y luego digo, día, lo que haya en x es, y lo que haya en la casilla y de este array de aquí, 00:27:48
lo que estoy escribiendo es 00:28:13
día 1 es lunes, día 2 es martes 00:28:15
día 3 es miércoles, lo veis 00:28:18
¿vale? 00:28:20
esta cosa aquí del x me sirve solo porque 00:28:21
si no sería feo que pondría día 0 es lunes 00:28:23
día 1 es martes 00:28:26
¿vale? 00:28:28
entonces como los seres humanos no estamos 00:28:29
acostumbrados a contar desde 0 00:28:31
solemos contar desde 1 00:28:33
pues entonces le sumo 1 00:28:35
habría podido en vez de utilizar x poner aquí 00:28:37
entre paréntesis y más 1 y habría 00:28:39
hecho lo mismo 00:28:41
¿sí? 00:28:42
dudas 00:28:45
con esta cosa aquí estoy recorriendo 00:28:46
este array, cuando esto 00:28:50
vale días de cero, escribiré lunes 00:28:52
cuando este es día de uno, martes 00:28:54
cuando este es día de dos, miércoles 00:28:56
preguntas 00:28:58
fácil esto 00:29:00
entonces añadamos 00:29:02
un nuevo for, que os encanta 00:29:07
añadir nuevos for 00:29:09
¿ok? 00:29:11
la estructura que se llama for each 00:29:12
La estructura forEach está pensada, no existía antes, ¿vale? 00:29:14
Se ha creado para las colecciones. 00:29:20
Funciona tanto en las colecciones que veremos más adelante, 00:29:24
pero en particular funciona también con los arrays también, ¿vale? 00:29:27
El forEach me sirve cuando yo quiero hacer algo por cada elemento de un array. 00:29:32
ForEach, element of the array. 00:29:40
¿Cómo funciona? 00:29:43
esta cosa de aquí 00:29:44
for 00:29:46
abierta paréntesis 00:29:48
int y dos puntos nums 00:29:49
donde nums es un array 00:29:52
escribe y 00:29:53
lo que estoy haciendo 00:29:56
es escribir este 00:29:58
este array en pantalla, todo en una línea 00:30:00
si os fijáis esto es sin leer 00:30:02
¿vale? 00:30:04
lo que hace esta estructura de aquí 00:30:06
es decirme en el primer ciclo 00:30:08
y vale lo que 00:30:10
está en la primera celda de nums 00:30:12
En el segundo ciclo, Y vale lo que hay en la segunda celda de Núñez. 00:30:14
En el tercer ciclo, la tercera. 00:30:20
En el cuarto ciclo, la cuarta. 00:30:22
Esto es útil cuando quiero recorrer un array y hacer algo, lo mismo probablemente, por cada una de las celdas. 00:30:26
Esto es obligatorio. 00:30:36
O sea, no lo puedes hacer con el Ford de toda la vida. 00:30:39
Sí, claro. 00:30:42
Son iguales. 00:30:43
Puedo hacer todo lo que hago con un FOR para hacerlo con un FOREACH y al revés, medio, con un poco de trabajo. 00:30:44
Fijaos que aquí, por favor chicos, oiga, hola, sigues hablando, que no tengo en un FOREACH, que sí tengo en un FOREACH. 00:30:53
más. ¿Y qué es? Más que esto, una variable de modificación. Es que aquí, en este for 00:31:11
de aquí, yo tengo i que me sirve como índice. Me dice en qué momento del ciclo estoy. Si 00:31:24
lo uso para un array, me dice en qué celda estoy trabajando en este momento. Estoy trabajando 00:31:33
a la celda 3. Aquí esto no está. 00:31:39
Yo he perdido el índice. 00:31:42
Yo sé que voy a recorrer 00:31:44
todas las celdas de la array 00:31:45
pero en un determinado momento, en un determinado ciclo 00:31:47
no sé si estoy en la celda 1 00:31:49
o en la celda 2 o en la celda 7. 00:31:51
Sé que he pillado el valor de una de estas celdas 00:31:53
y estoy haciendo algo con ella. 00:31:55
Pero por ejemplo, si mi objetivo 00:31:57
sería, yo tengo una array grande 00:31:59
te doy un valor 00:32:01
búscame en qué celda aparece 00:32:03
este valor, hacerlo con 00:32:05
el forEach? No lo sé. Porque no tengo control sobre en qué celda estoy en un determinado momento. Se puede hacer, pero con un contador y más más, etc. Pero hay veces que tener control sobre la celda en que estáis es útil y por lo tanto uso este for de aquí y otras veces en vez de que no me interesa en qué celda estoy, me interesa ir en todas las celdas. Por lo tanto, este es más cómodo. 00:32:07
O veremos, por ejemplo. Escribe el contenido de un Array. Existe Arrays.toString. Fijaos 00:32:39
que este de aquí es mayúscula. ¿Qué será este Arrays? Es una clase. Es parecido a... 00:32:52
¿Qué otras cosas hemos visto que funcionan así? Math.rando. El equals no. 00:33:04
Y el equals antes tiene un objeto, no tiene una clase. 00:33:14
Cosa distinta. 00:33:20
Y tú no haces string.equals. 00:33:22
Tú haces una variable, punto equals, otra variable. 00:33:25
Entonces, mientras aquí no lo estás llamando sobre una variable. 00:33:29
Si os fijáis aquí no hay ninguna variable que se llame arrays. 00:33:32
Esta es una clase. 00:33:35
Es como math. 00:33:38
Math.random sigue así. 00:33:39
Math.py que vimos alguna vez, pues misma cosa. 00:33:41
Entonces hay esta clase 00:33:44
Que es una clase de comodines 00:33:46
De cosas útiles para arrays 00:33:47
Que tiene el método toString 00:33:49
Que le paso un array 00:33:51
Y él me escribe 00:33:54
El contenido de cada uno de ellos 00:33:56
Esto 00:33:57
Si lo recordáis bien, si no os lo hacéis vosotros 00:33:59
Esto hace lo mismo que esto más o menos 00:34:02
Puede ser útil a veces para ver 00:34:04
Si he hecho la cosa bien o imprimir 00:34:06
Rápidamente un array 00:34:08
En vez de tener que hacer 00:34:09
todo un for, pues escribo esto y lo escribo. 00:34:12
Copia de un array. 00:34:17
Nos paramos aquí. 00:34:22
Mañana vemos la copia de un array 00:34:23
y luego los arrays multidimensionales 00:34:25
pues posiblemente los dejamos después 00:34:27
del examen, ¿vale? 00:34:29
Copia de un array. Prefiero antes 00:34:34
hacer algunos ejercicios antes de 00:34:36
meternos en una copia de array. 00:34:38
¿Vale? 00:34:40
Vamos a hacer algún ejercitito. 00:34:42
Última semana, de 24 a 28 00:34:46
No sé exactamente qué es 00:35:05
Estamos todos 00:35:06
No, no, vais a tener todos 00:35:08
En esta semana se suspenden las clases 00:35:15
para que hagáis los exámenes. 00:35:18
Entonces vais a tener todos los exámenes ahí. 00:35:21
Vale, vamos a crear un nuevo proyectito. 00:35:24
Vale, lo llamamos Arrays. 00:35:54
Y empezamos. 00:35:58
Aquí en Arrays creamos un package. 00:36:06
ejemplos 00:36:10
y empezamos 00:36:11
vale, entonces 00:36:14
vamos a 00:36:25
crear un array de enteros 00:36:27
vale, para empezar a jugar 00:36:30
un poquito con ellos 00:36:32
int array 00:36:33
que queréis que sean 00:36:35
es igual 00:36:38
a new 00:36:46
inter 00:36:47
y aquí tengo que poner 00:36:49
cuántas edades 00:36:52
puede contener esta cosa 00:36:54
¿vale? entonces ¿qué ponemos? 00:36:56
este de aquí me ha creado 00:36:58
un array de 5 00:37:01
posiciones 00:37:04
y yo puedo ahora 00:37:06
acceder a estas posiciones así. Edades de 0 es igual a 10. Edades, ¿cuánto hablaréis? 00:37:08
No os calláis nunca. 20. Edades, ahora os cambio. Por ejemplo, puedo hacer cosas como 00:37:17
O edades de 3 es igual a edades de 2 más 10. 00:37:38
O la edades de 4 es igual a 10. 00:37:49
¿Vale? 00:38:01
Con esto he rellenado mi array. 00:38:02
Fijaos que tengo un solo nombre y luego uso estos para poder cambiar, que son numéricos. 00:38:04
¿Vale? 00:38:12
Pero el nombre, la variable es una sola. 00:38:12
Tengo sólo el array de enteros que es edades. Ahora, ¿cómo lo escribo en pantalla esto? Pues 00:38:14
si hizo Arrays.Dostring de edades. Ya está. Yo lo lanzo, aquí lo tengo. Este es mi array. Vamos a 00:38:22
hacer lo mismo que hace él, o parecido, pero vamos a hacerlo nosotros. Vamos a imprimir el contenido 00:38:43
de esto. Entonces, for, si tenéis dudas me paráis. Y es igual a cero y menor que cinco y más más, 00:38:49
piso, ¿qué pongo? Edades. Entonces, como esto la primera vez va a ser cero, uno, dos, tres, 00:39:01
4 pues la primera vez me pedirá edades de cero la segunda edad es de 1 entonces hace esto veis 00:39:23
poniendo mayúsculas minúsculas 00:39:54
lo estarás haciendo a la hora. 00:39:57
A raíz. 00:40:00
Si no lo pones bien te lo... 00:40:03
Lo han cortado. 00:40:08
Quita tu string, pon el punto y pon el string. 00:40:09
¿Tiro tu string con el punto? 00:40:12
Sí. 00:40:14
Y menos que 5 puedes también poner... 00:40:15
Ahora llevo. 00:40:18
Ahora llevo. 00:40:20
Ah. 00:40:21
Tendré que salir. 00:40:22
Vale. 00:40:24
Esto funcionaría, ¿vale? 00:40:26
Pero es feo, lo que dice nuestro compañero. 00:40:28
Poner 5 aquí quiere decir que si ahora yo pongo 6 aquí 00:40:31
y le pongo una nueva edad de 5 00:40:35
y le pongo 110, 00:40:40
pues esto sigue funcionando, pero el mío no. 00:40:44
Esto de aquí sigue poniendo 110, 00:40:49
pero yo 110 no lo he puesto, porque me he limitado a 5. 00:40:51
Entonces usar estos valores así 00:40:55
Directamente con el literal 00:40:58
Normalmente es un pillarse los dedos en el futuro 00:41:01
¿Vale? 00:41:05
En vez de decir un número concreto 00:41:06
Le tengo que decir 00:41:08
Oye, mira, yo no sé el array cuántas posiciones hay 00:41:10
Pero me vas desde la cero hasta la posición final 00:41:13
Y esto se hace con edades.length 00:41:16
fijaos que es azulito 00:41:20
y que no tiene paréntesis 00:41:23
dudas 00:41:25
ahora 00:41:30
me funciona 00:41:36
veis que le doy también la sexta posición 00:41:39
le quito el 00:41:41
el n 00:41:45
le pongo un espacio 00:41:45
y me lo escribe 00:41:49
parecido a esto 00:41:52
vale, otra forma de hacerlo 00:41:55
por 00:42:02
int k 00:42:04
es igual, no, int k 00:42:06
dos puntos edades 00:42:09
si, so 00:42:10
k, más 00:42:14
un espacio 00:42:21
veis que esto es lo mismo, que hace 00:42:22
lo mismo 00:42:25
pero en este caso, que tengo que ir 00:42:26
en todas las 00:42:29
unidades, todas las 00:42:30
celdas, pues esto 00:42:33
queda mucho más bonito y leíble 00:42:35
con respecto a esta cosa aquí 00:42:37
Ahora, pero esto me permitiría poner, por ejemplo, 00:42:39
así, una cosa de ese estilo, la edad 0 es 10, la edad 1 es 20, la edad 2 es... En esto no tengo una variable 00:43:00
en el for que me permita 00:43:19
decir en qué celda estoy. 00:43:22
¿Me la puedo crear? Sí. 00:43:24
Pero no la tengo. ¿Vale? No tengo acceso. 00:43:25
Sé que accederé a todas las 00:43:28
celdas, pero no sé en qué celda 00:43:30
estoy en un determinado momento para poder escribir. 00:43:32
Oye, estoy en la celda 3, este escribo. 00:43:34
¿Me entiendes? Voy a hacer 00:43:36
un int 00:43:38
celda, un numcelda 00:43:39
es igual 00:43:41
a cero. Y luego 00:43:44
aquí poner un numcelda más más. 00:43:46
Pero si ya tengo que hacer esta cosa extra 00:43:48
Pues entonces voy a hacerlo así 00:43:55
Tú das 00:43:57
Por ahí, Estefano, lo utilizas 00:44:01
Acá para almacenar datos 00:44:08
Simplemente 00:44:10
Lo que ponga aquí es 00:44:11
Delta actual 00:44:13
Delta actual 00:44:15
Vale, o sea que no 00:44:20
El índice va en automático 00:44:21
Va en automático 00:44:26
En vez de basarse sobre el índice, él por automático 00:44:27
dice que en cada ciclo actualiza 00:44:29
la celda actual con el valor de la siguiente 00:44:32
celda 00:44:34
las 00:44:34
preguntas 00:44:39
la referencia 00:44:43
entonces la trae que es solo una 00:44:46
no que cada posición tenga una 00:44:47
referencia propia 00:44:50
no, la referencia es una, lo que cambia 00:44:51
es que cada celda luego tendrá un índice 00:44:54
0, 1, 2, 3, 4 00:44:56
entonces tú vas 00:44:58
al objeto y luego dentro del objeto dice 00:45:00
posición dentro del objeto 00:45:02
La raíz tiene una sola referencia. 00:45:03
Esa que sale en Ares. 00:45:07
¿Van dudas? 00:45:12
¿Preguntas? 00:45:14
Ejemplo 2. 00:45:18
Hagamos parecido, 00:45:30
pero en vez de ponerlo nosotros así, 00:45:32
hagamos que nos lo dé el usuario. 00:45:34
¿Vale? 00:45:37
Entonces, sí, so. 00:45:38
escáner, escáner, escáner, es igual a newscanner 00:45:39
de system.int, vale, y le digo 00:45:44
CISO, ¿cuántos valores 00:45:51
quieres insertar? 00:46:00
int, num, es igual a 00:46:06
scan.nexy, vale, con esta cosa aquí 00:46:10
estoy preguntando al usuario, fijaos que yo no lo sé 00:46:18
cuántos son. Pero ahora estoy preguntando 00:46:22
al usuario cuántos valores quiere insertar. 00:46:24
Si me da 3, pues leeré 00:46:26
13 valores. Si me da 18, leeré 00:46:27
18 valores. 00:46:30
Por lo tanto, 00:46:32
aquí tengo este 00:46:34
número. 00:46:36
Podríamos hacerlo con variables simples. 00:46:37
Imaginaos que ahora yo quiera almacenar todos estos valores 00:46:41
para luego hacer algo con estos valores. 00:46:44
No sé qué. 00:46:46
Con variables simples no podría 00:46:48
hacerlo, porque puedo decir 00:46:49
int n1 es igual a int n2 00:46:51
¿Cuántas de estas he neado? 00:46:54
¿Cien? 00:46:57
Y si me dan mil valores 00:46:58
¿Se entiende el problema? 00:47:00
Sí 00:47:03
Pues entonces lo que hago es 00:47:03
vale, muy bien 00:47:05
int 00:47:06
bdb 00:47:06
valores 00:47:08
es igual a new 00:47:08
int 00:47:12
en un 00:47:13
¡Oh! 00:47:15
¡Bum! 00:47:19
Entonces, estamos hasta aquí. 00:47:23
¿Hasta aquí sí? 00:47:31
Ahora, yo quiero leer cuántos números. 00:47:32
No lo sé. 00:47:35
Num números. Num valores. 00:47:36
Si el usuario me pone 7, quiero leer 7 valores. 00:47:39
Si el usuario me pone 35, 00:47:41
quiero leer 35 valores. 00:47:43
Ahora, lo que no puedo hacer es ponerme a hacer 00:47:45
Internet 1, 00:47:47
Internet 2, 00:47:49
Internet 3, 00:47:51
porque no sé cuántas N 00:47:53
tengo que hacer. Si él me da 7 00:47:55
tendré que hacer hasta N7. Si él me da 100 00:47:57
tendré que hacer hasta N100. 00:47:59
Pero es que no lo sé. Ahora a nivel de 00:48:01
programación, no lo sé. 00:48:03
Entonces, ¿qué hago? Esta maravilla. 00:48:05
¿Qué me dice? 00:48:08
Créame un array 00:48:10
de valores. Vale, perfecto. 00:48:11
¿Y cuántas posiciones tiene? 00:48:13
Pues tiene N1 posiciones. 00:48:15
¿Quién? El valor que te acaba de dar. 00:48:17
¿Te ha dado 7? Esto es 00:48:19
un array de 7 posiciones. ¿Te ha dado 00:48:21
35. Esto es un array de 35 00:48:23
posiciones. Se ha dado 1000. 00:48:25
Esto es un array de 1000 posiciones. 00:48:27
¿Sí? Perfecto. 00:48:31
Y ahora 00:48:34
voy a recorrerme el array 00:48:34
y rellenarlo. 00:48:37
For 00:48:40
int i es igual a 0 00:48:41
i menor que valores 00:48:44
punto length 00:48:46
i más más 00:48:48
créame una variable 00:48:50
que va desde 0 00:48:52
hasta NUM-1. Y me dice que CISO, dame el valor, el valor en posición así, y luego haré que dentro 00:48:54
de valores 00:49:18
de i 00:49:20
voy a poner que 00:49:24
dentro de valor de i 00:49:26
voy a poner que 00:49:33
exacto, scan.nexin 00:49:34
como este es un for 00:49:42
que por cada celda 00:49:47
me repitiera esto 00:49:48
lo que te está diciendo por cada celda es 00:49:49
dame el valor en la posición ese de allí 00:49:52
y te leo un valor y lo almacenará 00:49:54
en esa posición 00:49:56
entonces cuando i valdrá 0 00:49:57
te dirá dame el valor en posición 0 00:50:00
Y lo guardará en valores de 0 00:50:02
Luego pasará a 1 00:50:04
Y te dirá, dame el valor en posición 1 00:50:05
Y te lo guardará en valores de 1 00:50:08
Y así, así, así, así 00:50:10
Hasta el numerito que tú me has dado 00:50:11
¿Ok? 00:50:13
Cuando acabo esta cosa aquí 00:50:16
Si hizo 00:50:18
Arraiz.doString 00:50:19
Esta cosa aquí 00:50:23
Valores, para ver que 00:50:25
Efectivamente ha almacenado todos los numeritos 00:50:29
Que he puesto 00:50:31
vamos a verlo 00:50:32
like 00:50:33
¿cuántos valores quiere aceptar? 00:50:34
también puedo hacer 1 00:50:38
1, 2, 3, 4, 5, 6 00:50:40
y 7 00:50:44
y veis que ahora tengo mi array 00:50:45
con dentro los valores que le he pasado 00:50:47
al programar 00:50:49
yo no tengo ni idea 00:50:53
de cuántos valores me pregunta 00:50:55
ni de cuáles son los valores que me va a poner 00:50:57
pero luego funciona 00:51:00
yo le digo, ahora quiero darte solo 3 00:51:02
que son 11 00:51:06
menos 65 00:51:07
que es 46 00:51:09
y ahora tengo mi array con dentro 11 00:51:11
menos 65 es 46 00:51:13
preguntas 00:51:15
ejemplo 3 00:51:20
entonces, leamos una 00:51:31
palabra de teclado 00:51:49
y la transformamos en un array de string 00:51:51
donde en cada celda 00:51:54
hay una letra 00:51:57
de esa palabra 00:51:58
centraos cuando lo he enunciado 00:51:59
independientemente de lo que diga 00:52:06
podría decir, hagamos una variable 00:52:08
x con dentro 3, ¿cómo? 00:52:10
¿ves? centraos 00:52:14
leemos una palabra 00:52:15
scanner, scanner es igual 00:52:17
a new scanner 00:52:20
de system.in 00:52:21
Sí, so 00:52:24
¿Cómo te llamas? 00:52:28
String name 00:52:37
es igual a scan.next 00:52:38
Sí, y ahora empiezo 00:52:41
y quiero transformar esta string 00:52:45
en una array de char 00:52:48
¿Vale? Que tenga en cada celda 00:52:51
una letra de la string que he mandado, ¿vale? Por ejemplo, char pdb o mi array, 00:52:54
array, palabras, letras, es igual a new char, de esta cosa aquí, que ponga aquí dentro, name, 00:53:05
pero así 00:53:18
¿os acordáis que tenía 00:53:28
este metodito aquí 00:53:32
que me decía cuantos caracteres 00:53:34
tiene dentro un string 00:53:36
pues ya está 00:53:38
si yo he puesto 00:53:39
hola, cuatro caracteres 00:53:41
esto vale cuatro, me creará un array 00:53:43
de cuatro caracteres 00:53:46
Si yo he puesto dentro cocodrilo, pues me pondrá cuántas letras son cocodrilo, que no tengo yo. 00:53:47
Entonces ya tengo mi array de char listo. 00:53:55
Ahora lo que tengo que hacer es ir celda por celda y cargar dentro de la celda una letra. 00:54:01
por int i es igual a cero 00:54:09
i menor, menor, menor, menor, menor, menor 00:54:13
que letras punto lengua. 00:54:18
Fijaos esta vez sin el punto y sin la paréntesis. 00:54:23
Que i más más 00:54:27
lo que hago es que en letras 00:54:28
de i voy a poner 00:54:34
name.charact 00:54:38
de ahí 00:54:41
ponme en la posición 00:54:43
diezima de la 00:54:52
array el carácter 00:54:54
diezimo de la string 00:54:56
entonces 00:54:57
luego aquí si eso 00:55:01
array 00:55:04
punto 00:55:07
string de letras 00:55:08
y veo que me pone 00:55:12
lanzo 00:55:14
¿cómo te llamas? 00:55:15
Estefano, sin PH, con la O al final, una F sola, sin la E delante. 00:55:17
¡Ay! ¡Mi rey! 00:55:27
¡Guau! ¡Guau! ¡Guau! 00:55:30
¿Qué tal? 00:55:38
¿Qué tal? 00:55:41
Con esto, muchos ejercicios que antes habéis tardado una vida en hacer, se hacen mucho más rápido. 00:55:50
Con esto ahora puedo hacer los valores que me das, en vez de perderlos, los almaceno todos y luego después trabajo con los valores que me has dado y hago la media de lo positivo y la media de lo negativo. 00:56:01
¿Pero estáis razonando o estáis copiando como se está grabando? 00:56:25
Es inútil que copiéis, razonad, pensad en lo que se está haciendo, 00:56:29
no escribid cosas copiando sin entender qué estamos haciendo. 00:56:33
¿Entre qué habláis y qué pasa el tiempo acá a copiar? 00:56:42
Pues, ¿dudas? 00:56:46
Vamos a hacer un ejercicio difícil. 00:56:51
lo que has hecho en el char de letras 00:56:54
para que a mí me quede claro es 00:57:07
has creado un array de char 00:57:09
llamado letras 00:57:11
en el que 00:57:13
ese char recoge 00:57:15
la cantidad de posiciones 00:57:17
del string 00:57:19
o sea, un array de char 00:57:20
letras apunta a una estructura 00:57:23
con varias celdas 00:57:26
¿cuántas celdas? 00:57:28
¿cuántas letras tiene la palabra? 00:57:29
¿sí? 00:57:35
yo no entiendo lo de dentro del 00:57:37
yo lo del 00:57:38
dentro del for 00:57:40
en la posición 00:57:42
y de letras 00:57:44
que es el array 00:57:46
la primera vez en la posición 0, la posición 1, la posición 2 00:57:47
me pones 00:57:51
el carácter en posición 00:57:52
y de la palabra. 00:57:55
Entonces, ponme 00:57:58
en letras de cero 00:57:59
el carácter en posición 00:58:00
cero de la palabra que me 00:58:03
manda la carta. 00:58:05
Este es el charazo cero 00:58:07
que me da el primer carácter. 00:58:09
Entonces, luego me dice 00:58:14
ok, ahora y vale 00:58:15
uno. Ponme dentro de 00:58:17
letras de uno, o sea, en esta celda de aquí 00:58:19
el carácter que está 00:58:21
en posición 1 de esta palabra, o sea, esta cosa de aquí, entonces me pone aquí, ¿dudas? 00:58:23
Sí. 00:58:32
Todos los tipos primitivos, tú puedes crear un array de todos los tipos primitivos, y luego de string, 00:58:36
de lo que quieras. 00:58:42
cualquier tipo de cosa 00:58:44
tú puedes crear un array de strings 00:58:55
puedes crear un array de scanners 00:58:57
puedes crear un array de 00:58:58
dudas 00:59:00
hacemos 00:59:07
complicamos un poquito esto 00:59:10
a ver, ¿os parece? 00:59:13
Estos son ejercicios súper sencillos. 00:59:17
Vamos a hacerlo un poquito más complejo. 00:59:20
¿Eh? ¿Eh? 00:59:22
Temas de algo complejo. 00:59:32
No, lo que quería hacer es temas de algo complejo. 00:59:35
No, necesito lo que nos ha explicado todavía. 00:59:43
Para hacer lo que quiero. 00:59:47
Entonces... 00:59:50
Pero lo podemos hacer en una versión un poquito más simplificada, que es la siguiente, ¿vale? 00:59:50
Yo te doy una palabra, tú la pones en el array, como antes, pero si la letra está duplicada, no la pones. 00:59:54
Este es un ejercicio un poquito más complejo 01:00:06
Bastante más complejo 01:00:22
Si yo pongo casa 01:00:31
Me pone 01:00:32
C, A, S 01:00:33
Y un espacio vacío 01:00:35
¿Cash? 01:00:36
¿Cash? 01:00:38
¿Con H al final lo que quiero es un minuto? 01:00:39
¿Cash? 01:00:41
BigDollar. 01:00:44
¿Cash? 01:00:48
¿Cash? 01:00:50
Aquí pondría 01:00:51
C, A, S 01:00:53
y luego un espacio vacío. 01:00:55
¿Por qué? 01:00:57
Porque casas son de cuatro letras, 01:00:58
tú creas un array de cuatro espacios, 01:01:01
pero luego pones solo C, A, S 01:01:03
entonces de cada un espacio vacío quitar este espacio necesitaréis lo que veremos mañana 01:01:05
si imprimes en un array 01:01:10
si no metes un valor 01:01:16
si no metes un valor 01:01:21
si solo imprimes 01:01:23
que es lo que quieres 01:01:30
y vas a unir un índice 01:01:31
que imprimirías 01:01:33
yo le pongo 01:01:34
lo escribo aquí 01:01:37
aquí he creado la red 01:01:41
pero todavía no he puesto nada dentro 01:01:44
entonces, ¿qué hay dentro por defecto? 01:01:45
chicos 01:01:51
oigan 01:01:52
¿dónde estáis? 01:01:53
¿dónde creéis que estáis? 01:01:55
porque si lo sabéis, lo dejamos así 01:02:01
y hacemos el examen esta semana dentro de 3 01:02:03
porque si os hace reír 01:02:05
ha entendido enseguida 01:02:07
Vuestro compañero ha hecho una pregunta 01:02:12
Vosotros, aparte de 01:02:20
faltar respecto a mí 01:02:22
estáis faltando respecto a él 01:02:24
y no sabéis qué pregunta 01:02:26
ha hecho ni la respuesta a esta pregunta 01:02:28
Si os parece bien esta cosa 01:02:30
porque sepáis que no está 01:02:32
por defecto 01:02:34
este debería ser 01:02:49
el rey vacío 01:02:51
el carácter vacío 01:02:52
Porque luego pone un espacio. No sé si es el espacio o cero, pero podríamos hasta decir aquí, pint de letras de cero. Es el char cero. 01:02:55
El símbolo correspondiente al char cero. Que probablemente es como, no sé si es un espacio, una cosa rara que luego él interpreta como un cero de espacio. 01:03:28
porque veis aquí donde pone la S aquí pone un espacio 01:03:38
pero eso sustancialmente 01:03:40
representa el carácter vacío 01:03:42
podéis ir a ver la palabra 01:03:44
que tiene 01:03:51
y la mirada del cero 01:03:53
es null, es el carácter null 01:04:02
es un carácter especial 01:04:04
no es el valor null como tal 01:04:07
no, porque no es mujer 01:04:11
luego lo interpreta 01:04:14
como un espacio aquí 01:04:20
Pero en realidad, si te vas al koiwashi, hay un espacio, hay un carácter para el espacio. 01:04:22
Por algún lado aquí debería haber un carácter para el espacio, no lo he visto. 01:04:27
Pero es diferente, ¿no? O sea, que no es lo mismo ese espacio... 01:04:58
Yo diría que es diferente, pero a lo mejor no, a lo mejor es como se... 01:05:01
El 32 es el espacio. El 0 es carácter nulo. Que luego un procesador de texto, el Java, interprete que es carácter nulo, te lo hago como un espacio, es otra cosa. 01:05:07
Pero si tú luego vas a mirar allí, porque yo podría, yo podría, ahora no te lo pilla porque es next, ¿vale? 01:05:24
si yo como cuando te dice como te llaman me pongo stefano espacio y esa pues ese 01:05:33
espacio es un carácter que no es igual a este cerdo 01:05:37
ahora como aquí he utilizado next sólo me pilla stefano, debería por ejemplo pillar nextline 01:05:42
para que funcione así, para hacer nextline y luego lanzo esto y pongo 01:05:46
stefano, pieza y ahora este no es lo mismo que este 01:05:53
visualmente se ven pero no son 01:06:01
un valor malo 01:06:03
vale 01:06:08
pues nada 01:06:09
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
Visualizaciones:
6
Fecha:
4 de noviembre de 2025 - 14:33
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 06′ 13″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
555.78 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid