1
00:00:10,830 --> 00:00:12,600
Iniciarlos elementos de un arreglo.

2
00:00:14,040 --> 00:00:18,900
Vamos a ver a continuación la sintaxis para inicializar los elementos de un arreglo de una dimensión

3
00:00:18,930 --> 00:00:19,440
en Java

4
00:00:22,250 --> 00:00:28,730
podemos observar que una vez que hemos declarado el arreglo vamos a utilizar el nombre de la variable

5
00:00:29,280 --> 00:00:36,230
y posteriormente entre corchetes vamos a indicar el índice que queremos modificar posteriormente el

6
00:00:36,230 --> 00:00:40,760
signo de igual y asignamos un valor en el índice respectivo.

7
00:00:40,760 --> 00:00:47,000
De esta forma es que vamos a inicializar cada uno de los elementos del arreglo utilizando el índice

8
00:00:47,240 --> 00:00:50,060
es decir la posición del arreglo que queremos modificar.

9
00:00:50,060 --> 00:00:56,180
Debemos de recordar que el índice de un arreglo comienza de cero y el valor máximo de un arreglo es

10
00:00:56,180 --> 00:01:04,870
el valor del número de elementos menos 1 ya que el índice comenzó en cero y a continuación vemos un

11
00:01:04,870 --> 00:01:10,870
ejemplo para inicializar los elementos de un arreglo de tipo entero podemos observar que tenemos la

12
00:01:10,870 --> 00:01:18,160
variable enteros que es el arreglo que hemos declarado anteriormente el cual ya hemos declarado y también

13
00:01:18,250 --> 00:01:25,020
instancias como siguiente paso indicamos entre corchetes el índice que queremos modificar.

14
00:01:25,060 --> 00:01:32,290
En este caso el primer elemento del arreglo y le asignamos el valor de 15 al primer elemento del arreglo

15
00:01:33,070 --> 00:01:39,580
así que esta línea de código nos permite asignar el valor de 15 en el índice 0 de este arreglo pero

16
00:01:39,580 --> 00:01:42,430
también si quisiéramos modificar el siguiente elemento.

17
00:01:42,430 --> 00:01:49,360
Podemos indicar la variable posteriormente el índice en este caso el índice 1 es decir el segundo elemento

18
00:01:49,810 --> 00:01:56,890
y asignar el valor de 13 a este segundo elemento por lo que en este caso se asigna el valor de 13 en

19
00:01:56,890 --> 00:01:58,510
el índice 1.

20
00:01:58,510 --> 00:02:04,540
Esto es para arreglos de tipo primitivo y un ejemplo para inicializar los elementos de un arreglo manejando

21
00:02:04,550 --> 00:02:06,460
a tipos Object es como sigue.

22
00:02:06,690 --> 00:02:10,180
Ya debemos de tener declarada nuestra variable en instancia.

23
00:02:10,210 --> 00:02:17,200
Este arreglo es decir ya debemos de haber indicado cuántos elementos va a contener este arreglo y como

24
00:02:17,200 --> 00:02:21,580
siguiente paso lo que hacemos es indicar el índice que queremos modificar.

25
00:02:21,580 --> 00:02:30,690
En este caso el índice 0 o elemento 1 y le asignamos una nueva referencia de objeto de tipo personal.

26
00:02:30,820 --> 00:02:36,410
Por ello es que estamos utilizando el operador nio y creando un nuevo objeto de tipo personal.

27
00:02:36,610 --> 00:02:43,480
Así que en este momento se asigna la referencia del objeto persona en el índice 0 y también si quisiéramos

28
00:02:43,480 --> 00:02:48,920
modificar el elemento 2 es decir el valor del arreglo posicionado en el índice 1.

29
00:02:49,090 --> 00:02:55,060
Podemos también hacerlo con la siguiente sintaxis simplemente creamos nuevamente un objeto en este caso

30
00:02:55,090 --> 00:03:03,310
utilizando un constructor de dos argumentos y una vez creado este objeto le asignamos la referencia

31
00:03:03,310 --> 00:03:09,370
de memoria donde se encuentra este nuevo objeto y así es como asignamos la referencia del objeto creado

32
00:03:09,610 --> 00:03:11,110
en el índice 1.

33
00:03:11,170 --> 00:03:17,110
También si quisiéramos asignar un valor a nuestro arreglo de nombres de tipo cadena simplemente indicamos

34
00:03:17,140 --> 00:03:21,240
el índice y le asignamos un nuevo valor utilizando una cadena.

35
00:03:21,550 --> 00:03:26,590
Recordemos que el manejo de cadenas esto no va a ser lo común pero en este caso lo estamos utilizando

36
00:03:26,590 --> 00:03:29,220
para que vean que es un tipo obvie.

37
00:03:29,290 --> 00:03:35,980
Sin embargo basta con indicar entre comillas el valor de la cadena y esto en automático va a regresar

38
00:03:36,280 --> 00:03:40,840
una referencia donde se encuentre el objeto de tipo personal que se ha creado.

39
00:03:40,840 --> 00:03:47,530
Y así es como podemos asignar el valor de la referencia al índice cero es decir al elemento 1 de este

40
00:03:47,530 --> 00:03:54,610
arreglo y si quisiéramos modificar el elemento 2 es decir el valor posicionado en el índice 1 también

41
00:03:54,610 --> 00:04:00,500
podemos hacer lo mismo o simplemente poner entre comillas el valor de la cadena.

42
00:04:00,740 --> 00:04:08,060
Esto asigna el string indicado en el índice 1 o lo que es lo mismo en el elemento 2 de este arreglo

43
00:04:08,060 --> 00:04:08,910
de cadenas.

44
00:04:08,960 --> 00:04:14,360
Así que en este código podemos observar la inicialización de los elementos de un arreglo de una dimensión

45
00:04:14,870 --> 00:04:21,740
lo que debemos hacer para ir agregando elementos a un arreglo es seleccionar uno por uno los índices

46
00:04:21,740 --> 00:04:23,630
que queremos ir inicializar.

47
00:04:23,630 --> 00:04:30,110
Por ello es importante saber que el índice cero es el primer elemento del arreglo y el último elemento

48
00:04:30,110 --> 00:04:38,210
del arreglo lo podemos obtener con la propiedad Link menos 1 es decir el largo del arreglo menos 1 por

49
00:04:38,210 --> 00:04:45,080
ejemplo si escribimos enteros punto Link menos 1 nos devolverá el último índice del arreglo que podemos

50
00:04:45,080 --> 00:04:51,950
ocupar si nos pasamos del índice máximo y queremos agregar un elemento fuera de la cantidad máxima de

51
00:04:51,950 --> 00:05:00,000
elementos disponible para este arreglo nos arrojará un error conocido como Array Index a 2 Bown exception.

52
00:05:00,020 --> 00:05:06,320
Por ello debemos saber cuál es el máximo número de elementos con el código mencionado y así no pasarnos

53
00:05:06,380 --> 00:05:12,530
de la cantidad máxima de elementos así que aquí podemos observar varios ejemplos de cómo agregar elementos

54
00:05:12,560 --> 00:05:19,790
a nuestros arreglos podemos agregar los de manera manual es decir uno a uno cada elemento o podemos

55
00:05:19,790 --> 00:05:25,180
ir agregando los elementos de manera más dinámica por ejemplo utilizando ciclos como puede ser foro

56
00:05:25,250 --> 00:05:31,070
o Jail pero en este caso necesitamos saber si ya se ha llegado al límite de elementos agregados o no.

57
00:05:31,280 --> 00:05:35,730
Y para ello como hemos comentado se puede utilizar la fórmula del nombre del arreglo.

58
00:05:35,750 --> 00:05:41,720
La propiedad Link y menos 1 para que no nos pasemos de los elementos que soporta el arreglo.

59
00:05:42,170 --> 00:05:47,570
Así que con esto podemos observar más claramente que no siempre estarán llenos todos los elementos de

60
00:05:47,570 --> 00:05:48,590
un arreglo.

61
00:05:48,590 --> 00:05:54,230
Por ejemplo si el arreglo de enteros es de 10 elementos entonces sólo hemos llenado dos de los diez

62
00:05:54,230 --> 00:05:56,130
elementos disponibles.

63
00:05:56,150 --> 00:06:02,330
Esto quiere decir que ocho elementos tendrán el valor por default según el tipo según el tipo de arreglo

64
00:06:02,330 --> 00:06:03,600
que se haya definido.

65
00:06:03,830 --> 00:06:09,060
En este caso el valor de cero debido a que el arreglo de enteros es de tipo entero.

66
00:06:09,110 --> 00:06:14,930
Por ello en muchas ocasiones será conveniente tener un contador para poder conocer cuántos elementos

67
00:06:14,930 --> 00:06:21,800
del arreglo ya se han asignado lo cual es distinto al número de elementos máximo que soporta un arreglo

68
00:06:22,250 --> 00:06:24,680
en el ejercicio que vamos a realizar en esta elección.

69
00:06:24,680 --> 00:06:34,490
Veremos cómo inicializar los elementos de nuestros arreglos extraer elementos de un arreglo a continuación

70
00:06:34,490 --> 00:06:38,560
vamos a ver la sintaxis para extraer los elementos de un arreglo de una dimensión.

71
00:06:38,660 --> 00:06:45,260
Podemos observar que este es el proceso inverso a modificar un valor en este caso queremos leer el valor

72
00:06:45,560 --> 00:06:49,410
de un índice respectivo y para ello vamos a utilizar la siguiente sintaxis.

73
00:06:49,520 --> 00:06:55,730
Indicamos el nombre del arreglo posteriormente entre corchetes indicamos el índice al cual queremos

74
00:06:55,730 --> 00:07:02,270
acceder para recuperar el valor posicionado en este índice y una vez que hemos proporcionado esta sintaxis

75
00:07:02,570 --> 00:07:08,900
nos regresara el valor almacenado en este índice del arreglo indicado y simplemente asignamos el valor

76
00:07:08,990 --> 00:07:16,650
a una variable la cual debe de ser del mismo tipo o un tipo compatible del arreglo vamos a ver un ejemplo

77
00:07:16,650 --> 00:07:22,020
para extraer los elementos de un arreglo de tipo entero podemos observar que debemos indicar el nombre

78
00:07:22,020 --> 00:07:22,590
del arreglo.

79
00:07:22,590 --> 00:07:28,710
Posteriormente el índice entre corchetes y esto nos va a regresar el valor del elemento posicionado

80
00:07:28,890 --> 00:07:34,950
en el índice cero de la regla es decir el elemento 1 del arreglo por lo que con esto lo que estamos

81
00:07:34,950 --> 00:07:41,460
haciendo es extraer el valor almacenado en el índice cero y si quisiéramos extraer el valor posicionado

82
00:07:41,520 --> 00:07:48,540
en el índice 1 es decir el elemento 2 del arreglo simplemente con esta sintaxis podemos recuperar el

83
00:07:48,540 --> 00:07:56,910
valor y asignarlo a una variable y con esto estamos extrayendo el valor almacenado en el índice 1 y

84
00:07:56,910 --> 00:08:02,100
ahora un ejemplo para extraer los elementos de un arreglo de tipo obvie podemos observar que la sintaxis

85
00:08:02,250 --> 00:08:03,380
es idéntica.

86
00:08:03,510 --> 00:08:10,170
Simplemente indicamos el nombre del arreglo y posteriormente el índice respectivo y esto nos va a recuperar

87
00:08:10,380 --> 00:08:15,870
el elemento indicado en la posición según el índice que hemos proporcionado y nos va a regresar la referencia

88
00:08:15,870 --> 00:08:18,840
del objeto que esté almacenada en ese índice.

89
00:08:18,840 --> 00:08:26,010
En este caso el elemento 1 del arreglo y posteriormente indicando de nueva cuenta el nombre del arreglo

90
00:08:26,040 --> 00:08:32,160
y posteriormente el índice nos va a regresar en este caso el elemento 2 del arreglo ya que debemos de

91
00:08:32,160 --> 00:08:38,340
recordar que el elemento 1 de un arreglo está en la posición 0 y así sucesivamente.

92
00:08:38,340 --> 00:08:45,300
El elemento 2 está en el índice 1 y así sucesivamente hasta llegar al último elemento el cual se encuentra

93
00:08:45,390 --> 00:08:51,270
en el índice de la longitud máxima del arreglo menos 1 y lo mismo para el arreglo de nombre simplemente

94
00:08:51,330 --> 00:08:57,290
indicamos la posición del índice que queremos recuperar y nos va a regresar la referencia almacenada.

95
00:08:58,110 --> 00:09:03,660
Si no se ha inicializar ningún valor en esta posición nos va a regresar Nul ya que es un string y es

96
00:09:03,660 --> 00:09:09,500
un tipo obvie y si ya se ha asignado una referencia entonces nos va a regresar la referencia del objeto

97
00:09:09,510 --> 00:09:15,480
cadena que se haya almacenado en este índice tanto en el índice cero como en el índice 1.

98
00:09:15,480 --> 00:09:16,790
En esta segunda línea.

99
00:09:16,920 --> 00:09:22,560
Así que para leer o extraer los elementos almacenados en un arreglo basta con indicar el nombre del

100
00:09:22,560 --> 00:09:26,880
arreglo e indicar el índice del elemento que queremos extraer.

101
00:09:26,880 --> 00:09:30,480
Esto regresarã el elemento del índice indicado.

102
00:09:30,480 --> 00:09:33,550
Es importante no pasarnos del número máximo de elementos.

103
00:09:33,660 --> 00:09:37,020
De lo contrario regresarã un error según hemos indicado.

104
00:09:37,110 --> 00:09:42,810
Con esto hemos visto varios ejemplos con arreglos que almacenan tipos primitivos o tipos obvie y en

105
00:09:42,810 --> 00:09:45,230
ambos casos la sintaxis es la misma.

106
00:09:45,330 --> 00:09:51,780
Sólo debemos tener una variable que reciba el valor extraído del arreglo según el índice especificado.

107
00:09:51,780 --> 00:09:57,840
Más adelante veremos ejemplos de cómo extraer los elementos utilizando un ciclo o Quayle para recorrer

108
00:09:57,840 --> 00:09:59,740
cada uno de los elementos de la red.
