UNIDAD IV

Lenguaje de Programación
Orientado a Objetos JAVA
Parte 3

1
CONTENIDO
•Introducción a los arreglos
•Arreglos numéricos unidimensionales
– Declarar un arreglo
– Crear un arreglo
– Iniciar un arreglo
•Cadenas de caracteres como un arreglo
•La clase Arrays y sus métodos
•Arreglos multidimensionales

2
 Introducción a los arreglos
• Un arreglo es una estructura homogénea, compuesta por varios elementos, todos del
mismo tipo y almacenados consecutivamente en memoria. Cada elemento puede ser
accedido directamente por el nombre de la variable arreglo seguido de uno o más
subíndices encerrados entre corchetes.

• Ejemplo: Supongamos que tenemos un arreglo unidimensional de enteros llamada m,

el cual contiene 9 elementos. Estos elementos se identificarán de la siguiente forma:

Arreglo
m

3
 Introducción a los arreglos
m[0] m[1] m[2] m[3] m[4] m[5] m[6] m[7] m[8]
Vector m

• Observe que los subíndices son enteros consecutivos y

que el primer subíndice vale 0.

• Un subíndice puede ser cualquier expresión entera

positiva.
• El número máximo de dimensiones o el número máximo
de elementos, dentro de los límites establecidos por el
compilador, para una matriz depende de la memoria
disponible. 4
 Introducción a los arreglos
• En Java, cada elemento de un arreglo unidimensional es
de un tipo primitivo, o bien una referencia a un objeto; y
cada elemento de un arreglo multidimensional es, a su
vez, una referencia a otro arreglo.

Arreglos numéricos unidimensionales

• Antes de usar un vector, hay que declararlo.
• Para crear y utilizar un vector hay que realizar 3
operaciones:
– declararla,
– crearla e
– iniciarla.
5
• Declarar un vector.
Se hace indistintamente así:
tipo[] nombre;
tipo nombre[];
Donde:
tipo: tipo de elementos del vector, que pueden ser de
cualquier tipo primitivo o referenciado;
nombre: es un identificador que nombra al vector.

• Ejemplos de declaración de un vector:

int[] m;
float[] temperaturas;
Computadora[] computadoras; 6
• Notar que las declaraciones no especifican el tamaño del vector.
• El tamaño será especificado cuando se cree el vector, operación
que se hará durante la ejecución del programa.

Crear un vector.
• Significa reservar la cantidad de memoria necesaria para
contener todos sus elementos y asignar al nombre del vector una
referencia a ese bloque.
• El hecho de usar el operador new significa que Java implementa
los vectores como objetos.
• Ejemplos:
m = new int[10];
temperatura = new float[31];
ordenador = new Cordenador[25];

7
•Es bastante común declarar y crear un vector en una misma línea.
•Ejemplos:
int[] m = new int[10];

Iniciar un vector
•Un vector es un objeto; por lo tanto, cuando es creado, sus
elementos son iniciados automáticamente.
•Si el vector es numérico, sus elementos son iniciados a 0 y si no es
numérico a un valor análogo al 0.

•Ejemplos:
char[] c= new char[10]; // iniciados al valor ‘\u0000’
boolean[] b= new boolean[10]; //iniciados a false
Cliente[] clientes=new Cliente[10];
//las referencias a objetos, iniciados a null.
8
•Para iniciar un vector con otros valores diferentes a los
predeterminados, se hace de la siguiente forma:
float[] temperaturas = {10.2F, 12.3F, 3.4F, 14.5F, 15.6F,
16.7F};
Este ejemplo crea un vector temperatura de tipo float con tantos
elementos como valores se hayan especificado entre llaves.

•Acceder a los elementos de un vector.

int[] m = new int[100];
int k=0, a=0;
//....
A = m[1] + m[99];
k = 50;
m[k]++;
m[k+1] = m[k]; 9
Observe:
• Como subíndice se puede usar una constante, una variable o una
expresión de tipo entero.
• La primera posición es la 0.
• Si se intenta acceder a un elemento con subíndice fuera del rango,
Java lanzará una excepción de tipo
ArrayIndexOutOfBoundsException, indicando que el subíndice
está fuera de los límites establecidos cuando se creó el vector.

¿Como asegurarse de no exceder

accidentalmente el final de un vector?
• Verificando la longitud del vector mediante la variable estática
length, que puede ser accedida por cualquier vector.
int n = m.length; // n = cantidad de datos del vector m

10
 Métodos de un vector.
•La clase genérica ‘Arrays’ proporciona un conjunto de métodos que
ha heredado de la clase Object del paquete java.lang.
•Métodos destacables:
equals: permite verificar si dos referencias se refieren a
un mismo objeto y
clone: permite duplicar un objeto.

11
• Ejemplo: Crea e inicializa un vector de enteros, crea una
copia del vector y luego las compara.

public class ArregloEnteros {

public static void main(String []args) {
int[] m1 = {10, 20, 30, 40, 50};
int[] m2 = (int[])m1.clone(); //m2 será una copia de m1
if (m1.equals(m2)) //equivale a: if (m1 == m2)
System.out.println("m1 y m2 se refieren a la misma
matriz");
else
System.out.println("m1 y m2 se refieren a matrices
diferentes");
}
} 12
Ejemplo: Lee 5 cadenas de caracteres, y las presenta en pantalla.

import java.util.Scanner;
public class Cadenas{
public static void main(String [] args) throws IOException{
Scanner miEntrada = new Scanner(System.in);
String [] nombres;
nombres = new String [5];

System.out.println("Escriba 5 nombres:");
for (int i=0; i<5; i++)
nombres[i]=miEntrada.nextLine();

System.out.println("Los nombres almacenados en \nel arreglo de

String son:");
for (int i=0; i<5; i++)
System.out.println(nombres[i]);
}
}
13
//Ejemplo de busqueda lineal de un arreglo unidimensional
import javax.swing.*;

class BusquedaArreglo
{
public static void main ( String [] args )
{
int arreglo[], num;
String numero, result, busq;
boolean respuesta=true;
//crear arreglo y llenarlo con enteros
// pares de 0 a 198
arreglo = new int[100];

for ( int contador=0; contador < arreglo.length; contador++)

arreglo[contador]= 2 * contador;
14
while ( respuesta )
{
//obteniendo del usuario el numero a buscar
numero=JOptionPane.showInputDialog("Numero a buscar:");
num = Integer.parseInt(numero);

//pasar referencia a arreglo al método

//busquedaLineal
int elemento = busquedaLineal( arreglo, num );

//mostrar el resultado de la busqueda

if ( elemento != -1 )
result = "Valor encontrado en el elemento "+elemento;
else
result = "Valor no encontrado";
15
 JOptionPane.showMessageDialog(null, result);
//verificar si hay otra busqueda
busq = JOptionPane.showInputDialog("Otra busqueda Si/No ?");
if (busq.compareTo("SI")==0 || busq.compareTo("Si") ==0
|| busq.compareTo("si")==0 )
respuesta = true;
else
respuesta = false;
} //fin del while
System.exit(0);
} //fin de main

16
 public static int busquedaLineal ( int arreglo2[], int clave )
{
//iterar a traves de los elementos del arreglo
for ( int c=0; c < arreglo2.length; c++ )
//si el elemento del arreglo es igual al valor
//de la clase, devolver ubicacion
if ( arreglo2 [c] == clave )
return c;
return -1; //clave no encontrada
} //fin de busquedaLineal
} //fin de aplicacion

17
 Cadenas de caracteres
• Las cadenas de caracteres en Java son objetos de la
clase String.

• Básicamente, una cadena de caracteres se almacena

como un arreglo unidimensional de elementos de tipo
char:
char[ ] cadena = new char[10]; //iniciados
// con el valor ‘\0’

• Puede ser iniciado en el momento de su definición:

char[ ] cadena = {‘a’,’b’,’c’,’d’};
18
 Cadenas de caracteres
• Ya que que cada carácter es un entero, el ejemplo
podría escribirse como:
char[ ] cadena = {97, 98, 99, 100};

• Si se crea un vector de caracteres y se le asigna un

número de caracteres menor que su tamaño, el resto
de los elementos quedan con el valor ‘\0’ con el que
fueron iniciados.

19
 Ejercicio
• Realizar un programa que lea una cadena de n
caracteres e imprima el resultado que se
obtiene cada vez que se realice una rotación
de un carácter a la derecha sobre dicha
cadena. El proceso finalizará cuando se haya
obtenido nuevamente la cadena de caracteres
original. Ejemplo:
HOLA AHOL LAHO OLAH HOLA

20
 Clase Arrays y sus métodos

• La clase Arrays está definida en el paquete

java.util y se deriva de la clase
java.lang.Object

• Esta clase incluye una serie de métodos para

manipular los arreglos.
static int binarySearch(byte[] a, byte key);
static boolean equals(boolean[] a, boolean[] a2);
static void fill(boolean [] a, boolean val);
21
 Clase Arrays: método binarySearch

• El método binarySearch busca en el arreglo al

valor key utilizando el algoritmo de búsqueda
binaria.

static int binarySearch(byte[] a, byte key);

Este método está sobrecargado con arreglos y

valores de los diferentes tipos simples de
datos de java.
22
 Clase Arrays: métodos equals y fill

• El método equals regresa true si los dos

arreglos del tipo especificado son iguales uno
al otro.

static boolean equals(boolean[] a, boolean[] a2);

• El método fill asigna el valor especificado val

en todos los elementos del arreglo a
static void fill(boolean [] a, boolean val);
23
 Clase Arrays: método hashCode

• El método hashCode devuelve un código hash

basado en el contenido del arreglo a.

static int hashCode(byte[] a);

• Este método está sobrecargado con arreglos y

valores de los diferentes tipos simples de
datos de java.

24
 Clase Arrays: método sort

• El método sort ordena el arreglo especificado

en orden numérico ascendente.

static void sort(byte[] a);

• Esta otra versión de sort ordena el rango

especificado de elementos del arreglo en orden
numérico ascendente.
static void sort(byte[] a, int fromIndex, int toIndex);

25
import java.util.Arrays;
import javax.swing.JOptionPane;
public class AplicacionClaseArray {
public static void main(String []args) {
int[] m1 = {20, 15, 8, 3, 30, 26, 42, 1, 50};
Arrays.sort(m1);
for (int cont=0; cont<9; cont++)
System.out.println(m1[cont]);
String a=JOptionPane.showInputDialog("Numero a
buscar en el arreglo");
int b=Integer.parseInt(a);
int y=Arrays.binarySearch(m1,b);
if (y<0)
JOptionPane.showMessageDialog(null,"El valor
"+b+" no se encuentra en el arreglo");
else
JOptionPane.showMessageDialog(null,"El valor "+b+" se
encuentra en la posición "+y+" del arreglo");
System.exit(0);
}
} 26
 Arreglos Multidimensionales
• Java no soporta directamente el uso de
arreglos multidimensionales, pero sí permite
al programador especificar arreglos
unidimensionales cuyos elementos sean
también arreglos unidimensionales.

• Los arregloss no tienen que ser rectangulares.

27
Arreglos Multidimensionales

0 1 2
0 012 0 01
0
012 012 1
1 1
2
2 012 2 0 3
3 012 3 012

Tomado de: Deitel y Deitel, Java

Como Programar. 28
 Arreglos de arreglos unidimensionales

• Al igual que los arreglos unidimensionales, los arreglos

multidimensionales pueden inicializarse mediante
inicializadores de arreglos en las declaraciones.
int b[ ][ ] = { { 1, 2 }, { 3, 4 } };

• En el ejemplo, los valores inicializadores se agrupan por fila

entre corchetes.

• El arreglo b en realidad esta compuesto de dos arreglos

unidimensionales separados. El arreglo b en sí es un arreglo
unidimensional que contiene dos elementos. Cada elemento es
una referencia a un arreglo unidimensional de variables int.
29
 Arreglos de arreglos unidimensionales

• La forma en que Java representa los arreglos

multidimensionales los hace bastante flexibles. De hecho
las longitudes de las filas en el arreglo b no tienen que ser
iguales.
int b[ ][ ] = { { 1, 2 }, { 3, 4, 5 } };

• Un arreglo multidimensional con el mismo número de

columnas en cada fila puede crearse mediante una
expresión de creación de arreglos.
int b[ ][ ];
b = new int[ 3 ][ 4 ];
30
 Arreglos de arreglos unidimensionales

• Un arreglo multidimensional, en el que cada fila tiene un

número distinto de columnas, puede crearse de la
siguiente manera:
int b[ ][ ];
b = new int[ 2 ][ ]; //crear 2 filas
b [0] = new int [5]; //crear 5 cols para la fila 0
b[1] = new int[3]; //crear 3 cols para la fila 1

• Estas instrucciones crean un arreglo bidimensional con

dos filas. La fila 0 tiene cinco columnas y la fila 1 tiene 3
columnas.

31
Ejemplo: Arreglo bidimencional de enteros
import java.io.*;
public class MatrizEnteros {
public static void main (String [] args) throws IOException {
InputStreamReader isr = new
InputStreamReader(System.in);
BufferedReader MiFlujo = new BufferedReader(isr);
String Dato;
int [ ][ ] Números = new int[5][3];
System.out.println("digite los números: ");
for (int i=0; i<5; i++) {
System.out.println("Fila "+(i+1)+" : ");
for (int j=0; j<3;j++) {
Dato = MiFlujo.readLine();
Números[i][j] = Integer.parseInt(Dato);
} //fin de for j
32
} //fin de for i
 for (int i=0; i<5; i++)
{
System.out.println();
for (int j=0; j<3;j++)
System.out.print(Números[i][j]+" " );
}
} //fin de main
} //fin de la clase

33
Ejemplo: Inicializa dos matrices de enteros y las
imprime por filas
import javax.swing.*;

public class IniciaArreglo

{
public static void main( String [] args )
{
int arreglo1[ ][ ] = {{1,2,3},{4,5,6}};
int arreglo2[ ][ ] = {{1,2}, {3}, {4,5,6}};
String mensaje;

mensaje = "Los valores en arreglo 1 por fila son:\n ";

crearSalida (arreglo1, mensaje);
mensaje = "\nLos valores en arreglo 2 por fila son:\n ";
crearSalida (arreglo2, mensaje);

System.exit( 0 );
} 34
 public static void crearSalida (int arreglo[ ][ ], String s )
{
//iterar a traves de las filas del arreglo
for ( int fila = 0; fila < arreglo.length; fila ++ )
{
for (int col = 0; col < arreglo[fila].length; col ++ )
{
s = s+arreglo[fila][col];
s = s+" ";
}
s = s+"\n";
}
JOptionPane.showMessageDialog(null, s,
"Impresion Arreglo",
JOptionPane.INFORMATION_MESSAGE);
} //fin del método crearSalida
} //fin de la aplicacion
35