Saltar navegación

Arrays 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 29 de octubre de 2024 por Stefano C.

20 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si me decís algo es porque autorizáis a grabar vuestra voz. 00:00:00
Hoy vamos a hablar de los arrays. 00:00:06
¿Qué es un array en Java? 00:00:11
O un array en general, en programación estructurada, en otros lenguajes es más o menos lo mismo. 00:00:13
Es una estructura de datos que nos permite almacenar un conjunto de datos de un mismo tipo. 00:00:19
Si una variable es un trocito de memoria, un cajón, donde nosotros podemos guardar un determinado valor y este trozo de memoria tiene un tipo y un nombre, el array es una extensión de esta cosa. 00:00:23
Es siempre un espacio de memoria donde puedo almacenar valores de un determinado tipo, pero no un valor solo, sino varios valores. 00:00:41
Es, si la variable es un cajón, pues esta es una cajonera, donde pero pongo en cada cajón los mismos tipos de valores, ¿vale? 00:00:51
Declaro un valor, enteros, pues en cada celda de este array, en cada posición de este array, podré guardar enteros. 00:01:00
Si la variable que tiene tipo int se llama x, tiene dentro un valor 00:01:10
Un array tendrá siempre un tipo, tendrá siempre un nombre 00:01:20
Pero en vez de una posición, tiene varias posiciones 00:01:25
Entonces yo podré guardar siempre enteros y solo enteros 00:01:30
Porque esto es un array de enteros 00:01:36
¿Y cómo accedo? Cada una de estas posiciones tendrá asignado un índice. 00:01:37
Entonces, yo, por ejemplo, para acceder a esta celda de aquí, usaré AR de 3. 00:01:46
Esto es VTR, pero AR no es una variable sola, es toda esta estructura de aquí. 00:01:59
Entonces, puedo acceder a la celda 0, 1, 2, 3 de AR, accederé a la celda 3. 00:02:04
Y le puedo decir que, por ejemplo, aquí dentro ponme el valor 5 00:02:10
Entonces lo que hará es irse aquí y poner dentro el 5 00:02:14
Se ha ido mal, luego se parece a un 50 00:02:19
Pondrá aquí dentro el 5 00:02:25
Y luego podré hacer que, por ejemplo, int x es igual a 00:02:29
Arr de 3 00:02:41
Más 2 00:02:43
Entonces 00:02:46
En x 00:02:49
Pondré 00:02:52
Esto vale x 00:02:53
Arr de 3 00:02:56
Vale 5 00:03:04
Más 2, 7 00:03:05
Y lo guardo dentro de x 00:03:07
Por ejemplo 00:03:09
Entonces es una extensión de lo que es una variable 00:03:10
La variable puede contener un solo valor 00:03:15
Mientras un array puede contener una colección de valores 00:03:17
Pero siempre de un solo tipo y que se accede a él a través de un nombre 00:03:19
Solo que como tiene varias celdas será un nombre y luego el índice de la celda a la que quiera acceder 00:03:24
Este es un array 00:03:30
Dudas 00:03:31
El tamaño de los arrays, es decir, cuántas posiciones puede tener el array 00:03:33
Se declara en un primer momento y no puede cambiar en tiempo de ejecución 00:03:42
Es decir, que cuando yo creo un array le diré, quiero un array de 10 posiciones 00:03:47
posiciones. Pues este array tiene 10 posiciones. No se puede ni hacer más grande ni hacer 00:03:51
más pequeño. Si yo tengo 10 posiciones y me dan 11 números, tengo estrategias para 00:03:57
poder almacenar 11 números. Pero no en ese array. Tendré que tirar ese array, crear 00:04:04
un array más grande, copiar los datos que tenía antes y ahora tengo un array más grande. 00:04:10
Pero un array una vez creado de un cierto tamaño 00:04:15
Pues no se puede cambiar el tamaño que tiene 00:04:17
Es una estructura estática 00:04:22
Yo lo puedo hacer a tiempo de ejecución 00:04:24
Es decir, puedo decirle al usuario 00:04:26
Dame el tamaño del array 00:04:28
Tú le dices 50 00:04:30
Y yo me creo un array de 50 posiciones 00:04:31
Lo puedes hacer 00:04:33
Y a la siguiente ejecución me dice 3 00:04:34
Pues yo crearé un array de 3 posiciones 00:04:37
Pero una vez que he creado ese array 00:04:39
Pues es de ese tamaño 00:04:41
Y me guardará allí dentro tantos valores como las posiciones que yo he creado. 00:04:43
¿Cómo se declara un array? 00:04:50
Como antes habíamos visto declaraciones de variables, veamos las declaraciones de array. 00:04:52
Es un tipo, corchetes y el nombre del array, punto y coma. 00:05:02
Por ejemplo, int corchetes miArray de int será un array de int grande cuanto, no lo sé, ¿vale? 00:05:10
String corchetes miArray de string será un array que tiene dentro objetos string, ¿vale? 00:05:18
Esto es como cuando nosotros hacemos int x punto y coma, sin inicializarlo, ¿vale? 00:05:24
Es, declaro que existirá este señor, pero todavía no existe. 00:05:32
Será una referencia a una zona de memoria que por ahora está vacía 00:05:37
A la espera de que cree un array 00:05:43
En realidad, por debajo, en Java un array es un objeto 00:05:46
Pero nosotros no sabemos qué es, por lo tanto no 00:05:50
Lo utilizaremos sin saber qué son los objetos, al menos para este trimestre 00:05:53
¿Cómo se inicializa? 00:05:57
Es decir, una vez que yo lo he declarado y tengo mi array de int 00:06:00
¿Qué hago? 00:06:02
Pues el nombre de array es igual a new, tipo, corchete, tamaño, corchete, punto y coma 00:06:03
Por ejemplo, mi array de int, que era un array de enteros, es igual a new, int, porque es un array de int 00:06:12
Corchetes 20, corchetes, punto y coma 00:06:19
Estoy creando una estructura que puede contener dentro 20 distintos enteros 00:06:22
¿Cómo se llama esta estructura? Mi array de int 00:06:28
¿Vale? Ese es su nombre 00:06:31
Y tendrá dentro celdas numeradas desde el 0 hasta el 19, 20 celdas, ¿sí? 00:06:32
¿Dudas? 00:06:43
Vale, ¿cómo creo un array de string? 00:06:44
Pues mi array de string es igual a new string corchetes 15 corchetes punto y coma. 00:06:47
Estoy creando una estructura de 15 strings, ¿vale? 00:06:53
O sea, numeradas desde el 0 hasta el 14, ¿sí? 00:06:58
¿Veis este new? ¿Dónde lo hemos visto nosotros el new? 00:07:04
Con Scanner, y era un objeto 00:07:07
Cuando está del medio del new, estamos hablando de objetos 00:07:09
Pero como nosotros todavía los objetos no los tenemos 00:07:13
En principio, el array no es una cosa propia de los objetos 00:07:15
Es una cosa que se puede utilizar también en programación estructurada 00:07:19
En Java, pero está implementado como un objeto y se declara así 00:07:24
Aquí ya, como nos metemos en Java, en nuestro lenguaje 00:07:30
Pues aprendemos esto 00:07:33
Claramente se puede hacer estas dos cosas en uno 00:07:34
Es decir, que puede hacer int corchetes mi array de int igual a new int de 20 00:07:40
Sin hacerlo en dos pasos 00:07:45
Asignación de valores a sus celdas 00:07:48
Pues nombre de array, corchetes, número de la celda, corchetes es igual a valor 00:07:51
Por ejemplo, mi array de int de 0 es igual a 16 00:07:58
Mi array de int de 19 es igual a menos 2 00:08:02
Entonces lo que está diciendo es 00:08:06
Vete a la estructura mi array de int 00:08:08
Accede a la posición con número 19 00:08:10
Y en esa celda de allí me pones un menos 2 00:08:13
Aquí será lo mismo 00:08:16
Pero con string 00:08:19
Existe una forma de crear directamente 00:08:23
Un array de un cierto tamaño 00:08:27
Que es esta de aquí 00:08:28
donde digo int 00:08:29
corchetes, mi array de int es igual 00:08:31
y luego entre llaves 00:08:34
le pongo los valores separados por coma 00:08:35
esto me creará un array 00:08:38
de tres celdas 00:08:40
que contienen 00:08:42
solo tipo int 00:08:44
la celda 0 contendrá 1 00:08:45
la celda 1 menos 2 00:08:48
la celda 2 00:08:50
perdón, un 3 00:08:52
dudas 00:08:54
se entiende esta sintaxis 00:08:57
Esto habrá que probarlo y probarlo y probarlo hasta que esto funcione 00:08:59
Variables índices 00:09:03
Una de las ventajas de los arrays es que puede acceder a cada celda, a cada compartimento, a cada sección interior del array 00:09:05
Utilizando un número entero, o sea un int 00:09:16
Hemos dicho que las celdas van numeradas, 0, 1, 2, 3, 4, 5 00:09:19
Y esto es un entero 00:09:26
entonces puedo utilizar una variable int para acceder a esta cosa 00:09:27
si esta variable aquí le puedo sumar 1 y acceder a la siguiente celda 00:09:33
le puedo restar 1 y acceder a la celda anterior y cosas por el estilo 00:09:37
y esto me permite manejar de forma reciente fácil los arrays 00:09:41
si este número no es un literal, a de 1 es igual a 10 00:09:45
sino variable, a de i es igual a 10 00:09:49
Podremos cambiar el valor de i según necesitamos, creando potentes algoritmos de búsqueda, ordenación o recorrido de la red. 00:09:53
Entonces, si os fijáis, en vez de a acceder a la posición 1, pues digo a acceder a la posición i. 00:10:01
Él irá a mirar la posición i cuánto vale, y si vale 3 accederá a la posición 3, y si vale 7 accederá a la posición 7. 00:10:07
todo esto que estamos diciendo 00:10:15
acceder y acceder con la variable 00:10:18
con que creéis 00:10:19
que combina 00:10:22
perfectamente 00:10:23
con el for 00:10:25
nosotros cuando hacemos un for 00:10:27
tenemos normalmente una variable 00:10:29
un índice, un i que va de 0 00:10:31
a cierto valor 00:10:34
pongamos a 19 00:10:36
en el caso de nuestro array de 20 00:10:37
y entonces tendré un for que por cada 00:10:40
ciclo del for tendré una variable 00:10:42
Que me apunta el primer ciclo a la primera celda, el segundo ciclo a la segunda celda, el tercer ciclo a la tercera celda 00:10:44
Y me podrá hacer un recorrido de todos los valores del array 00:10:50
Entonces for y array van de la manita 00:10:53
Son muy amigos y muchas veces que veis un array por algún lado aparece un for 00:10:57
Se pueden definir los valores del array con un scanner 00:11:03
Claramente tú aquí pones mi array de int de 0 es igual a scan.nexit 00:11:11
Lo pones en un for o en un while 00:11:17
Pones miArray de int de i 00:11:23
Es igual a scan.nextInt 00:11:26
Entonces por cada ciclo del for 00:11:28
La primera vez te guardará lo que lees en el 0 00:11:30
La segunda vez en el 1 00:11:33
La tercera vez en el 2 00:11:34
Lo veremos 00:11:35
¿Sí? 00:11:37
Pero sí se puede hacer 00:11:38
Ejemplo, ¿vale? 00:11:39
Entonces vamos a ver este ejemplito 00:11:42
Tenemos la public class 2 00:11:44
¿Por qué se llama 2? No tengo idea 00:11:46
Main, ¿vale? 00:11:47
Y aquí creo un array de que 00:11:50
Que es esto 00:11:51
Un array de string 00:11:52
Esto se llama Dias 00:11:55
Es decir que estoy creando una estructura 00:11:57
Estoy creando una estructura 00:12:00
Que se llama Dias 00:12:09
Que tiene 00:12:11
Uno, dos, tres, cuatro 00:12:14
Cinco, seis, siete 00:12:19
Celdas 00:12:21
Son siete, tres, seis, uno, siete 00:12:23
Vale, y en cada una de estas 00:12:24
celda estaré poniendo aquí lunes, aquí martes, aquí miércoles, etcétera, etcétera, 00:12:27
etcétera, ¿vale? Como string, porque el tipo de esta cosa son string, ¿sí? Por ejemplo, 00:12:39
luego puedo decir que el primer día de la semana es días de cero, accedo a la primera 00:12:49
la posición y entonces es lunes. ¿Sí? Y el último es días de seis. Accedo a la posición 00:12:54
seis. Cero, uno, dos, tres, cuatro, cinco, seis. Y entonces esto pondrá domingo. Y uno 00:13:02
en el medio es días de la posición tres. Cero, uno, dos, tres. Es que era jueves. ¿Se 00:13:09
¿Entiende? ¿Dudas? ¿No? ¿No? 00:13:17
Sigo. 00:13:23
R-index out of bounds. 00:13:26
Vuestro peor enemigo. 00:13:28
El que saldrá mil veces por cada ejercicio. 00:13:29
¿Vale? 00:13:32
Esta es una excepción. 00:13:33
Es una explosión. 00:13:34
¿Vale? 00:13:36
Es cuando intentas hacer algo que no debería ser 00:13:36
y Java lanza un error, lanza una excepción, lanza un... 00:13:39
Oye, aquí hay un problema. 00:13:45
Aprenderemos en un futuro una forma de recoger este problema 00:13:46
Y decir, en vez de terminar y acabar el programa 00:13:51
Intenta recuperarte, ¿vale? 00:13:55
Cuando veremos las gestiones de excepciones 00:13:58
Por ahora, simplemente las lanzamos 00:13:59
Y si se lanza, muere, ¿vale? 00:14:02
¿Qué pasa? 00:14:04
Que si yo intento, veis que aquí he quitado uno, ¿no? 00:14:05
Lunes, martes, miércoles, jueves, viernes, sábado, falta domingo 00:14:07
Y lanzo el mismo programa que antes 00:14:10
Cuando acedo al día de seis 00:14:13
Ahora no hay 6 00:14:16
Porque hay 0, 1, 2, 3, 4 y 5 00:14:18
La posición 6 no existe 00:14:22
Entonces me voy fuera de los límites 00:14:25
Out of bounds 00:14:28
Y cuando intenta acceder al 6 00:14:30
Me dice aquí en qué sitio pasa 00:14:33
Si clico aquí me marcará esta línea de aquí 00:14:38
Porque dice que cuando intenta acceder a la posición 6 00:14:41
Pues no la encuentro 00:14:45
Porque soy fuera 00:14:47
Es una excepción de índice 00:14:47
Fuera de los límites 00:14:50
Los límites son de 0 a 5 00:14:52
Entonces lo mismo me pasaría 00:14:53
Si yo intentara acceder a días de menos 1 00:14:58
Me diría, estás por fuera 00:15:00
Porque el límite mínimo es 0 00:15:02
¿Dudas? 00:15:03
La primera es siempre 0 00:15:08
Existe un atributo 00:15:09
Que se llama length 00:15:14
Que nos dice el número de elementos 00:15:16
Que posee el array 00:15:19
Cuidado, no es el mismo length de string 00:15:21
En string, yo hago mi string.length paréntesis 00:15:25
Porque es un método 00:15:31
Es una función del objeto string 00:15:33
Que me devuelve, me cuenta cuantos elementos hay ahí dentro 00:15:36
En los array no es un método 00:15:40
Va sin las paréntesis, lo veis aquí 00:15:43
Es un atributo, ¿qué es un atributo? Lo veremos 00:15:47
Es una variable, es una variable asociada con este array, ¿vale? 00:15:49
Donde está escrita allí dentro cuántas celdas tiene, ¿vale? 00:15:56
Recordaos que en un array como esto mediría 6, la length es 6 porque tiene 6 elementos, 00:16:00
pero así la length es 6, va desde la posición 0 hasta la posición 5. 00:16:07
Nunca hay la posición length, ¿sí? 00:16:13
Los arrays van de 0 a length-1 00:16:16
¿Cuál es la length de este array? 00:16:20
¿Cuánto es la length de este array? 00:16:28
No, no, 6 00:16:31
¿Y cuál es la última posición? 00:16:32
5, o sea, length-1 00:16:37
El array cuando tú lo creas 00:16:39
Le estás diciendo su tamaño 00:16:52
Se lo estás diciendo aquí 00:16:54
Y este es su tamaño 00:16:56
Que luego esté vacío o no esté vacío 00:16:59
haya gatos dentro, me da igual 00:17:01
esto es 15 00:17:03
¿sí? eso es 00:17:04
efectivamente, en este caso 00:17:10
aquí, me devuelve 00:17:12
3, porque hay 3 elementos 00:17:13
¿sí? 00:17:17
entonces, aquí viene 00:17:23
la clave que tenemos nosotros, ¿vale? 00:17:24
tengo char de array 00:17:27
es un array, ¿vale? array es igual a 00:17:28
new char de 10, estoy creando 00:17:30
un array de 10 posiciones 00:17:32
y luego viene mi amigo el for 00:17:34
que me permite ir desde i igual a 0 00:17:36
a i menor que array.length menor estrecho 00:17:39
entonces esto llegará hasta 00:17:43
array.length menos 1 00:17:45
porque cuando i será igual a array.length 00:17:47
esto será falso 00:17:51
haciendo is más más y lo que hago es 00:17:53
imprimir cada una de las celdas 00:17:57
de esta array 00:18:00
o rellenarla o recorrerla o hacer algo con ella 00:18:01
Ya veremos, depende del algoritmo que yo hago 00:18:05
Pero este trocito de aquí es como puedo recorrer un array 00:18:08
¿Lo veis? 00:18:14
Esto dará varias veces 00:18:17
En el primer ciclo valdrá 0 y por lo tanto mirará array de 0 00:18:19
Vuelve aquí, va a 1 00:18:23
Entonces mirará array de 1 00:18:26
Vuelve aquí, array 2, array 3, array 4, array 5, array 6 00:18:28
Hasta que llegue a array 9 00:18:33
Array 9 entra y mira la última posición 00:18:35
Porque de 10 posiciones irá de 0 a 9 00:18:37
Vuelve aquí, ahora vale 10 00:18:40
10 no es menor que 10 00:18:42
Y por lo tanto saldrá 00:18:44
Cuidado que si pongo menor o igual 00:18:47
Me dará 00:18:49
Array out of bound exception 00:18:54
2.10 00:18:56
Ahí está recorriendo un array 00:18:57
Tengo mi array de lunes, martes, miércoles, jueves y viernes 00:19:04
For int i es igual a 0 00:19:07
Y menor que 10.length y más más 00:19:10
Un poquito lo podía hacer, ¿no? 00:19:13
Allí, ¿se ve? 00:19:15
Pues, x es igual a y más 1, creo que es, ¿qué es esto? 00:19:17
Y si está en puntual, te diré, el día x, que es y más 1, es días de y. 00:19:25
Esto lo hago para no decir que el día 0 es lunes, ¿vale? 00:19:34
Para que ponga día 1 es lunes 00:19:37
Día 2 es martes 00:19:40
Día 3 y es lo que me sale aquí 00:19:42
Día 1 es lunes 00:19:44
Día 2 es martes 00:19:46
Día 3 es miércoles 00:19:47
Entonces estoy recorriendo este array 00:19:48
En cada ciclo del for 00:19:51
Estoy leyendo una celda distinta del array 00:19:54
Dudas, preguntas 00:19:57
Ahora, existe 00:20:04
Esto de recorrer un array 00:20:12
De ir desde el principio hasta el final 00:20:15
de un array leyendo todas sus celdas 00:20:18
es tan común en programación 00:20:20
tan utilizado, que han creado 00:20:24
una estructura for 00:20:27
más específica para hacer este tipo de actividades 00:20:29
lo que se llama el forEach 00:20:33
en otros lenguajes lo encontráis justo como forEach 00:20:35
en Java 00:20:40
es esta cosa aquí 00:20:42
Nums es una raíz de enteros. 00:20:44
Si yo hago for int y dos puntos nums, esto quiere decir que por cada ciclo de esto, y valdrá una de las posiciones de nums. 00:20:51
En la primera vuelta valdrá 100, en la segunda vuelta y valdrá 200, en la tercera vuelta y valdrá 300. 00:21:06
Es como si hiciera aquí una vuelta por cada posición de la rey y en cada vuelta valdrá el valor de una de las posiciones. 00:21:16
Y haré aquí dentro algo con Y, que la primera vez me valdrá 100, la segunda vez me valdrá 200, la tercera vez me valdrá 300. 00:21:26
Puedo esto no usarlo nunca en la vida y usaré esto. 00:21:34
Es lo mismo, simplemente que aquí en vez de utilizar Y, o debería hacer aquí intY, es igual a días, o en este caso que es a nums de Y. 00:21:39
Y ya está, es lo mismo. 00:21:49
Solo que como es una cosa tan común de utilizar, en vez de utilizar aquí dentro, cuando uso el valor siempre nums de Y, nums de Y, nums de Y, 00:21:50
pues lo que hago es me lo guardo en una variable y uso esa variable. 00:22:00
Ahora hacemos ejemplos y vemos cómo podemos cambiar. 00:22:04
no, el nombre de la variable que tú quieras 00:22:06
efectivamente, me ahorro de saltarme el B 00:22:17
si yo quiero, por ejemplo, si mi ejemplo me dice 00:22:22
busca el tercer elemento 00:22:27
o que se yo, busca los primeros tres elementos 00:22:32
a lo mejor esto no me vale 00:22:34
a mi esto me vale si tengo que hacer algo 00:22:36
en todos los elementos de un array 00:22:40
Porque esta cosa de aquí 00:22:43
Me funcionará para todos los elementos de la array 00:22:44
¿Sí? 00:22:47
Luego puedo poner breaks y salir a mitad 00:22:48
Si quiero, ¿vale? 00:22:50
Pero técnicamente esto está pensado 00:22:52
Si yo quiero hacer una operación 00:22:53
Pillando primero la primera celda 00:22:55
Luego la segunda, luego la tercera 00:22:58
Y que la quiero hacer para absolutamente todas 00:22:59
¿Vale? 00:23:02
Entonces uso este for de aquí, el for each 00:23:03
Si en vez no estoy seguro que tenga que mirarla a todas 00:23:05
O no lo tengo que hacer para todas 00:23:08
Pues entonces casi uso un for 00:23:10
Escribir el contenido de un array 00:23:11
Existe esto, pero esto de aquí 00:23:18
Lo podéis usar solo en casos 00:23:23
Extraordinarios 00:23:25
Si vosotros hacéis 00:23:27
Arrays.toString 00:23:28
Y le metéis entre paréntesis un array 00:23:30
Esto os devuelve un string 00:23:33
Que es la representación 00:23:35
De lo que contiene 00:23:37
El array, es decir, esta cosa aquí 00:23:39
¿Veis? 00:23:41
Lunes, martes, miércoles, jueves, viernes 00:23:42
Pero yo esto lo quiero que lo utilicéis 00:23:44
Al menos por ahora, en un futuro lo utilizáis como os da la gana 00:23:50
Pero por ahora esto sirve como comodín 00:23:53
Acabo el ejercicio, quiero ver que dentro esté la cosa que he puesto 00:23:56
Quiero ver el array, pues uso esta de aquí rápidamente 00:24:01
Pero si el ejercicio os dice, escribeme el contenido de un array 00:24:04
Es para que vosotros aprendáis a utilizar el for 00:24:08
No porque aprendáis a utilizar esto 00:24:10
entonces me podéis utilizar esto 00:24:12
para ver el contenido 00:24:16
y luego hacerme el ejercicio utilizando el for 00:24:17
para que veáis 00:24:20
que lo que habéis escrito vosotros es lo mismo que hay 00:24:22
dentro de verdad y que lo estáis haciendo bien 00:24:24
eso sí 00:24:26
pero por ahora nosotros 00:24:26
queremos que si leemos un array 00:24:30
o miramos un array o escribimos en pantalla un array 00:24:31
lo hagamos nosotros utilizando 00:24:34
while, for o lo que sea 00:24:36
porque estamos estudiando eso 00:24:37
copia de un array 00:24:40
vale 00:24:48
vamos a dejarlo 00:24:49
un momento 00:24:52
vamos a dejarlo un momento 00:24:52
y vamos a hacer 00:24:55
unas pruebas, unos ejercicios 00:24:57
algo, vale, para ver 00:24:59
un poco y luego volvemos a esto 00:25:03
de la copia de un array, vale, que es importante 00:25:05
entonces 00:25:08
ejercicios básicos 00:25:09
SRC 00:25:11
Me creo un nuevo package 00:25:13
Que será 00:25:15
Arrays 00:25:18
Y aquí me creo una nueva clase 00:25:20
Ejemplo 1 00:25:25
Vale, entonces 00:25:28
Tengo mi 00:25:32
Ejemplo 1 00:25:32
Main, hagamos una cosa básica 00:25:35
Por ahora, luego lo complicamos si queremos 00:25:40
Vale, creámonos 00:25:42
Un array de 5 posiciones 00:25:44
¿Cómo creo un array 00:25:47
De 5 posiciones? 00:25:48
entero, int 00:25:50
corchetes, nombre del array 00:25:53
que son edades, acostumbrados por favor 00:26:00
a no llamar todas las variables int, o sea, todos los enteros i 00:26:05
todos los array ar, todos los 00:26:08
booleano b, porque llega un momento en que no entenderéis que estáis escribiendo 00:26:13
los nombres tienen que tener, o sea, la variable tiene que tener significado 00:26:17
Si es un array de edades, pues llamadle edades 00:26:21
Si es un array de 00:26:23
Longitudes, pues pongamos longitudes 00:26:25
O algo por el estilo, pero que se entienda 00:26:28
Cuando vosotros miráis esto 00:26:30
Sepáis 00:26:32
Lo que es, ¿vale? 00:26:33
Entonces, int edades, ¿vale? 00:26:35
Se las doy yo, directamente 00:26:39
Tenemos 00:26:41
Hemos dicho de 5 00:26:49
otra opción 00:26:54
int 00:26:57
edades 2 00:26:59
¿cómo creo un array de 5? 00:27:01
new 00:27:09
int 00:27:10
corchete 00:27:12
en los dos casos he creado 00:27:15
dos arrays 00:27:19
de 5 posiciones 00:27:22
esto 00:27:24
ya está rellenado 00:27:25
Este no 00:27:28
Pregunta 00:27:29
Arraiz.toString 00:27:31
De edades 00:27:37
¿Qué me escribe? 00:27:41
¿Sí? 00:27:49
¿Y si en vez le pregunto edades 2? 00:27:51
Por defecto 00:28:00
Las variables int 00:28:01
Si no están inicializadas 00:28:03
Pues se asume que son 0 00:28:04
¿Sí? 00:28:06
Como los char 00:28:07
No tengo idea de las cosas iniciales de char 00:28:10
Luego lo miramos 00:28:13
Ojo, se enfada 00:28:14
Los booleanos 00:28:15
Creo falso 00:28:17
Los string null 00:28:18
Cosa por esto 00:28:21
Si tenéis curiosidad 00:28:23
Pues hacéis esto 00:28:25
Creáis un array de lo que sea 00:28:26
Y lo imprimís 00:28:29
Y miráis que os da 00:28:30
Vamos a verlo 00:28:31
Null probablemente 00:28:37
Creo un array de string 00:28:39
Lo conseguiré 00:28:42
String 00:28:46
Que se llame 00:28:47
str 00:28:50
new string 00:28:53
y aquí le pongo 00:28:56
str 00:28:59
¿qué pondrá? 00:29:00
5, 0 00:29:02
pongo 00:29:02
char 00:29:09
vamos a ver char 00:29:10
¿qué hace char? 00:29:11
chr 00:29:14
char 00:29:15
chr 00:29:20
¿qué es char? 00:29:22
esto es interesante, no sé si es un espacio 00:29:26
o si es un carácter, yo creo que es un espacio 00:29:32
no, creo que es un espacio, porque un espacio lo pone aquí 00:29:34
y tienes un espacio, el espacio que es este de aquí 00:29:38
otro espacio, yo creo que por defecto este es un espacio 00:29:42
cadena vacía no pondría nada 00:29:45
pero es raro, ¿vale? 00:29:47
esto lo podríamos hacer así 00:29:51
Si, so, int chr de cero, un cero, y ahora me voy a así, y el carácter cero es el carácter nulo, sería el nul, sería el equivalente de un nul 00:29:52
Carácter nulo que posiblemente 00:30:23
Aquí es interpretado como un espacio 00:30:25
Pero no es un espacio 00:30:27
Porque el espacio oficial es otro numerito 00:30:29
Es el numerito 00:30:31
Espacio 00:30:33
Es el 32 00:30:35
¿Sí? 00:30:36
Porque no es nul 00:30:40
Nul es un valor especial para objetos 00:30:41
String es un objeto, ¿te acuerdas? 00:30:44
Esto es el carácter nulo 00:30:46
Es un carácter, no es nul 00:30:48
Pero luego representa 00:30:50
Que no has puesto nada 00:30:52
Pero nula es otra cosa 00:30:54
Es el objeto nulo 00:31:03
Y esto no es un objeto, entonces no es lo mismo 00:31:04
Y booleano 00:31:07
Falsi, creo que corresponderá a cero 00:31:10
Vámonos 00:31:13
Como sois vagos 00:31:15
Por defecto se ponen estas cosas 00:31:15
Ahora yo pillo 00:31:42
Todo esto 00:31:45
lo pongo así 00:31:46
porque no lo quiero utilizar, ¿vale? 00:31:49
vamos a pensar sobre los enteros 00:31:50
entonces, este de aquí lo he rellenado 00:31:52
ahora, este de aquí lo tengo que rellenar 00:31:54
pongamos que lo quiero rellenar 00:31:56
con todos 100, quiero 100 en todas 00:31:58
celdas, ¿cómo lo hago? 00:32:00
¿verdad? 00:32:27
claro, veis que si lo pongo así 00:32:29
me da un error 00:32:31
no existe el método 00:32:32
length para arrays 00:32:35
¿vale? pero existe el 00:32:37
atributo length para race, cuidado que es azul 00:32:39
¿veis? 00:32:41
veremos la diferencia cuando entenderemos los objetos 00:32:43
¿sí? pero esta es una 00:32:45
variable 00:32:47
para una string existe el método 00:32:47
es una función 00:32:51
mientras esta no es una función, es una variable 00:32:52
asociada con el aes2 00:32:55
entonces ¿qué hago aquí? 00:32:56
si ahora vuelvo a escribirlo 00:33:18
así se ve como se va rellenando 00:33:19
¿vale? por cada ciclo 00:33:30
lo estoy escribiendo 00:33:34
Veis que en el primer ciclo pone 100 aquí y los otros son todavía 0. 00:33:36
Segundo ciclo, pues he rellenado las primeras dos y se quedan los otros 0. 00:33:40
Tercer ciclo, cuarto ciclo, quinto ciclo. 00:33:45
Y al final del quinto ciclo, en todos he puesto 100. 00:33:48
¿Sí? 00:33:55
Pongamos aquí... 00:33:58
¿Por qué no me he pillado? No me he pillado. 00:34:30
Voy a hacer un... 00:34:35
Item.out.println 00:34:36
Dame un valor 00:34:40
Más 00:34:49
Sobre 00:34:52
Ahora sí, vale 00:34:54
Más 00:35:00
Edades 00:35:01
Dos punto 00:35:04
Length 00:35:06
Vale, entonces ahora lo lanzo 00:35:07
No, hay errores 00:35:15
¿Dónde hay errores? 00:35:17
Aquí hay errores 00:35:18
Lanzo, dice 00:35:19
Dame un valor, el cero sobre cinco, vale 00:35:27
Habría tenido que ponerle más uno 00:35:29
Pero el primer valor es doce 00:35:32
Y veis que me ha guardado doce en la primera 00:35:34
En la posición cero 00:35:36
Ahora pongo cuarenta y cuatro 00:35:38
Me la ha guardado en la posición uno 00:35:41
Quinto, cuarenta y tres 00:35:42
Once 00:35:45
Tres 00:35:46
Esto está feo 00:35:47
Le vamos a poner 00:35:52
Y más uno 00:35:54
Y entonces ahora me sale 00:35:56
Dame el valor uno de cinco 00:36:03
es 10, segundo valor 00:36:05
20, 30, 40 y 50 00:36:08
vale 00:36:10
y al final me encuentro 00:36:11
los valores en mi array 00:36:14
¿lo veis? 00:36:15
estoy haciendo esta array 00:36:20
5 veces 00:36:22
la primera vez 00:36:23
me pondrá en la 00:36:26
posición 0, la segunda vez en la posición 00:36:28
1, la tercera vez en la posición 2 00:36:30
hasta la posición 4 00:36:32
irá de 0 a 00:36:33
edades2.length 00:36:35
menos 1, 4 00:36:37
y por cada ciclo 00:36:38
me pide de escribir algo y lo guardo 00:36:41
¿dudas? 00:36:44
¿preguntas? 00:36:47
eh, momento no 00:36:54
vamos ahora a escribir 00:36:55
esta array, sin usar esta cosa 00:36:57
aquí, y quiero escribirlo en vertical 00:36:59
for 00:37:01
int y es igual 00:37:06
a 0 00:37:08
y menor que edades2.length 00:37:09
Y más más 00:37:13
Por cada posición de la rey 00:37:14
Si, so 00:37:18
Más 00:37:22
Dos puntos 00:37:23
Más, ¿cómo escribo el contenido de la posición 00:37:25
De la rey? 00:37:30
Puedo poner, mira 00:37:32
Posición 00:37:33
Posición 00:37:35
Contiene 00:37:44
¿Cómo se llama la rey? 00:37:46
edades 2 00:37:53
ya está 00:37:56
entonces cuando salga a posición 0 00:38:02
dirá posición 0 00:38:06
y pondrá edades 2 de 0 00:38:07
cuando será 1, posición 1 00:38:09
y pondrá edades 2 de 1 00:38:12
¿sí? 00:38:14
ahí, ahora cada vez 00:38:18
1, 2, 3, 4, 5 00:38:19
¿veis? 00:38:21
este es el 00:38:24
contenido que me está escribiendo 00:38:24
1, 2, 3, 4, 5 00:38:28
¿Cómo lo puedo hacer de otra forma? 00:38:30
Por int actual dos puntos 00:38:38
Edades dos, si eso, actual 00:38:44
Uno, dos, tres, cuatro, cinco 00:38:54
Aquí lo tienes 00:39:02
Fijaos que mientras en esto tengo un índice 00:39:04
Y puedo trabajar con el índice 00:39:12
En realidad aquí un índice no lo tengo 00:39:14
¿Sí? Tengo el valor 00:39:17
Pero no tengo el índice de este valor 00:39:21
Si lo quisiera, debería construírmelo 00:39:24
Como int index es igual a cero 00:39:28
Y cada vez que hago una vez este aquí 00:39:33
Pues le pongo index++ por algún lado 00:39:36
¿Vale? 00:39:38
Pero si lo quiero usar así 00:39:40
pues entonces casi mejor que me lo planteé directamente así 00:39:42
si necesito este índice porque quiero hacer algo con este índice 00:39:45
entonces casi mejor que vaya directamente a esta función 00:39:51
si el índice no me sirve, por ejemplo quiero escribir el contenido 00:39:54
pero sin decir esta posición 0 y esta posición 1 00:39:58
pues entonces puedo ir directamente con este aquí 00:40:01
como sintaxis es mucho más ligera 00:40:03
Con respecto a esta cosa aquí 00:40:11
Esto en particular nos servirá mucho más 00:40:13
Cuando tendremos objetos 00:40:18
Entonces pillaremos objetos 00:40:21
Y haremos algo sobre cada objeto 00:40:23
Probémoslo 00:40:25
String 00:40:28
MiArray 00:40:30
Es igual a 00:40:33
NewString 00:40:35
De 4 00:40:36
Mejor 00:40:41
Y ahora pongo que mi array de 0 contiene, hola, mi array de 1 contiene 1, 2 00:40:55
Pregunta para vosotros, ¿cómo podría haber hecho esto mucho más rápido? 00:41:14
No oigo absolutamente nada 00:41:33
yo digo, aquí arriba 00:41:50
pero no creo que esto lo pille 00:42:01
el Java 00:42:03
cuéntame, es lo mismo 00:42:03
me crea un array de cuatro posiciones 00:42:45
y cosas por el estilo, vale 00:42:48
esto sirve cuando yo tengo que crear un array de cuatro posiciones 00:42:49
y no sé que va a poner dentro 00:42:52
este de aquí me sirve si ya tengo lo que sea 00:42:54
para hacer pruebas y cosas por el estilo 00:42:56
esto normalmente 00:42:58
me creo un array de pruebas, lo uso y cosas por el estilo 00:42:59
luego sustituyo esta línea 00:43:02
con la línea que 00:43:04
me lo lee por teclado y cosas por el estilo 00:43:06
y así evito cada vez que tenga 00:43:08
que hacer este trabajo, pues de tener que 00:43:10
ir a leer cinco números 00:43:12
así me explico 00:43:13
por ejemplo, en este ejercicio para llegar a esta parte 00:43:16
aquí, que es la parte que me interesa, tendré que poner 00:43:20
cinco números aquí 00:43:22
me gusta 00:43:23
entonces 00:43:25
he creado estos arrays, vale, fenomenal 00:43:28
imaginamos que ahora yo 00:43:30
quiera escribir 00:43:32
no el contenido 00:43:33
pero el tamaño de cada una 00:43:35
de las letras 00:43:37
dentro de cada una de las celdas 00:43:38
entonces se haría 00:43:41
for 00:43:43
int 00:43:44
string s 00:43:46
dos puntos 00:43:49
mi array 00:43:50
se hizo 00:43:52
s.length 00:43:57
entonces 00:43:59
antes me pide este valor de aquí 00:44:06
sería esta parte 00:44:08
de aquí 00:44:15
la primera 00:44:16
son 4, la segunda 00:44:19
son 5 00:44:21
la tercera son 8, porque es este 00:44:22
de aquí 00:44:25
y la última 00:44:25
son 3 00:44:28
¿sí? 00:44:30
aquí no estoy utilizando 00:44:33
el índice, me interesa saber 00:44:35
la longitud de todas las cadenas 00:44:37
que he guardado, pues entonces tengo esto 00:44:39
imaginamos que quiero saber 00:44:42
la longitud total 00:44:45
de lo que he escrito en este array 00:44:48
int total 00:44:50
es igual a cero 00:44:53
y aquí podría hacer 00:44:55
total 00:44:58
más igual 00:44:59
a ese punto length 00:45:01
y cuando salgo 00:45:07
si eso 00:45:09
total dos puntos 00:45:10
más total 00:45:13
entonces ahora tengo esta cosa aquí 00:45:14
el total son 20 letras 00:45:20
en todo mi array 00:45:23
tengo 20 letras 00:45:25
4 más 5 más 8 00:45:26
más 3, 20 00:45:31
entonces, la cosa interesante aquí 00:45:32
es que yo antes 00:45:38
cuando hacía 00:45:41
estos ejercicios que vosotros habéis hecho 00:45:42
de for, de while, de cosas por el estilo 00:45:44
las variables 00:45:46
que me daban, los valores 00:45:49
que me daban, los perdía 00:45:50
en cada ciclo yo leía 00:45:52
una cosa, la podía acumular 00:45:54
podía calcular la suma y luego 00:45:56
cuánto me había metido y dividir 00:45:58
pero perdía ese valor 00:46:00
si yo leía todo 00:46:01
lo podía acumular en un string 00:46:04
pero era algo 00:46:06
que luego guardándolo en string no lo puedo volver 00:46:08
a utilizar, porque son string 00:46:10
debería 00:46:12
trocearlo, sacar otra vez 00:46:13
el string y transformarlo en 00:46:16
se vuelve engorroso, ahora en vez 00:46:18
tengo un sistema para poder decir 00:46:20
los datos que me das, guárdatelos 00:46:22
en un array, los guardas 00:46:24
ya en las casillas 00:46:26
y luego después cuando has leído todos los 00:46:27
datos y ya los tienes todos 00:46:30
pues a este punto puedes 00:46:32
mirarlos todos para hacer 00:46:33
la suma, para hacer 00:46:36
la media, para contar cuantos 00:46:38
son y cosas por el estilo, a ese punto ya los ten 00:46:40
no sé si me explico lo que quiero decir 00:46:42
técnicamente no hay 00:46:44
un límite, yo creo que esto 00:46:53
es un entero lo que se le pasa 00:46:54
aquí, por lo tanto 00:46:56
habría el 4.000 millones 00:46:59
aún así 00:47:01
no suele ser 00:47:02
no, no, las posiciones 00:47:03
no puedes hacer 3 posiciones y media 00:47:10
posiciones un entero 00:47:12
creo que sea un entero 00:47:14
este de aquí, y si es un entero 00:47:16
pues puede pillar como máximo 4.000 millones 00:47:18
pero, o sea, 2.000 millones en realidad 00:47:20
no se suele hacer 00:47:22
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
stefano chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
20
Fecha:
29 de octubre de 2024 - 11:05
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
47′ 26″
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:
138.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid