Vectores y matrices
Curso de Computación
Objetivos
• Manipular una colección de datos usando vectores
• Declarar y utilizar un vector de tipos de datos primitivos en
la implementación de un programa
• Inicializar vectores mediante lazos y en la declaración
• Utilizar lazos para realzar operaciones con vectores.
• Ordenar un vector
• Leer datos desde un archivo y almacenarlos en un vector
Definición de vector
Un vector es una colección del mismo tipo de datos.
Declaración de un vector:
Tipo[] identificador;
lluvia[0]
0.0
O
lluvia[1]
0.0
Tipo identificador[];
lluvia[2]
0.0
Un vector es un objeto en java
lluvia[3]
0.0
Un vector se construye con el operador new
lluvia[4]
0.0
double lluvia[];
lluvia = new double[12];
lluvia[5]
0.0
lluvia[6]
0.0
O
lluvia[7]
0.0
double lluvia[] = new double[12];
lluvia[8]
0.0
lluvia[9]
0.0
lluvia[10]
0.0
lluvia[11]
0.0
Se crea un vector de 12 componentes
Acceso a los elementos
Los elementos de un vector se acceden mediante un subíndice.
lluvia[2] o
lluvia[i+1]
El índice de la primera posición de un vector es siempre 0.
Ejemplo
Leer 12 valores de lluvia mensual y calcular el promedio
double lluvia[] = new double[12];
double mediaAnual, suma = 0.0;
for( int i = 0; i < 12; i++) {
lluvia[i] = entrada.getDouble(
“lluvia para el mes “+ (i+1)+”:”);
suma += lluvia[i];
}
mediaAnual = suma/12;
System.out.println(“Media anual = ”+mediaAnual);
Calcular diferencias
Calcula la diferencia entre la lluvia del mes y la media anual
double diferencia;
for( int i = 0; i < 12; i++) {
System.out.println(formato.rightAlign
(17,1,lluvia[i]));
diferencia = Math.abs(lluvia[i]mediaAnual);
System.out.println(formato.rightAlign
(17,2,diferencia));
}
Tamaño de un vector
El tamaño de un vector se obtiene por medio de la constante
pública length.
Los lazos anteriores pueden escribirse como:
for( int i = 0; i < lluvia.length; i++) {
}
Iniciación de vectores
Otra forma de iniciar un vector al declararlo es como sigue:
String[] nombreMes =
{“enero”,”febrero”,”marzo”,”abril”,”mayo”,”
junio”,”julio”,”agosto”,”septiembre”,”octub
re”,”noviembre”,”diciembre”};
Lluvia para meses pares e
impares
Cálculo de la media de lluvia en meses pares e impares
double lluvia[] = new double[12];
double sumaMesImpar = 0.0, mediaMesImpar,
sumaMesPar = 0.0, mediaMesPar;
for(int i=0; i<lluvia.length; i++){
lluvia[i]=(double) entrada.getFloat(
"lluvia para el mes de " + nombreMes[i] + ": ");
}
for(int i = 0; i < lluvia.length; i+=2)
sumaMesImpar += lluvia[i];
mediaMesImpar = sumaMesImpar/6;
for(int i = 1; i < lluvia.length; i+=2)
sumaMesPar += lluvia[i];
mediaMesPar = sumaMesPar/6;
Preguntas rápidas
1. ¿Cuáles de las siguientes sentencias son válidas?
a. float numeros[13];
b. float numeros = {1.0f, 2.0f, 3.0f};
c. int numeros;
numeros = new Vector[23];
d. int[] numeros = {1, 2, 3, 4};
2. Escriba un programa que lea con un SimpleInput las
componentes y calcule el producto punto de dos vectores de 2
dimensiones declarados como:
float x[] = new double[2];
float y[] = new double[2];
Preguntas rápidas
3. Escriba un programa que lea los milímetros de lluvia de cada
mes e imprime el nombre del mes con mayor nivel de lluvia y el
nombre del mes con menor nivel de lluvia.
Criba de Eratóstenes
Se van tachando los múltiplos de los primos que se van siendo
encontrados hasta los múltiplos de sqrt(n) (sqrt(20)~4).
Múltiplos de 2
Múltiplos de 3
1
2
3
11 12
x 13
1
2
3
11 12
x 13
x4
14
x
5
15
x6
16
x
x4 5 x6
14
x 15
x
x 16
7
17
7
17
x8
18
x
9 10
x
19 20
x
x8 x9 10
x
18
x 19 20
x
Los números no tachados son números primos, i.e. : 2, 3, 5,
7, 11, 13, 17 y 19.
Programa en Java
//Implementa la criba de Eratóstenes
public class Criba{
public static void main(String []args){
boolean primo[] = new boolean[100];
int i,j;
//iniciar arreglo
for(i = 0; i<primo.length; i++)
primo[i] = true;
for (i = 2; i<Math.sqrt(100); i++){
//marca los múltiplos de i del 2o en adelante
for (j = 2; i*j<(100); j++)
primo[i*j]=false;
}
for(i = 0; i<primo.length; i++)
if(primo[i])
System.out.print(i+" ");
}
}
Actividad
Escriba una aplicación que calcule la desviación estándar de N
números reales. La desviación estándar se calcula con:
N
s
 x
i
 x
2
i 1
N 1
Donde x es la media de los N valores.
desviación
estándar
pequeña
promedio
desviación
estándar
grande
promedio
Algoritmo
Se utilizará un vector x de 100 elementos.
1. Leer los elementos del vector
2. Calcular el promedio
3. Calcular la desviación estándar
4. Desplegar resultados
//Esqueleto de programa
class Desviacion{
static public void main(String[] args){
//declaración de variables
//leer elementos del vector
//calcular el promedio
//calcular desviación estándar
//desplegar resultados
}
}
Primer refinamiento
Se requieren variables de tipo double para los valores (x), la suma
(suma), el promedio (prom) y la desviación estándar (des). También
variables de tipo int para el número de valores (n) y el control de los lazos
(i).
class Desviacion{
static public void main(String[] args){
//declaración de variables
double x[] = new double[100], suma = 0, prom, des;
int n,i;
//leer elementos del vector
//calcular el promedio
//calcular desviación estándar
//desplegar resultados
}
}
Lectura de valores
Puede leerse primero el valor de n y después en un lazo leer cada elemento de x, o
bien, puede leerse con un centinela los valores de x, el centinela podría ser un valor
<0. Optaremos por la segunda opción.
import javabook.*;
class Desviacion{
static public void main(String[] args){
//declaración de variables
double x[] = new double[100], suma, prom, des, v;
int n,i;
SimpleInput entrada = new SimpleInput();
//leer elementos del vector
i = 0;
do{
v = SimpleInput.getDouble(“Tecle valor para x”+i+”:”);
if(v>0){x[i] = v; i++;}
}while(v>0 && i<x.length);
n = i;
//calcular el promedio
//calcular desviación estándar
//desplegar resultados
}
}
Calcular promedio
Calculamos mediante un lazo for.
import javabook.*;
class Desviacion{
static public void main(String[] args){
//declaración de variables
double x[] = new double[100], suma, prom, des, v;
int n,i;
SimpleInput entrada = new SimpleInput();
//leer elementos del vector
i = 0;
do{
v = SimpleInput.getDouble(“Tecle valor para x”+i+”:”);
if(v>0){x[i] = v; i++;}
}while(v>0 && i<x.length);
n = i;
//calcular el promedio
suma = 0;
for(i = 0; i<n; i++) suma += x[i];
prom = suma/n;
//calcular desviación estándar
//desplegar resultados
}
}
Calcular desviación
Calculamos mediante un lazo for.
import javabook.*;
class Desviacion{
static public void main(String[] args){
//declaración de variables
double x[] = new double[100], suma, prom, des;
int n,i;
SimpleInput entrada = new SimpleInput();
//leer elementos del vector
i = 0;
do{
v = SimpleInput.getDouble(“Tecle valor para x”+i+”:”);
if(v>0){x[i] = v; i++;}
}while(v>0 && i<x.length);
n = i - 1;
//calcular el promedio
suma = 0;
for(i = 0; i<n; i++) suma += x[i];
prom = suma/n;
//calcular desviación estándar
suma =0;
for(i = 0; i<n; i++) suma += (x[i]-prom)*(x[i]-prom);
des = Math.sqrt(suma/(n-1));
//desplegar resultados
}
}
Despliegue
Desplegar con formato.
import javabook.*;
class Desviacion{
static public void main(String[] args){
//declaración de variables
double x[] = new double[100], suma, prom, des;
int n,i;
SimpleInput entrada = new SimpleInput();
//leer elementos del vector
i = 0;
do{
v = SimpleInput.getDouble(“Tecle valor para x”+i+”:”);
if(v>0){x[i] = v; i++;}
}while(v>0 && i<x.length);
n = i - 1;
//calcular el promedio
suma = 0;
for(i = 0; i<n; i++) suma += x[i];
prom = suma/n;
//calcular desviación estándar
suma =0;
for(i = 0; i<n; i++) suma += (x[i]-prom)*(x[i]-prom);
des = Math.sqrt(suma/(n-1));
//desplegar resultados
System.out.println(“total de valores leídos: “+n);
System.out.println(“el promedio es: “+Format.leftAlign(8,3,prom));
System.out.println(“la desviación es: “+Format.leftAlign(8,3,des));
}
}
Prueba del programa
Los siguientes datos fueron calculados con Excel
x
0
4.5
promedio=
1
4.6
desviación=
2
4.4
3
4.8
4.575
0.170782513
Actividad
Agregue código al programa de ejemplo para calcular lo
siguiente:
Desviación media

1
N
N

xi  x
i 1
Raíz del valor cuadrático medio

N
N
Medio armónico
1
 1 x 
 N
N

2
xi
i 1
i
i 1
Intervalo = máx(x1, x2, x3,...,xN) – mín(x1, x2, x3,...,xN)
Medio geométrico

N
x1  x 2 ...  x N
Lectura de archivos en Java
La clase BufferedReader (lector con buffer) lee texto desde un flujo de caracteres. Debe
construirse sobre un lector de flujos o de archivos.
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
El método readLine() lee una línea de texto.
La lectura debe hacerse manejando los posibles errores que se puedan producir en un bloque
try.
try{
instrucciones si no hay error;
}
catch (Excepción x){
instrucciones si hay error;
}
Ejemplo
import java.io.*;
public class Ejemplo1TextIO {
public static void main(String args[]) {
// Vamos a leer el archivo prueba.txt
// input es el objeto para leer desde el archivo
BufferedReader entrada = null;
try {
FileReader arch = new FileReader("prueba.txt"); // Abre el archivo.
entrada = new BufferedReader(arch); // Ata 'input' a este archivo.
}
catch(FileNotFoundException x) { // El archivo puede no existir
System.err.println("Archivo no encontrado: prueba.txt");
System.exit(2);// Termina el programa con código 2
}
// Ahora lee el archivo y despliega cada línea
try {
String linea;
while( (linea = entrada.readLine()) != null ) {
System.out.println(linea);
}
}
catch(IOException x) {
x.printStackTrace();//Esto se ejecuta si hay error al leer
}
}
}
Lectura de números enteros
import java.io.*;
public class Ejemplo2TextIO {
public static void main(String args[]) {
// Vamos a leer el archivo numeros.txt
BufferedReader entrada = null;
try {
FileReader arch = new FileReader("numeros.txt"); // Abre el archivo.
entrada = new BufferedReader(arch); // Ata 'input' a este archivo.
}
catch(FileNotFoundException x) { // El archivo puede no existir.
System.err.println("Archivo no encontrado: numeros.txt");
System.exit(2);// Termina el programa con código 2
}
int n,suma = 0;
// Ahora lee el archivo y despliega el total
try {
String linea;
while( (linea = entrada.readLine()) != null ) {
n = Integer.parseInt(linea);
suma += n;
}
System.out.println("la suma es: "+suma);
}
catch(IOException x) {
x.printStackTrace();//Esto se ejecuta si hay error al leer
}
}
}
Lectura de números reales
import java.io.*;
public class Ejemplo3TextIO {
public static void main(String args[]) {
// Vamos a leer el archivo numeros.txt
BufferedReader entrada = null;
try {
FileReader arch = new FileReader("numeros.txt"); // Abre el archivo.
entrada = new BufferedReader(arch); // Ata 'input' a este archivo.
}
catch(FileNotFoundException x) { // El archivo puede no existir.
System.err.println("Archivo no encontrado: numeros.txt");
System.exit(2);// Termina el programa con código 2
}
int n = 0;
double d[] = new double[100];
// Ahora lee el archivo y despliega cada valor
try {
String linea;
while( (linea = entrada.readLine()) != null ) {
d[n++] = Double.parseDouble(linea);
}
for(int i = 0; i<n; i++)
System.out.println("d["+i+"]="+d[i]);
}
catch(IOException x) {
x.printStackTrace();//Esto se ejecuta si hay error al leer
}
}
}
Actividad
Haga un programa que lea una lista de nombres y los muestre
ordenados en la pantalla.
Algoritmo
1. Leer los nombres desde un archivo y almacenarlos en un
vector.
2. Ordenar los nombres alfabéticamente
3. Desplegar los nombres ordenados
Lectura de datos
import java.io.*;
public class Ejemplo4TextIO {
public static void main(String args[]) {
// Vamos a leer el archivo nombres.txt
BufferedReader entrada = null;
try {
FileReader arch = new FileReader("nombres.txt"); // Abre el archivo.
entrada = new BufferedReader(arch); // Ata 'input' a este archivo.
}
catch(FileNotFoundException x) { // El archivo puede no existir.
System.err.println("Archivo no encontrado: nombres.txt");
System.exit(2);// Termina el programa con código 2
}
int n = 0, i, j;
String d[] = new String[100];
// Ahora lee el archivo y despliega cada valor
try {
String linea;
while( (linea = entrada.readLine()) != null ) {
d[n++] = linea;
}
}
catch(IOException x) {
x.printStackTrace();//Esto se ejecuta si hay error al leer
}
Método de ordenación
El método consiste en comparar el primer elemento con el segundo, luego el
segundo, el tercero, etc., si es necesario se intercambian los elementos. Al final
de este proceso se tendrá el más pequeño al inicio.
El proceso se repite con el segundo elemento comparándolo con los demás y
luego el tercero, etc.
Algoritmo en Java
for(i = 0; i<n-1; i++)
for(j = i+1; j<n; j++)
if(d[i]>d[j]){
intercambiar d[i] y d[j];
}
Ordenación y despliegue
Usaremos el método más sencillo (la burbuja)
//Despliega lista desordenada
System.out.println("Desordenados\n");
for(i = 0; i<n; i++)
System.out.println(d[i]);
System.out.println("\nOrdenados\n");
//ordena el vector
for(i = 0; i<n-1; i++)
for(j = i; j<n; j++)
if(d[i].compareToIgnoreCase(d[j])>0){
String temp = d[i]; d[i] = d[j]; d[j] = temp;
}
//Despliega lista ordenada
for(i = 0; i<n; i++)
System.out.println(d[i]);
}
}
Intercambia cadenas
Compara cadenas
0 – iguales
>0 – la primera mayor
<0 – la primera menor
Escritura en archivos
La clase BufferedWriter (Escritor con buffer) escribe texto en un flujo de caracteres. Debe
construirse sobre un escritor de flujos o de archivos.
BufferedWriter in = new BufferedWriter(new FileWriter("foo.out"));
El método write(s,off,len) escribe una parte de una cadena de caracteres empezando en off
y con longitud len.
La escritura debe hacerse manejando los posibles errores que se puedan producir en un bloque try.
try{
instrucciones si no hay error;
}
catch (Excepción x){
instrucciones si hay error;
}
Ejemplo
import java.io.*;
public class Ejemplo5TextIO {
public static void main(String args[]) {
// Vamos a escribir el archivo salida.txt
BufferedWriter salida = null;
try {
FileWriter arch = new FileWriter("salida.txt"); // Crea el archivo.
salida = new BufferedWriter(arch); // Ata 'salida' a este archivo.
}
catch(IOException x) { // El archivo puede no ser creado.
System.err.println("Archivo no se creo: salida.txt");
System.exit(2);// Termina el programa con código 2
}
int i;
String d[] = {"hola","que","tal"};
// Ahora escribe el archivo
try {
for(i=0; i< d.length; i++ ) {
salida.write(d[i],0,d[i].length());//Escribe cadena
salida.newLine();
//Escribe nueva línea
}
salida.close();//Es necesario cerrar el archivo
}
catch(IOException x) {
x.printStackTrace();//Esto se ejecuta si hay error al escribir
}
}
}
Escritura de números
import java.io.*;
public class Ejemplo6TextIO {
public static void main(String args[]) {
// Vamos a escribir el archivo salidanum.txt
BufferedWriter salida = null;
try {
FileWriter arch = new FileWriter("salidanum.txt"); // Crea el archivo.
salida = new BufferedWriter(arch); // Ata 'salida' a este archivo.
}
catch(IOException x) { // El archivo puede no ser creado.
System.err.println("Archivo no se creo: salidanum.txt");
System.exit(2);// Termina el programa con código 2
}
int i;
double a;
// Ahora escribe el archivo
try {
for(i=0; i< 20; i++ ) {
a = i*i;
String s = ""+i+" "+a;
salida.write(s,0,s.length());//Escribe cadena
salida.newLine();
//Escribe nueva línea
}
salida.close();//Es necesario cerrar el archivo
}
catch(IOException x) {
x.printStackTrace();//Esto se ejecuta si hay error al escribir
}
}
}
Descargar

Document