Ejemplos:

Ejemplo1

public class Arrays01 {
public static void main(String args[]) {
int ita_nro[] = new int[4];
int it_cont;
for (it_cont = 0;it_cont <>



Ejemplo2

Se tienen las notas de 5 exámenes de 10 alumnos, y se desea promediar la nota final de cada uno de ellos. Diseñe una aplicación que solucione este problema.



1 import javax.swing.*;

2 public class MatrizNotas{

3 public static void main (String args []) {

4 int f,c;

5 double suma, promedio;

6 double notas [][]=new double[10][5];

7 String leer;

8 for(f=0; f<10;>

9 {

10 suma=0;

11 for(c=0; c<5;>

12 {

13 leer=JOptionPane.showInputDialog("Ingrese la nota: "+c+" del alumno: "+f);

14 notas[f][c]=Double.parseDouble(leer);

15 while(notas[f][c]>10 notas [f][c]<0) leer="JOptionPane.showInputDialog(" suma="suma+notas[f][c];" promedio="suma/5;">



Ejemplo3
Se sabe que la velocidad de un proyectil está dada por la ecuación, en forma vectorial: V= ai+ bj+ ck. Diseñe una aplicación que sea capaz de leer los valores de las constantes a, b y c. y muestre la magnitud y dirección de dicho proyectil.


1 import javax.swing.*;

2 public class Proyectil{

3 public static void main (String args []){

4 String leer;

5 double magnitud, direccion, sum;

6 double vector[]=new double[3];

7 int ban=1;

8 while(ban==1)//miestras hayan datos a procesar

9 {

10 //leemos el valor de las constantes

11 leer=JOptionPane.showInputDialog("Ingrese el valor de a:");

12 vector[0]=Double.parseDouble(leer);

13 leer=JOptionPane.showInputDialog("Ingrese el valor de b:");

14 vector[1]=Double.parseDouble(leer);

15 leer=JOptionPane.showInputDialog("Ingrese el valor de c:");

16 vector[2]=Double.parseDouble(leer);

17 //calculamos la magnitud

18 //la cual es la raíz cuadrada de las suma+

19 //de las componentes al cuadrado

20 sum=(vector[0]*vector[0])+(vector[1]*vector[1])+(vector[2]*vector[2]);

21 magnitud=Math.sqrt(sum);

22 //La dirección viene dada por la tangente inversa

23 //del cociente de las componentes x,y

24 direccion=Math.atan(vector[1]/vector[0]);

25 JOptionPane.showMessageDialog(null, "El valor de la magnitud es: "+magnitud+"\n y con un angulo direccional de: "+direccion+" Radianes");

26 leer=JOptionPane.showInputDialog("¿Hay más datos a procesar?\n\nSi=1 y No=0");

27 ban=Integer.parseInt(leer);

28 }//del while

29 }//del main

30 }//de la clase

Arreglos.

En java a diferencia del lenguaje C, existe un tipo de variable “especial” el Array, este tipo de variables no es mas que un conjunto secuencial de memoria a las que se accede a través de un índice de posición.

Los arreglos en Java son objetos por lo que cuentan con propiedades y métodos para manipularlos. Se pueden declarar arreglos de tipos de datos primitivos y de objetos.
Mas abajo tienes la sintaxis básica de declaración de arrays.

Sintaxis:
tipodedato nombre [] [= new tipodedato[capacidad]] o
tipodedato[] nombre [= new tipodedato[capacidad]]

Como puedes observar puedes inicializar un array al momento de declararlo o postergar esta operación para cuando sea necesario.

Para inicializar un array existen 2 maneras:
int[] arreglo=new int[4] o
int[] arreglo={100,200,302,400}

Como podrás concluir la primera inicializas el array nada mas diciéndole la cantidad de memoria secuencial que se debe reservar, en el segundo ejemplo se inicializa el array dándole los valores que va a contener (obviamente la cantidad de memoria secuencial reservada será igual a la cantidad de elementos insertados).

Al momento de inicializar un arreglo de la manera:
int[] arreglo=new int[4]
cada posición del arreglo será inicializada con el valor por defecto del tipo de variable. Por ejemplo si el arreglo si el arreglo es de tipo boolean, todas las posiciones del arreglo serán inicializadas con el valor false (ya que este es valor por defecto de este tipo de dato), por el contrario si el arreglo fuese de un tipo no primitivo, el valor que contendrá cada casilla será null.
A continuación tienes una lista de los valores por defecto de cada tipo de dato

Tipo de Dato-->Valor
byte-->0
short-->0
int-->0
long-->0
float-->0.0
double-->0.0
char-->/u0000
boolean-->false
Object (Cualquier tipo de Objeto)-->null

Para obtener el tamaño de un array de manera dinámica se utiliza la propiedad .length, esta propiedad es común para todos los array . También es importante saber que los arreglos se empiezan a enumerar desde el numero (0) cero por tanto para acceder al valor almacenado en la ultima posición deberás colocar el tamaño del arreglo menos 1 unidad.
Al momento de tratar de acceder a una posición fuera del rango del arreglo se lanzara un exception de tipo java.lang.ArrayIndexOutOfBoundsException (esta exception es una exception no chequeada es por eso que no es necesario colocar un bloque try/catch en el código)

Arreglos

Los arreglos en Java son dinámicos, pero no extensibles, lo cual significa que deben ser creados con el tamaño que tendrán hasta el final de su vida.
Un arreglo se declara de la siguiente forma:
[] ;
O sea, para declarar, por ejemplo, un arreglo de números enteros utilizaremos la siguiente sentencia:
int[] arrInt;
Es importante notar que el arreglo aún no ha sido creado, sino meramente declarado. Para crear el arreglo (reservar su memoria e inicializarlo) deberemos recurrir al operador new:
arrInt = new int[10];

Este comportamiento debe comprenderse de esta forma: en Java todo es un objeto, y los objetos deben ser creados mediante el operador new. El caso de los arreglos no es diferente, el tipo de datos del arreglo (int[] en este caso) es una clase y cada una de sus instancias debe ser creada explícitamente, el tamaño puede pensarse como un parámetro al constructor de la clase.
A partir de este momento podemos utilizar arrInt como un arreglo de cualquier otro lenguaje.
Una de las características que hacen de Java un entorno de programación seguro, y que se relaciona con el manejo de los arreglos es que el lenguaje no permite la indexación de arreglos fuera de rango, o sea, una asignación de este tipo generará una excepción:
ArrInt[25] = 1;

Otra forma de declararlos es la siguiente:
UNIDIMENSIONALES:
tipo nombre_array[]=new tipo[nº];
tipo nombre_array[]={valores};
BIDIMENSIONALES:
tipo nombre_array[][]=new tipo[nº][nº];
tipo nombre_array[][]={valores};

Inicializacion

Inicialización de arrays:
1. Los arrays se pueden inicializar con valores entre llaves {...} separados por comas.
2. También los arrays de objetos se pueden inicializar con varias llamadas a new dentro de unas llaves {...}.
3. Si se igualan dos referencias a un array no se copia el array, sino que se tiene un array con dos nombres, apuntando al mismo y único objeto.
4. Creación de una referencia a un array. Son posibles dos formas:
double[] x; // preferible
double x[];
5. Creación del array con el operador new:
x = new double[100];
6. Las dos etapas 4 y 5 se pueden unir en una sola:
double[] x = new double[100];

Caracteristicas

Algunas de sus características más importantes de los arrays son las siguientes:
1. Los arrays se crean con el operador new seguido del tipo y número de elementos.
2. Se puede acceder al número de elementos de un array con la variable miembro implícita length (por ejemplo, vect.length).
3. Se accede a los elementos de un array con los corchetes [] y un índice que varía de length-1.
4. Se pueden crear arrays de objetos de cualquier tipo. En principio un array de objetos es un array de referencias que hay que completar llamando al operador new.
5. Los elementos de un array se inicializan al valor por defecto del tipo correspondiente (cero para valores numéricos, el carácter nulo para char, false para boolean, null para Strings y para referencias).
6. Como todos los objetos, los arrays se pasan como argumentos a los métodos por referencia.
7. Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array como argumento actual en la llamada a un método).

Resumen de Arreglos

Declaración de un arreglo
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 arreglosString
S[]; // S es un arreglo de strings

S[1]="" // error, el arreglo no ha sido creado


Creación de un arreglo
int A[]= new int[10]; // 10 enteros


Subindicación de un arreglo
A[0], A[1], ..., A[9] // correcto
A[10] // error, índice fuera de rango


Modificación de un arreglo
A[3]= 8;


Tamaño de un arreglo
A.length // correcto
A.length() // error, sin paréntesis


Inicialización de un arreglo
for (int i=0; i

Asignación de punteros a arreglos
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


Copia de un arreglo
B= (int[])A.clone();