Estudiante

Génesis Abigail Quijije Célleri

Docente

Erick Orlando Guerrero Zambrano

Asignatura

Estructura de datos

Carrera

Sistemas de la información

Año lectivo

2020-2021
ARREGLOS UNIDIMENSIONALES

VARIABLES CON ÍNDICE O LOCALIZADOR. ARRAYS (ARREGLOS).

Vamos a repasar algunos conceptos que ya deberíamos conocer. Un array (arreglo) en

Java es una estructura de datos que nos permite almacenar un conjunto de datos de un

mismo tipo. El tamaño de los arrays se declara en un primer momento y no puede cambiar

luego durante la ejecución del programa, como sí puede hacerse en otros lenguajes.

Veremos ahora cómo declarar arrays estáticos de una dimensión.

ARRAYS UNIDIMENSIONALES

La sintaxis para declarar e inicializar un array será:

Tipo_de_variable[ ] Nombre_del_array =

new Tipo_de_variable[dimensión];

También podemos alternativamente usar esta declaración:

Tipo_de_variable[ ] Nombre_del_array;

Nombre_del_array = new Tipo_de_variable[dimensión];

El tipo de variable puede ser cualquiera de los admitidos por Java y que ya hemos

explicado. Ejemplos de declaración e inicialización con valores por defecto de arrays

usando todos los tipos de variables Java, serían:

- byte[ ] edad = new byte[4];

- short[ ] edad = new short[4];

- int[ ] edad = new int[4];

- long[ ] edad = new long[4];

- float[ ] estatura = new float[3];

- double[ ] estatura = new double[3];

- boolean[ ] estado = new boolean[5];

- char[ ] sexo = new char[2];

- String[ ] nombre = new String[2];

Aclarar que los valores por defecto son los siguientes:

a) Para números el valor cero “0”.

b) Para cadenas y letras el valor vacío.

c) Para booleanos el valor false.

En caso de que queramos inicializarlos con valores propios, haremos esto:

Para números enteros

int[ ] edad = {45, 23, 11, 9}; //Array de 4 elementos

De la misma forma procederíamos para los otros tipos de enteros : byte, short, long.

Para números reales

double[ ] estatura = {1.73, 1.67, 1.56}; //Array de 3 elementos

De la misma forma procederíamos para el tipo float, pero teniendo en cuenta que los

números deberán llevar al final la letra “f” o “F”. Por ejemplo 1.73f o 1.73F.

Para cadenas

String[ ] nombre = {"María", "Gerson"}; //Array de 2 elementos

Para caracterers

char[ ] sexo = {'m', 'f'}; //Array de 2 elementos

Para booleanos

boolean[ ] = {true,false}; //Array de 2 elementos

Cuando creamos un array de nombre “a” y de dimensión “n” (int[ ] a = new int[n])

estamos creando n variables que son a[0], a[1], a[2], ..., a[n-1]. Los arrays se numeran

desde el elemento cero, que sería el primer elemento, hasta el n-1 que sería el último

elemento. Es decir, si tenemos un array de 5 elementos, el primer elemento sería el cero

y el último elemento sería el 4. Esto conviene tenerlo en cuenta porque puede dar lugar

a alguna confusión. Disponer de un valor con índice cero puede ser de utilidad en

situaciones como considerar cada variable asociada a una hora del día, empezando a

contar desde la hora cero hasta la 23 (total de 24 horas), cosa que es habitual en algunos

países. En lugar de 1, 2, 3, ..., 24 estaríamos usando 0, 1, 2, ..., 23.

Vamos a trabajarlo sobre el ordenador en un programa y ver qué pasaría si declaramos un

array de tamaño “n” y vamos asignando un valor a cada variable del array desde la

posición cero hasta la posición “n-1”. Adicionalmente vamos a comprobar qué ocurre si

tratamos de asignarle valor a la variable de posición “n”.

El código fuente del programa (escríbelo en BlueJ) es el siguiente:

/* Ejemplo uso Arrays – aprenderaprogramar.com */

public class ArrayDeNombres {

public static void main(String arg[ ]) {

String[ ] nombre = new String[4];

nombre[0] = "Luis";

nombre[1] = "María";

nombre[2] = "Carlos";

nombre[3] = "Jose";
 nombre[4] = "Ismael"; //Error:No existe esta variable array de

índice 4

Procedemos a la compilación del programa pulsando en el botón de Compile y después a

su ejecución:

Obtenemos una respuesta (interpretación) que es la siguiente:

Una vez escrito el programa, cuando compilamos observamos que no hay ningún error

de sintaxis, es decir, no faltan puntos y comas, las llaves están bien equilibradas, las

palabras reservadas del lenguaje son las correctas, etc. Por tanto, aparentemente el

programa debería ejecutarse y darnos un resultado. Sin embargo cuando cuando

interpretamos el programa observamos un error “ArrayIndexOutBoundsException”. Este

mensaje de error significa “desbordamiento de array”, es decir, que tratamos de acceder

a una posición del array que no existe. En nuestro caso, hemos tratado de acceder a la

posición 4, que no está definida (sólo se ha definido hasta la posición 3). En esto Java es

muy estricto y no admite este tipo de error lógico del programador. Siguiendo el análisis

del error que nos aparece en la ventana leemos lo siguiente “ArrayDeNombres.java:12”,

que nos está indicando que el error está en el archivo que contiene el programa de nombre

“ArrayDeNombres.java”, y más concretamente en la línea 12.

Ahora ampliaremos conocimientos con respecto a la instrucción public static void

main(String arg[ ]). Esta instrucción es un estándar en Java, es decir, es la forma habitual

de encabezar un programa que se ejecuta en consola. Ahora trataremos de entender un

poco mejor el significado de este encabezado. Vamos a analizar el significado de (String

arg[ ]). En esta instrucción el método main admite que se le pase un “array de Strings”
cuando se proceda a la ejecución del programa si así lo deseamos. String arg[] significa

“un array de Strings” cuyo nombre es arg. Dicho de otra manera, al ejecutar el programa

podemos indicar “parámetros de entrada” de forma opcional. Si especificamos

parámetros de entrada, éstos parámetros quedan asignados al array arg tomando el orden

arg[0], arg[1].

Lo dicho podemos aclararlo mejor con el siguiente ejemplo:

El código fuente del programa es el siguiente. Escríbelo en el editor de BlueJ:

/* Ejemplo uso parámetros de entrada – aprenderaprogramar.com

*/

public class ParametrosDeEntrada {

public static void main(String arg[ ]) {

System.out.println("Cantidad de parámetros : " + arg.length);

System.out.println(arg[0]);

System.out.println(arg[1]);

Damos por entendido que ya hemos compilado el programa y no hay errores de sintaxis.

Nos centramos por tanto en la ejecución del programa (interpretación).

Si hacemos click derecho sobre ParametrosDeEntrada y seleccionamos la opción void

main(String arg[ ]) pasaremos a ejecutar el programa. En la ventana emergente

pondremos lo siguiente: { "Pepe", "Luis", "Juan"} incluidos las llaves y las comillas

dobles, los parámetros de entrada son Pepe, Luis y Juan. Cuando ejecutamos el programa

se nos mostrará que la cantidad de parámetros son tres, y además nos mostrará el primer

y segundo elementos del array, es decir, Pepe y Luis.

Si al ejecutar el método main de ParamentrosDeEntrada le pasaramos solo el parámetro

“Pepe”, como solo hay un solo parámetro de entrada, el array arg tiene un solo

elemento. En este caso el programa nos va a dar un error porque la única variable que

existe es arg [0], y al tratar de llamar a arg[1] nos va a dar error.

Veamos ahora qué ocurre al ejecutar ParametrosDeEntrada con los parámetros "Hola"

"Java":

Estos dos parámetros son las cadenas "Hola" y "Java", las cuales son capturadas en las

variables del array de cadenas arg[0] y arg[1]. Estas variables se usan para imprimir los

parámetros en pantalla. Esto se puede ver en el código fuente del programa. Por otro lado,

con el atributo “arg.length” podemos saber cuántos parámetros se le han pasado a nuestro

programa. También decir que hacemos uso de un nuevo símbolo: “+”, que significa

“concatenar” la cadena “Cantidad de parámetros” con el valor del atributo arg.length (que
es 2 en este caso). El resultado es la cadena “Cantidad de parámetros : 2 “, que se imprime

en la ventana como parte de la salida de nuestro programa.

El introducir parámetros al mismo tiempo que se invoca la ejecución de un programa es

una posibilidad que admite Java. En otros lenguajes no es posible pasar parámetros de

entrada a un programa.

Aporte personal

Si hablamos de un arreglo unidimensional simple mente hablamos de una estructura

básica obviamente no tediosa sino como principal se le llama también vector, esta

estructura es de una sola fila ya que es un vector por eso se llama unidimensional.
ARREGLOS BIDIMENSIONALES

Los arreglos Bidimensionales son aquellos que conocemos como matrices y esté es un

ejemplo de ellos:

Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo

bidimensional está simultáneamente en una fila y en una columna.

En matemáticas, a los arreglos bidimensionales se les llama matrices, y son muy

utilizados en problemas de Ingeniería.

En un arreglo bidimensional, cada elemento tiene una posición que se identifica

mediante dos índices: el de su fila y el de su columna.

Crear arreglos bidimensionales

Los arreglos bidimensionales también son provistos por NumPy, por lo que debemos

comenzar importando las funciones de este módulo:

from numpy import *

Al igual que los arreglos de una dimensión, los arreglos bidimensionales también

pueden ser creados usando la función array, pero pasando como argumentos una lista

con las filas de la matriz:

a = array([[5.1, 7.4, 3.2, 9.9],

[1.9, 6.8, 4.1, 2.3],
[2.9, 6.4, 4.3, 1.4]])

Todas las filas deben ser del mismo largo, o si no ocurre un error de valor:

>>> array([[1], [2, 3]])

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.

Los arreglos tienen un atributo llamado shape, que es una tupla con los tamaños de cada

dimensión. En el ejemplo, a es un arreglo de dos dimensiones que tiene tres filas y

cuatro columnas:

>>> a.shape
(3, 4)

Los arreglos también tienen otro atributo llamado size que indica cuántos elementos

tiene el arreglo:

>>> a.size
12

Por supuesto, el valor de a.size siempre es el producto de los elementos de a.shape.

Hay que tener cuidado con la función len, ya que no retorna el tamaño del arreglo, sino

su cantidad de filas:

>>> len(a)
3
Las funciones zeros y ones también sirven para crear arreglos bidimensionales. En vez

de pasarles como argumento un entero, hay que entregarles una tupla con las cantidades

de filas y columnas que tendrá la matriz:

>>> zeros((3, 2))

array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])

>>> ones((2, 5))

array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])

Lo mismo se cumple para muchas otras funciones que crean arreglos; por ejemplom la

función random:

>>> from numpy.random import random

>>> random((5, 2))
array([[ 0.80177393, 0.46951148],
[ 0.37728842, 0.72704627],
[ 0.56237317, 0.3491332 ],
[ 0.35710483, 0.44033758],
[ 0.04107107, 0.47408363]])

Operaciones con arreglos bidimensionales

Al igual que los arreglos de una dimensión, las operaciones sobre las matrices se aplican

término a término:

>>> a = array([[5, 1, 4],

... [0, 3, 2]])
>>> b = array([[2, 3, -1],
... [1, 0, 1]])

>>> a + 2
array([[7, 3, 6],
[2, 5, 4]])

>>> a ** b
array([[25, 1, 0],
[ 0, 1, 2]])
Cuando dos matrices aparecen en una operación, ambas deben tener exactamente la

misma forma:

>>> a = array([[5, 1, 4],

... [0, 3, 2]])
>>> b = array([[ 2, 3],
... [-1, 1],
... [ 0, 1]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape

Obtener elementos de un arreglo bidimensional

Para obtener un elemento de un arreglo, debe indicarse los índices de su fila i y su

columna j mediante la sintaxis a[i, j]:

>>> a = array([[ 3.21, 5.33, 4.67, 6.41],

[ 9.54, 0.30, 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76],
[ 8.72, 1.47, 0.77, 8.78]])
>>> a[1, 2]
2.14

>>> a[4, 3]
8.78

>>> a[-1, -1]

8.78

>>> a[0, -1]

6.41

También se puede obtener secciones rectangulares del arreglo usando el operador de

rebanado con los índices:

>>> a[2:3, 1:4]

array([[ 0.54, 0.71, 2.56]])

>>> a[1:4, 0:4]

array([[ 9.54, 0.3 , 2.14, 6.57],
 [ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76]])

>>> a[1:3, 2]
array([ 2.14, 0.71])

>>> a[0:4:2, 3:0:-1]

array([[ 6.41, 4.67, 5.33],
[ 2.56, 0.71, 0.54]])

>>> a[::4, ::3]

array([[ 3.21, 6.41],
[ 8.72, 8.78]])

Para obtener una fila completa, hay que indicar el índice de la fila, y poner : en el de las

columnas (significa «desde el principio hasta el final»). Lo mismo para las columnas:

>>> a[2, :]
array([ 5.62, 0.54, 0.71, 2.56])

>>> a[:, 3]
array([ 6.41, 6.57, 2.56, 8.76, 8.78])

Note que el número de dimensiones es igual a la cantidad de rebanados que hay en los

índices:

>>> a[2, 3] # valor escalar (arreglo de cero dimensiones)

2.56

>>> a[2:3, 3] # arreglo de una dimensión de 1 elemento

array([ 2.56])

>>> a[2:3, 3:4] # arreglo de dos dimensiones de 1 x 1

array([[ 2.56]])

Otras operaciones

La trasposicion consiste en cambiar las filas por las columnas y viceversa. Para

trasponer un arreglo, se usa el método transpose:

>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
 [ 5.62, 0.54, 0.71, 2.56]])

>>> a.transpose()
array([[ 3.21, 9.54, 5.62],
[ 5.33, 0.3 , 0.54],
[ 4.67, 2.14, 0.71],
[ 6.41, 6.57, 2.56]])

El método reshape entrega un arreglo que tiene los mismos elementos pero otra forma.

El parámetro de reshape es una tupla indicando la nueva forma del arreglo:

>>> a = arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

>>> a.reshape((4, 3))

array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])

>>> a.reshape((2, 6))

array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])

La función diag aplicada a un arreglo bidimensional entrega la diagonal principal de la

matriz (es decir, todos los elementos de la forma a[i, i]):

>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56]])

>>> diag(a)
array([ 3.21, 0.3 , 0.71])

Además, diag recibe un segundo parámetro opcional para indicar otra diagonal que se
desee obtener. Las diagonales sobre la principal son positivas, y las que están bajo son
negativas:

>>> diag(a, 2)
array([ 4.67, 6.57])
>>> diag(a, -1)
array([ 9.54, 0.54])
La misma función diag también cumple el rol inverso: al recibir un arreglo de una
dimensión, retorna un arreglo bidimensional que tiene los elementos del parámetro en la
diagonal:

>>> diag(arange(5))
array([[0, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 2, 0, 0],
[0, 0, 0, 3, 0],
[0, 0, 0, 0, 4]])

Reducciones por fila y por columna

Algunas operaciones pueden aplicarse tanto al arreglo completo como a todas las filas o
a todas las columnas.
Por ejemplo, a.sum() entrega la suma de todos los elementos del arreglo. Además, se le
puede pasar un parámetro para hacer que la operación se haga por filas o por columnas:

>>> a = array([[ 4.3, 2.9, 9.1, 0.1, 2. ],

... [ 8. , 4.5, 6.4, 6. , 4.3],
... [ 7.8, 3.1, 3.4, 7.8, 8.4],
... [ 1.2, 1.5, 9. , 6.3, 6.8],
... [ 7.6, 9.2, 3.3, 0.9, 8.6],
... [ 5.3, 6.7, 4.6, 5.3, 1.2],
... [ 4.6, 9.1, 1.5, 3. , 0.6]])
>>> a.sum()
174.4
>>> a.sum(0)
array([ 38.8, 37. , 37.3, 29.4, 31.9])
>>> a.sum(1)
array([ 18.4, 29.2, 30.5, 24.8, 29.6, 23.1, 18.8])

El parámetro indica a lo largo de qué dimensión se hará la suma. El 0 significa «sumar a

lo largo de las filas». Pero hay que tener cuidado, ¡por que lo que se obtiene son las
sumas de las columnas! Del mismo modo, 1 significa «a lo largo de las columnas, y lo
que se obtiene es el arreglo con las sumas de cada fila.
Las operaciones a.min() y a.max() funcionan del mismo modo:

>>> a.min()
0.1
>>> a.min(0)
array([ 1.2, 1.5, 1.5, 0.1, 0.6])
>>> a.min(1)
array([ 0.1, 4.3, 3.1, 1.2, 0.9, 1.2, 0.6])

a.argmin() y a.argmax() también:

>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4])

Aporte personal

Los arreglos bidimensionales son los que usan matrices , estas matrices están formadas

por filas y columnas (en ese orden) aquí en este arreglo se usa un bucle para que

podamos aparte de que es para que haya un ciclo una secuencia de instrucciones es para

usar el length que lo que hace es que lee la magnitud de esta matriz también en este

arreglo podemos poner excepciones que es para que el programa no se caiga sino mas

bien muestre el mensaje de cual es el error mas no se cae pero eso profundizaremos mas

adelante
Glosario:

Vector un segmento de recta en el espacio que parte de un punto hacia otro, es decir,

que tiene dirección y sentido. Los vectores en física tienen por función expresar las

llamadas magnitudes vectoriales.

Fila las posiciones que se encuentran horizontalmente

Columna las posiciones que se encuentran verticalmente

Matriz En matemática, una matriz es un arreglo bidimensional de números. Dado que

puede definirse tanto la suma como el producto de matrices, en mayor generalidad se

dice que son elementos de un anillo. Una matriz se representa por medio de una letra

mayúscula (A,B, …) y sus elementos con la misma letra en minúscula (a,b, …), con un

doble subíndice donde el primero indica la fila y el segundo la columna a la que

pertenece.

Enteros son los valores que no tienen punto decimal, pueden ser positivos o negativos

y el cero. Reales: estos caracteres almacenan números muy grandes que poseen parte

entera y parte decimal.

Length El método que se usa para conocer el tamaño es sencillo (.length()). Este, se

aplicará directamente sobre el objeto que represente la cadena o String.

Referencias
Paredes, J. G. (2016). Arreglos unidimensionales en Java. Mexico: dcodingames.

Perez, J. (19). Repaso arrays o arreglos unidimensionales en Java. Tipos de inicialización.

Ejemplos de código (CU00903C). España: APR.

Villa, J. (2020). arreglos unidimensionales. España: Programacion Basica JAVA.