Вы находитесь на странице: 1из 27

Arreglos en Java

Programación Orientada a Objetos

Arreglos

Un arreglo es una secuencia de datos del mismo tipo

Los datos se llaman elementos del arreglo y se numeran 0, 1, 2,

Estos números localizan al elemento dentro del arreglo y se denominan índices

En Java, los índices del arreglo empiezan

con 0 y terminan con el tamaño del arreglo -1

Si el arreglo tiene n elementos, se denotan

como a[0], a[1],

a[n-1]

Declaración de un arreglo

La sintaxis de declaración de arreglos en Java es

tipo [] identificador tipo identificador []

Ejemplos:

char cad[], p;

int [] v, w;

double [] m, t[], x;

En la declaración del arreglo no se permite indicar el número de elementos, así, int numeros[12] es erroneo

Definir arreglo de número de elementos

Sintaxis para definir arreglo de un número determinado de elementos:

tipo nombreArreglo[] = new tipo [numeroDeElementos]

tipo nombreArreglo[];

nombreArreglo = new tipo[numeroDeElementos];

Ejemplo:

float notas = new float [26];

int [] a;

a = new int[10]

Tamaño del arreglo

Java considera cada arreglo como un objeto

El número de elementos de un arreglo se conoce accediendo al campo length

double [] v = new double [15] System.out.print(v.length); // escribe 15

El campo length está protegido, no se puede modificar

Ejemplo, método con un argumento arreglo, devuelve la suma de elementos

1.double suma (double [] w)

2.{

3.

double s = 0.0;

4.

for (int i=0; i < w.length; i++)

5.

s += w[i];

6.

return s;

7.}

Inicialización de arreglos

Se deben asignar valores a los arreglos antes de utilizarlos, por defecto se inicializan con 0

precios[0] = 10;

precios[1] = 20;

precios[2] = 30;

int numeros[]={10, 20, 30, 40, 50, 60};

char c[]={'L','u','i','s'};

final int ENE=31, FEB=28, MAR=31,ABR=30;

int meses[]={ENE, FEB, MAR, ABR};

for(i=0; i<numeros.length; i++)

numeros[i] = -1;

Arreglos de caracteres y cadenas de texto

Una cadena de texto es un conjunto de caracteres, 'abcdefg'. Son soportadas por la clase String: String cadena = 'abcdefg'

Los arreglos tipo char son secuencias de carcateres, con características de arreglos de otros tipos String mas = “programador Java”;

char datos[] = {'D','i','r','e','c','t','o','r','i','o'};

Copia de arreglos

final int N = 12;

int v1[]= new int[N], v2[]=new int[N];

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

v1[i]=(int)Math.random()*199+1;

//elementos de v1 copiados a v2

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

v2[i] = v1[i];

Arreglos multidimensionales

Los arreglos vistos son unidimensionales, se conocen también como listas (vectores)

Los arreglos multidimensionales tiene más de una dimensión.

Los de dos dimensiones, se llaman tablas o matrices

Sintaxis:

<tipo datoelemento> <nombreArreglo>[][]

<tipo datoelemento> [][] <nombreArreglo>

char pantalla[][];

pantalla = new int[10][5];

Arreglo bidimensional

Es un arreglo de arreglos, es decir, un arreglo unidimensional donde cada elemento es un arreglo

Arreglo de 4 renglones y 2 columnas:

int tabla[][]=new int[4][2]; si cada entero ocupa 4 bytes:

Elemento

Posición relativa en memoria

Tabla[0][0]

0

Tabla[0][1]

4

Tabla[1][0]

8

Tabla[1][1]

12

Tabla[2][0]

16

Tabla[2][1]

20

Tabla[3][0]

24

Tabla[3][1]

28

Inicialización de arreglos multidimensionales

int tabla[][]={{51,52,53},{54,55,56}};

int tabla[][]={{51,52,53},

{54,55,56}};

double tb[][]={{1.5,-2.5},{5.0,-0.0,1.5}};

int []a={1,3,5}, b={2,4,6,8,10};

int mtb[][]={a, b};

double [][]gr=new double[3][];

gr[0]=new double[3];

gr[1]=new double[6];

gr[2]=new double[5];

Atributo length de una tabla

En un arreglo bidimensional tabla, length de tabla contiene el número de renglones, y length de cada renglón contiene el número de columnas

float ventas[][]={{0.,0.,0.},{1.0,1.0},{-1.0}};

System.out.print(ventas.length); //escribe 3

System.out.print(ventas[0].length); //escribe 3

System.out.print(ventas[1].length); //escribe 2

System.out.print(ventas[2].length); //escribe 1

Acceso a elementos de arreglos bidimensionales

nombreArreglo[renglon][columna] = valor;

variable = nombreArreglo[renglon][columna];

Tabla[2][3]=4.5;

Resistencias[2][4]=50;

Ventas = Tabla[1][1];

Dia = Semana[3][6];

for(ren=0; ren < Matriz.length; ++ren)

for(col=0; col<Matriz[ren].length; ++col)

Procesar elemento Matriz[ren][col];

Lectura y visualización

import input.Keyboard; class Tabla { public static void main(String[] a){ int[][]=new int[3][5]; leer(a); visualizar(a);

}

static void leer(int b[][]){ Int i,j; System.out.println(“Mete datos a matriz”); for(i=0;i<b.length; i++){ System.out.println(“Renglón: “+i); for(j=0;j<b[i].length; j++) b[i][j]=Keyboard.readInt();

}

}

Lectura y visualización

static void visualizar(int b[][]){ int i,j; System.out.println(“\n\t Matriz leida “); for(i=0; i < b.length; i++){ for(j=0; j < b[i].length; j++) System.out.print(b[i][j]+“ “); System.out.println(“ “);

}

}

}

Mete datos a matriz

Renglón 0:

Matriz leida

45

45 75 25 10 40

75

20 14 36 15 26

25

21 15 37 16 27

10

40

Arreglos de más de dos dimensiones

Java proporciona la posibilidad de almacenar varias dimensiones, por ejemplo un arreglo de tres dimensiones

Un arreglo tridimensional:

int volumen[][][]=new[181][178][190];

Z

un arreglo de tres dimensiones ● Un arreglo tridimensional: ● int volumen[][][]=new[181][178][190]; Z Y Y X

Y

Y

un arreglo de tres dimensiones ● Un arreglo tridimensional: ● int volumen[][][]=new[181][178][190]; Z Y Y X

X

Z

un arreglo de tres dimensiones ● Un arreglo tridimensional: ● int volumen[][][]=new[181][178][190]; Z Y Y X

X

System.arraycopy

arraycopy(Object src, int srcPos, Object dest, int destpos, int length)

Copia un arreglo desde el arreglo fuente especificado, empezando en la posición especificada, hasta la posición especificada del arreglo destino

El número de componentes copiados es igual al argumento length. Los componentes en las posiciones srcPos hasta srcPos+length-1 en el arreglo fuente se copian en las posiciones destPos hasta destPos+length-1, respectivamente, del arreglo destino.

Ejemplo, borrar elemento de arreglo

1.public class arregloPrueba

2.{

3.

public static int[] remover(int _i, int[] _a)

4.

{

5.

int[] b = new int[_a.length-1];

6.

System.arraycopy( _a, 0, b, 0, _i );

7.

System.arraycopy( _a, _i+1, b, _i, b.length-_i );

8.

return b;

9.

}

10.

11.

public static void main(String[] args)

12.

{

13.

int[] a = {1, 2, 3, 4, 5};

14.

// remover elemento 3

15.

int[] b = remover(3, a);

16.

17.

for( int i=0; i<b.length; i++ ) {

18.

System.out.println( b[i] );

19.

}

20.

}

Ejemplo de remover en arreglo

1.int[] a = new int[10]; 2.int[] b = new int[9];

3.

4.int i = 0; 5.int j = 0; 6.int borrarElemento = 5;

7.while (i < a.length && j < b.length) {

8.

if (i == borrarElemento) {

9.

i++;

10.

}

11.

else {

12.

b[j] = a[i];

13.

i++;

14.

j++;

15.

}

16.}

17.// en este punto, b = a sin el 5º elemento

Ejemplo de arreglo

public class ArrayPlay{

int[] intarray = new int[0];

public static void main(String[] args){

ArrayPlay arrayplay = new ArrayPlay();

arrayplay.play();

}

Ejemplo, método play

//Juega con el arreglo de enteros intarray

public void play(){

System.out.println("There are no elements.");

printArray(); //there are no elements

System.out.println("Adding an element with value 5.");

intarray = addArrayElement(5);

printArray(); //there is 1 element

System.out.println("Adding an element with value 33.");

intarray = addArrayElement(33);

printArray(); //there are 2 elements

System.out.println("Adding an element with value 26.");

intarray = addArrayElement(26);

printArray(); //there are 3 elements

System.out.println("Adding an element with value 78.");

intarray = addArrayElement(78);

printArray(); //there are 4 elements

System.out.println("Adding an element with value 345.");

intarray = addArrayElement(345);

printArray(); //there are 5 elements

System.out.println("Removing element at position 2.");

intarray = removeArrayElement(2);

Ejemplo, método play

printArray(); //there are 4 elements

System.out.println("Removing element at position 1.");

intarray = removeArrayElement(1);

printArray(); //there are 3 elements

System.out.println("Inserting an element at position 2 with value 717783.");

intarray = insertArrayElement(2,717783);

printArray(); //there are 4 elements

}

Ejemplo, método printArray

/** Despliega tamaño del arreglo.

*/

public void printArray(){

System.out.println("Size of intarray is "+

String.valueOf(intarray.length) + ".");

for (int i = 0;i < intarray.length;i++){

System.out.println("Array intarray["+ String.valueOf(i) +

"]

String.valueOf(intarray[i]));

= "

+

}

}

Ejemplo, método removeArrayElemento

/** Crea un nuevo arreglo de intarray saltando el elemento

n.

*/

public int[] removeArrayElement(int n){

int[] newarray = new int[intarray.length - 1];

for (int i = 0;i < intarray.length;i++){

if (i < n)

if (i > n)

newarray[i] = intarray[i]; newarray[i-1] = intarray[i];

}

return newarray;

}

Ejemplo, método addArrayElemento

/** Crea un nuevo arreglo de intarray agregando un elemento con valor n.

*/

public int[] addArrayElement(int n){

int[] newarray = new int[intarray.length + 1];

for (int i = 0;i < intarray.length;i++){

newarray[i] = intarray[i];

}

newarray[intarray.length] = n;

return newarray;

}

Ejemplo, método insertArrayElemento

/** Crea un nuevo arreglo de intarray insertando un nuevo elemento en el índice j con valor n.

*/

public int[] insertArrayElement(int j,int n){

int[] newarray = new int[intarray.length + 1];

for (int i = 0;i < intarray.length+1;i++){

if (i < j)

if (i

if (i > j)

newarray[i] = intarray[i];

j) newarray[i] = n;

newarray[i] = intarray[i-1];

}

return newarray;

}

}