Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
A partir de la línea de código anterior, java crea una matriz unidimensional m con
2 elementos m[0] y m[1] que son referencias a otras dos matrices
unidimensionales de 3 elementos. Gráficamente podemos imaginarlo así:
Matriz m
mo m1
Fila 0
Fila 1
Fila 1
Fila 2
Fila 3
Fila 4
Fila 5
Columnas
Columnas 1 2 3 4 …. J …. N
Fila 1
Fila 2
…..
B[I,J]
Fila I
……
Fila M
Primer ejemplo:
Como ejemplo de aplicación de matrices bidimensionales, vamos a realizar un
programa que asigne datos a una matriz m de dos dimensiones y a continuación
{
for (col = 0; col < ncols; col++)
{
System.out.print("m[" + fila + "][" + col + "] = ");
m[fila][col] = Lector.nextFloat();
}
}
Una vez creada la matriz, calculamos la suma de cada fila y visualizamos los
resultados para comprobar el trabajo realizado.
System.out.println();
for (fila = 0; fila < nfilas; fila++)
{
sumafila = 0;
for (col = 0; col < ncols; col++)
sumafila += m[fila][col];
System.out.println("Suma de la fila " + fila + ": " + sumafila);
}
//
//
//
import java.util.*;
public class CMatrizMultidimensional
{
//******* Creación de una matriz multidimensional.
//******* Suma de las filas de una matriz de dos dimensiones.
public static void main(String[] args)
{
int nfilas, ncols; // filas y columnas de la matriz
do
{
System.out.print("Número de filas de la matriz: ");
nfilas = Lector.nextInt();
}
while (nfilas < 1); //********* no permitir un valor negativo
do
{
System.out.print("Número de columnas de la matriz: ");
ncols = Lector.nextInt();
}
while (ncols < 1); //********* no permitir un valor negativo
char. Desde nuestro punto de vista es más fácil imaginarse una matriz de
cadenas de caracteres como una lista. Por ejemplo, la matriz m del ejemplo
anterior estará compuesta por las cadenas de caracteres m[0], m[1], …, etc.
mo
m1
m2
m3
Para acceder a los elementos de la matriz m, puesto que se trata de una matriz
de cadenas de caracteres, utilizaremos sólo el primer subíndice , el que indica la
fila. Sólo utilizaremos dos subíndices cuando sea necesario acceder a un
carácter individual.
Por ejemplo, la primera sentencia del ejemplo siguiente crea una matriz de
cadenas de caracteres. La segunda asigna una cadena de caracteres a m[0]
desde el teclado; la cadena tendrá nCarsPorFila caracteres como máximo y será
almacenada a partir de la posición 0 de m[0]. Y, la tercera sentencia, reemplaza
el último carácter leido en m[0] por “\0”, puesto que read devuelve el número de
caracteres leídos.
Es importante hacer recordar que que m[0], m[1], … etc son cadenas de
caracteres y que, por ejemplo, m[1][3] es un carácter, el que está en la fila 1,
columna 3.
María
Francisco
Javier
//
//
import java.io.*;
import java.util.*;
Asimismo, una vez finalizada la entrada de los datos, se lanza una pregunta
acerca de si se desea visualizar el contenido de la matriz. En este caso, la
respuesta tecleada, se obtiene con readLine. Como este método lee hasta el
carácter ‘\n’ inclusive, utilizamos el método charAt para obtener del String
devuelto por readLine el primer carácter, que deberá ser una ‘s’ o una ‘n’.
Observa la respuesta:
respuesta = ((flujoE.readLine()).toLowerCase()).charAt(0);
Es equivalente a:
String s=flujoE.readLine()
s = s.toLowerCase();
respuesta = s.charAt(0);
¿De qué longitud son las cadenas de caracteres nombre [0], nombre [1], etc.?
Independientemente del número de caracteres leídos para cada uno de los
nombres solicitados, todas son de la misma longitud.-. nCarsPorFila caracteres
(recuerda que las matrices de caracteres son iniciadas con nulo); para verificarlo
puede recurrir al atributo length de las matrices. Evidentemente, esta forma de
proceder supone un derroche de espacio de memoria, que se puede evitar
haciendo que cada fila de la matriz nombre tenga una longitud igual al número de
caracteres del nombre que almacena. Apliquemos esta teoría al programa
anterior.
unNombre J e s ú s \r \n
nombre
nombre0 C a r m e n Fila 0
nombre1 F r a n c I s c o Fila 1
nombre2 J e s ú s Fila 2
….
//****
import java.io.*;
import java.util.*;
Notas=new double[n][m];
Notas[i][j]= Lector.nextDouble();
Donde i representa la fila y j la columna.
La primera vez que se ingresa al primer for i vale 0 y la primera vez que se
ingresa al segundo for, j vale 0; por lo tanto, el primer elemento que se lee es el
elemento Notas[0,0] , el segundo es el elemento Notas[0,1], Notas[0,2] y así
sucesivamente hasta M cursos.
Una vez que se termina de leer las notas del primer alumno (que corresponden a
la fila 0), se continúa con las notas del segundo alumno (que corresponden a la
fila 1). Es decir, se lee el elemento Notas[1,0] , Notas[1,1], Notas[1,2] y así
sucesivamente hasta M cursos.
Y de esa manera se continúan leyendo las notas de todos los N alumnos.
Ejercicio:
1. Modificar el programa, de manera que permita leer las notas; pero por
curso. En este caso se intercambian los for.
2. Verificar que las notas ingresadas se encuentren en un rango válido (entre
0 y 20 inclusive)
suma=0;
antes de entrar al segundo for. Esto es necesario, porque debemos sumar las
notas de cada alumno y antes de sumar sus notas, debemos poner esta variable
en cero. Si no lo hacemos( por ejemplo si ponemos la instrucción antes del
primer for), se acumularían las notas de todos los alumnos.
promedio=suma/m;
Luego, en la instrucción:
PromedioAl[i]=promedio;
Ejercicio:
Agregar un método al programa, que permita mostrar en la pantalla los
nombres de todos y cada uno de los alumnos, junto con sus notas y sus
promedios.
class CNotas
{
static double[][] Notas;
static double[] PromedioAl,PromedioCur;
static String[]Nombres,Cursos;
static int m,n;
{
System.out.println("\nAlumno: "+Nombres[i]);
for(int j=0;j<m;j++)
{
System.out.print("Nota en el curso "+Cursos[j]+" : ");
Notas[i][j]=Leer.datoDouble();
}
}
}
public static void LeerNombres()
{
System.out.println("\n*****Ingreso de los Nombre de los alumnos: ");
for(int i=0;i<n;i++)
{
System.out.print("Alumno :"+i);
Nombres[i]= Leer.dato();
}
System.out.println("\n******Ingreso de los Nombres de los cursos: ");
for(int j=0;j<m;j++)
{
System.out.print("Curso :"+j);
Cursos[j]=Leer.dato();
}
}
suma=suma+Notas[i][j];
}
promedio=suma/m;
PromedioAl[i]=promedio;
System.out.println("el promedio del alumno "+Nombres[i]+" es:
"+PromedioAl[i]);
}
}
public static void CalcularPromCurso()
{
double suma,promedio;
for(int j=0;j<m;j++)
{
suma=0;
for(int i=0;i<n;i++)
{
suma=suma+Notas[i][j];
}
promedio=suma/n;
PromedioCur[j]=promedio;
System.out.println("el promedio del curso de "+Cursos[j]+" es:
"+PromedioCur[j]);
}
}
public static void main (String[]args)
{
CNotas miObjeto=new CNotas();
System.out.println("**** Programa de ejemplo de arreglos ****");
System.out.println("\nNotas de N alumnos en M cursos\n");
miObjeto.LeerNM();
miObjeto.CrearMatrices();
miObjeto.LeerNombres();
miObjeto.LeerNotas();
miObjeto.CalcularPromAlumno();
miObjeto.CalcularPromCurso();
}
}
Tenga en cuenta que necesita la clase Leer para que pueda funcionar este
programa. Por tanto, debes cargar esta clase que te entrego junto con este
programa a la misma carpeta donde tienes la clase CNotas.