Unidad 3

1 //Escenario
Escenario26
Lectura fundamental
Fundamental

Arreglosdeyun
Etapas matrices
plan de comunicación
estratégica

Contenido

1 Arreglos y matrices

2 Arreglos

3 Arreglos y ciclos

4 Matrices

5 Resumen

Palabras clave: algoritmo, programa, Java, arreglo, matriz.

 1. Arreglos y matrices
Muchas aplicaciones reales toman su información de bases de datos que contienen entre unos
pocos cientos y varios millones de datos. Esto obliga a que los lenguajes de programación cuenten
con estrategias para almacenar y hacer referencia a la información de manera más eficiente que el
esquema de una variable por dato. Los arreglos permiten albergar bajo un mismo nombre (una misma
variable) grandes colecciones de datos de un mismo tipo, al tiempo que posibilitan acceder a cada
dato de manera individual.

En la primera parte se introduce el concepto de arreglo, junto con la sintaxis del lenguaje Java para su
declaración, creación y acceso. En una segunda parte se discute la importancia de la instrucción For
en el procesamiento de arreglos. Finalmente, la última parte se extiende el concepto de arreglos a
matrices (arreglos de dos dimensiones) y demuestra su utilización en programas sencillos.

2. Arreglos
Un arreglo es una colección de datos de un mismo tipo representados bajo un único nombre.
Adicionalmente, los datos en un arreglo están organizados de manera lineal, esto es, hay un primer
elemento, un último elemento, y para cada elemento, con excepción del último, un único elemento
siguiente (Oracle Inc., 2015). Una representación gráfica de un arreglo de 10 elementos se presenta
en la figura 1.

0 1 2 3 4 5 6 7 8 9
N D O
Tamaño = 10
Índices

Figura 1. Representación gráfica de un arreglo de tamaño 10. Cada elemento del arreglo se identifica con un índice
único, en el rango de 0 a tamaño – 1
Fuente: elaboración propia

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 2
El número de elementos que componen un arreglo es llamado el tamaño del arreglo. Este es inmutable,
i.e., una vez creado el arreglo no puede hacerse más pequeño o más grande. Los elementos del arreglo se
encuentran enumerados iniciando desde 0 y finalizando en tamaño - 1. El número que identifica a cada
elemento se conoce como su índice. Así, el primer elemento del arreglo tiene índice 0, el segundo índice 1,
el tercero índice 2 y, así, el penúltimo índice tamaño - 2 y el último índice tamaño - 1.

2.1. Declaración de arreglos

Al igual que las variables de tipo primitivo, las variables de tipo arreglo deben ser declaradas. La sintaxis
para hacerlo es la siguiente:

<tipo>[] <nombre>;

donde <tipo> es el tipo de dato de cada uno de los elementos que compondrán el arreglo y
<nombre> es el nombre que le daremos al arreglo. Los corchetes indican al compilador que la
variable corresponde a un arreglo y no a un único dato.

La declaración del arreglo indica al compilador que se usará dicha variable, pero no crea el arreglo
como tal, dado que no se ha indicado cuál será su tamaño. Mientras el arreglo no sea creado, la
variable correspondiente contendrá el valor null (nulo o vacío).

2.2. Creación de arreglos

La sintaxis para la creación de un arreglo es la siguiente:

<nombre> = new <tipo>[<tamaño>];

Donde <tamaño> es cualquier expresión que arroje como resultado un valor de tipo int no negativo.

El siguiente conjunto de instrucciones demuestra cómo declarar y crear arreglos:

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 3
 int[] arr;

arr = new int[1000];

double[] arr2;

arr2 = new double[n];

boolean[] arr3 = new boolean[2*(m+n)];

Al ser creado, todas las posiciones del arreglo son llenadas con un valor por defecto, que es 0 en los
tipos numéricos y false en el tipo booleano.

2.3. Creación alternativa de arreglos

Además de la forma presentada anteriormente, existe una manera alternativa de crear arreglos
enumerando los elementos que contendrá en su declaración:

<tipo>[] <nombre> = {<elem_1>, <elem_2>, <elem_3>, …, <elem_n>};

La siguiente instrucción crea un arreglo con los primeros diez números naturales:

int[] digitos = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

Esta forma de crear arreglos es útil solamente en un número limitado de situaciones en la que los
elementos que componen el arreglo son conocidos con antelación y su tamaño es pequeño (<50).

2.4. Acceso a los elementos de un arreglo

Con el fin de acceder, tanto para actualización como para consulta, a un elemento particular de un
arreglo se debe usar el operador []. Para acceder al elemento del arreglo debe usarse la expresión
<nombre_arreglo>[<índice>]. A continuación se presentan ejemplos de uso del operador
[] usados con el objetivo de modificar y consultar elementos de un arreglo (se utiliza el operador de
asignación de manera idéntica que con las variables de tipos primitivos):

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 4
 int[] arr = new int[5];

arr[0] = 1;

arr[1] = 10;

arr[2] = arr[0] * 2 + arr[1];

2.5. La variable length

Al procesar un arreglo es necesario conocer en todo momento su tamaño para así no intentar acceder a
posiciones no existentes en este. Por tal razón, al momento de la creación de un arreglo es generada una
variable inmutable que contiene su tamaño. Para acceder a dicha variable se debe escribir el nombre del
arreglo seguido de un punto, seguido de la palabra length: <nombre_arreglo>.length.

3. Arreglos y ciclos
Cuando el tamaño de un arreglo es variable o suficientemente grande, es necesario el uso de ciclos
para procesar todos los elementos del arreglo. Los ciclos for son idóneos para el procesamiento de
arreglos, ya que permiten describir de manera simple, y en solo una línea, el conjunto de valores que
debe tomar la variable de ciclo, en este caso, el conjunto de índices del arreglo ([0, tamaño - 1]).

Suponga que desea llenar un arreglo con valores ingresados desde el teclado por el usuario. Primero,
debe preguntarle al usuario cuál es la cantidad de valores que ingresará. Con este valor, el siguiente
paso será crear el arreglo y, mediante un ciclo, pedir un dato para cada una de sus posiciones:

     static double[] leer_arreglo(){

        Scanner entrada = new Scanner(System.in);

        System.out.print(«Número de datos a ingresar: «);

        int n = entrada.nextInt();

System.out.print(«Ingrese los « + n + «datos: «);

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 5
 double[] datos = new double[n];

        for (int i = 0; i <= n-1; i++)

              datos[i] = entrada.nextDouble();

return datos;

  }

Note, con el ejemplo anterior, que es posible también devolver arreglos como salidas de métodos.

Otras tareas comunes sobre arreglos incluyen sumar sus elementos, imprimirlos o llenar un arreglo
con un único valor:

static double sumar(double[] datos) {

        double suma = 0;

        for (int i = 0; i <= datos.length - 1; i++)

              suma = suma + datos[i];

        return suma;

  }
 

  static void imprimir(double[] datos) {

        for (int i = 0; i <= datos.length - 1; i++)

              System.out.print(datos[i] + “  “);

  }

  static void llenar_arreglo(double[] datos, int valor) {

        for (int i = 0; i <= datos.length - 1; i++)

              datos[i] = valor;

  }

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 6
Observe en los ejemplos anteriores que el código para realizar una tarea específica sobre los
elementos de un arreglo tiene una estructura estándar y que varía principalmente en las instrucciones
incluidas en el cuerpo del ciclo for.

4. Matrices
Al igual que los arreglos, las matrices son colecciones de datos de un mismo tipo representados bajo
un único nombre. No obstante, a diferencia de los arreglos, en la matriz los datos están organizados
en una estructura de dos dimensiones a manera de tabla. Así, cada elemento de la matriz es
identificado por una pareja de índices: su fila y su columna. Una representación gráfica de una matriz
se presenta en la figura 2.

Columnas

0 1 2 3 4 5 6 7 8 9
0
1
Filas 2

3
4

matriz [2][5]

Figura 2. Representación gráfica de una matriz de 5 filas y 10 columnas. Cada elemento de la matriz se identifica con un
par de índices: fila y columna
Fuente: elaboración propia

El tamaño de una matriz está definido por dos valores: número de filas y número de columnas. Se puede
calcular el número total de elementos de la matriz como número de filas x número de columnas. Las
filas y columnas se enumeran iniciando desde 0, de manera similar a las posiciones en un arreglo.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 7
 4.1. Declaración de matrices

La sintaxis para declarar una variable de tipo matriz es la siguiente:

<tipo>[][] <nombre>;

Note que para indicar que la variable corresponde a una matriz, el tipo debe ser seguido de dos parejas
de corchetes, una por cada dimensión de la matriz. Al igual que en los arreglos, hasta ser creada, una
variable de tipo matriz contendrá el valor null.

4.2. Creación de matrices

La sintaxis para la creación de una matriz es la siguiente:

<nombre> = new <tipo>[<número_de_filas>][<número_de_columnas>];

donde <número_de_filas> y <número_de_columnas> corresponden a expresiones de tipo int

y valor no negativo.

El siguiente conjunto de instrucciones demuestra cómo declarar y crear matrices:

  float[][] mat;

  mat = new float[m][n];

  byte[][] mat2 = new byte[100][2 * n + 10];

Al ser creada, todas las posiciones de la matriz son llenadas con un valor por defecto, que es 0 en los
tipos numéricos y false en el tipo booleano.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 8
 4.3. Creación alternativa de matrices

Es posible también crear matrices enumerando los elementos que contendrá en su declaración:

<tipo>[][] <nombre> = { {<elem_1_1>, <elem_1_2>, …, <elem_1_n>},

{<elem_2_1>, <elem_2_2>, …, <elem_2_n>},

{<elem_m_1>, <elem_m_2>, …, <elem_m_n>} };

La siguiente instrucción crea una matriz conteniendo un cuadrado mágico de 4 x 4:

int[] cuadrado = {  { 4,  5, 16,  9},

 {14, 11,  2,  7},

 { 1,  8, 13, 12},

 {15, 10,  3,  6} };

4.4. Acceso a los elementos de una matriz

Para acceder a un elemento particular de una matriz se debe usar el operador doble [][]. A
continuación se presentan ejemplos de uso del operador [][] para modificar y consultar elementos
de una matriz:

int[][] unos = { {1, 1, 1}, {1, 1, 1}, {1, 1, 1} };

unos[1][1] = 2;

unos[2][2] = unos[1][1] + unos[0][2];

System.out.println(unos[2][2] + unos[2][1]);

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 9
 4.5. Dimensiones de la matriz

El número de filas de una matriz es almacenado en una variable inmutable al momento de su creación.
Para acceder a dicha variable se debe escribir el nombre de la matriz seguido de un punto, seguido de
la palabra length: <nombre_matriz>.length. Por otra parte, el número de columnas puede
ser recuperado mediante la expresión <nombre_matriz>[i].length, donde i es cualquier valor
entre 0 y el número de filas menos 1.

5. Resumen
Los arreglos y las matrices permiten albergar bajo un solo nombre colecciones de datos de un mismo
tipo, al tiempo que posibilitan acceder a cada dato de manera individual.

En un arreglo los datos están organizados de manera lineal y es posible acceder a cada uno mediante
su correspondiente índice, el cual es un valor entero entre 0 y el tamaño del arreglo menos 1. En
el caso de las matrices, los arreglos se organizan en una estructura bidimensional, en la que cada
elemento es identificado por dos índices: el número de fila y el número de columna. Las filas y
columnas se enumeran iniciando en 0.

Para declarar una variable de tipo arreglo o matriz debe hacerse de igual manera que una de tipo
primitivo, agregando al tipo una o dos parejas de corchetes, según corresponda. Al declarar una
variable de arreglo o matriz, esta es inicializada con el valor null. Un arreglo o una matriz puede ser
creado mediante el operador new e indicando su tamaño, o por extensión enumerando todos los
elementos que contiene. Esta última opción solamente es posible cuando se conocen con antelación
los datos que contendrá la estructura y su cantidad es pequeña.

Tanto para actualizar como para consultar el valor en una posición de un arreglo o una matriz se deben
utilizar los operadores [] o [][], respectivamente. En cada pareja de corchetes deben ubicarse los
índices del elemento que se desea acceder. Para actualizar el valor en una posición de la colección, la
referencia a la posición debe estar en el lado izquierdo de un operador de asignación, tal como ocurre
con las variables de tipo primitivo.

Los ciclos For son idóneos para el procesamiento de arreglos y matrices, ya que permiten describir
de manera simple, y en solo una línea, el conjunto de valores que debe(n) tomar la(s) variable(s) de
ciclo, en este caso, el conjunto de índices del arreglo o matriz.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 10
Referencias
Oracle Inc. (2015). Language Basics. The Java ™ Tutorials. Recuperado de https://docs.oracle.com/javase/
tutorial/java/nutsandbolts/if.html

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 11
 INFORMACIÓN TÉCNICA

Módulo: Programación de Computadores

Unidad 3: Instrucciones repetitivas, arreglos y matrices
Escenario 6: Arreglos y matrices

Autor: Edwin Andrés Niño Velásquez

Asesor Pedagógico: Jeiner Velandia

Diseñador Gráfico: Kelly Yohana Valencia Forero
Asistente: Ginna Quiroga

Este material pertenece al Politécnico Grancolombiano.

Prohibida su reproducción total o parcial.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 12