Scribd
Cargar
123 vistas

Matrices de Java

Las matrices de Java permiten almacenar múltiples valores en una sola variable. Se pueden acceder y modificar elementos individuales mediante sus índices. Las matrices multidimensionales almacenan matrices dentro de otras matrices. Las ArrayList son matrices de tamaño variable que permiten agregar y eliminar elementos fácilmente.

Cargado por

Sadia Maria Cuello
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
123 vistas

Matrices de Java

Las matrices de Java permiten almacenar múltiples valores en una sola variable. Se pueden acceder y modificar elementos individuales mediante sus índices. Las matrices multidimensionales almacenan matrices dentro de otras matrices. Las ArrayList son matrices de tamaño variable que permiten agregar y eliminar elementos fácilmente.

Cargado por

Sadia Maria Cuello
Derechos de autor
© © All Rights Reserved
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 8

Matrices de Java

Las matrices se utilizan para almacenar múltiples valores en una sola variable, en
lugar de declarar variables separadas para cada valor.
Para declarar una matriz, defina el tipo de variable con corchetes:

String[] cars;

Ahora hemos declarado una variable que contiene una matriz de cadenas. Para
insertarle valores, puede colocar los valores en una lista separada por comas,
dentro de llaves:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};

Para crear una matriz de enteros, podría escribir:

int[] myNum = {10, 20, 30, 40};

Acceder a los Elementos de un Array


Puede acceder a un elemento de matriz consultando el número de índice.

Esta sentencia accede al valor del primer elemento en cars:

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};


System.out.println(cars[0]);
// Outputs Volvo

Nota: los índices de matriz comienzan con 0: [0] es el primer elemento. [1] es el
segundo elemento, etc.

Cambiar un elemento de matriz


Para cambiar el valor de un elemento específico, consulte el número de índice:

cars[0] = "Opel";

String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};


cars[0] = "Opel";
System.out.println(cars[0]);
// Now outputs Opel instead of Volvo
Longitud de la matriz
Para averiguar cuántos elementos tiene una matriz, use la propiedad de length:
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
System.out.println(cars.length);
// Outputs 4

Bucle a través de una matriz


Puede recorrer los elementos de la matriz con el bucle for y usar la propiedad de
longitud para especificar cuántas veces debe ejecutarse el bucle.

El siguiente ejemplo genera todos los elementos en la matriz de automóviles:


String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (int i = 0; i < cars.length; i++) {
System.out.println(cars[i]);
}

Bucle a través de una matriz con For-Each


También hay un ciclo "para cada uno", que se usa exclusivamente para recorrer
elementos en matrices:
for (type variable : arrayname) {
...
}
String[] cars = {"Volvo", "BMW", "Ford", "Mazda"};
for (String i : cars) {
System.out.println(i);
}

El ejemplo anterior se puede leer así: para cada elemento String (llamado i - como
en el índice) en los automóviles, imprima el valor de i.

Si compara el ciclo for y el ciclo for-each, verá que el método for-each es más fácil
de escribir, no requiere un contador (usando la propiedad de longitud) y es más
legible.
Matrices multidimensionales
Una matriz multidimensional es una matriz de matrices.

Las matrices multidimensionales son útiles cuando desea almacenar datos en


forma tabular, como una tabla con filas y columnas.

Para crear una matriz bidimensional, agregue cada matriz dentro de su propio
conjunto de llaves:
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };

myNumbers ahora es una matriz con dos matrices como elementos.

Elementos de acceso
Para acceder a los elementos de la matriz myNumbers, especifique dos índices: uno
para la matriz y otro para el elemento dentro de esa matriz. Este ejemplo accede al
tercer elemento (2) en la segunda matriz (1) de myNumbers:

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };


System.out.println(myNumbers[1][2]); // Outputs 7

Recuerde que: Los índices de matriz comienzan con 0: [0] es el primer elemento.
[1] es el segundo elemento, etc.

Cambiar valores de elementos


También puede cambiar el valor de un elemento:

int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };


myNumbers[1][2] = 9;
System.out.println(myNumbers[1][2]); // Outputs 9 instead of
7

Bucle a través de una matriz multidimensional


También podemos usar un bucle for dentro de otro bucle for para obtener los
elementos de una matriz bidimensional (todavía tenemos que señalar los dos
índices):
public class Main {
public static void main(String[] args) {
int[][] myNumbers = { {1, 2, 3, 4}, {5, 6, 7} };
for (int i = 0; i < myNumbers.length; ++i) {
for(int j = 0; j < myNumbers[i].length; ++j) {
System.out.println(myNumbers[i][j]);
}
}
}
}

Obtenga la suma de los elementos de la matriz:

int[] myArray = {1, 5, 10, 25};


int sum = 0;
int i;

// Loop through the array elements and store the sum in the
sum variable
for (i = 0; i < myArray.length; i++) {
sum += myArray[i];
}

System.out.println("The sum is: " + sum);

Java ArrayList
La clase ArrayList es una matriz de tamaño variable, que se puede encontrar en el
paquete java.util.

La diferencia entre una matriz integrada y una ArrayList en Java es que el tamaño
de una matriz no se puede modificar (si desea agregar o eliminar elementos de una
matriz, debe crear uno nuevo). Mientras que los elementos se pueden agregar y
eliminar de un ArrayList cuando lo desee. La sintaxis también es ligeramente
diferente:

Crear un objeto ArrayList llamado cars que almacena un strings:


import java.util.ArrayList; // import the ArrayList class

ArrayList<String> cars = new ArrayList<String>(); // Create


an ArrayList object

Agregar elementos
La clase ArrayList tiene muchos métodos útiles. Por ejemplo, para agregar
elementos a ArrayList, use el método add():

import java.util.ArrayList;

public class Main {


public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
System.out.println(cars);
}
}

Acceder a un artículo
Para acceder a un elemento en ArrayList, use el método get() y consulte el número
de índice:
cars.get(0);

Quitar un artículo
Para eliminar un elemento, utilice el método remove() y consulte el número de
índice:
cars.remove(0);

Para eliminar todos los elementos de ArrayList, utilice el método clear():

cars.clear();
Tamaño de ArrayList
Para averiguar cuántos elementos tiene un ArrayList, use el método Size:

cars.size();

Bucle a través de una ArrayList


Recorra los elementos de una ArrayList con un bucle for y utilice el método size()
para especificar cuántas veces debe ejecutarse el bucle:

public class Main {


public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
for (int i = 0; i < cars.size(); i++) {
System.out.println(cars.get(i));
}
}
}

Otros tipos
Los elementos de una ArrayList son en realidad objetos. En los ejemplos anteriores,
creamos elementos (objetos) de tipo "String". Recuerda que un String en Java es
un objeto (no un tipo primitivo). Para usar otros tipos, como int, debe especificar
una clase contenedora equivalente: Integer. Para otros tipos primitivos, use:
Boolean para boolean, Character para char, Double para double, etc.:

Ejemplo
Cree una ArrayList para almacenar números (agregue elementos de tipo Integer):

import java.util.ArrayList;

public class Main {


public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(10);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(25);
for (int i : myNumbers) {
System.out.println(i);
}
}
}

Ordenar una ArrayList


Otra clase útil en el paquete java.util es la clase Collections, que incluye el método
sort() para ordenar listas alfabética o numéricamente:

import java.util.ArrayList;
import java.util.Collections; // Import the Collections class

public class Main {


public static void main(String[] args) {
ArrayList<String> cars = new ArrayList<String>();
cars.add("Volvo");
cars.add("BMW");
cars.add("Ford");
cars.add("Mazda");
Collections.sort(cars); // Sort cars
for (String i : cars) {
System.out.println(i);
}
}
}

Integer:

import java.util.ArrayList;
import java.util.Collections; // Import the Collections class
public class Main {
public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);

Collections.sort(myNumbers); // Sort myNumbers

for (int i : myNumbers) {


System.out.println(i);
}
}
}

También podría gustarte