Algoritmia y Programación

Mayra Alejandra Sacanamboy

maylesac@eisc.univalle.edu.co

http://eisc.univalle.edu.co/~maylesac/algoritmia/
 Los Temas de la Clase

• Arreglos Unidimensionales
• Arreglos de DOS Dimensiones
 Arreglos
public class Ejemplo16{
public static void main(String a[]){
String n1, n2, n3;

n1 = JOptionPane.showInputDialog("Entre un nombre");
n2 = JOptionPane.showInputDialog("Entre un nombre");
n3 = JOptionPane.showInputDialog("Entre un nombre");

JOptionPane.showMessageDialog(null, "El tercer nombre fue " + n3);

JOptionPane.showMessageDialog(null, "El segundo nombre fue " + n2);
JOptionPane.showMessageDialog(null, "El primer nombre fue " + n1);
System.exit(0);
}
}
 Arreglos Unidimensionales

• ¿Qué es un arreglo?
Es un conjunto de datos, todos del mismo tipo, a los que
se referencia bajo el mismo nombre o identificador

Nombres = {“Oscar”, “Juan”, “Jhon”, “Carlos”}

Notas = {3.5 , 4.0 , 5.0 }

• Nombres es un arreglo de cadenas de caracteres

(Strings) que tiene 4 elementos
• Notas es un arreglo de doubles que tiene 3 elementos
 Arreglos Unidimensionales

Así la variable Nombres se puede representar como

sigue:
0 1 2 3
“Oscar” “Juan” “Jhon” “Carlos”

Y la variable Notas:
0 1 2

3.5 4.0 5.0

 Arreglos Unidimensionales

¿Cómo declaramos Variables de Tipo Arreglo?

Lo primero que se debe hacer es crear la variable

que va a almacenar los valores del arreglo, para ello
se crea así:

tipo_dato nombre_variable[] = new tipo_dato[# _elementos];

Ejemplos:
String nombres[ ] = new String[4];
double notas[ ] = new double[3];
 Arreglos Unidimensionales

Otra manera de crear las variables es poniendo los corchetes

después del tipo de dato, así:
tipo_dato[] nombre_variable = new tipo_dato[# _elementos];

Ejemplos:
String[ ] nombres = new String[4];
double[ ] notas = new double[3];

También se puede crear directamente con los datos:

String[ ] nombres = {“Oscar”, “Juan”, “Jhon”, “Carlos”};
 Arreglos Unidimensionales

En el ejemplo anterior dentro de las llaves se pone cada uno de

los elementos del arreglo, Ellos deben ser del mismo tipo y deben
coincidir con el tipo de dato de la variable.

NO SE PUEDE HACER:
String[ ] nombres = {“Oscar”, 100, “Jhon”, ‘A’};

¿La siguiente línea es correcta?

String[ ] valores = {“100”, “200”, “300”, “400”};
 Arreglos Unidimensionales
Cada uno de los elementos del arreglo se referencia (o se accede) a
través de su posición así:

String[ ] nombres = {“Oscar”, “Juan”, “Jhon”, “Carlos”};

Esto es:
0 1 2 3

“Oscar” “Juan” “Jhon” “Carlos”

nombres[0] almacena el valor “Oscar”

nombres[1] almacena el valor “Juan”
nombres[2] almacena el valor “Jhon”
nombres[3] almacena el valor “Carlos”
 Arreglos Unidimensionales
• ¿Cómo ingresar datos a un arreglo uni-dimensional?
Se debe indicar en qué posición del arreglo va a insertar el valor:

String[ ] nombres = new String[4];

nombres[1] = “Sarah”; Asigne la cadena

nombres[2] = “Juan”; “Sarah” a la posición 1
nombres[0] = “Oscar”; del arreglo nombres
nombres[3] = “Carlos”;

0 1 2 3
“Oscar” “Sarah” “Juan” “Carlos”
 Arreglos Unidimensionales
•Pregunta:
¿ La instrucción nombres[4] = “Jose”; genera algún error?, tenga
en cuenta que el arreglo se declaro como

String[ ] nombres = new String[4];

Y se representa así:
0 1 2 3
“Oscar” “Sarah” “Juan” “Carlos”
 Arreglos Unidimensionales
• Resuelva el siguiente problema:

Presente el conjunto de instrucciones Java para obtener el

siguiente arreglo unidimensional llamado precios.

0 1 2 3 4 5

1200 3400 7800 1000 3200 6100

Después de crear dicho arreglo muestre cada uno de los valores

con su respectiva posición en pantalla.
 Arreglos Unidimensionales
public class Ejemplo17{
public static void main(String a[]){
int precios[] = new int[6];
precios[0] = 1200; precios[1] = 3400;
precios[2] = 7800; precios[3] = 1000;
precios[4] = 3200; precios[5] = 6100;

for (int i = 0; i < precios.length; i++) El método length devuelve la

capacidad del arreglo
{
JOptionPane.showMessageDialog(null, "El Arreglo Precios en la Posicion " +
i + " tiene: " + precios[i]);
} System.exit(0);
}
}
 Arreglos Unidimensionales
Problema:

Desarrolle una aplicación en JAVA que permita leer el nombre

de 10 productos de una tienda y su correspondiente precio. La
aplicación debe decir cuantos de ellos cuestan más de 3000
pesos y mostrar su nombre y precio en pantalla.

Utilice la metodología vista en clase para desarrollar el

problema.
 Arreglos Unidimensionales
1. Entender el Problema
- Pedir el nombre de 10 Productos de una tienda
- Pedir el precio de cada producto
- Comparar cada valor con 3000 y mostrar el nombre y el
precio del producto.

2. Objetos del Dominio del Problema

- Necesitamos un objeto que almacene la información de los
productos (nombre y precio). Leer los datos y mostrarlos.
- Necesitamos un objeto que utilice el objeto Productos
 Arreglos Unidimensionales

La representación grafica de los objetos es:

Productos UsaProductos
String nombre[];
duble valor[];

leerProductos(); main()
boolean comparar (int valor);
mostrarValores();
 Arreglos Unidimensionales

3. Diagrama de Clases:

Productos JOptionPane

String nombre[]; usa

duble precio[];
showMessageDialog();
leerProductos(); showInputDialog();
comparar (int valor);
mostrarValores();

usa
UsaProductos System

usa
main() exit()
 Arreglos Unidimensionales

4. Desarrollo de los Algoritmos:

void leerProductos()
inicio
Desde x = 0 mientras x < nombre.longitud(), de 1 en 1
inicio
escribir(“Ingrese el nombre del Producto No ”+x+” :”);
leer(nombre[x]);
escribir(“Ingrese el precio del Producto No ”+x+” :”);
leer(precio[x]);
fin
fin
 Arreglos Unidimensionales

boolena comparar (double valor)

inicio
si valor >= 3000 entonces
return true;
sino
return false;
fin si;
fin
 Arreglos Unidimensionales

void mostrarValores ()
inicio
Desde x = 0 mientras x < nombre.longitud(), de 1 en 1
inicio
si this.comparar(precio[x]) entonces
escribir(“El Producto ”+nombre[x]+” tiene un costo de ”+
precio[x]);
fin si
fin
fin
 Arreglos Unidimensionales

void main (String arg[ ])

inicio
Productos listaProductos = new Productos();
listaProductos.leerProductos();
listaProductos.mostrarValores();
System.exit(0);
fin
 Arreglos Unidimensionales
5. Programas JAVA
import javax.swing.JOptionPane;
class Productos{
String[] nombre = new String[10];
double[] precio = new double[10];

public void leerProductos(){

for (int x = 0; x < nombre.length; x++)
{
nombre[x] = JOptionPane.showInputDialog("Ingrese el nombre del
Producto No " + x + ": ");
precio[x] = Double.parseDouble(JOptionPane.showInputDialog("Ingrese
el precio del Producto : "));
}
}
 Arreglos Unidimensionales

public boolean comparar(double valor){

if (valor >= 3000)
{
return true;
}
else
{
return false;
}
}
 Arreglos Unidimensionales

public void mostrarValores(){

for (int x = 0; x < nombre.length; x++)
{
if (this.comparar(precio[x]))
{
JOptionPane.showMessageDialog(null, "El Producto
"+nombre[x]+" tiene un costo de "+ precio[x]);
}
}
}
}
 Arreglos Unidimensionales

public class UsaProductos{

public static void main(String arg[]){

Productos listaProductos = new Productos();

listaProductos.leerProductos();
listaProductos.mostrarValores();
System.exit(0);
}
}
 Un Problema de Series

Realice un algoritmo que permita calcular la siguiente serie:

1 1 1 1 (−1) n +1
Sn = 1 − + − + − K
3! 5! 7! 9! (2n − 1)!

Calcule la serie, tanto por la formula general y a través de la

formula particular.
 Arreglos Bidimensionales
• Declaración:
tipo_dato nombre_variable[ ][ ] = new tipo_dato[ #fil ][ #col ];

Ejemplos:
String[ ][ ] productos = new String[100] [50];
 Arreglos Bidimensionales

• ¿Cómo ingresar o leer datos a un Arreglo?

Para ingresar o leer los datos de un arreglo se debe indicar la
posición a la que se va a ingresar o de la que se va a leer:

Productos[45][20] = 12;
 Arreglos

• Representación gráfica de un Arreglo Unidimensional:

“Oscar” “Juan” “Jhon” “Carlos”

• Representación gráfica de un Arreglo Bidimensional:

Columna
3.5 4.0 5.0 5.0

5.0 5.0 3.0 2.5

Fila
4.5 4.5 4.0 5.0

Arreglo Bidimensional con tres (3) Filas y cuatro (4) Columnas

 Vectores

Un VECTOR es una estructura que permite almacenar

CUALQUIER cantidad de datos de un mismo tipo, sin necesidad
de especificar de antemano el tamaño.

• Los Vectores son una clase, por tanto, para crear un vector se
debe instanciar dicha clase:

Vector miVector = new Vector ();

La clase vector provee diferentes métodos que permiten

ingresar, leer y borrar elementos del Vector.
 Ejercicio

Una compañía tiene 4 vendedores que venden
cinco productos distintos (1 a 5). Una vez al
día, cada vendedor entrega una boleta por
cada tipo de producto vendido. Cada boleta
contiene:
1. El número del vendedor
2. El número del producto
3. El importe total de la venta del producto ese
día.
 Vectores

• Para ingresar elementos al Vector:

- miVector.addElement(“Carlos”);
-miVector.addElement(“Andres”);
-miVector.addElement(“Daniel”);

Nota: Un vector no puede almacenar números directamente,

para su almacenamiento se deben utilizar las clases de dichos
números.

- miVector.addElement(new Integer(123));
 Vectores
• Para leer elementos del Vector:
- miVector.get(1); Retorna “Andres”
- miVector. firstElement(); Retorna “Carlos”
- miVector.lastElement(); Retorna “Daniel”
- miVector.elementAt(1); Retorna “Andres”

• Para remover elementos del Vector:

- miVector.remove(2); Elimina a “Andres”

- miVector.removeElement(“Daniel”); Elimina la primera aparición

de “Daniel”
- miVector.removeAllElements(); Elimina todos los elementos
del vector;
 Vectores
• Para obtener el numero de elementos del vector:
- miVector.size(); Retorna 3

• Para reemplazar un elemento del vector:

- miVector.setElementAt(“Julian”, 2); Reemplaza “Daniel” por “Julian”

• Búsquedas:
- miVector.lastIndexOf(“Andres”); Retorna la posición de la ultima
ocurrencia de “Andres”

- miVector.indexOf(“Carlos”); Retorna la posición de la primera

ocurrencia de “Carlos”
 Superclases y Subclases

Herencia permite crear nuevas clases a
partir de clases ya existentes

Una subclase es más específica que su
superclase.

Todo objeto de una subclase también es
un objeto de la superclase de esa
subclase. Sin embargo no se cumple lo
opuesto
 Superclases y Subclases

Una subclase puede acceder a los miembros
public, protected y “amigables” de su
superclase.

Los miembros protected de la superclase
pueden ser accedidos por los métodos de
subclase y los métodos de otras clases del
mismo paquete de la superclase.

Desde la subclase es posible acceder a
miembros de la superclase anteponiendo la
palabra super seguida del operador punto (.)