Arrays
Quan es necessita processar múltiples dades del mateix tipus, es poden guardar en un array
i processar-les conjuntament com una sola unitat. És una forma convinent de fer-ho quan hi ha una gran quantitat
de dades o quan no se sap a priori quantes dades hi haurà.
Has de considerar un array com una col·lecció d'elements del mateix tipus. Tots els elements
es guarden a la memòria de forma seqüencial (un darrere de l'altre).
Imagina un programa on hem de processar les notes dels alumnes. Per a guardar-les en memòria podríem utilitzar
difrents variables de tipus float:
float nota1 = 5.6f;
float nota2 = 9.8f;
float nota3 = 7.75f;
float nota4 = 6.25f;
En casos com aquest, podem utilitzar un array per a emmagatzemar totes les notes en una
única variable:
float[] notes = { 5.6f, 9.8f, 7.75f, 6.25f };
Un array proporciona un únic nom per a tots els elements. La quantitat d'elements que es pot emmagatzemar s'estableix
quan es crea l'array i no es pot canviar. Sí que es pot canviar un element guardat a l'array.
Per a accedir a un element de l'array (per obtenir el seu valor, o modificar-lo)
s'ha d'utilitzar el seu índex numèric. Els índex comencen per 0:
El primer element d'un array té index 0, i l'últim té l'índex igual al tamany - 1.
Seguint l'analogia de les capses que vam veure amb les variables, podem imaginar un array com una capsa amb múltiples
calaixos. La capsa té un nom identificador, i cada calaix té un número d'índex:
Per exemple, al següent array podem guardar fins a 4 Strings:
String[] unArray = new String[4];
Per a accedir a un calaix (element) de l'array, posem el seu índex entre corxets [index]:
unArray[1] = "Joan";
Podem accedir per a guardar un valor, i també per a obtenir el valor que hi ha guardat. Per exemple, per a imprimir-lo:
System.out.println(unArray[1]); // Joan
Crear un array
Per a declarar un array hem de posar els caracters [] després del tipus dels elements de l'array:
tipusElements[] nomArray;
Per exemple, per a declarar un array d'enters:
int[] arrayEnters;
Per a inicialitzar els valors d'un array, podem enumerar-los entre claus {} i separats per comes ,:
int[] arrayEnters = { 23, 34, 45, 56 };
String[] arrayStrings = { "this", "is", "an", "array", "of", "Strings" };
També es pot inicialitzar un array simplement indicant el seu tamany (la quantitat d'elements).
En aquest cas el valor dels elements de l'array serà un valor per defecte segons el tipus.
tipusElements[] nomArray = new tipusElements[tamany];
Per als tipus numèrics, el valor per defecte és 0, per als booleans és false i per als Strings és el
valor especial null.
int[] arrayEnters = new int[5]; // { 0, 0, 0, 0, 0 }
float[] arrayFloats = new float[5]; // { 0.0, 0.0, 0.0, 0.0, 0.0 }
char[] arrayChars = new char[5]; // { 0, 0, 0, 0, 0 }
boolean[] arrayBooleans = new boolean[5]; // { false, false, false, false }
String[] arrayStrings = new String[5]; // { null, null, null, null, null }
Inicialitzar array
Tamany d'un array
El tamany (o longitud) d'un array es refereix al nombre d'elements que té.
Com hem vist, un array no es pot canviar de tamany un cop creat
(tot i que sí que es pot crear un array diferent y copiar-hi les dades).
Per a obtenir el tamany d'un array, es pot accedir a la propietat especial length. Aquí tens un exemple:
int[] arrayEnters = { 13, 25, 37, 49 };
int tamany = arrayEnters.length; // quantitat d'elements de l'array
System.out.println(tamany); // 4
Els índex d'un array sempre van des de 0 fins a length - 1.
A l'arrayEnters de l'exemple anterior, els índex van de 0 fins a 3 (4 - 1).
Accedir als elements
Per a accedir a un element d'un array s'ha posar l'índex de l'element entre corxets [] després del nom de l'array.
nomArray[indexElement]
D'aquesta forma pots obtenir el valor d'un element, o modificar-lo.
String[] arrayStrings = { "hola", "que", "tal" };
// obtenim el valor de l'element en la posició 0, i l'imprimim
System.out.println(arrayStrings[0]); // hola
// obtenim el valor de l'element en la posició 1, i l'assignem a la variable element
String element = arrayStrings[1]; // element: "que"
// modifiquem el valor de l'element en la posició 2
arrayStrings[2] = "qual"; // arrayStrings: {"hola", "que", "qual" }
Un altre exemple:
int[] arrayEnters = { 111, 456, 888, 954 };
System.out.println(arrayEnters[2]); // 888
int element = arrayEnters[3]; // 954
arrayEnters[1] = 30000; // arrayEnters: { 111, 30000, 888, 954 }
New array
True index
Array Index Out Of Bounds Exception
Si un programa tracta d'accedir a un element d'un array utilitzant un índex inferior a 0 o igual o superior
al tamany, el programa s'aturarà amb una exepció ArrayIndexOutOfBoundsException. Significa que
l'índex al qual s'està tractant d'accedir està fora dels límits de l'array:
int[] numeros = { 13, 24, 35, 46 };
System.out.println(numeros[-1]); // OutOfBounds, l'index mes baix es 0
System.out.println(numeros[4]); // OutOfBounds, l'index mes alt es 3
Si executem aquest programa, s'aturarà amb la execepció ArrayIndexOutOfBoundsException:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 4
Si tenim aquest array:
int[] numbers = { 1, 2, 3, 5, 4, 6, 4 };
Emparella les següents operacions amb el seu resultat:
numbers[0] 1
numbers[6] 4
numbers.length 7
numbers[7] OutOfBounds
Quin serà el valor de l'array numbers després d'executar aquest codi?
int[] numbers = new int[5];
numbers[3] = 79;
{ 0, 0, 79, 0, 0 }
{ 5, 5, 79, 5, 5 }
{ 0, 0, 0, 79, 0 }
Execpció OutOfBounds
Llegir un array de l'entrada
Utilitzant un bucle podem llegir una llista de dades de l'entrada i guardar-les en un array.
Per exemple, la següent entrada consisteix en dues línies. La primera conté el número d'elements, i a
la segona hi ha la llista d'elements.
5
101 102 504 302 881
Podem crear un array amb length igual al número d'elements i després utilitzar un bucle per a llegir
els elements i guardar-los a l'array. La variable i del bucle determina l'índex (posició) de l'array
on es guardarà el valor llegit. Per tant, la variable i haurà d'anar des de 0 fins a length - 1.
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
5
101 102 504 302 881
Llegim el número d'elements
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
5
101 102 504 302 881
Creem un array de tamany igual al número de l'elements.
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
5
101 102 504 302 881
Usarem la variable i per a saber en quina posició hem de guardar els valors que llegim.
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 0, 0, 0, 0, 0 }
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 0, 0, 0, 0, 0 }
i: 0
5
101 102 504 302 881
Llegim un valor de l'entrada i el guardem en la posició que indica la i, és a dir, la posició 0
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 0, 0, 0, 0, 0 }
i: 0
5
101 102 504 302 881
Sumem 1 a la i, així el pròxim element es guardarà a la posició 1
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 0, 0, 0, 0 }
i: 0
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 0, 0, 0, 0 }
i: 1
5
101 102 504 302 881
Llegim un valor de l'entrada i el guardem en la posició que indica la i (la 1)
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 0, 0, 0, 0 }
i: 1
5
101 102 504 302 881
La i ja serà 2, i el següent element el guardarem en aquest índex (posició).
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 0, 0, 0 }
i: 1
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 0, 0, 0 }
i: 2
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 0, 0, 0 }
i: 2
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 0, 0 }
i: 2
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 0, 0 }
i: 3
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 0, 0 }
i: 3
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 302, 0 }
i: 3
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 302, 0 }
i: 4
5
101 102 504 302 881
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 302, 0 }
i: 4
5
101 102 504 302 881
Ja hem aconseguit guardar en l'array tots els números. Avancem la i per última vegada...
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 302, 881 }
i: 4
5
101 102 504 302 881
La i ja no és menor que el tamany de l'array, sortim del bucle.
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
len: 5
array: { 101, 102, 504, 302, 881 }
i: 5
5
101 102 504 302 881
A la variable array tenim guardats tots els números de l'entrada.
int len = scanner.nextInt();
int[] array = new int[len];
for (int i = 0; i < len; i++) {
array[i] = scanner.nextInt();
}
// el programa continua per aquí...
len: 5
array: { 101, 102, 504, 302, 881 }
5
101 102 504 302 881
Recòrrer un array
Quan diem recòrrer un array significa accedir un per un a cadascun dels elements de l'array.
Podem utilitzar un bucle for amb una variable i que vagi tenint els valors des de 0 (la primera
posició de l'array) fins a length - 1 (l'última posició). Llavors, utilitzarem la variable i com a índex,
i així aconseguirem accedir a tots els elements:
El següent codi accedeix a cadascun dels elements de l'array, per a imprimir-los:
String[] paraules = { "anem", "a", "recorrer", "aquest", "array" };
for (int i = 0; i < paraules.length; i++) {
System.out.println(i + " -> " + paraules[i]);
}
0 -> anem
1 -> a
2 -> recorrer
3 -> aquest
4 -> array
Arrays multidimensionals
Als arrays que hem vist fins ara, el tipus dels seus elements eren tipus primitius (int, float, boolean, String).
Aquests arrays s'anomenen unidimensionals.
Java també permet l'ús d'arrays multidimensionals. Són aquells arrays on el els seus elements són altres arrays.
Per a declarar un array multidimensional, indiquem tants corxets [] com dimensions ha de tenir l'array:
tipus[][] nomArray; // array de dues dimensions
tipus[][][] nomArray; // array de tres dimensions
tipus[][][][] nomArray; // array de quatre dimensions
...
En la declaració d'un array, el tipus pot ser qualsevol tipus primitiu (int, float, boolean, String).
Per exemple, es poden declarar els següents arrays:
int[][] arrayP;
boolean[][][] arrayQ;
String[][] arrayR;
float[][][][] arrayS;
La forma de llegir la declaració d'arrays és:
Per exemple el següent array és un array multidimensional. Els seus elements són arrays d'enters:
int[][] array = { { 13, 16, 17, 18, 19 }, { 43, 44, 46, 48, 49 }, { 71, 72, 73, 78, 79 } };
Aquest array té tres elements. Cadascun d'aquests tres elements és un altre array amb 5 elements.
Per a accedir als elements dels arrays interns, hem d'indicar la posició de l'array intern dintre de l'array extern,
i la posició de l'element dintre de l'array intern.
int[][] array = { { 13, 16, 17, 18, 19 }, { 43, 44, 46, 48, 49 }, { 71, 72, 73, 78, 79 } };
int a = array[0][0]; // a és 13
int b = array[1][2]; // b és 46
int c = array[2][3]; // c és 78
Inicialització
Podem inicialitzar un array amb valors literals de la manera que hem vist abans. El més habitual és posar cada array intern
en una nova línia (com una taula). Per exemple:
boolean[][] array = {
{ true, true, true },
{ false, false, true },
{ false, false, false }
};
També es pot crear un array multidimensional indicant els seus tamanys:
float[][] array = new float[2][5]; // { { 0f, 0f, 0f, 0f, 0f }, { 0f, 0f, 0f, 0f, 0f } }
float[][] array = new float[5][2]; // { { 0f, 0f }, { 0f, 0f }, { 0f, 0f }, { 0f, 0f }, { 0f, 0f } }
Els valors per defecte seran els mateixos que per als arrays:
- int: 0
- float: 0f
- boolean: false
- String: null
Llegir un array bi-dimensional de l'entrada
Suposem que tenim a l'entrada el següent array bi-dimensional:
3 5
13 14 16 17 19
43 44 46 48 49
55 56 57 58 59
El primer nombre 3 indica la quantitat de files de la matriu, i el 5 indica
la quantitat de columnes.
Podem utilizar el següent esquema per a llegir aquest array:
int files = scanner.nextInt();
int columnes = scanner.nextInt();
int[][] array = new int[files][columnes];
for (int i = 0; i < files; i++) {
for (int j = 0; j < columnes; j++) {
array[i][j] = scanner.nextInt();
}
}
Imprimir un array en format de taula
int[][] array = { { 13, 16, 17, 18, 19 }, { 43, 44, 46, 48, 49 }, { 71, 72, 73, 78, 79 } };
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
Per a definir una matriu d'enters de dues files i tres columnes, podem utilitzar
int[][] matriu = new matriu[2][3];
int[][] matriu = new int[2][3];
int[2][3] matriu = new int[3][2];
int[][] matriu = new matriu[2][3];
Indica si la forma d'inicialitzar aquesta matriu és correcta:
float[][] mat = new float[2][2];
mat[0] = new float[]{ 1.5f, 1.3f };
mat[1] = new float[]{ 2.3f, 2.7f };
Sí
No
Cercant mines
Matrix
Xirtam
Bomberman