Arreglos en java

Los arreglos se pueden definir como objetos en los que podemos guardar mas de una variable, es decir, al tener un unico arreglo, este puede guardar multiples 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 Numerico que puede almacenar 10 variables, solo podra almacenar 10 numeros diferentes, no otras variables como caracteres o Strings.

Existen 2 tipos de arreglos, los unidimensionales, y los multidimensionales(generalmente 2 dimensiones y se les denomina matrices), en esta lección veremos como declarar y utilizar los arreglos unidimensionales, estos son mas sencillos y faciles de comprender, y pueden servirnos para muchas aplicaciones.

------------------------------------------------------------------------------------------------------------

Una reglo en JAVA se puede definir de muchas formas.

Primero debemos identificar el tipo de dato que almacenará el arreglo, los tipos de datos mas usados: String (Texto), int (Entero), double (decimales), char (Caracteres), ó cualquier otro objeto definido en java.

Definición:

Los arreglos en Java son objetos, demostrando el compromiso de Java con la orientación a objetos.

?

Codigo Fuente de Computrachos con Fines Educativos!!!!!!!!!!!!!!!

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

import javax.swing.*;    public class InicArreglo {       public static void main( String args[] )    {       int arreglo[];            // declarar la referencia a un arreglo          arreglo = new int[ 10 ];  // crear el arreglo          String salida = "Índice\tValor\n";          // anexar el valor de cada elemento del arreglo al String salida       for ( int contador = 0; contador < arreglo.length; contador++ )          salida += contador + "\t" + arreglo[ contador ] + "\n";          JTextArea areaSalida = new JTextArea();       areaSalida.setText( salida );          JOptionPane.showMessageDialog( null, areaSalida,          "Inicialización de un arreglo de valores int",          JOptionPane.INFORMATION_MESSAGE );          System.exit( 0 );       } // fin de main    }

Es posible definir arreglos de la siguiente forma:

?

Codigo Fuente de Computrachos con Fines Educativos!!!!!!!!!!!!!!!
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16	//arreglos int (Enteros) int arreglo[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; int arreglo[]=new int [10]; arreglo[0]=1; arreglo[1]=2; arreglo[2]=3; arreglo[3]=4; arreglo[4]=5; arreglo[5]=6; arreglo[6]=7; arreglo[7]=8; arreglo[8]=9; arreglo[9]=10;

 Arreglos:

Los arreglos se pueden definir como objetos en los que podemos guardar mas de una variable, es decir, al tener un unico arreglo, este puede guardar multiples 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 Numerico que puede almacenar 10 variables, solo podra almacenar 10 numeros diferentes, no otras variables como caracteres o Strings.

Existen 2 tipos de arreglos, los unidimensionales, y los multidimensionales(generalmente 2 dimensiones y se les denomina matrices), en esta lección veremos como declarar y utilizar los arreglos unidimensionales, estos son mas sencillos y faciles de comprender, y pueden servirnos para muchas aplicaciones.

Declaración:

La estructura de declaración de un arreglo es la siguiente:

tipo_dedato [] nombre_variable;  //tambien puede declararse “tipo_dedato nombre_variable[];”

ejemplos:

1	String array[]; //donde array es un arreglo que guardara variables tipo Strings
2	double array2[]; //donde array2 es un arreglo que guardara variabels tipo double

3	int [] array3;   //donde array3 es un arreglo que guardara variables tipo int(numericas)

Video declarar arreglos en java:

Definir tamaño de arreglos:

Para asignar a un arreglo su tamaño o capacidad, se hace de la siguiente forma:

arreglo = new tipo_dedato[capacidad];

ejemplo:

1	array = new String[10];   //el arreglo array guardara hasta un maximo de 10 variables de tipo String

Para realizar una declaración de un arreglo y definir su tamaño en una misma linea se puede usar la siguiente estructura:

1	String array[] = new String[10];  //se declara un arreglo y se asigna su tamaño en una misma linea

Asignación de valores a elementos del array

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. Para hacer esto es necesario proceder de la siguiente forma:

arreglo[indicador]=valor;

ejemplos:

1	array[0] = "Ejemplo"; //aqui se asigna el valor "Ejemplo" a un arreglo de String en su primera posicion
2	array2[3] = 5;      //se asigna un valor de 5 al 4to elemento de un arreglo numerico;

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:

01	int array1[]; //declaracion arreglo de tipo numerico
02

03	array1 = new int[3]; //tamaño del arreglo es 3 elementos
04

05	//asignacion de valores a elementos del arreglo;
06

07	array[0] =2;
08

09	array[1] = 10;
10

11	arra[2] = 7;
12

13	System.out.println("El valor de la posicion 1 en el arreglo es" + array[0]);

Fin del ejemplo:

Esperamos esta lección te haya sido de utilidad.{jcomments on}

Arreglos

Java cuenta con un tipo de datos verdadero de posiciones secuenciales, arreglo (array), que dispone de comprobaciones exhaustivas para su correcta manipulación; por ejemplo, la comprobación de sobrepasar los límites definidos para el array para evitar el desbordamiento o corrupción de la memoria.

En Java hay que declarar un arreglo antes de poder utilizarlo. Y en la declaración hay que incluir el nombre del arreglo y el tipo de datos que se van a almacenar en él. La sintaxis general para declarar e instanciar un arreglo es:

    tipoDeElementos[] nombreDelArreglo = new tipoDeElemetos[tamañoDelArreglo];

Se pueden declarar en Java arreglos de cualquier tipo:

    char s[];

    int iArreglo[];

Incluso se pueden construir arreglos de arreglos:

    int tabla[][] = new int[4][5];

Al igual que los demás objetos en Java, la declaración del arreglo no localiza, o reserva, memoria para contener los datos. En su lugar, simplemente localiza memoria para almacenar una referencia al arreglo. La memoria necesaria para almacenar los datos que componen el arreglo se buscará en memoria dinámica a la hora de instanciar y crear realmente el arreglo. Cuando se crea un arreglo, Java lo inicializa automáticamente, utilizando false para un arreglo que almacene objetos boolean, null para un arreglo de objetos, o el equivalente a 0 en cualquier otro caso.

Para crear un arreglo en Java hay dos métodos básicos. Se puede crear un arreglo vacío:

    int lista[] = new int[50];

o bien crear el arreglo con sus valores iniciales:

    String nombres[] = {

        "Juan","Pepe","Pedro","Maria"

    };

lo que es equivalente a:

    String nombres[];

    nombres = new String[4];

    nombres[0] = new String( "Juan" );

    nombres[1] = new String( "Pepe" );

    nombres[2] = new String( "Pedro" );

    nombres[3] = new String( "Maria" );

No se pueden crear arreglos estáticos en tiempo de compilación:

    int lista[50]; // generará un error en tiempo de compilación

Tampoco se puede rellenar un arreglo sin declarar el tamaño con el operador new:

    int lista[];

    for( int i=0; i < 9; i++ )

        lista[i] = i;

En las sentencias anteriores simultáneamente se declara el nombre del arreglo y se reserva memoria para contener sus datos. Sin embargo, no es necesario combinar estos procesos. Se puede ejecutar la sentencia de declaración del arreglo y posteriormente, otra sentencia para asignar valores a los datos.

Una vez que se ha instanciado un arreglo, se puede acceder a los elementos de ese arreglo utilizando un índice, de forma similar a la que se accede en otros lenguajes de programación. Los índices de un arreglo siempre empiezan por 0.

   

    miArreglo[5] = 6;

    miVariable = miArreglo[5];

Todos los arreglos en Java tienen una función miembro: length(), que se puede utilizar para conocer la longitud del arreglo.

    int a[][] = new int[10][3];

    a.length;    /* 10 */

    a[0].length; /* 3  */