INTRODUCCIÓN A LOS ARREGLOS

Un arreglo es una estructura homogénea, compuesta por varios componentes, todos del mismo tipo y almacenados consecutivamente en memoria. Cada componente puede ser accesado directamente por el nombre del arreglo seguido de un subindice encerrado en corchetes.
Arreglos Unidimensionales
Un arreglo unidimensional es un tipo de datos estructurado que está formado de una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la dirección base del arreglo, la cota superior y la inferior.
DECLARACIÓN
La declaración de un arreglo unidimensional consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
[ ] < identificador > ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes, [ ], representa la dimensión del arreglo y encierra un número entero que corresponde al número de elementos del arreglo.
Ejemplos:
int [ ] a ;
float [ ] distancia ;
Artículo [ ] art = new Artículo[ 3];
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
CREACIÓN.
La creación de un arreglo unidimensional consiste en reservar espacio de memoria para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new [ tamaño ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
tamaño es un número entero que representa el número de elementos del arreglo.
Ejemplos:
a = new int [10] ; // Se crea el arreglo a , con 10 elementos de tipo entero.
distancia = new float[ 5] ; // Se crea el arreglo distancia , con 5 elementos de punto flotante y precisión sencilla .Artículo [] art = new Artículo[3];
Artículo [ ] art = new Artículo[ 3]; // Se crean 3 referencias a objetos de la clase Artículo
art[0]= new Artículo(); // Se crea el primer objeto del arreglo art
art[1]= new Artículo(); // Se crea el segundo objeto del arreglo art
art[2]= new Artículo(); // Se crea el tercer objeto del arreglo art

Las dos primeras operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
int [ ] a = new int [10] ;
float [ ] distancia = new float[5] ;
INICIALIZACIÓN.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
• Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
• Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
• Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
• Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:
int [ ] a = { 1, 0,4,-6, 2,9, 23,455, 90,35 };
float [ ] distancia = { 2.50F, 286.45F, 46.75F, 30.62F, 93.00F };
string [ ] pato = { "Hugo", "Paco", "Luís" };
ACCESO.
Se puede acceder a los valores de los elementos de un arreglo a través del nombre del arreglo y un subíndice. El subíndice debe escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y el subíndice del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Ejemplo:
float [ ] distancia = new float[5] ; // Crea el arreglo distancia con 5 elementos.

float x = 25F, y = 10F ; // Crea dos variables de punto flotante y precisión sencilla.

Distancia [0] = x + y; // El valor asignado al primer elemento es 35.

Distancia [1] = ++distancia [0]; // Asigna 36 al segundo elemento.

Distancia [2] = distancia [1] - distancia [0] + 4; // Asigna 5 al tercer elemento.

Distancia [3] = distancia [2]--; // Asigna 5 al cuarto elemento
// y disminuye en 1 el valor del tercero.

distancia[4] = distancia[3] * distancia[2] ; // Asigna 20 al quinto elemento.

y = distancia[4] ; // Asigna a y el valor almacenado en el quinto elemento.

Arreglos Bidimensionales
Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito ordenado y homogéneo. El acceso a ellos también es en forma directa por medio de un par de índices.
Los arreglos bidimensionales se usan para representar datos que pueden verse como una tabla con filas y columnas. La primera dimensión del arreglo representa las columnas, cada elemento contiene un valor y cada dimensión representa una relación


DECLARACIÓN.
La declaración de un arreglo consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
[ , ] < identificador > ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos números enteros, cuyo producto corresponde al número de elementos del arreglo.
Ejemplos:
double [ , ] matriz ;
int [ , ] ubicación ;
Rama [ , ] árbol; // Rama es una clase.
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
CREACIÓN.
La creación de un arreglo bidimensional consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:
< identificador > = new [ dim1, dim2 ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
dim1 y dim2 son valores enteros que representan las dimensioes del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.
Ejemplos:
matriz = new double [2, 3] ; // Se crea el arreglo matriz, con 6 elementos de tipo
//punto flotante y precición doble .
ubicación = new int[ 4,2] ; // Se crea el arreglo ubicación, con 8 elementos de
//tipo entero de 32 bits .
árbol = new Rama[5,2] ; // Se crea el arreglo arbol, con 10 objetos
//de la clase Rama.
Las operaciones de declaración y creación anteriores se pueden agrupar en una sola instrucción, como se muestra enseguida:
double [ , ] matriz = new double [2,3] ;
int [ , ] ubicación = new int[4, 2] ;
Rama [ , ] alumno = new Rama[5,2] ;
INICIALIZACIÓN.
Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan automáticamente valores iniciales predeterminados a cada uno de sus elementos, de acuerdo a los siguientes criterios:
• Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
• Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.
• Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
• Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por ejemplo:
double [ , ] matriz = { {1.5, 0, 4, -6.5, 2 } , {2.3, 9, 3.5, 4.8, 6.2} };
int [ , ] ubicación = { {2, 4} , {6, 8} , {9, 10}, {5 , 1}};
string [ , ] funcionario = { {"Hugo", "jefe"} ,
{ "Paco", "operador "},
{ "Luís","ayudante"} };
ACCESO.
Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del arreglo menos uno.
Ejemplo:
int [ , ] posición = new int[5, 10] ; // Crea el arreglo posición , con 50 elementos de tipo entero.
int x;

posición[ 3, 5] = 3 ;
x = posición[ 3, 5] ;