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 Y Z

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. }
21.}
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) newarray[i] = intarray[i];
● if (i > n) 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) newarray[i] = intarray[i];
● if (i j) newarray[i] = n;
● if (i > j) newarray[i] = intarray[i-1];
● }
● return newarray;
● }
● }
●