1
00:00:00,000 --> 00:00:11,680
Vale, bueno pues entonces hasta aquí, vale ¿no?, así declaramos una variable que sea

2
00:00:11,680 --> 00:00:17,800
muchos de algo, antes de empezar a usarla, es decir, con usarla me refiero a meterle

3
00:00:17,800 --> 00:00:23,880
cosas para luego usar esas cosas para asignarlas a otros lados, antes de empezar a usarla hay

4
00:00:23,880 --> 00:00:30,120
que comprometerse y decir cuántas casillas va a tener, eso es impeccible, lo comprometemos

5
00:00:30,120 --> 00:00:34,800
de esta manera y una vez que eso ya está hecho, que eso ya está hecho, ahora ya podemos

6
00:00:34,800 --> 00:00:41,220
empezar a usarla como hemos dicho, yo me refiero ahora ya a cada posición con su número

7
00:00:41,220 --> 00:00:47,120
de posición como si fuera cualquier variable. Vale, entonces la pregunta que os surgiría

8
00:00:47,120 --> 00:00:54,560
a vosotros es, Jolines, vale, muy bien, ahora en el caso de que yo quiero 100 enteros, a

9
00:00:54,560 --> 00:01:00,120
la hora de declarar espacio para 100 enteros, esto me ha venido muy bien, en una línea,

10
00:01:00,120 --> 00:01:06,800
en una línea he declarado espacio para 100, cuando antes si no teníamos array hubiéramos

11
00:01:06,800 --> 00:01:13,600
tenido que hacer int n1, int n2, int n3, así hasta 100, algo ya hemos hecho, nos hemos

12
00:01:13,600 --> 00:01:18,520
declarado de golpe espacio para 100 enteros, lo hemos declarado de golpe sin tener que

13
00:01:18,520 --> 00:01:24,400
declarar 100 variables una a una, vale, eso está bien, pero claro, aquí sobre todo se

14
00:01:24,400 --> 00:01:31,000
trata de ahora ya ser operativos usando esto, entonces por ejemplo, ahora nos surge el problema,

15
00:01:31,000 --> 00:01:39,640
vamos a rellenar todas estas variables que son 100, vamos a rellenarlas con unos, por

16
00:01:39,640 --> 00:01:43,960
ejemplo, porque quiero yo ponerlo todo a 1, todo el array lo quiero poner a 1, vale,

17
00:01:43,960 --> 00:01:50,000
porque forma parte de mi inicialización concreta todo a 1, claro, pues entonces si uno se planteara

18
00:01:50,000 --> 00:01:58,040
hacer esto, quiero ponerlas todos a 1, pues hombre, pues no parecemos haber ganado mucho

19
00:01:58,040 --> 00:02:07,120
tampoco, si nos ponemos a hacer números 0 igual a 1, ala, ya tengo la primera, un 1,

20
00:02:07,120 --> 00:02:15,960
ala, tengo que iniciar a 1 la segunda, números 1 igual a 1, ala, ya tengo la segunda, pero

21
00:02:15,960 --> 00:02:22,640
es que como tenga que hacer eso con las 100, números 2, números 3, pues no he ganado

22
00:02:22,640 --> 00:02:28,120
nada respecto a declarar variables sueltas, hombre, he ganado la de línea de declaración,

23
00:02:28,120 --> 00:02:32,120
pero la de asignación, como tengo que ir con ellas sueltas por libre, que he ganado

24
00:02:32,120 --> 00:02:40,320
con un array, no he ganado nada si lo hago así, claro, pero de que nos podemos aprovechar,

25
00:02:40,320 --> 00:02:47,480
de que el índice es lo único que va cambiando en esta expresión, verdad, esta de abajo

26
00:02:47,480 --> 00:02:56,600
es la misma de arriba, pero con la posición a 1, y esta de aquí es lo mismo que lo de

27
00:02:56,600 --> 00:03:02,280
arriba, pero con la posición a 2, la posición de una raíz es lo que se le suele llamar

28
00:03:02,280 --> 00:03:10,960
índice, a la posición es lo que se le suele llamar índice, entonces el índice 0, índice

29
00:03:10,960 --> 00:03:16,440
1, índice 2, que se refiere a la posición 0, posición 1, posición 2, entonces cada

30
00:03:16,440 --> 00:03:21,040
una de esas expresiones es la de arriba, pero cambiando este índice o esta posición, hombre,

31
00:03:21,360 --> 00:03:26,840
pues voy a meterlo en un for, es que para eso, me viene fenomenal, voy a meter esto

32
00:03:26,840 --> 00:03:32,600
en un bucle, voy a meter esto en un bucle, donde lo que va cambiando es esta posición,

33
00:03:32,600 --> 00:03:38,360
entonces en lugar de escribir 100 veces números 0, números 1, números 2, escribo esto en

34
00:03:38,360 --> 00:03:45,200
un bucle, y en ese bucle lo que voy cambiando es esto, le pongo i por ejemplo, y este i,

35
00:03:45,200 --> 00:03:50,520
que en la primera iteración sea 0, y en la siguiente sea 1, y en la siguiente sea 2,

36
00:03:50,520 --> 00:03:59,040
pues ya lo tengo, un bucle que se ejecuta 100 veces, y 100 veces que me hace, números

37
00:03:59,040 --> 00:04:04,760
de i igual a 1, y esto lo quiero hacer 100 veces, pero la primera vez lo quiero hacer

38
00:04:04,760 --> 00:04:11,000
con i igual a 0, y la segunda vez lo quiero hacer con i igual a 2, a 1, y la tercera vez

39
00:04:11,000 --> 00:04:15,240
lo quiero hacer con i igual a 2, eso es lo que yo quiero hacer, quiero hacer esto 100

40
00:04:15,240 --> 00:04:20,120
veces, pero con i variando, pues hombre, como lo quiero hacer 100 veces, meterlo en

41
00:04:20,120 --> 00:04:27,000
un bucle, vale, meterlo en un bucle, y ahora este bucle, que vaya iterando, y en cada iteración

42
00:04:27,000 --> 00:04:34,240
que este i vaya cambiando, bueno hombre, claro, lo podríamos hacer con un while, obviamente

43
00:04:34,240 --> 00:04:42,400
¿no?, pues venga, lo voy a meter en un while, mientras i sea menor o igual que 100, por

44
00:04:42,400 --> 00:04:51,040
ejemplo, lo meto ahí en mi while, inicializando i a 0, y aquí incrementando i, vale, así

45
00:04:51,040 --> 00:04:56,160
lo podríamos hacer, me hago un bucle, para que esto se ejecute 100 veces, perdón, i

46
00:04:56,160 --> 00:05:04,320
menor o igual que 100, no, i menor que 100, porque tengo que llegar hasta 99, ¿verdad?,

47
00:05:04,320 --> 00:05:09,080
parto de un índice de posición i igual a 0, mientras no haya llegado a la 100, te

48
00:05:09,080 --> 00:05:14,960
haces esta asignación e incrementas i para la siguiente, pues esa sí es la ventaja

49
00:05:14,960 --> 00:05:23,240
de los arrays, que yo puedo recorrer sus posiciones, simplemente cambiando este índice de aquí,

50
00:05:23,240 --> 00:05:30,120
pues hombre, lo metes en un bucle, y ese bucle que te vaya cambiando este índice, y ya está,

51
00:05:30,120 --> 00:05:36,760
en este único bucle tienes todas las 100 asignaciones, números 0, números 1, números

52
00:05:36,760 --> 00:05:43,800
2, números 3, solamente ahí ya tienes escritas las 100 asignaciones, gracias a el funcionamiento

53
00:05:43,800 --> 00:05:48,920
del array, que según vas cambiando tú este i, vas avanzando de posición, vale, pues

54
00:05:48,920 --> 00:05:53,400
con ese while podríamos hacer eso, pero claro, si pensamos y nos acordamos, anda, es que

55
00:05:53,400 --> 00:05:58,520
esto es el for, esto lo puedo hacer en un for, pongo esto como la primera sentencia

56
00:05:58,520 --> 00:06:04,600
que se hace, esto la condición, y esta la que se hace en cada iteración, es un for,

57
00:06:04,840 --> 00:06:11,640
me va a quedar más bonito en un for, ¿verdad?, pues esto mucho más bonito si lo escribo así,

58
00:06:11,640 --> 00:06:19,800
esta es la primera sentencia que hago, mientras que, mientras i sea menor que 100, condición,

59
00:06:19,800 --> 00:06:26,040
hago aquí lo que tenga que hacer, y después de cada iteración, esto se tiene que hacer,

60
00:06:26,040 --> 00:06:30,040
después de cada iteración, pues eso iba aquí en el for, ¿verdad?, lo que se pone

61
00:06:30,040 --> 00:06:33,720
aquí se hace después de cada iteración, ¿y ahora qué hago dentro del for?, pues

62
00:06:33,720 --> 00:06:46,200
esto en particular, vale, o sea, esto y eso es lo mismo, normalmente pondremos esto,

63
00:06:46,200 --> 00:06:58,840
queda mucho más claro, uy, estoy aquí, no estoy grabando la pizarra, vale, o sea, esto

64
00:06:58,840 --> 00:07:03,320
y esto es lo mismo, normalmente pondremos eso, queda mucho más claro ese for ahí,

65
00:07:08,360 --> 00:07:17,960
pues aquí sí que está ya la utilidad de los arrays, que mediante bucles yo puedo acceder

66
00:07:17,960 --> 00:07:24,200
a todas las posiciones, y me ahorro hacer número 0 igual a 1, número 1 igual a 1, lo que yo quiera,

67
00:07:24,200 --> 00:07:33,000
bueno, pues así es como se suelen recorrer, este es el bucle típico de recorrida de arrays,

68
00:07:33,000 --> 00:07:37,800
el bucle típico es un for, donde usamos una variable i, que se la suele llamar índice,

69
00:07:37,800 --> 00:07:45,160
y viene de índice, precisamente, porque se suele aplicar el for arrays, y esto es el índice,

70
00:07:45,880 --> 00:07:56,680
donde una variable la inicializo con la primera posición, ¿hasta cuándo?, pues hasta mientras

71
00:07:56,680 --> 00:08:02,760
sea menor que el tamaño del array, si el tamaño es 100, me queda en 99, claro, el tamaño es 100,

72
00:08:02,760 --> 00:08:08,120
me quedo en 99, porque empiezo en 0, por eso pongo menor, no pongo menor igual, para que ese bucle

73
00:08:08,120 --> 00:08:14,720
vaya de 0, 1, 2, hasta 99, y ahora, ¿qué hago en cada iteración?, después de esto que hay aquí

74
00:08:14,720 --> 00:08:20,280
dentro, implementarlo, claro, para pasar a la siguiente, ¿vale?, es el bucle típico de recorrida

75
00:08:20,280 --> 00:08:30,000
de un array, y ahora ya toda esta información, que es la única, que necesitamos, uno ya la combina

76
00:08:30,000 --> 00:08:46,600
para hacer lo que quiera con arrays, ¿vale?, por ejemplo, a ver, vamos a hacer ejemplos sueltos de

77
00:09:00,720 --> 00:09:10,320
arrays, vale, voy a hacer esto ya en un proyecto aparte, que se llame ejemplos de arrays,

78
00:09:10,320 --> 00:09:12,280
para cuando se suba a la ola virtual,

79
00:09:30,000 --> 00:09:42,720
venga, ejemplo 1, por ejemplo, vale, pues vamos a hacer esto mismo que hemos hecho ahí, y luego planteamos

80
00:09:42,720 --> 00:09:50,960
pequeñas variaciones para trabajar con arrays, para que vayáis haciendo, pues venga, vamos a declarar un array

81
00:09:51,280 --> 00:10:00,480
para que guarde 100 numeritos, pues lo llamo que a mí me dé la gana, y si quiero que tenga 100 numeritos,

82
00:10:00,480 --> 00:10:09,920
tengo que hacer esto, ala, ya tengo ahí en memoria, espacio para 100 números enteros, ya están ahí en memoria,

83
00:10:09,920 --> 00:10:13,720
ahora, ¿qué quiero hacer con ese espacio para 100 números enteros?, bueno, vamos a hacer eso mismo que hemos hecho

84
00:10:13,720 --> 00:10:38,480
en la pizarra, vamos a inicializarlos todos esos espacios a 1, ala, ya están todos, el número 0, número 1, número 2,

85
00:10:38,480 --> 00:10:46,360
ya están todos inicializados a 1, todos tienen dentro 1, vamos a comprobarlo, vamos a hacer otro bucle ahora,

86
00:10:46,360 --> 00:10:55,800
que recorra el array, pero esta vez no para recibir un valor, sino para mostrarlo por consola, para asegurarnos

87
00:10:55,800 --> 00:11:18,960
de que tiene unos, pues venga, otro bucle para recorrer todas y cada una de las posiciones, una por una, y ahora con cada posición

88
00:11:18,960 --> 00:11:28,000
número sí, en este caso, ¿qué quiero hacer?, en este caso no quiero asignarle 1 a la posición, en este caso lo que quiero es mostrarla por consola,

89
00:11:28,000 --> 00:11:38,640
bueno, pues nada, se lo damos a este, que es el que muestra por consola, se lo damos a este, ¿vale?, cada número sí del recorrido,

90
00:11:38,640 --> 00:11:50,800
números 0, números 1, números 2, cada uno de ellos, se lo paso a este, para que lo muestre por consola, luego el resultado de este programa será mostrar 100 unos,

91
00:11:50,800 --> 00:12:12,400
claro, entonces si lo ejecutamos, bueno, pues ahí los 100 unos que ha tenido que mostrar, entonces si hubiéramos tenido que usar 100 variables enteras por separado,

92
00:12:12,400 --> 00:12:25,360
las 100, darles el valor 1, y las 100 mostrarlas, tendríamos que haber declarado 100 variables, haber hecho esta asignación 100 veces, luego haber hecho 100 System.out.println,

93
00:12:25,360 --> 00:12:38,320
hubiera sido impranteable, ¿no?, 100 declaraciones, 100 asignaciones y 100 System.out. de cada una de las variables, si lo hacemos con un array, recorriéndolo y cambiando el índice, ya lo tengo todo, dime.

94
00:12:38,320 --> 00:12:42,320
¿Pero el print no se puede poner directamente en el otro bucle de arriba?

95
00:12:42,320 --> 00:12:56,320
A ver, sí, hombre, sí, pero vamos, que yo aquí estaba separando los recorridos, para dejar claro que uno recorre y luego hace dentro lo que quiera, en el primero hemos recorrido por asignar, ahora en este vamos a recorrer para mostrar,

96
00:12:56,320 --> 00:13:12,320
ahora, por ejemplo, vamos a cambiar el código para que ahora este array, ahora se va a rellenar con valores que yo lea por teclado, para probarlo cambiaremos el 100, voy a meter 100 números,

97
00:13:12,320 --> 00:13:40,320
vamos a olvidarnos, vamos a pisarlos y los unos que tiene y vamos a rellenarlo por consola, por teclado, vale, pues entonces, vamos a rellenar todo el array, habrá que recorrerlo otra vez, pues venga, vamos a recorrerlo,

98
00:13:42,320 --> 00:14:03,320
y ahora, ¿qué hay que hacer con cada posición números de i? Pues en este caso, con cada posición números de i, le queremos asignar un número entero que vamos a leer del teclado, pues entonces, el escáner, perdón, lo tengo que poner aquí, si lo quiero usar,

99
00:14:12,320 --> 00:14:41,320
vale, pues entonces, ¿qué queremos hacer aquí con cada números de i? Pues aquí con cada números de i, queremos recibir un número de teclado y asignárselo, pues lo que queramos hacer en cada momento, vale, ¿qué ahora quiero mostrar otra vez lo que tiene?

100
00:14:41,320 --> 00:15:08,320
Vamos a volver a hacer el bucle de mostrar para ver lo que tiene esta vez, pues nada, aquí mostraríamos los valores que tiene, que son los que le hemos metido, y así, cada uno hace lo que quiera y necesite, vamos a probarlo, pero en lugar de meter 100 números que es mucho, vamos a probarlo con un array de 10 solo,

101
00:15:08,320 --> 00:15:35,320
estoy cambiando los 100 a 10 para que solo tenga 10 posiciones, para que cuando me pida aquí, solo me pida hasta 10 números, pues venga, vamos a ejecutarlo, primero me muestra los 10 unos, y ahora se me ha quedado ahí esperando un número, pues venga, le he ponido 3, 1, 5, este, 6, 3, 5, 9, pues ya está, me ha mostrado efectivamente todos los números,

102
00:15:35,320 --> 00:15:57,320
yo le he metido 3, 1, 4, 5, 6, 7, 9, y es lo que me ha mostrado, 3, 1, 4, 5, 6, bueno, me salta el 2, 2, 5, 6, 7, vale, 6, 7, 9, vale, uno ya recorre y hace con este array lo que necesite, por ejemplo, ¿qué podríamos querer hacer en este array?

103
00:15:57,320 --> 00:16:17,320
vamos a hacer una cosa, vamos a hacer este mismo programa, pero que me los muestre, a ver si os ocurre, los números que yo he leído, que he leído 10, pues que a continuación me los muestre, pero no en el mismo orden en el que los leí, sino que me los muestre en orden inverso, ¿cómo haríais?

104
00:16:17,320 --> 00:16:39,320
porque este for me muestra todos los números que yo acabo de asignar ahí, pero en el mismo orden en el que los introduje, me muestra primero la posición 0, luego la 1, luego la 2, imaginaos que el programa me dice, programa que lea 10 números y luego te los muestre en el orden inverso al que tú le introdujiste, ¿qué haríais?

105
00:16:39,320 --> 00:17:08,320
claro, este for cambiarlo, en lugar de empezar en la 0, empezar en la 99, mientras sea mayor o igual que la 0, que sería la última, y en lugar de ir incrementando, ir decrementando, por ejemplo, o sea, uno ya entendiendo el funcionamiento, ya entendiendo cómo funcionan los for, los arrays, ya puede hacer lo que le dé la gana, entendiendo estas bases, que son las unidades que tenéis que entender, no hay más, pero ya hay que construirlo, por ejemplo, vamos a poner aquí

106
00:17:09,320 --> 00:17:38,320
en orden inverso, pues para mostrar en orden inverso, haríamos, para la posición 99, que es la última, mientras sí sea mayor o igual que la 0, porque yo voy a ir bajando y decrementando de uno en uno, y decrementando de uno en uno, entonces primero era 99, luego era 98, luego era 97, pues entonces, ¿qué haremos?

107
00:17:39,320 --> 00:18:02,320
mostrar, vale, pues efectivamente aquí me va a mostrar en orden inverso, primero me hace los 1, ahora se queda esperando los números, 1, 2, 3, 4, 5, 6, 7, 8, 9 y 10, vale

108
00:18:03,320 --> 00:18:26,320
Ah, sí, me he pasado de, claro, me he pasado porque estoy en 9, le he bajado a 10, sería 9, vale, primero vemos a los 10 y 1, se le va a meter 10 números, 1, 2, 3, 4, 5, 6, 7, 8, 9 y le voy a meter el 10, ¿veis?

109
00:18:27,320 --> 00:18:42,320
primero me lo ha mostrado en el orden correcto, en el orden de inserción, y en el segundo for, de recorrido, ya en el segundo, me ha mostrado el contenido, pero al revés, me ha mostrado el contenido al revés, vale, porque yo empecé en la 9

110
00:18:42,320 --> 00:19:07,320
vale, pues entonces, ejemplitos sencillos para consolidar esto, por ejemplo, imaginaos que ahora os digo, pues, vamos a hacerlo en uno aparte, ejemplo 2

111
00:19:12,320 --> 00:19:32,320
vale, pues aquí, imaginaos que queremos hacer, programa que lea, pongo 100, porque la utilidad de los arrays realmente, bueno, venga, vamos a poner 10, es cuando son muchos, pero bueno, vamos a poner 10 para que no lo tengáis que cambiar luego al ejecutar

112
00:19:32,320 --> 00:19:58,320
que lea 10 números enteros y a continuación muestre la suma de todos los que han sido positivos y luego también la suma de todos los negativos

113
00:20:02,320 --> 00:20:22,320
vale, los dos somas acumulativas, entonces, los números, pues aquí no haría falta un array porque uno puede, según va leyendo número, sumando y mostrándolo, pero vamos a hacerlo para que haga falta un array

114
00:20:22,320 --> 00:20:46,320
entonces, para que haga falta un array, vamos a, y a continuación, muestra, vamos a poner, y a continuación, debe mostrar, finalmente, a modo de comprobación, que uno compruebe que lo ha hecho bien, todos los números que ha leído

115
00:20:46,320 --> 00:21:15,320
ahora sí que no nos queda más remedio que hacerlo con un array, porque si yo uso una sola variable y en esa misma variable voy pisando el número anterior y voy incrementando la suma y luego me dice, muestra todos los que has leído, uy, es que los he perdido, estoy utilizando una misma variable para ir pisando el nuevo número, entonces, esto lo tenemos que hacer con un array de 10 enteros, no hay otra, y conservarlos ahí los 10

116
00:21:16,320 --> 00:21:24,320
luego ya opero, hago la suma, lo que haya que hacer y cuando ya he hecho la suma acumulativa de todo, recorro el array para mostrarlo, los tengo ahí los 10 números, no los he perdido, porque estaban en un array

117
00:21:25,320 --> 00:21:28,320
venga, pues a ver, como haríais esto, vale