Saltar navegación

Estructuras de control iterativas - 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 15 de octubre de 2024 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a grabar la clase, por lo tanto, si habláis o hacéis preguntas, pues me autorizáis a grabar vuestra voz, ¿vale? 00:00:00
Entonces, hasta ahora estamos con las estructuras de control, ¿vale? 00:00:07
Entonces, lo que permiten hacer es controlar el flujo de ejecución de un programa. 00:00:15
Hemos visto que, en teoría, vemos tres familias, tres cosas distintas. 00:00:21
Una es el condicional que sostancialmente me está diciendo que un bloque se ejecutará o no dependiendo de una condición 00:00:27
El if como ejemplo básico 00:00:35
Más hemos visto el if-else, más hemos visto el switch que son otras estructuras parecidas 00:00:38
Ahora vamos a ver el segundo bloque de opciones que son las estructuras iterativas 00:00:45
Son, sustancialmente, pillar un bloque, un conjunto de comandos, una serie de instrucciones y que estas instrucciones se repitan más de una vez. 00:00:53
La idea es que mientras una condición sea verdadera o un cierto número de veces, quiero repetir un bloque de instrucciones. 00:01:05
Veremos para qué sirve y haremos ejemplos. 00:01:14
La tercera, tercer bloque será el de llamada de métodos 00:01:17
Porque sustancialmente yo estoy ejecutando un código 00:01:22
Interrumpo un código en un cierto momento 00:01:25
Me voy a otro bloque de códigos 00:01:28
Ejecuto eso y luego vuelvo a lo que estaba ejecutando 00:01:30
Pero lo veremos más adelante 00:01:33
Por ahora centrámonos en las estructuras iterativas 00:01:34
Estructuras iterativas permiten repetir un determinado bloque más de una vez 00:01:38
Podría ser cero, una o más veces 00:01:42
La idea es que se pueda repetir un bloque 00:01:46
Y existen dos grandes estructuras iterativas que podemos utilizar en este contexto 00:01:50
Posiblemente en algunos lenguajes existen más 00:01:59
En Java existe también otra que es parecida a estas 00:02:01
Que son el while y el for 00:02:04
El while es una estructura que te dice 00:02:08
Vete repitiendo este bloque, esta serie de instrucciones 00:02:13
Mientras que una condición sea verdadera 00:02:19
Tú estableces una condición 00:02:22
Esta condición será una expresión booleana 00:02:24
Mientras que esta condición será verdadera 00:02:27
Mi programa seguirá ejecutando una vez y otra y otra y otra el mismo bloque 00:02:31
Cuando esta condición se volverá falsa 00:02:38
Pues entonces saldré del bloque y seguiré adelante 00:02:42
Con la instrucción que está debajo del while 00:02:45
¿Cuántas veces lo voy a ejecutar? 00:02:47
No lo sé 00:02:51
El while, a priori, no sé cuántas veces voy a ejecutar ese bloque 00:02:51
Mientras que la condición sea verdadera, sigo 00:02:58
Cuando la condición se volverá falsa, pues a ese punto saldré 00:03:01
Por otro lado está en vez el for 00:03:05
El for es, a nivel lógico, lo mismo 00:03:09
Es siempre una estructura iterativa 00:03:13
De hecho, puedo cambiar un while para que haga como un for 00:03:15
Y puedo cambiar un for para que haga como un while 00:03:19
Pero el for se suele utilizar cuando yo ya sé 00:03:21
Cuántas veces voy a ejecutar ese bloque 00:03:26
Cuidado, que este cuántas veces puede que sea una variable 00:03:30
Puede que sea n 00:03:33
Entonces, hasta que el usuario no me dé ese número 00:03:34
no lo sé, pero sé que una vez que 00:03:39
se ha fijado ese número, que habré sacado ese número 00:03:41
por donde sea, pues ese número 00:03:43
n vale 10, pues sé que ejecutaré 00:03:45
este bloque 10 veces, ese número vale 3 00:03:47
pues sé que ejecutaré este bloque 3 veces 00:03:49
¿vale? 00:03:51
mientras en un while 00:03:52
tú no sabes cuántas veces lo vas 00:03:54
a hacer porque estás esperando que una condición 00:03:57
se cumpla o no se cumpla en este caso 00:03:59
entonces mientras que la condición 00:04:01
está verdadera, sigues dando 00:04:03
vueltas hasta que llega un momento en que 00:04:05
Cambiará algo, tendrá que cambiar algo 00:04:07
Para que tú salgas 00:04:10
En el for 00:04:11
Pues puede ser que 00:04:12
A nivel de 00:04:14
De programación 00:04:15
Mientras estás programando 00:04:19
No sabes cuantas veces harás este ciclo 00:04:20
Pero está escrito en algún lado 00:04:23
Está escrito en una variable 00:04:25
Cuando esta variable estará instanciada 00:04:26
Pues ese es el número de veces que lo hace 00:04:28
Guay, vale 00:04:30
Entonces, si yo tengo un cierto bloque de instrucciones 00:04:33
Este de aquí, vale 00:04:36
Y yo lo que quiero es que llego desde arriba, entro en una condición y evalúo esta condición 00:04:38
Esta será una expresión booleana 00:04:44
Podrá haber AND, OR y todas las cosas que hemos visto de los booleanos 00:04:46
Pero al final, después de haber evaluado esta condición, tendré o TRUE o FALSE 00:04:51
Si tengo FALSE, salto todo y sigo adelante 00:04:56
Si tengo true, ejecuto una vez el bloque de instrucciones asociado con el while 00:05:02
Y vuelvo arriba a evaluar nuevamente la condición 00:05:09
Mientras que esta condición sea verdadera, yo seguiré dando vueltas en este bucle de aquí 00:05:14
La idea es que por algún lado aquí en estas instrucciones haya un momento en que algo de esta condición cambie 00:05:25
Para que llegue un momento en que esta condición se vuelva falsa, salgo del while y sigo adelante 00:05:33
Cuidado, porque hasta ahora todos los programas que hemos hecho siempre acababan 00:05:39
Tú lanzabas un programa, se quedaba a lo mejor ahí a la espera que tú escribías algo 00:05:46
Pero en cuanto tú habías lanzado el programa y escrito los datos, pues ese programa acababa 00:05:51
Ahora, con el while, nos exponemos a un problema nuevo 00:05:56
Que es un bucle infinito 00:06:01
Si yo pongo una condición aquí 00:06:04
Y no cambio esta condición nunca en las instrucciones 00:06:07
No saldré nunca de este bucle 00:06:12
Y si esto es lo que quiero hacer, muy bien 00:06:15
Pero si no es lo que quiero hacer, pues es un problema 00:06:19
Porque puede que mi programa empiece a dar vuelta aquí un mogollón de veces 00:06:24
Y me consume, me gaste mucho de procesador, de memoria, cosas por el estilo 00:06:29
Porque está allí para siempre dando vueltas en ese bucle 00:06:39
¿Existen programas que no acaban nunca? 00:06:41
Sí, pensad al programa de un cajero automático 00:06:45
Pues tú vas allí, metes la tarjeta, pillas el dinero 00:06:48
Y luego el programa no acaba, vuelve al principio 00:06:52
Entonces se puede hacer programas que estarán para siempre dando ciclos aquí 00:06:54
Y que estarán parados de otra forma 00:07:00
Que algo externo lo parará o cosas por el estilo 00:07:03
Sí, se puede hacer 00:07:08
Pero la cosa fundamental es que vosotros tenéis que saber qué estáis haciendo 00:07:09
Tenéis que saber que si el programa tiene que acabar 00:07:15
Pues aquí en las instrucciones 00:07:17
En algún momento tendréis que poner algo 00:07:19
Que cambie esta condición 00:07:21
¿Sí? 00:07:22
Cuando la condición se vuelve 00:07:24
False, pues salimos y seguimos adelante 00:07:27
Ejemplo de un while muy sencillo 00:07:29
¿Qué hace 00:07:32
Este while 00:07:32
Según vosotros? 00:07:34
Deja jugar 00:07:38
También a los demás 00:07:39
Deja un minuto 00:07:40
Que la gente piense 00:07:42
O 20 segundos 00:07:43
Y me decís, según vosotros, que va a aparecer en pantalla 00:07:47
Un momento, ahora os lo digo yo 00:07:54
Pablo, venga, ¿qué hace esto? 00:08:00
Vale, este de aquí pone, al principio i vale 0 00:08:23
Entrará aquí y se preguntará, ¿i es menor o igual que 10? 00:08:52
Pues sí, entrará aquí dentro y imprimirá 0 00:08:57
y luego hace i es igual a i más 1, o sea que i será 1 00:08:59
vuelve aquí arriba y dice 1 es menor o igual que 10 00:09:04
si, entra aquí dentro y imprime 1 y i será 2 00:09:08
vuelve aquí y dice 2 es menor que 10 00:09:11
y así, así, así hasta que llega un momento en que aquí se ejecutará 00:09:15
i más 1 y será 10, vuelve aquí y me pregunta 00:09:19
i es menor o igual que 10, si, por lo tanto entra 00:09:23
y escribe 10, entonces los números del 0 al 10 00:09:27
a este punto, por favor un momento 00:09:30
a este punto i suma 1, llega a 11 00:09:33
va aquí, 11 no es menor o igual que 10 00:09:39
y por lo tanto saldría de este bloque y seguiría 00:09:43
aquí adelante, tened en cuenta que a partir de aquí abajo 00:09:47
i valdría 11 00:09:51
Porque la última vez que ha pasado por aquí 00:09:55
Ha ejecutado esto, valía 10 00:09:59
Entonces ha entrado, ha escrito 10 00:10:01
Se ha actualizado a 11 00:10:03
Ha llegado aquí, ha salido 00:10:05
Dentro de ahí se ha quedado 11 00:10:07
¿Sí? 00:10:09
Pablo, no 00:10:13
No porque he declarado int fuera 00:10:17
La variable está declarada fuera de este bloque 00:10:19
Por lo tanto el ámbito de esta variable es el bloque externo 00:10:26
Por lo tanto aquí debajo sigue valiendo 11 00:10:29
A ver, oficialmente sería 1, 2, 3, 4, 5, 6, 7, 8, 9 00:10:32
Pero como es tan rápido, tú lo vas a ver como de bloque 00:10:46
Si le pusieras aquí algo o una operación muy compleja 00:10:48
Que él tarda 30 segundos en hacerla 00:10:54
Pues entonces te escribiría un número cada 30 segundos 00:10:56
Cuando lo va a ejecutar 00:10:59
Solo que estas operaciones aquí son tan rápidas 00:11:01
Que tú lo ves de bloque 00:11:04
Podrías ponerle lo que se llama un thread.slip 00:11:05
Que es sustancialmente párate un segundo, por ejemplo 00:11:14
Entonces, un thread.sleep 00:11:17
Lo veremos más adelante 00:11:19
Entonces, entrarías aquí, harías una operación 00:11:20
Luego estarías un segundo parado, sin hacer nada 00:11:22
Luego lo harías otra vez 00:11:25
Entonces verías lo que sale una vez a cada segundo 00:11:26
Sí 00:11:29
Repetir un bloque 00:11:30
Ahora, ¿cuál es el sentido de esto? 00:11:35
Escribir los números de 1 a 10 00:11:39
O sea, de 0 a 10 00:11:41
Sin tener que escribir 10 veces 00:11:42
Si está en .ato.println 00:11:45
¿Sí? 00:11:46
O los números de 1, de 0 a 5000, sin tener que escribir 5000 veces system.auto.println. 00:11:48
Ahora, ¿para qué sirve en la vida real? Por mogollón de cosas. 00:11:58
O sea, hoy lo vamos a utilizar y no lo vais a dejar nunca jamás. 00:12:01
Pensad a todos los ejercicios donde os he dado una palabra y decía que tiene que ser de 4 letras, 00:12:08
O una palabra que tiene un número de tres dígitos 00:12:15
Y cosas por el estilo 00:12:18
Porque no teníamos la posibilidad de 00:12:19
Un número N de dígitos 00:12:21
Y hacer las cosas desde el primer dígito 00:12:23
Hasta el final 00:12:26
Porque tenía que hacerlo yo 00:12:26
Con fuerza bruta 00:12:28
Pues ahora mismo no 00:12:31
Ahora mismo ya yo puedo pillar una cualquier palabra 00:12:33
Y ver si es palíndroma o no 00:12:36
O capicúa 00:12:38
O sea, que serán los próximos ejercicios 00:12:39
Los ejercicios que vamos a hacer ahora serán parecidos 00:12:41
A los que hemos visto hasta ahora 00:12:43
Pero con un poquito más de complejidad 00:12:45
En vez de resolver solo problemas concretos 00:12:48
De solo números con tres dígitos 00:12:50
Pues ahora haremos, dame un número cualquiera 00:12:53
Y ese número voy a hacer lo que tengo que hacer 00:12:55
¿Sí? 00:12:59
Veremos 00:13:00
¿Qué aclaró el while? 00:13:00
O sea, ¿qué hace? 00:13:03
Como la estructura, la sintaxis, ¿vale? 00:13:04
While, palabra reservada 00:13:06
Una condición, no necesariamente tiene que utilizar y 00:13:08
Pues aquí he utilizado y, pero ¿qué más da? 00:13:11
Y aquí dentro escribe 00:13:14
Fijaos que en este caso 00:13:16
La condición depende de i 00:13:20
Y que dentro del bloque 00:13:22
En algún momento he toqueteado i 00:13:25
Si quito este i 00:13:27
Imaginaos que esta línea no esté 00:13:29
¿Qué haría este programa? 00:13:32
Sin esta línea 00:13:34
Muy bien, ¿por qué levantar las manos? 00:13:34
¿Qué haría esta cosa? 00:13:42
Efectivamente 00:13:46
Escribiría cero 00:13:46
Nunca se actualiza cero 00:13:48
Por lo tanto, cada vez que pasa por aquí, escribiría un cero 00:13:49
Y cada vez cero sería menor o igual que diez 00:13:52
Entonces se quedaría aquí al infinito poniendo cero, cero, cero, cero 00:13:55
¿Vale? 00:13:59
Y mi programa no acaba 00:14:01
No, no explota 00:14:03
Porque es lo que le has dicho que haga 00:14:13
¿Vale? 00:14:15
Si lo que estás haciendo es algo que gasta recursos 00:14:17
Crea memoria 00:14:22
No si creas una variable aquí dentro 00:14:23
Porque cada ciclo se destruiría 00:14:25
Si por ejemplo creas un proceso, cada vez que pasas por aquí creas otro programita. 00:14:27
Y entonces vas creando proceso, vas creando proceso, como los recursos son limitados, 00:14:32
llega un momento en que el sistema operativo no puede crear más procesos y explota. 00:14:37
Pero esta cosa de aquí puede tirar para siempre. 00:14:41
Luego lo hacemos. 00:14:45
Así es como podría funcionar algún tipo de virus. 00:14:49
Pero sería muy básico un virus que hace eso. 00:14:53
dudas una versión un poquito distinta del while que pero es muy parecida es el do while vale si 00:14:59
os fijáis en el while podría ser que estas instrucciones no se ejecuten nunca si yo llego 00:15:11
a esta condición y esta condición es falsa salto esto y sigo adelante vale si este número de aquí 00:15:20
en vez de ponerle 0 le digo al usuario 00:15:28
dame un número 00:15:30
y el usuario le pone 30 00:15:31
30 es menor o igual que 10 00:15:33
no, saltaría esto y seguiría adelante 00:15:35
nunca haría nada 00:15:38
dentro de este bloque 00:15:40
si yo quiero 00:15:40
estar seguro que al menos 00:15:43
una vez este bloque se ejecute 00:15:46
luego puede ser que no se repita 00:15:48
pero que una vez se ejecuta 00:15:50
y a partir de allí podría 00:15:52
repetirse varias veces o podría 00:15:53
no repetirse, pues puedo utilizar 00:15:56
el do while 00:15:58
el do while tiene las instrucciones 00:15:58
antes 00:16:02
y una vez siempre 00:16:03
se ejecutará esta instrucción 00:16:06
una vez ejecutada esta instrucción 00:16:07
llego a la condición 00:16:10
y si es verdadero, vuelvo 00:16:11
a ejecutar las instrucciones 00:16:14
si es falso, sigo adelante 00:16:16
entonces la sintaxis sería así 00:16:17
int contador es igual a 0 00:16:22
y luego el bloque, esta ejecución de aquí, esta cosa aquí 00:16:24
se ejecutará al menos una vez siempre 00:16:29
y luego después, mientras el contador es menor o igual que 10 00:16:32
pues sigue haciendo cosas, fijaos 00:16:36
no hay punto y coma por ningún lado, aquí en las instrucciones 00:16:39
pero en el while no, si ponéis un punto y coma aquí, habéis hecho 00:16:44
un while eterno que no hace nada 00:16:48
Como el if que no haría nada 00:16:52
Pero en este caso el problema es que el while 00:16:56
Se quedaría aquí dentro para siempre 00:16:58
Porque esto no se actualiza 00:17:00
Y estaría haciendo un comando vacío para siempre 00:17:01
Por tanto cuidado con esto 00:17:04
Sin embargo en el do while 00:17:06
La condición while 00:17:09
Acaba con un punto en coma 00:17:11
Entonces cuidado con la sintaxis 00:17:13
Si aquí pusiera 11 00:17:17
La primera vez escribiría 11 00:17:28
Haría contador 12 00:17:31
Aquí se daría cuenta que 12 es menor o igual que 10 00:17:34
No, por lo tanto salgo y sigo adelante 00:17:37
Y a partir de aquí abajo, mi contador valdría 12 00:17:39
Si pongo 100, pues me imprimiría 100 00:17:42
Valdría 101 y saldría 00:17:47
Si pongo 0, como es este caso 00:17:49
Pues entro aquí dentro, escribo el 0 y cambio a 1 00:17:52
Escribo 1 y cambio a 2 00:17:55
Escribo 2 y cambio a 3 00:17:58
Hasta que valga 10 00:17:59
Entonces escribo el 10 00:18:01
esto me vale 11, y aquí 11 no es menor o igual que 10 00:18:03
por lo tanto salgo, o sea que haría exactamente lo mismo que antes 00:18:07
solo que la diferencia es que 00:18:11
esto una vez se ejecutará siempre, mientras que aquí 00:18:14
esto podría no ejecutarse nunca, dependiendo de la condición 00:18:19
en cierto sentido, aquí antes evalúo la condición y luego empiezo a repetir 00:18:22
mientras aquí empiezo a repetir y luego evalúo la condición 00:18:28
o dicho de otra forma 00:18:32
esto me permite repetir esto 00:18:35
cero o más veces 00:18:37
esto me permite 00:18:39
repetir esto una o más veces 00:18:41
dudas 00:18:44
tanto el while 00:18:47
como el do while 00:18:52
se utilizan 00:18:53
normalmente cuando no tengo 00:18:56
claro cuantas veces 00:18:58
tengo que ciclar 00:19:01
cuantas veces tengo que 00:19:03
volver a repetir este bloque aquí 00:19:04
¿Vale? 00:19:06
Si, por ejemplo, en este caso de aquí 00:19:08
Que yo sé más o menos cuántos son 00:19:11
Se repite unas 10 veces 00:19:13
El while no sería el más indicado 00:19:15
¿Vale? 00:19:18
Se pone aquí como ejemplo porque es la cosa más fácil que se puede hacer 00:19:19
Escribir un número 10 veces 00:19:21
¿Sí? 00:19:23
O 11 00:19:24
Pero 00:19:24
Cuando yo sé que voy a repetir esta cosa 10 veces 00:19:25
O 11 veces 00:19:30
O 20 veces seguro 00:19:31
Lo que debería utilizar 00:19:32
Es el for 00:19:34
¿Vale? 00:19:35
Son equivalentes 00:19:36
Lo que puede hacer con el for 00:19:38
Se puede hacer con el while 00:19:40
Lo que puede hacer con el while 00:19:42
Lo puede hacer con el for 00:19:44
Pero es un poco como el if y el switch 00:19:45
El if y el switch pueden hacer las mismas cosas 00:19:48
Pero hay veces 00:19:50
Que mejor un switch de un if 00:19:52
Y hay veces que mejor un if de un switch 00:19:54
Pues aquí lo mismo 00:19:56
Cuando uso el while 00:19:57
Cuando no sé cuantas veces voy a estar aquí dentro 00:19:59
Imaginaos un ejercicio que os diga 00:20:02
Dame un número 00:20:04
Yo leo el número 00:20:05
Y si el número es positivo 00:20:07
Sigo pidiendo números 00:20:08
Si el número es negativo, acabo 00:20:10
¿Sé cuántas veces voy a pedir números? 00:20:13
No, porque depende del usuario 00:20:17
Si un día el usuario se despierta 00:20:18
Y me da 100 números positivos 00:20:20
Pues yo repetiré esto 100 veces 00:20:22
Y cuando me dará el negativo, saldré 00:20:24
Si mañana se despierta y me da 3 números positivos 00:20:26
Y luego un negativo, pues solo tendré que repetir 3 veces 00:20:29
Pero a tiempo aquí 00:20:31
No sé cuántas veces serán 00:20:32
Serán n veces, ¿sí? Sin embargo, si yo sé que quiero hacerlo 10 veces, por ejemplo, pues debería utilizar un for. ¿Cómo funciona un for? Es un poquito más complejo, pero hace lo mismo que antes, ¿vale? Hay una inicialización donde se inicializa un índice, una variable, un contador, ¿vale? A un cierto valor. 00:20:34
Por ejemplo, i igual a 0, lo mismo que se hacía aquí, pero esto está incrustado en el mismo for, ahora veremos la cosa. 00:20:56
Luego se empieza a mirar una condición, si la condición es verdadera, entro y hago las instrucciones, 00:21:05
pero tengo un paso adicional que una vez acabadas las instrucciones, tengo una fase de actualización barra incremento de la variable que he inicializado aquí. 00:21:14
esto 00:21:24
for int i es igual a 0 00:21:27
i menor que 10 00:21:31
i más más 00:21:32
fijaos que aquí estoy utilizando el menor estricto 00:21:34
block 00:21:37
entonces esta cosa de aquí 00:21:38
se ejecutará 00:21:41
mientras que i es menor que 10 00:21:43
pero i valdrá 0 00:21:46
la primera vez que empiezo 00:21:48
esta es la fase de inicialización 00:21:49
0 es menor que 10 00:21:51
por lo tanto entraré 00:21:54
Y antes de volver aquí, antes de volver a comprobar esta, voy a hacer la fase de actualización, que es esta de aquí. 00:21:55
Y más más. 00:22:05
Si ponéis un igual aquí, esto hace exactamente lo mismo que esto. 00:22:08
Lo mismo. 00:22:15
Inicializa, verifica, actualiza. 00:22:16
Solo que como esto se hace muchas veces, Java proporciona, y muchos otros programas, lenguaje de programación, 00:22:20
Proporciona una estructura propia 00:22:27
Para cuando tienes que hacer este tipo de cosas 00:22:30
Cuando tú sabes una variable que empieza en un valor 00:22:32
Y que tiene que hacer una cosa varias veces 00:22:35
Y este valor va incrementando cada vez 00:22:37
37 y mayor que 94 y menos menos 00:22:39
¿Qué te hago? 00:22:51
Ah, aquí, scan, sí, sí 00:22:54
¿Por qué no? 00:22:56
Cuidado 00:23:03
Esto se entiende más o menos 00:23:04
¿Vale? Entonces es como un ciclo 00:23:07
Pero en automático 00:23:09
Por cada ciclo se ejecuta esto 00:23:10
Entonces en este caso por ejemplo 00:23:12
Y empezaría en 0 y por cada ciclo 00:23:14
Cada vez que voy a comprobar esto 00:23:16
Y me aumenta de 1 00:23:18
La primera vez valdrá 0, la segunda vez 1, la tercera vez 2 00:23:19
Etcétera, etcétera, etcétera 00:23:22
Hasta que valdrá 10 y entonces saldrá 00:23:23
Esto que me escribe en pantalla 00:23:26
Los números 00:23:29
De 0 al 9 00:23:33
Cuidado, eh 00:23:38
Menor estricto 00:23:39
Entonces, ¿cuántas veces me repite esto? 00:23:41
Diez veces. 00:23:49
Del 0 al 9, lo está repitiendo diez veces. 00:23:51
Lo está repitiendo este veces. 00:23:54
Ejemplos de for también. 00:24:01
inti.com 00:24:03
for i igual a 0, i menor que 3, i más más. 00:24:05
Existe el punto alto, el punto del n, i. 00:24:10
i es igual a 10. 00:24:12
Esta cosa de aquí es correcta. 00:24:14
¿Por qué? 00:24:16
¿Por qué? Porque int i se hace fuera de este bloque. Int i se ha declarado fuera del for. Por lo tanto, existe su ámbito, el ámbito de esta i, de esta variable, es todo esto. Aquí sigue existiendo. 00:24:17
De hecho, si yo aquí imprimiera i, ¿me valdría cuánto? 00:24:34
Si en esta línea aquí, en vez de hacer i igual a 10, imprimiera en pantalla i, ¿cuánto valdría? 00:24:39
Entra aquí, vale 0, se pone a ciclar aquí imprimiendo todo lo que sea. 00:24:49
Y cuando i, mientras i es menor que 3, sigue haciéndolo, cuando i se volverá 3, saldrá de aquí, y por lo tanto en este punto vale 3. 00:24:54
Luego yo lo puedo cambiar a 10, es correcto 00:25:04
En pantalla este código pondría 0, 1, 2 00:25:08
La primera vale 0, escribe 0 00:25:11
Luego vale 1, escribe 1 00:25:15
Luego vale 2, escribe 2 00:25:16
Luego vale 3, sale 00:25:18
En este caso no es correcto 00:25:20
Explotaría 00:25:29
A tiempo de compilación 00:25:30
O sea, no lo puedo ejecutar esto 00:25:32
Porque estoy declarando la variable dentro del for 00:25:34
Al declarar la variable dentro del for 00:25:39
Esta variable solo existe en este bloque 00:25:42
Cuando salgo de este bloque 00:25:45
Y ya no existe 00:25:47
Y si intento utilizarla 00:25:49
Pues me da un error 00:25:51
Me dice y no existe 00:25:52
Me dice que no resuelve el símbolo 00:25:53
¿Dudas? 00:26:00
Claramente se pueden poner for dentro de for 00:26:04
While dentro de while 00:26:07
For dentro de while 00:26:08
while dentro de for dentro de if 00:26:09
if dentro de for de while 00:26:11
podéis hacer lo que os da la gana 00:26:13
y esto es lo que hace caos 00:26:14
¿vale? 00:26:18
utilizarlos así es relativamente sencillo 00:26:20
cuando empezáis a meter 00:26:22
for dentro de for y while dentro de while 00:26:23
la cosa se complica 00:26:26
se complica por dos cosas 00:26:28
primero porque es más difícil entender que está pasando 00:26:29
ahora intentamos analizar esto 00:26:32
¿vale? 00:26:34
pero la segunda cosa es que 00:26:35
Normalmente cuando metemos un while dentro de un while 00:26:36
O un for dentro de un for 00:26:40
La complejidad computacional 00:26:41
De los algoritmos 00:26:44
Se vuelve peor 00:26:47
¿Vale? 00:26:50
¿Qué es la complejidad computacional? 00:26:51
Es una medida de 00:26:53
En base a los datos que me das 00:26:55
Cuanto tarda mi programa 00:26:58
Hacer lo que tiene que hacer 00:27:01
¿Vale? 00:27:02
Y eso se mide en términos de n 00:27:03
Con n representa sustancialmente los datos que tú me das 00:27:06
Si me das un dato, dos datos, mil datos 00:27:13
Y por ejemplo la complejidad computacional puede ser del orden de n mismo 00:27:15
Linear 00:27:27
Eso quiere decir que si me das 10 datos tardaré 10 segundos 00:27:28
Si me das mil datos, tardaré mil segundos 00:27:33
Cuanto más datos me das, más tiempo tardaré 00:27:37
Pero de una forma linear 00:27:41
Luego hay programas buenos, algoritmos buenos 00:27:42
Que pueden ser, por ejemplo, logarítmicos 00:27:46
O sea, que el tiempo que tardan es logaritmo de n 00:27:49
Eso quiere decir que cuanto más datos me das 00:27:52
Si me das diez datos, tardaré un cierto tiempo 00:27:55
Si me das mil datos, no tardo mil 00:27:59
Tardo menos que 1000 00:28:02
Más que 10 00:28:03
Pero menos que 1000 00:28:07
O sea que es mejor, es un algoritmo mejor con respecto al lineal 00:28:10
El problema de poner for dentro de for y while dentro de while 00:28:14
Es que podría llegar a tener un coste computacional de n elevado a la 2 00:28:18
O sea que te doy un dato y me tardas un segundo 00:28:26
te doy 10 y me tardas 100, te doy 1000 y me tardas 10.000 segundos. 00:28:31
Estos son los problemas que cuando se complican, cuando intento hacerlo con más datos, 00:28:39
pues llega un momento en que tarda demasiado el sistema y colapsa. 00:28:44
Aún así, el estudio de la complejidad de un algoritmo no es una cosa que vemos aquí, 00:28:49
alguna vez a lo mejor daré unas pinceladas cuando veremos algoritmos de búsqueda o cosas por el estilo, 00:28:54
O de, no sé si habéis visto alguna vez en internet, en redes sociales o cosas por el estilo, TikTok o lo que sea 00:29:00
Hay vídeos de ordenación de colecciones de datos 00:29:09
Que salen una serie de columnitas desordenadas y os la ordena en un triangulito 00:29:17
¿Esto nunca es una cosa así? 00:29:27
No, lo buscaríais lo anterior 00:29:29
Deberías intentar 00:29:31
Evitarlo si no es necesario 00:29:38
Hay problemas 00:29:40
Que lo tienes que hacer 00:29:43
Si o si, entonces lo vas a hacer 00:29:44
Pero tienes que saber que cuando vas a hacer 00:29:46
Una cosa así 00:29:48
Tienes la posibilidad de crearte 00:29:49
Un bloque de código 00:29:52
Que luego va a ser 00:29:55
Lento 00:29:56
Cuando ejecutas 00:29:58
Y si tienes un algoritmo que lo puede evitar 00:29:59
pero eso siempre es en términos de optimización 00:30:01
por ejemplo, ¿qué hace esta monstruosidad aquí? 00:30:07
fijaos, tengo un for externo 00:30:11
este for trabaja con i 00:30:13
y va de 1 a 2 00:30:16
o sea que lo que está aquí dentro 00:30:20
se ejecutará dos veces, ¿lo veis? 00:30:23
la primera vez valdrá 1, sumará 1, valdrá 2 00:30:26
sigue entrando y cuando esto valdrá 3 00:30:28
pues saldrá, por lo tanto la parte interna de este for 00:30:32
se ejecutará dos veces 00:30:36
dentro de este for hay otro for que va de 1 00:30:37
a 2 también, ¿vale? y lo que hace 00:30:44
es imprimir I 00:30:47
luego un espacio, luego J 00:30:51
luego un espacio y luego la multiplicación de I por J 00:30:56
Entonces, la primera vez que entrará aquí, il vale 1 y j vale 1. 00:31:03
Por lo tanto, esto será 1, 1, 1. 00:31:09
¿Sí? 00:31:14
Acaba este for y no vuelve el for exterior, vuelve el for interior. 00:31:15
Justo. 00:31:21
Y actualizará j. 00:31:24
Por lo tanto, ahora j valdrá 2. 00:31:26
Por lo tanto, entra aquí otra vez y sigue valiendo 1. 00:31:28
J vale 2 00:31:32
Y 2 por 1, 2 00:31:34
Por lo tanto, 1, 2, 2 00:31:36
Porque todavía no he pasado por aquí 00:31:39
Porque he entrado en este bloque 00:31:44
Y este for tiene que ciclar dos veces 00:31:45
Antes de salir y llegar al final del for anterior 00:31:48
¿Sí o no? 00:31:51
Por lo tanto, ejecuto dos veces estas 00:31:54
Antes de volver a actualizar este de arriba 00:31:57
¿Vale? 00:32:00
Lo he ejecutado dos veces 00:32:01
Salgo fuera, vuelvo arriba 00:32:03
Ahora i se actualiza, ahora i vale 2 00:32:05
Y entra otra vez aquí dentro 00:32:08
Y fijaos que cuando vuelve a entrar 00:32:11
Esto antes había desaparecido 00:32:13
Vuelve a ser un nuevo for 00:32:15
E int j vuelve a empezar otra vez desde 1 00:32:17
Entonces entra aquí dentro 00:32:20
Esto vale 2, esto vale 1 00:32:25
Y esto vale 2 por 1 00:32:28
2, 1, 2 00:32:29
Llego aquí y vuelvo a este for 00:32:32
Actualizo j, ahora j vale 2 00:32:37
Compruebo que j es menor o igual que 2, verdadero 00:32:42
Vuelvo a entrar aquí, i sigue valiendo 2 00:32:46
j vale 2, y 2 por 2 es 4 00:32:50
2, 2, 4 00:32:54
Llego aquí, actualizo j que diventa 3 00:32:57
3 no es menor o igual que 2, por lo tanto salgo del for interno, llego aquí, voy aquí arriba, actualizo i, ahora i vale 3, 3 no es menor o igual que 2, por lo tanto salgo también del for externo. 00:33:01
Poner for dentro de for empieza a ser un buen juego mental. 00:33:19
No lo sé, este es un ejemplo. 00:33:33
Pero imagínate que estas sean posiciones de una matriz. 00:33:34
es que yo quiero recorrer esta matriz por líneas 00:33:39
pues entonces estoy recorriendo la primera línea 00:33:42
celda 1, celda 2 00:33:44
luego cambio de línea, celda 1, celda 2 00:33:46
¿para qué sirve? no lo sé 00:33:49
¿se puede hacer? sí 00:33:54
si mi problema me dice que tengo que hacer una cosa así 00:33:56
pues veremos, hay situaciones en las que tengo que poner 00:34:00
un while dentro de un while, un for dentro de un for 00:34:03
un while dentro de un for o cosas por el estilo 00:34:05
hay algoritmo que requieran 00:34:07
hacer esa cosa 00:34:11
fijar un valor y mirar todos los demás 00:34:13
luego fijar otro valor y mirar todos los demás 00:34:17
luego fijar otro valor y mirar todos los demás 00:34:20
eso es un for 00:34:22
dentro de un for 00:34:25
ejemplos 00:34:27
la idea es que ahora hagamos unos ejemplos 00:34:39
luego a partir de mañana haremos más ejemplos todavía 00:34:44
y luego empezaremos con ejercicios 00:34:48
tened en cuenta que todo lo que hemos usado hasta ahora 00:34:51
sigue funcionando 00:34:55
sigue allí, sabemos los casting, crear variables 00:34:58
operar con string, etc, etc, pues lo tenemos que saber 00:35:03
pues vamos a ver ahora que pasa 00:35:08
vale, entonces, vamos a hacer un ejercicio sencillo 00:35:12
Vendrá seguramente más adelante 00:35:25
Vamos a hacer el ejercicio que decíamos antes 00:35:26
Quiero un programa 00:35:30
Que lo que hace es pedir números al usuario 00:35:36
Si los números son positivos 00:35:39
Pedirá más y más 00:35:43
En cuanto el usuario quiera acabar el programa 00:35:45
Tiene que poner un número negativo 00:35:50
Entonces 00:35:52
ScannerScan es igual a 00:35:54
NewScanner 00:35:57
Existe en punto 00:35:58
Sí 00:36:01
Sí 00:36:02
Eso se puede hacer muchos ejercicios 00:36:04
Sí 00:36:15
Por ejemplo 00:36:15
Luego modificamos eso para hacer ese 00:36:17
Int 00:36:19
N es igual a 00:36:21
Scanner.nextInt 00:36:24
¿Vale? 00:36:26
Ahora yo quiero un 00:36:28
Bueno, dame un num 00:36:37
Negativo para acabar 00:36:44
Ahora, ¿cómo le digo 00:36:48
Mientras que este n sea mayor que 0 00:36:53
O mayor o igual que 0 00:36:57
Sigue adelante 00:36:58
Wille, why lo for? 00:37:00
¿Por qué why? 00:37:05
No sé cuántos números voy a pedir 00:37:06
¿Vale? 00:37:09
Pido todo lo que sea necesario 00:37:11
Hasta que el usuario diga 00:37:12
Ya está 00:37:13
While n mayor o igual que 0 00:37:14
Mientras esto sea verdadero 00:37:18
¿Qué hago? 00:37:21
Pido otro 00:37:25
Cuando lo he acabado me preguntas cómo era el ejercicio 00:37:25
Si hizo, ha acabado 00:37:39
¿Qué hace esto de aquí? 00:37:45
Me pide un primer número 00:37:50
Fijaos que si esto es negativo 00:37:52
Aquí dentro no entro 00:37:54
Me voy aquí 00:37:56
Y se ha acabado 00:37:58
Si esto es positivo 00:38:00
Como es positivo, entro dentro del while 00:38:02
Y le digo, muy bien, dame otro número 00:38:05
Y mientras que n 00:38:08
Siga siendo positivo 00:38:11
Siempre esta de aquí será positiva 00:38:13
Y por lo tanto me quedaré aquí dando vueltas 00:38:15
Y vueltas, y vueltas, y vueltas, y vueltas 00:38:17
Hasta que me pongan 00:38:19
Un número negativo 00:38:21
Entonces será falso esto 00:38:22
Y saldré aquí 00:38:25
¿Cómo funciona esto? 00:38:26
Dame un número para 3 00:38:36
4, 5, 3 00:38:38
36, 500, 700 00:38:40
Hasta que le ponga 00:38:42
Un número negativo 00:38:48
¿Sí? Cualquier número 00:38:49
¡Bum! 00:38:58
Este aquí no es un entero 00:39:06
No es un int 00:39:07
¿Vale? Es un long 00:39:10
Y quizás ni siquiera 00:39:12
A lo mejor debería utilizar double 00:39:14
¿Sí? Pero bueno 00:39:16
Pero para nuestra cosa 00:39:18
Nos vale 00:39:22
¿Sí? Entonces, este es un ejemplo de while 00:39:23
¿Para qué me puede servir while? 00:39:26
¿Os acordáis? 00:39:29
No, no os acordáis 00:39:30
Por ejemplo, para hacer un menú 00:39:31
¿Vale? 00:39:33
Imaginaos un programa que puede hacer varias cosas 00:39:35
Como eso de las sumas, las restas y las multiplicaciones 00:39:38
Y que al final, después de haber hecho la suma, la resta 00:39:40
Diga, ¿quieres hacer otra operación? 00:39:43
Y si tú pones S, vuelve arriba 00:39:46
Y me pide otra vez los números y la cosa 00:39:48
Si tú pones N, pues sale abajo 00:39:52
¿Sí? 00:39:54
Ejemplo de for, mañana. 00:39:58
Autor/es:
Stefano chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
11
Fecha:
15 de octubre de 2024 - 13:22
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 03″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
91.07 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid