c





 
  

 

c 













 




c


c



 INTRODUCCION

Un tipo arreglo es una lista de datos con un número

fijo de componentes, todos del mismo tipo
denominado tipo base; los que son referenciados o
calificados mediante índices o expresiones ordinales
encerradas en corchetes, que actúan como prefijo al
identificador del arreglo, siendo su tipo denominado
tipo índice.
 OBJETIVO
Conocer y comprender la estructura de un
arreglo.
 
mos arreglos se pueden definir como objetos
en los que podemos guardar mas de una
variable, es decir, al tener un único arreglo,
este puede guardar múltiples variables de
acuerdo a su tamaño o capacidad, es
importante recordar que las variables
guardadas deben ser del mismo tipo,
por ejemplo:
Si tenemos un arreglo de tipo numérico que
puede almacenar 10 variables, solo podrá
almacenar 10 números diferentes, no otras
variables como caracteres o Strings.
 p


Ò ma estructura de declaración de un arreglo es la
siguiente:
tipo_dedato [] nombre_variable; //también
puede declararse "tipo_dedato
nombre_variable[];͞

Ò ejemplos:
String array[]; //donde array es un arreglo que
guardara variables tipo Strings
double array2[]; //donde array2 es un arreglo que
guardara variables tipo double
int array3 []; //donde array3 es un arreglo que
guardara variables tipo int (numericas)
 p

   
Ò ›ara asignar a un arreglo su tamaño o capacidad,
se hace de la siguiente forma:
arreglo = new tipo_dedato[capacidad];
ejemplo:
array = new String[10]; //el arreglo array
guardara hasta un máximo de 10 variables de tipo
String
Ò ›ara realizar una declaración de un arreglo y
definir su tamaño en una misma línea se puede
usar la siguiente estructura:
String array[] = new String[10]; //se declara un
arreglo y se asigna su tamaño en una misma línea


     

Una vez se tiene declarado un arreglo, y al
mismo se le ha asignado un tamaño o
capacidad, podemos accesar a los datos
dentro del mismo y asignarle valores. ›ara
hacer esto es necesario proceder de la
siguiente forma:

arreglo[indicador]=valor;
 ejemplos

array[0] = "Ejemplo"; //aquí se asigna el valor

"Ejemplo" a un arreglo de String en su primera
posición
array2[3] = 5; //se asigna un valor de 5 al
4to elemento de un arreglo numérico;
Es importante recordar que para accesar a los
datos guardados en un arreglo se utilizan
indicadores iniciando desde el "0", si un
arreglo tiene un tamaño de 10 variables,
entonces se puede accesar a sus elementos
con los indicadores del 0 al 9.

A continuación un ejemplo mas completo:

int array1[]; //declaración arreglo de tipo
numérico
array1 = new int[3]; //tamaño del arreglo es 3
elementos
//asignación de valores a elementos del arreglo;
array[0] =2;
array[1] = 10;
array[2] = 7;
System.out.println("El valor de la posición 1 en el
arreglo es" + array[0]);
  


// Inicialización de un arreglo con los enteros pares del 2 al 20.

import javax.swing.*;
public class Inic2Arreglo {
public static void main( String args[] )
{
final int mONGITUD_ARREGmO = 10; // constante
int arreglo[]; // referencia a un arreglo int
arreglo = new int[ mONGITUD_ARREGmO ]; // crear el arreglo
// calcular el valor para cada elemento del arreglo
for ( int contador = 0; contador < arreglo.length; contador++ )
arreglo[ contador ] = 2 + 2 * contador;
String salida = "Índice\t Valor\n";
for ( int contador = 0; contador < arreglo.length; contador++ )
salida += contador + "\t" + arreglo[ contador ] + "\n";
JTextArea areaSalida = new JTextArea();
areaSalida.setText( salida );
JOption›ane.showMessageDialog( null, areaSalida, "Inicialización con enteros
pares del 2 al 20", JOption›ane.INFORMATION_MESSAGE );
System.exit( 0 );
} // fin de main
} // fin de la clase InicArreglo
ANEXOS
 p

 
  

int A[]; // A es un arreglo de enteros

int A[10]; // error, el tamaño no va aquí
int[] A; // A es un arreglo de enteros
int A,B[]; // A es un entero, B un arreglo
int[] A,B; // A y B son arreglos
String S[]; // S es un arreglo de strings
S[1]="" // error, el arreglo no ha sido creado
 
 
 

int A[]= new int[10]; // 10 enteros


 

 
  

A[0], A[1], ..., A[9] // correcto

A[10] // error, índice fuera de rango
 

 
  

A[3]= 8;
 „ 
  

A.length // correcto
A.length() // error, sin paréntesis


 
  
for (int i=0; i< A.length; i++)
A[i]= i;

 
  

int B[];
B= A; // A y B son el mismo arreglo
if (A==B) // Comparación de punteros true!
...
A[0]= 10;
B[0] // también 10
 
  

B= (int[])A.clone();


 
Al declarar un arreglo seria
Tipo de dato [] nombre variable;
O
Tipo de dato nombre nombre variable[];

Al definir una variable seria

arreglo = new tipo_dedato[capacidad];