JAVAMATRICESTOMOLXI

Autor: Luis Felipe Wanumen Silva 1
ENCICLOPEDIA CONOCIENDO
Próximame
nte en
Internet y
en su
librería más
cercana
TOMO LXI
JAVA
MATRICES
ELABORADO POR:
LUIS FELIPE WANUMEN SILVA

INGENIERO DE SISTEMAS, CATÓLICO
Y AUTOR DE LA ENCICLOPEDIA CONOCIENDO
CONTIENE
CONCEPTOS DE
MATRICES,
EJEMPLOS,
EJERCICIOS
PROPUESTOS Y ALGO
MÁS.
PRIMERA VERSIÓN AUN NO REVISADA

SANTAFE DE BOGOTA D.C.
Enciclopedia Conociendo Java Matrices

SEPTIEMBRE DE 2003.

Incluye un CD con los

ejemplos del libro

INTRODUCCIÓN
De antemano, quiero decir que mi deseo siempre habia sido el poder

escribir un libro sobre java, pero a pesar de haber estudiado sobre
este lenguaje y de haber desarrollado aplicaciones en dicho lenguaje,
la verdad, nunca me quedo tiempo para organizar un material digno de
poder presentar a la comunidad académica. Este manual inicialmente se
empezó a realizar debido a mi vinculación como docente de hora
cátedra en la Universidad Distrital de Bogota – Colombia, más
exactamente en la Facultad Tecnológica de dicha Universidad, donde a
pesar de tener este nombre, también se forman Ingenieros de Sistemas
con énfasis en redes y no es por hacer propaganda, pero en esta parte
de redes, me parece que los Ingenieros que salen de esta Alma Mater
son muy buenos.
Tenía unos apuntes, desorganizados y solo los entendía yo, así que
decidí poner todo mi empeño en el desarrollo de este material y
espero que se siga mejorando este material, así como he mejorado
otros materiales que desde hace mucho tiempo he venido publicando,
como son los libros de Algoritmia y Programación, JavaScript, Bases
de Datos con énfasis en SQL Server, ASP, etc.
Gracias al Ingeniero Miller por haber confiado en mí y haberme dado

la oportunidad de dar la cátedra de “Lenguaje de Programación II”, en
la cual, los estudiantes ven Java.
Espero que este material sea una muy buena herramienta para las
personas que se introducen en el mundo de Java y para las personas
experimentadas que ya tienen algún conocimiento de este excelente
lenguaje de programación. De antemano, gracias a mis familiares por
la paciencia que me tuvieron cada vez que me veían trabajando horas y
horas en el computador y gracias a mi novia Esmeralda, por comprender
que la elaboración de este material demanda tiempo y paciencia.
Gracias a DIOS TODOPODEROSO por haberme dado salud, paciencia y
licencia de culminar este material que hoy presento a cualquier
persona que quiera iniciar, conocer, profundizar y afianzar sus
conocimientos de Java.
Cualquier sugerencia que me quieran hacer sobre el presente material, será bien
recibida y la pueden hacer en el correo luchofelipe2000@yahoo.com y mientras siga
trabajando en la Universidad en el correo lwanumen@udistrital.edu.co.

SOBRE EL AUTOR
Ingeniero de Sistemas egresado de la Universidad Distrital Francisco

José de Caldas. Fue docente de la Universidad del Cauca en Popayán en
materias como Ingenieria de Software I e Introducción a la
Informática. A lo largo de su vida a escrito numerosos artículos, los
cuales con el paso del tiempo ha ido recolectando en libros que él
mismo a denominado Enciclopedia Conociendo. En dicha enciclopedia
trata temas variados, es así como en ocasiones trata sobre las bases
de datos, los ensayos psicológicos que son experiencias vividas por
él; cómo ser un buen docente, donde trata experiencias puramente
académicas; html, donde trata algunos aspectos de este lenguaje de
marcado; guitarra, donde trata algunos aspectos de este instrumento y
presenta un repertorio de canciones en su mayoría dictadas en el
Colegio María Auxiliadora.
Luis Felipe es un Ingeniero que se ha caracterizado por ser un

programador ante todo y esto lo demuestra con su participación en
diversos proyectos, incluso desde su tesis en la que fue un
investigador del grupo denominado “Biblioteca Virtual”, ha querido
mostrar no sólo su carácter programador, sino escritor. Desde muy
chico le ha gustado escribir y es así como incluso desde el colegio,
ha escrito un mini manual de fórmulas matemáticas.
Es una persona muy católica, y esto lo ha demostrado con su

participación en eucaristías en Popayán, en el cerro de Guadalupe en
Bogotá, en la parroquia Cristo de la Paz en Santa Librada – Bogotá.
Su gran pasión ha sido la guitarra, incluso ha participado en el
festival de colcultura realizado en el año 1998, ha sido profesor de
guitarra en Oscus del Barrio Bochica, ha sido docente de guitarra en
el colegio María Auxiliadora, ha participado en el programa estampas
juveniles, ha participado en la celebración de la novena de
aguinaldos en la policía metropolitana, en buses amrillos y en muchas
partes donde se ha podido vincular activamente a ésta celebración
maravillosa de fin de año.

PROLOGO
Este material está enfocado principalmente a personas que no tienen conocimiento de

java o personas que tienen unos conocimientos no muy profundos de java. La idea es
con el paso del tiempo si DIOS me da vida, ir mejorando el material con el fin de
lograr que cada día cubra más y mejores temas avanzados de este lenguaje.
La organización de este libro sigue una secuencia más o menos clásica, pues se
comienza dando los fundamentos de cómo utilizar el compilador, las principales
estructuras del lenguaje java, las matrices y programas cada vez más elaborados,
juegos y al final se dedican esfuerzos por explicar swing y la conexión de java con
bases de datos.
Este es un material que trata al máximo de colocar ejercicios resueltos con el fin de
lograr que el aprendizaje sea rápido por parte del estudiante, pues mi experiencia me
ha demostrado que el estudiante aprende mejor cuando se le dan ejemplos ya
elaborados que le van mostrando como se aplican los diversos conceptos, casi se
puede decir que siguiendo linealmente los ejercicios desarrollados en este libro, el
estudiante está en capacidad de ir asimilando los conceptos sin necesidad de incluir
mucha teoría. Obviamente la teoría se incluye en temas críticos como el inicio, en el
cual hay necesidad de orientar al estudiante sobre la estructura, forma y alcances de la
programación en java y en capítulos sobre matrices y vectores que son temas bastante
trabajados en cursos de programación, pero en donde la mayoría de profesores carecen
de ejercicios completos que muestren como se aplican dichos conceptos.

AGRADECIMIENTOS
En primera medida, gracias a DIOS TODOPODEROSO por haberme dado salud,

licencia, paciencia y constancia para escribir este material, el cual a veces me hacía
sufrir. De manera muy especial a mi hermana Gloria por haberme prestado su
computador para trabajar en el documento, debido a que este equipo es más rápido que
el que tengo yo. Gracias a todos mis queridos estudiantes, quienes con su entusiasmo
me han dado ánimo para continuar este material y con su apoyo han hecho que este
convencido que el desarrollo de este material no es cosa vana.

NORMAS PARA CLASE
1) Al final del semestre no se aceptan reclamos

2) El profesor para realizar una verdadera labor docente no debe dar todo el
material a los estudiantes, por cuanto es bueno que el estudiante adquiera la
habilidad necesaria para ser un investigador de conocimiento y en realidad el
profesor es un guía a cerca de los temas a tratar y un bosquejo y/o propuesta de
desarrollo de temas con algunos ejemplos que no son los definitivos y que
pueden estar sujetos a cambios
3) No colocarle apodos al profesor
4) El profesor puede hacer hasta 2 quices por clase y sin previo aviso
5) Todo trabajo debe ser presentado por escrito y con copia en disquete.
6) Los disquetes entregados se devuelven al finalizar el semestre, una vez ya se
halla entregado notas y no existan reclamos por parte de los estudiantes.
7) El estudiante que falte a clase pierde la materia sin importar las notas que
tenga.
8) Estudiante que no entregue los trabajos completos, es decir, todos los talleres
propuestos en el presente material no pasa la materia, pues el 30% del total de
la definitiva es la recopilación de todos los talleres y a parte de todo estudiante
que no halla presentado trabajos no tiene derecho a presentar el programa final.
9) Los valores en porcentaje y peso de las notas son:
15% parcial1
15% parcial2
15% talleres primera entrega
15% talleres segunda entrega
40% programa final
Por desorden en clase, faltas de respeto, groserías, mala presentación de
trabajos se baja las notas de entrega de talleres en el porcentaje que estime
conveniente el profesor.
10) El programa final,debe aplicar como mínimo conceptos de: arreglos, matrices,
archivos, bases de datos y swing.
11) Las dudas extraclase se atienden solamente a personas que hallan leido el
presente material o por lo menos los temas de este libro que tienen que ver con
la duda del estudiante.
12) Después de mitad de semestre, el estudiante debe ir mostrando sus avances con
respecto al programa final. Estudiante que no entregue avances previos al
programa final está reservado el derecho del profesor a calificarlo o no.
13) Salvo ciertas circunstancias expuestas en clase por el mismo profesor, algunos
normas pueden ser removidas, actualizadas o añadidas, en función del
rendimiento y actitudes del curso.
14) A todos los estudiantes se les da la misma posibilidad de ser evaluados,
tratados con equidad, respeto y de la misma manera se exige por parte del
profesor la misma actidud de los estudiantes.

15) El presente material no puede ser utilizado por ningún otro docente, ni
comercializado por persona alguna a menos que se tenga por escrito la
autorización del autor: Luis Felipe Wanumen Silva y en ningún caso se
transpasará, cederán, venderán o regalarán propiedades de autoría por parte del
autor de parte(s) o totalidad del material aquí expuesto.
16) Los estudiantes que hallan sido estudiantes del profesor Luis Felipe Wanumen
tienen un permiso explícito concedido en esta parte para fotocopiar, reproducir,
imprimir y utilizar este material únicamente con fines académicos para clase y
para sí mismos y en ningún caso puede utilizar este material como ayuda
didáctica para dictar una cátedra de programación y/o entregar copias a
terceros a menos que tenga una autorización escrita del autor y no le cambie
nada al material, como son encabezados, portadas citas, explicaciones y en
ningún caso se ceden licencias comerciales o transferencias de propiedad de
autoría a ninguna persona natural o jurídica.
17) El derecho a adquirir la versión mejorada del presente material por parte de ex
-estudiantes del profesor y que sean graduados se tiene únicamente si se le
avisa al autor que se desea la adquisición de dicha copia y es responsabilidad
utilizar dicha copia y sacarle copias escritas o por otro medio únicamente para
sí mismo y en ningún caso para publicación para ser vista por terceros; y
aunque la copia sea para sí mismo en ningún caso se permite la alteración del
contenido, de los encabezados de página, de los pies de página y páginas de
presentación.
18) A ningún estudiante se le obliga a comprar el presente material al profesor en
forma electrónica o escrita, el profesor vendería las fotocopias del mismo
solamente a estudiantes que así lo hallan solicitado. Ningún estudiante puede
vender fotocopias del presente material a personas que no sean estudiantes del
profesor y el derecho a repartir copias electrónicas del presente material está
reservado únicamente al profesor.
19) El profesor le regala a sus estudiantes el derecho a copiar este material en
forma electónica únicamente para fines académicos y estrictamente
relacionados con su crecimiento profesional en el curso y no para distribuir o
fotocopiar este material para terceros. Para sí mismo cada estudiante puede
sacarle cuantas copias desee de la manera que desee, pero nunca con el ánimo
de lucro.
20) Si algún estudiante pretende publicar este material en un sitio web, lo puede
hacer siempre y cuando cuente con la aprobación del profesor, deje intacto el
material,no le quite ni le añada, no lo utilice con fines lucrativos indirecta o
directamente y haga una referencia al autor siempre que se refiera a este
material.
21) El profesor no se hace responsable por el uso que sus estudiantes hagan del
presente material, ni mucho menos por las consecuencias ocasionadas en los
equipos de cómputo, estaciones de trabajo o afines por la utilización,
aplicación de conceptos y demás cuestiones expuestas en el presente material.

22) Bajo ninguna circunstancia un estudiante puede lucrarse con este material
reproduciendo por cualquier medio el presente y vendiéndolo a terceros, así los
terceros sean estudiantes del docente en mención.
23) La propiedad intelectual, de autoría y patente está únicamente dada al autor
Luis Felipe Wanumen Silva y en ningún caso será cedida.
24) Cualquier marca aquí expuesta en el presente material es propiedad de la
respectiva empresa y si en algún caso la mención de alguno de ellos se hace
con el fin de causar deterioro de imagen, goodwill de empresa alguna, se dice
que esta no es la intencion, puesto que se respetan las marcas, empresas,
propiedades, patentes y estandares y a nadie se le discrimina por se empresa de
software libre o propietaria, por tener o dejar de tener cualquier caracteristica y
en la medida de lo posible se pretende dar a entender en el presente material
que no se pretende pordebajear otros lenguajes de programacion, empresas,
revistas o cualquier entidad relacionada directa o indirectamente con este
material.
25) La utilización del presenta material es responsabiliad solamente de la persona
que lo haga y el autor no corre con ninguna responsabilidad que se haga del
mismo.
26) El autor no garantiza que en un 100% los conceptos sean válidos, actuales,
verídicos, pero garantiza que frecuentemente hace revisiones al presente
material e intenta mejorar errores encontrados en versiones anteriores.
27) El presente material no es propiedad intelectual de ningún estudiante, empresa,
universidad, multinacional o similar diferente al autor: Luis Felipe Wanumen
Silva.
28) El derecho comercial y de lucro del presente material es exclusividad del autor:
Luis Felipe Wanumen Silva

1. PRIMEROS EJERCICIOS CON MATRICES
1.1. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y NO DINAMICA
En este capitulo relacionado con las matrices es importante notar que un tema bien
importante es la inicilización de la matriz con valores. Para hacer la cuestión bien
didáctica, vamos en primera instancia a llenar la matriz con valores colocados por el
programa y a medida que vayamos avanzando iremos incorporando nuevas
complejidades. El siguiente programa solamente inicializa los valores de una matriz y
posteriormente los imprime.
/******************************************************************
Nombre : matriz3.java
Descripcion : El siguiente programa muestra como se
: crean e inicializan matrices de tipo int
Tipo: : No Maneja apuntadores, maneja arrays (Matrices)
: Es de tipo APPLET
: El tamaño de la matriz es establecido por
: el programador
Autor : Luis Felipe Wanumen luchofelipe2000@yahoo.com
Revision : No hay revisiones por el momento.
Agradecimientos : No hay
D.Historico : 03/05/2003
******************************************************************/
import java.awt.*;
import java.applet.*;
public class MyApp extends Applet

{
int num,pos_x,pos_y,x=15,y=25;
int matriz[][];
public void init()
{
matriz=new int[5][3];
for(pos_x=0; pos_x<5; pos_x++)
{
for(pos_y=0; pos_y<3; pos_y++)
{
num=(int)(Math.random()*13)+1; // Sirve para establecer rango
de
// aleatoriedad de numeros
producidos
// Produce Numeros entre 1 y 14
matriz[pos_x][pos_y]=num;//asigna los numeros randomicos a la
matriz
}
}
}

public void paint(Graphics g)

{
for(pos_x=0; pos_x<5; pos_x++)
{
for(pos_y=0; pos_y<3; pos_y++)
{
g.drawString(""+matriz[pos_x][pos_y], x, y);
x+=22; // avanzo 22 posiciones graficas en x
}
x=15; //Me vuelvo a colocar en la posicionn en x inicial
//cada vez que comienze el otro ciclo
y+=22; // avanzo 22 posiciones graficas en y

}
}
}
1.2. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y DINAMICA
/******************************************************************
: crean e inicializan matrices de tipo int
: Como se le asignan valores y posteriormente
: se imrime el contenido en un TextArea
Tipo: : El programa utiliza CONCAT de la clase STRING
: No Maneja apuntadores, maneja arrays
: Es de tipo Autonomo
: El tamaño de la matriz es ditigado por el
: usuario
******************************************************************/
import java.awt.*;
import java.awt.event.*;
public class MyApp extends Frame

{
TextArea area = new TextArea(10,50);
Label etiqueta = new Label("Digite numero columnas");
TextField campo = new TextField("",5);
Button boton1 = new Button("Aceptar");
int col=0, fil=0, contador=0, tamano=0, i, j;
public boolean action(Event evt, Object arg){

String cadena1 = new String("Digite numero columnas");
String cadena2 = new String("Digite numero filas");
int comparo1 = cadena1.compareTo(etiqueta.getText());
if(comparo1==0){
col = Integer.parseInt(campo.getText());

etiqueta.setText("Digite numero filas");

campo.setText("");
}
else
{
if(comparo2==0 && contador==0){
fil = Integer.parseInt(campo.getText());
etiqueta.setText("La matriz se va a llenar: fil=");
int Matriz[][] = new int[fil][col];
int matriz2[];
int valor = 1;
for(int k=0; k<fil; k++)
{
for(int m=0; m<col; m++){
Matriz[k][m]=valor;
valor++;
}
}
area.setText("");
for(int ii=0; ii<fil; ii++)
{
for(int jj=0; jj<col; jj++){
Integer auxiliar = new Integer(Matriz[ii][jj]);
String areas = new String(area.getText());
String matris = new String(auxiliar.toString()+" ");
area.setText(areas.concat(matris.toString())+"");
matris.concat(auxiliar.toString());
}
area.setText(area.getText()+"\n");
}
campo.setText("Que paso");
campo.setVisible(false);
boton1.setVisible(true);
campo.setText("");
contador++;
tamano = fil*col;
area.setVisible(true);
}
else
{
}//cierra comparo2==0 && contador==0
}
return true;
}
public MyApp()
{
this.addWindowListener (new WindowAdapter(){
public void windowClosing(WindowEvent e){
dispose();
System.exit(0);
}

});
Panel p = new Panel();

add(p);
//FLOWLAYOUT: 0 LEFT, 1 CENTER, 2 RIGHT
p.setLayout(new FlowLayout(1,10,10));
p.add(etiqueta);
p.add(campo);
p.add(area);
p.add(boton1);
p.show();
boton1.setVisible(false);
}
public static void main(String args[])

{
System.out.println("Starting App");
MyApp f = new MyApp();
f.setSize(400,300);
f.show();
}
}
1.3. PROGRAMA QUE PIDE CADA UNO DE LOS VALORES DE UNA MATRIZ
Uno de los programas más interesantes en la parte de matrices es el relacionado con

las matrices y en especial en la forma en como se podría hacer un programa que
solicite al usuario cada uno de los contenidos que irían en una matriz. En este caso
particular se va a mostrar como dada una matriz de enteros de tamaño 3 x 3, se le
puede pedir al usuario los valores que han de ser colocados en dicha matriz.
Obviamente el programa que vamos a mostrar inserta los valores en el siguiente
orden:
1 2 3
4 5 6
7 8 9
/******************************************************************
Nombre : matriz3a.java
Descripcion : El siguiente programa llenar una matriz
: de tamaño prdeterminado con valores
: digitados por el usuario.
: El programa halla una nueva matriz inserva e
: imrime el contenido de la misma en un TextArea
Tipo: : El programa utiliza ciclos
: Maneja matrices estaticas
: Es de tipo Applet

: El tamaño de la matriz es predeterminado

: por el usuario
******************************************************************/
import java.awt.*;

{
GridLayout grilla = new GridLayout(2,1,5,5);
Button b1 = new Button("0k");
TextField t1 = new TextField();
TextArea ta = new TextArea();
Panel p1 = new Panel();
int matriz[][] = new int[3][3];
int matrizT[][] = new int[3][3];
int pos_x=0, pos_y=0;
String cadena = "";
almacenar guardar = new almacenar();
public void init(){

setLayout(grilla);
add(p1);
p1.add(t1);
p1.add(b1);
b1.addActionListener(guardar);
add(ta);
} // Cierra funcion ini()
public class almacenar implements ActionListener{

public void actionPerformed(ActionEvent ev){
if(pos_x==2 && pos_y==2){

matriz[pos_x][pos_y] =
Integer.parseInt(t1.getText().trim());
ta.setText("");
for(int j=0; j<3; j++){
for(int i=0; i<3; i++){
matrizT[j][i] = matriz[i][j];
cadena = cadena + matrizT[j][i];
cadena = cadena + "\t";
} // Cierra for interno
cadena = cadena + "\n";
} // Cierra for externo
ta.setText(cadena);
}// Cierra if(pos_x==2 && pos_y==2)
if(pos_x<3 && pos_y<3){

System.out.println("ANTES = x = "+pos_x);
System.out.println("ANTES = y = "+pos_y);

matriz[pos_x][pos_y] =
Integer.parseInt(t1.getText().trim());
if(pos_x<2){
pos_x = pos_x+1;
}
else{
if((pos_y+1)<3){
pos_y = pos_y+1;
pos_x = 0;
}
} // Cierra else interno
System.out.println("DESPUES = x = "+pos_x);
System.out.println("DESPUES = y = "+pos_y);
System.out.println(" ");
} // Cierra if (pos_x<2 && pos_y<2)
} // Cierra actionPerformed
} // Cierra class almacenar
}
En términos de interfaz al usuario, el anterior programa tiene un aspecto similar al

siguiente:
En donde el usuario puede comenzar a digitar los valores que harán parte de la matriz
“matriz”. Cuando el usuario presione el botón con el rótulo “OK” se insertará dicho
valor en el respectivo de la matriz. Al momento de insertar el último valor, no solo se
inserta, sino que también se calcula su inversa y se muestra en el “TextArea” ubicado
en la parte inferior de la aplicación. Para ser didácticos supongamos que insertamos
los siguientes valores:
1 2 30
0 0

4 5 60
0 0
7 8 90
0 0
Al insertar el último valor obtenemos una interfaz similar a la siguiente:
1.4. PROGRAMA QUE CALCULA LA TRANSPUESTA DE UNA MATRIZ
El programa siguiente es una mejora del anterior programa, por cuanto el programa
además de permitir al usuario insertar los datos digitados por el usuario en una matriz,
también crea una matriz con la transpuesta y la muestra al usuario.
Veamos en primera medida el programa:
import java.awt.*;

{
String cadena=" ";
Panel p1=new Panel();
llena_matriz obj=new llena_matriz();
TextField t1=new TextField(" ");
Button b1=new Button ("OK");
TextArea ta=new TextArea();
GridLayout grilla=new GridLayout(2,1,0,0);
int matriz[][]=new int[4][4];
int x=0,y=0,contador=0;
int matrizT[][]=new int[4][4];
public void init(){
setLayout(grilla);

add(p1);
add(ta);
p1.add(t1);
p1.add(b1);
b1.addActionListener(obj);
}
public class llena_matriz implements ActionListener{

if(contador<16){
int valor;
valor=Integer.parseInt(t1.getText().trim());
matriz[x][y]=valor;
matrizT[y][x]=valor;
//System.out.println(""+valor);
if(y<3){
y=y+1;
}
else {
y=0;
x=(x+1);
}
contador=contador+1;
}
else{
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
cadena=cadena+matrizT[i][j]+ "\t";
}
cadena=cadena+"\n";
}
t1.setVisible(false);
b1.setVisible(false);
ta.setText(cadena);
}
}
}
}
En primera medida cabe anotar que la disposición de los elementos es la siguiente:
En donde podemos asegurar que en la parte superior se ha colocado un panel y en la

parte inferior se ha colocado un TextField, tal como se muestra a continuación:
Panel p1
TextArea ta

Esto se logra con las instrucciones:
add(p1);
add(ta);
Ahora bien, dentro del Panel “p1” se colocan dos elementos, tal como se muestra a
continuación:

Panel p1
TextArea ta
TextField t1 Button b1
Y esto se logra con las instrucciones:
p1.add(t1);
p1.add(b1);
En donde se puede observar que los elementos van a ser insertados dentro del panel
superior, el cual en nuestro caso tiene el nombre de “p1”.
En este ejercicio, se ascocia un objeto de tipo evento a nuestro boton, el cual para este
caso es el botón b1, mediante la instrucción:
b1.addActionListener(obj);
Podríamos pensar que la asociación de un objeto tipo evento al botón se podría

representar abstractamente de la siguiente manera:
b1
Clase Tipo
ActionListener
Cuando se presione el boton b1, se activa la

clase ActionListener
De tal suerte que cuando se hace click sobre el botón, en realidad se activa la clase
Tipo ActionListener. Las clases que implementan ActionListener son clases evento en
java, por esta razón una clase para que sea activada como un evento debe implementar
la clase ActionListener
Otra cuestión importante que es necesario tener en cuenta es el hecho que cuando se
activa una clase tipo “ActionListener”, se ejecuta la función actionPerformed, tal
como se muestra en el siguiente diagrama conceptual:

Funcion
Clase Tipo ActionListener ¡ACTIVESE!
actionPerformed
¡EJECUTE FUNCION
ACTIONPERFORMED!
Con todo lo mostrado hasta el momento, vemos pues que todo el programa en esencia
se reduce a comprender el funcionamiento de las instrucciones inmersas en la función
“actionPerformed”:
En primera medida la función “actionPerformed” contiene un primer if con las

siguientes instrucciones:
if(contador<16){
int valor;
valor=Integer.parseInt(t1.getText().trim());
matriz[x][y]=valor;
matrizT[y][x]=valor;
//System.out.println(""+valor);
if(y<3){
y=y+1;
}
else {
y=0;
x=(x+1);
}
contador=contador+1;
}
Las cuales verifican que la variable contador sea menor que 16 y si ello se cumple se
toma el valor que hay en la caja de texto, se convierte a entero y finalmente se
almacena en la matriz, tal como se muestra en el siguiente diagrama conceptual:

b1
Es necesario que el amigo lector / estudiante tenga en cuenta que si para este ejercicio
en particular, si estamos situados en la primera, segunda o tercera columna podemos
insertar el valor en la matriz y posteriormente incrementar la variable de la columna,
en este caso, la variable “y”, tal como se muestra en el siguiente diagrama conceptual:
b1
Guarde el valor e incremente la variable y Y=0
Guarde el valor pero NO INCREMENTE e Y=3

incremente la variable y
Pero como el amigo lector / estudiante lo ha podido notar, el problema se presentará

cuando lleguemos al final de la fila, con lo cual diremos que este problema se
soluciona mediante las instrucciones:
if(y<3){
y=y+1;
}
else {
y=0;
x=(x+1);
}

Las cuales se encargan de incrementar el valor de la fila, pero volver a inicializar la

columna en la primera columna de la matriz (valga la redundancia). Esta situación se
muestra concptualmente en el siguiente diagrama mental:
1. La siguiente posición es:
2. Paso a la siguiente fila aumentando el valor de j
3. Paso a la siguiente columna dejando el valor de i en 0
Esta situación se presentará las primeras 16 veces que el usuario haga click sobre el
botón. La verdad es que cuando el usuario haga click por vez 17, se ejecutará las
instrucciones contenidas en el bloque “else”:
else{
cadena=cadena+matrizT[i][j]+ "\t";
}
cadena=cadena+"\n";
}
ta.setText(cadena);
}
Las cuales vuelven a recorrer la matriz pero con el fin de colocar los datos de la matriz
transpuesta en una variable “cadena”, la cual es asignada como contenido del
TextArea. Al finalizar la inserción de elementos, el programa produce una pantalla
similar a la siguiente con los resultados que se muestran a continuación:

Esto obviamente se debe a que existe la instrucción que deshabilita el botón y la caja
de texto, haciéndola invisible al usuario. Este efecto se obtiene cuando se ejecutan las
instrucciones:
y suponiendo por supuesto que han sido asignados valores enteros consecutivos que
van del 1 al 16 y se iban insertando en la matriz.
1.5. MATRIZ MAGICA
/******************************************************************
: implementa el algoritmo de la MATRIZ
: MAGICA
: se imrime el contenido en un TextArea
Tipo: : El programa utiliza CONCAT de la clase STRING
: No Maneja apuntadores, maneja arrays
: Es de tipo Autonomo
: El tamaño de la matriz es ditigado por el
: usuario
******************************************************************/
import java.awt.*;
public class MyApp extends Frame

{
TextArea area = new TextArea(10,50);

Label etiqueta = new Label("Digite numero columnas");

TextField campo = new TextField("",5);
Button boton1 = new Button("Aceptar");
int col=0, fil=0, contador=0, tamano=0, i, j;
public boolean action(Event evt, Object arg){

String cadena1 = new String("Digite numero columnas");
String cadena2 = new String("Digite numero filas");
if(comparo1==0){
col = Integer.parseInt(campo.getText());
etiqueta.setText("Digite numero filas");
campo.setText("");
}
else
{
if(comparo2==0 && contador==0){
fil = Integer.parseInt(campo.getText());
etiqueta.setText("La matriz se va a llenar: fil=");
int Matriz[][] = new int[fil][col];
int matriz2[];
for(int k=0; k<fil; k++)

{
for(int m=0; m<col; m++){
Matriz[k][m]=0;
}
}
int fila, columna;
fila = fil-1;
columna = (col-1)/2;
//CONCRETAMENTE ESTA PARTE LLENA LA MATRIZ

int valor = 1;
Matriz[fila][columna]=valor;
etiqueta.setText("Ey:"+fila+"
"+columna+"valor"+Matriz[fila][columna]);
// Aqui se colocan los valores de la matriz magica

do {
// Cuando todo funciona normalmente
// Se puede incrementar fila y col
if( (fila+1)<fil && (columna+1)<fil && (Matriz[fila+1]
[columna+1]==0) )
{
valor++;
Matriz[fila+1][columna+1]=valor;
fila++;
columna++;
}

// Cuando es valido incrementar fila y columna

// pero esta ocupada por un numero ya puesto
// se debe disminuir la fila
if( (fila+1)<fil && (columna+1)<fil && (Matriz[fila+1]
[columna+1]!=0) )
{
valor++;
Matriz[fila-1][columna]=valor;
fila--;
}
// Si estoy en la posicion inferior derecha

// Es decir en la posicion (n,n)
// siempre debo subir en la fila
// Compruebelo
if( ((fila+1)==fil) && ((columna+1)==fil) )
{
valor++;
Matriz[fila-1][columna]=valor;
fila--;
}
// Siempre que estoy en la ultima columna de la matriz

// pero no en la posicion (n,n) tengo la seguridad que
// la columna a la que hay que pasar es a la primera
// y la fila es a la siguiente.
// La columna primera = 0
// Fila siguiente fila++
if( ((columna+1)==fil) && ((fila+1)<fil) )
{
valor++;
fila++;
columna=0;
}
// Siempre que estoy en la ultima fila de la matriz

// pero no en la posicion (n,n) tengo la seguridad que
// la fila a la que hay que pasar es a la primera
// y la columna es a la siguiente.
// La fila primera = 0
// columna siguiente col++
if( ((fila+1)==fil) && ((columna+1)<fil) )
{
valor++;
columna++;
fila=0;
}
} // cierra do
while(valor<fil*fil);
//AQUI TUVO QUE HABER LLENADO LA MATRIZ

area.setText("");
// Esta parte imprime la matriz

for(int ii=0; ii<fil; ii++)
{
for(int jj=0; jj<col; jj++){
Integer auxiliar = new Integer(Matriz[ii][jj]);
String areas = new String(area.getText());
String matris = new String(auxiliar.toString()+" ");
area.setText(areas.concat(matris.toString())+"");
matris.concat(auxiliar.toString());
}
area.setText(area.getText()+"\n");
}
campo.setText("Que paso");
campo.setVisible(false);
boton1.setVisible(true);
campo.setText("");
contador++;
tamano = fil*col;
area.setVisible(true);
}
else
{
}//cierra comparo2==0 && contador==0
}
return true;
}
public MyApp()
{
this.addWindowListener (new WindowAdapter(){
public void windowClosing(WindowEvent e){
dispose();
System.exit(0);
}
});
Panel p = new Panel();

add(p);
//FLOWLAYOUT: 0 LEFT, 1 CENTER, 2 RIGHT
p.setLayout(new FlowLayout(1,10,10));
p.add(etiqueta);
p.add(campo);
p.add(area);
p.add(boton1);
p.show();
boton1.setVisible(false);
}
public static void main(String args[])

{

System.out.println("Starting App");
MyApp f = new MyApp();
f.setSize(400,300);
f.show();
}
}
1.6. MATRIZ DE TEXTFIELD
A continuación se muestra que no solo es posible construir matrices de tipos de datos,

ya sean objetos o tipos primitivos, sino que también es posible construir matrices de
otros objetos como TextField. En este ejercicio que viene a continuación se crea una
matriz de 8*8 TextField, los cuales se añaden a una cuadrícula utilizando el diseñador
GridLayout y se verifica a que diagonal pertenece dicho TextField y de acuerdo a ello,
se le coloca el número de la diagonal y se le coloca un color.
Veamos en primera medida el código y después la explicación del mismo:
/******************************************************************
: implementa una matriz de TextField. Tambien
: muestra como dibujar un tablero de ajedrez
: con dichos TextField y numerar las diagonales
Tipo: : El programa utiliza AWT de la clase APPLET
: No Maneja apuntadores, maneja matrices
: Es de tipo Applet
: El tamaño de la matriz es 8*8
******************************************************************/
import java.awt.*;

{
TextField textos[][] = new TextField[8][8];
Graphics graficos[][] = new Graphics[8][8];

{
g.drawString("Hello World", 20, 20);
}
public void init(){

setLayout(grilla);
for(int i = 0; i<8; i++){
for(int j = 0; j<8; j++){

double par;
par = (i+j) % 2;
textos[i][j] = new TextField();
add(textos[i][j]);
if(par == 1.0){
textos[i][j].setBackground(Color.green);
textos[i][j].setForeground(Color.black);
}
else{
textos[i][j].setBackground(Color.blue);
textos[i][j].setForeground(Color.white);
}
textos[i][j].setText(""+(i+j));
}
}
}
}
Para poder entender este ejemplo es necesario que se vea con detenimiento la
siguiente matriz:
Fila/Columna 0 1 2 3 4 5 6 7
0 4
1 4
2 4
3 4
4 4
5
6
7
Las celdas que tienen el número cuatro tienen algo en común y es que la suma de sus
índices suman cuatro. Veamos pues, la siguiente tabla mejorada:
Fila/Columna 0 1 2 3 4 5 6 7
0 0+4 0+7
=4 =7
1 1+3 1+6
=4 =7
2 2+2 2+5
=4 =7
3 3+1 3+4
=4 =7
4 4+0 4+3
=4 =7
5 5+2 5+7

=7 =12
6 6+1 6+6
=7 =12
7 7+0 7+5
=7 =12
A continuación se muestra un tablero de ajedrez y los números de sus diagonales

según lo visto anteriormente:
Fila/Columna 0 1 2 3 4 5 6 7
0 0 1 2 3 4 5 6 7
1 1 2 3 4 5 6 7 8
2 2 3 4 5 6 7 8 9
3 3 4 5 6 7 8 9 10
4 4 5 6 7 8 9 1 11
0
5 5 6 7 8 9 1 1 12
0 1
6 6 7 8 9 1 1 1 13
0 1 2
7 7 8 9 1 1 1 1 14
0 1 2 3
Según esto para dibujar un tablero de ajedrez, es posible preguntar por la suma de los
indices (es decir de las posiciones de la fila y la columna) y posteriormente preguntar
si es par o si es impar para proceder a colocarle el color que se quiera. Es decir, se
debe adicionar una variable, en este caso una denominada “par”, la cual va a tomar el
residuo entre la suma de fila y columna con el numero dos. Es decir va a tomar el
siguiente valor:
Par = (i+j) mod 2 para todos los valores de i y todos los valores de j.
Al utilizar dicha variable veremos que la matriz con los valores de par toma la
siguiente forma:
Fila/Columna 0 1 2 3 4 5 6 7
0 0 1 0 1 0 1 0 1
1 1 0 1 0 1 0 1 0
2 0 1 0 1 0 1 0 1
3 1 0 1 0 1 0 1 0
4 0 1 0 1 0 1 0 1
5 1 0 1 0 1 0 1 0
6 0 1 0 1 0 1 0 1

7 1 0 1 0 1 0 1 0
Y por último, según dicho valor se toma la decisión de pintarlo de un color el

TextField y de otro color la letra. El fondo del TextField con la función
“setBackground()” y el color de la letra con la función “setForeground()”.
Ahora, si, para finalizar veamos gráficamente el resultado del programa en java
mostrado anteriormente:
0 1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9 10
4 5 6 7 8 9 1 11
0
5 6 7 8 9 1 1 12
0 1
6 7 8 9 1 1 1 13
0 1 2
7 8 9 1 1 1 1 14
0 1 2 3
1.7. DETALLANDO LAS DIAGONALES DE UNA MATRIZ
En el ejercicio anterior se mostraba como identificar la siguiente diagonal:
Fila/Columna 0 1 2 3 4 5 6 7
0 0 1 2 3 4 5 6 7
1 1 2 3 4 5 6 7 8
2 2 3 4 5 6 7 8 9
3 3 4 5 6 7 8 9 10
4 4 5 6 7 8 9 1 11
0
5 5 6 7 8 9 1 1 12
0 1
6 6 7 8 9 1 1 1 13
0 1 2
7 7 8 9 1 1 1 1 14
0 1 2 3

Es decir una diagonal en forma gráfica ascendente y hacia la derecha, tal como se
muestra en el siguiente gráfico:
Fila/Columna 0 1 2 3 4 5 6 7
0
1
2
3
4
5
6
7
Ahora nos proponemos identificar la siguiente diagonal:
Fila/Columna 0 1 2 3 4 5 6 7
0
1
2
3
4
5
6
7
Esta diagonal, también la podemos identificar mediante los índices, pero esta vez,
mediante la resta de sus índices, tal como se muestra a continuación:
Fila/Column 0 1 2 3 4 5 6 7
a
0 0-0 = 0 0 – 4 = -4
1 1-1 = 0 1-5 = -4
2 2-2 = 0 2-6 = -4
3 3-3 = 0 3-7 = -4
4 4-0 = 4 4-4 = 0
5 5-1 = 4 5-5 = 0
6 6-2 = 4 6-6 = 0
7 7-3 = 4 7-7 = 0

Los valores de las restas se muestran todos en el siguiente cuadro:
Fila/Columna 0 1 2 3 4 5 6 7
0 0 -1 -2 -3 -4 -5 -6 -7
1 1 0 -1 -2 -3 -4 -5 -6
2 2 1 0 -1 -2 -3 -4 -5
3 3 2 1 0 -1 -2 -3 -4
4 4 3 2 1 0 -1 -2 -3
5 5 4 3 2 1 0 -1 -2
6 6 5 4 3 2 1 0 -1
7 7 6 5 4 3 2 1 0
Ahora sólo restaria asignar a la variable par el valor del residuo, pero hay que tener en
cuenta que el operador “%” no funciona bien cuando el numerador es negativo y el
mod es positivo, con lo cual hay que preguntar quien es mayor. Es decir:
Si (i>j) par = (i-j ) % 2

Si No par = (j-i) % 2.
Con lo cual el programa definitivo que implementa esta tablero de ajedrez, pero
siguiendo la lógica de las diagonales descendentes, se muestra a continuación.
Veamos:
/******************************************************************
: implementa una matriz de TextField. Tambien
: muestra como dibujar un tablero de ajedrez
: con dichos TextField y numerar las diagonales
: Es de tipo Applet
******************************************************************/
import java.awt.*;

{

{
}
public void init(){

setLayout(grilla);
for(int i = 0; i<8; i++){
for(int j = 0; j<8; j++){
double par;
if(i>j){
par = (i-j) % 2;
}
else{
par = (j-i) % 2;
}
add(textos[i][j]);
if(par == 1.0){
}
else{
}
textos[i][j].setText(""+(i-j));
}
}
}
}
Y el resultado gráfico, es el siguiente:
0 -1 -2 -3 -4 -5 -6 -7
1 0 -1 -2 -3 -4 -5 -6
2 3 0 -1 -2 -3 -4 -5
3 4 5 0 -1 -2 -3 -4
4 5 6 7 0 -1 -2 -3
5 6 7 8 9 0 -1 -2
6 7 8 9 1 1 0 -1
0 1
7 8 9 1 1 1 1 0
0 1 2 3
1.8. TRIANGULARES Y DIAGONALES DE UNA MATRIZ

Con todos los ejercicio hechos hasta el momento no es difícil entender que la fórmula
para identificar que un elemento se encuentre en una triangular o en una diagonal
específica, está dada por la siguiente tabla:
En donde se encuentra Forma para identificarlo con los indices de columna y fila
En la triangular superior Fila – columna < 0
En la triangular inferior Fila – columna > 0
En la diagonal ascendente Fila + Columna = máximo valor de indice de la matriz
cuadrada
En la diagonal descendente Fila = columna
Y la implementación de dicho programa no hace más que preguntar por estas

condiciones y de acuerdo a la respuesta coloca el TextField de un color o de otro.
Veamos pues el código fuente del ejercicio:
/******************************************************************
Descripcion : El siguiente programa muestra como se identifica
: las diagonales de una matriz.
: También se identifican los triangulos superior e
: e inferior formados por dichas diagonales
: Es de tipo Applet
******************************************************************/
import java.awt.*;

{

{
}
public void init(){

setLayout(grilla);
for(int i = 0; i<8; i++){
for(int j = 0; j<8; j++){
add(textos[i][j]);

if(i>j){
}
if(i<j){
}
if(i==j){
textos[i][j].setBackground(Color.red);
}
if( (i+j)==7){
textos[i][j].setBackground(Color.cyan);
}
textos[i][j].setText(""+(i-j));
}
}
}
}
El programa anterior produce el siguiente resultado:
0 -1 -2 -3 -4 -5 -6 -7
1 0 -1 -2 -3 -4 -5 -6
2 3 0 -1 -2 -3 -4 -5
3 4 5 0 -1 -2 -3 -4
4 5 6 7 0 -1 -2 -3
5 6 7 8 9 0 -1 -2
6 7 8 9 1 1 0 -1
0 1
7 8 9 1 1 1 1 0
0 1 2 3
1.9. PROGRAMA QUE COLOCA 15 MINAS EN UNA MATRIZ
La idea de esta parte del libro es ir dando elementos para desarrollar completamente el
problemas de un buscaminas, pero para poder hacerlo, es necesario que primero se
haga el ejercicio de colocar 15 minas en una matriz. La forma de hacerlo, es definiento
dos vectores denominados vectx[] y vecty[], los cuales contendrán 15 posiciones
vistas como parejas; es decir:
Posición 0 = matriz[vectx[0]][vecty[0]]

Y en dichas posiciones de la matriz estarán las minas. Ahora bien, por medio de unas
instrucciones, se garantiza que siempre se van a colocar 15 minas, es decir en 15
posiciones de la matriz estará el número “1” y en el resto, estará el número “0”. Las
instrucciones mencionadas son las siguientes:
for(int x=0;x<15;x++)
{
minasx = (int)(Math.random()*10);
minasy = (int)(Math.random()*10);
if(minas[minasx][minasy] != 1)
{
minas[minasx][minasy] = 1;
vecx[x] = minasx;
vecy[x] = minasy;
}
else x--;
}
El programa completo es el siguiente:
/******************************************************************
Descripcion : El siguiente programa muestra como se colocan
: quince unos en diferentes posiciones de una matriz
: para despues mostrarlos gráficamente
: Lo cual será util para desarrollar un buscaminas
: Es de tipo Applet
******************************************************************/

import java.awt.*;

{
Panel[][] paneles = new Panel[10][10];
Panel principal = new Panel();
Panel comandos = new Panel();
Button boton1 = new Button("Colocar 15 minas");
int numeros[][] = new int[10][10];
int minas[][] = new int[10][10];
int vecx[] = new int[15];
int vecy[] = new int[15];
int minasx, minasy;
{
for(int x=0;x<10;x++){
for(int y=0;y<10;y++){
minas[x][y] = 0;
}
}
{
{
vecx[x] = minasx;
vecy[x] = minasy;
}
else x--;
}
for(int i = 0; i<10; i++){

for(int j = 0; j<10; j++){
if(minas[i][j]== 1){
paneles[i][j].setBackground(Color.red);
}
else{
paneles[i][j].setBackground(Color.yellow);
}
}
}
// init();
}
public void init(){

setLayout(null);
principal.setLayout(grilla);
add(principal);
principal.setBounds(0,30,300,300);

add(comandos);
comandos.setBounds(0,0,100,30);
comandos.add(boton1);
boton1.addActionListener(new aleatorio());
for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
paneles[i][j] = new Panel();
principal.add(paneles[i][j]);
// paneles[i][j].setBackground(Color.green);
} // Cierra funcion init()
public class aleatorio implements java.awt.event.ActionListener{

if(ev.getSource() == boton1){
repaint();
} // Cierra if
} // Cierra aleatorio()
A manera de ejemplo, el programa anterior puede mostrar una pantalla similar a la

siguiente(similar, debido a que es aleatorio):
En donde los paneles de color rojo son los paneles que indican que existe una mina en
dicha posición.
1.10. PROGRAMA QUE COLOCA UN BUSCAMINAS DESCUBIERTO
Ahora intentaremos colocar en las posiciones alrededor de las minas los números
correpondientes al número de minas que debe tener cada posición. Es decir que se va a
colocar un valor para las posiciones cuya parte izquierda, derecha, inferior, superior o

diagonal en cualquier sentido tenga una mina. El programa mejorado con respecto al
anterior es pues, el siguiente:
/******************************************************************
Descripcion : El siguiente programa muestra como se colocan
: valores en las posiciones cercanas a las minas
: del anterior ejercicio
: Es el mismo programa anterior, pero mejorado
: Es de tipo Applet
******************************************************************/
import java.awt.*;

{
Label letreros[][] = new Label[10][10];
int minasx, minasy;
{
// Se inicializa la matriz en ceros
minas[x][y] = 0;
numeros[x][y] = 0;
}
}
// Se colocan solo 15 minas en la matriz

{
{
vecx[x] = minasx;

vecy[x] = minasy;
}
else x--;
}
// Se pintan las minas de rojo y el resto de amarillo

for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
paneles[i][j].setBackground(Color.red);
}
else{
paneles[i][j].setBackground(Color.yellow);
}
for(int i = 0; i<10; i++){

for(int j = 0; j<10; j++){
letreros[i][j].setText(" ");
letreros[i][j].setText("M");
}
// Si hay una mina a la derecha
if(j<9 && minas[i][j+1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
letreros[i][j].setText(""+numeros[i][j]);
}
// Si hay una mina abajo
if(i<9 && minas[i+1][j]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina a la izquierda
if(j>0 && minas[i][j-1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina arriba
if(i>0 && minas[i-1][j]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina arriba izquierda
if(i>0 && j>0 && minas[i-1][j-1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina arriba derecha
if(i>0 && j<9 && minas[i-1][j+1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina abajo a la izquierda
if(i<9 && j>0 && minas[i+1][j-1]==1 && minas[i][j]!= 1){

numeros[i][j]++;
}
// Si hay una mina abajo a la derecha
if(i<9 && j<9 && minas[i+1][j+1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
} // Cierra funcion paint()
public void init(){

setLayout(null);
add(principal);
add(comandos);
for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
letreros[i][j] = new Label(" ");
paneles[i][j].add(letreros[i][j]);

repaint();
} // Cierra if
A manera de ejemplo, el programa anterior muestra un resultado similar al siguiente:
1 M 2 2 1 1
1 1 2 2 M 3 M 1
1 M 1 1 2 M 2 1
1 2 2 1 1 1 2 1 1
2 4 M 2 1 M 1

M M M 2 1 1 2 1 1
2 3 2 1 1 M 2 1 1 1
1 2 M 2 2 M
1 1 1 1 2 M 2 1
1 M 1 1 1 1
1.11. PROGRAMA QUE IMPLEMENTA UN BUSCAMINAS
Ahora bien, después de haber analizado los dos anteriores programas, vemos que es
cuestión de ocultar las minas y de agregar una variable global que se llame
“comienzo”, la cual cuando tenga el valor de “1” es porque es el comienzo del
programa y cuando tenga el valor de “0”, es porque es el fin del programa. Entonces
como se verá en el siguiente programa, lo que se hace es añadir a la función “paint()”,
una pregunta para indagar por el valor de esta variable y si es el comienzo se juega. En
caso de ser el final, se buscan las minas y se muestran (con setVisible(true)),
utilizando para ello la matriz denominada “minas[][]”.
El siguiente es el código que se añade:
if(minas[x][y] == 1){
paneles[x][y].setBackground(Color.red);
letreros[x][y].setVisible(true);
//paneles[x][y].setBackground(Color.yellow);
}
También se agrega una función mouseDown, con la cual se pregunta en que panel se
hace clic y se compara si en dicha posición hay o no hay mina, si no hay mina, se va
descrubriendo el Label, tal como se muestra en el siguiente fragmento de código:
for(int i = 0; i<10; i++){

for(int j = 0; j<10; j++){
if(evt.target == paneles[i][j] && comienzo ==1){
if(minas[i][j] == 0){
letreros[i][j].setVisible(true);
visibles[i][j] = 1;
}
else{
comienzo = 0;
repaint();
}
} // Cierra if

Y en caso de ser una mina, se termina el juego colocando la variable comienzo en cero
y volviendo a llamar a la función “paint()”. Recordemos que cuando se llame a la
función “paint()” y la variable comienzo valga cero sencillamente se descubren todas
las minas.
También es bueno mencionar que ahora ya no es necesario pintar las minas de

diferente color cuando empieza el juego, por cuanto el chiste es que el usuario piense
donde están las minas. Por lo tanto el siguiente código:

for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
paneles[i][j].setBackground(Color.blue);
}
else{
}
fue reemplazado por:
for(int i = 0; i<10; i++){

for(int j = 0; j<10; j++){
Bueno, pero ahora para lograr un entendimiento global del programa veamos, el
programa completo que implementa un buscaminas:
/******************************************************************
Descripcion : El siguiente programa muestra como se implementa
: en su totalidad un buscaminas. Es la mejora a los
: dos ejercicios anteriores
: Es de tipo Applet
******************************************************************/
import java.awt.*;


{
Label letreros[][] = new Label[10][10];
int visibles[][] = new int[10][10];
int comienzo;
int minasx, minasy;
{
if(comienzo == 1){
// Se inicializa la matriz en ceros
minas[x][y] = 0;
numeros[x][y] = 0;
}
}
// Se colocan solo 15 minas en la matriz

{
{
vecx[x] = minasx;
vecy[x] = minasy;
}
else x--;
}

for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
letreros[i][j].setText(" ");
letreros[i][j].setText("M");
}

// Si hay una mina a la derecha

if(j<9 && minas[i][j+1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina abajo
if(i<9 && minas[i+1][j]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina a la izquierda
if(j>0 && minas[i][j-1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina arriba
if(i>0 && minas[i-1][j]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina arriba izquierda
if(i>0 && j>0 && minas[i-1][j-1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina arriba derecha
if(i>0 && j<9 && minas[i-1][j+1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina abajo a la izquierda
if(i<9 && j>0 && minas[i+1][j-1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
// Si hay una mina abajo a la derecha
if(i<9 && j<9 && minas[i+1][j+1]==1 && minas[i][j]!= 1){
numeros[i][j]++;
}
if(visibles[i][j]== 1){
}
else{
letreros[i][j].setVisible(false);
}
} // Cierra si comienzo == 1 SI INICIA JUEGO
else{
if(minas[x][y] == 1){
paneles[x][y].setBackground(Color.red);
letreros[x][y].setVisible(true);

//paneles[x][y].setBackground(Color.yellow);
}
} // Cierra si comienzo NO ES 1 "SI ES FINAL DE JUEGO"
public void init(){

setLayout(null);
add(principal);
add(comandos);
comienzo = 1;
for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
// paneles[i][j].addActionListener(new aleatorio());
letreros[i][j] = new Label(" ");
visibles[i][j] = 0;
paneles[i][j].add(letreros[i][j]);
public boolean mouseDown(Event evt, int x, int y){

for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){
if(evt.target == paneles[i][j] && comienzo ==1){
if(minas[i][j] == 0){
visibles[i][j] = 1;
}
else{
comienzo = 0;
repaint();
}
} // Cierra if
return false;
} // Cierra mouseDown

comienzo = 1;
for(int i = 0; i<10; i++){
for(int j = 0; j<10; j++){

visibles[i][j] = 0;
repaint();
} // Cierra if
// repaint();
}
1.12. PROGRAMA QUE ENSEÑA A DIVIDIR
El siguiente programa, funciona con algunos valores, la verdad no funciona con todos
los valores, por cuanto no se tuvo en cuenta el caso en el que al hacer la resta se
disminuye un valor. Es decir cubre el caso: 82-75 = 7 (El resultado tiene una cifra
menos que los operandos), pero no cubre los casos en los cuales el resultado tiene el
mismo número de digitos que los operandos. Por ejemplo para los siguientes casos
funciona:
44389 / 452
443892 / 45
369852 /587
Y para otros valores no funciona. Pero bueno, usted se estará preguntando porque en
un libro como este aparece un ejercicio que no funciona con todos los valores. La
respuesta es muy sencilla: ¡Es un ejercicio para que usted amigo lector practique con
las matrices y con la programación en Java!.
Bueno y para no hablar demasiado, veamos el ejercicio:
/******************************************************************
Descripcion : Programa que enseña a dividir
: Con algunos valores no funciona
: Si el problema sobrepasa el No de paneles
: produce un error de desbordamiento.
: Es de tipo Applet
******************************************************************/
import java.awt.*;

import java.util.Vector;
public class MyApp extends Applet implements

java.awt.event.ActionListener
{
int comienzo;
int cociente;
Panel pregunta = new Panel();
Panel respuesta = new Panel();
Label numerador = new Label("Dividendo");
Label denominador = new Label("Divisor");
Button boton1 = new Button("Calcular");
TextField operando1 = new TextField();
TextField operando2 = new TextField();
Vector dividendo[][] = new Vector[6][11];
Vector divisor[][] = new Vector[6][11];
TextField textos1[][] = new TextField[11][11];
int lon1; // Longitud del dividendo
int lon2; // Longitud del divisor
int lon3; // Longitud del cociente

{
int columnis = 1;

if(comienzo == 2){
// Este for es para hacer las restas sucesivas

for(int x = 0; x<11; x++){
int resta1 = 0;
int resta2 = 0;
int contador = 0;
int encontro = 0;
int inicial = 0;
for(int y = 0; y<11; y++){
if(numeros[x][y]== 99){
contador++;
if(encontro == 0){
inicial = y;
encontro = 1;
} // Cierra if interno
} // Cierra primer if
if(encontro == 1){
String cadena = new String("");
String cadena1 = new String("");
for(int j = inicial; j<(inicial+contador); j++){
String cad = new String(cadena+numeros[x-2][j]);
cadena = cad;
String cad1 = new String(cadena1+numeros[x-1][j]);
cadena1 = cad1;

}
int oper_resta1 = Integer.parseInt(cadena);
int oper_resta2 = Integer.parseInt(cadena1);
int subtotal = oper_resta1 - oper_resta2;
System.out.println(subtotal);
String sub_resta = new String(""+subtotal);
for(int j = 0; j<contador; j++){

numeros[x][j+columnis] =
Integer.parseInt(sub_resta.substring(j,j+1));
}
columnis++;
} // Cierra if encontro == 1
} // Cierra for externo para las restas
// Para graficar el resultado

for(int i = 0; i<11; i++){
for(int j = 0; j<11; j++){
if(numeros[i][j] >= 0){
textos1[i][j].setText(""+numeros[i][j]);
System.out.println("numeros["+i+"]["+j+"]="+numeros[i][j]);
}
else{
textos1[i][j].setVisible(false);
}
// Colorea el divisor
if(i== 0 && j>=6){
textos1[i][j].setBackground(Color.green);
}
// Colorea el cociente
if(i== 1 && j>=6){
textos1[i][j].setBackground(Color.yellow);
}
// Colorea el dividendo
if(i== 0 && j<6){
textos1[i][j].setBackground(Color.pink);
}
} // Cierra for externo para graficar
} // Cierra if comienzo == 2
public void init(){

setLayout(null);
comienzo = 1;
pregunta.setLayout(null);
respuesta.setLayout(null);
add(pregunta);
pregunta.setBounds(0,0,300,60);
pregunta.setBackground(Color.yellow);
pregunta.add(numerador);
pregunta.add(operando1);
numerador.setBounds(0,0,90,30);

operando1.setBounds(0,30,90,30);
pregunta.add(denominador);
pregunta.add(operando2);
denominador.setBounds(100,0,90,30);
operando2.setBounds(100,30,90,30);
pregunta.add(boton1);
boton1.setBounds(200,20,90,30);
boton1.addActionListener(this);
add(respuesta);
respuesta.setBounds(0,60,300,290);
respuesta.setBackground(Color.cyan);
respuesta.setLayout(grilla);
for(int i = 0; i<11; i++){
for(int j = 0; j<11; j++){
textos1[i][j] = new TextField("X");
respuesta.add(textos1[i][j]);
numeros[i][j] = -1;

if(ev.getSource() == boton1 && comienzo==1){
String op1 = new String(operando1.getText().trim());
String op2 = new String(operando2.getText().trim());
int arriba = Integer.parseInt(op1);
int abajo = Integer.parseInt(op2);
cociente = arriba/abajo;
String op3 = new String((new Integer(cociente)).toString());
lon1 = op1.length();
if(lon1>lon2 && lon1<7 && lon2>0 && lon1>0 && lon2<5){
comienzo = 2;
// Este for para colocar el dividendo
for(int m = 0; m<op1.length(); m++){
String aux = new String(""+op1.substring(m,m+1));
textos1[0][m].setText(aux.trim());
numeros[0][m] = Integer.parseInt(aux);
System.out.println(""+aux );
System.out.println("Bien dentro"+numeros[0][m]);
}
// Este for para colocar el divisor
for(int k = 0; k<op2.length(); k++){
String aux = new String(""+op2.substring(k,k+1));
textos1[0][k+6].setText(aux.trim());
numeros[0][k+6] = Integer.parseInt(aux);
System.out.println("Bien dentro"+numeros[0][k+6]);
}
// Este for para colocar el cociente
for(int n = 0; n<op3.length(); n++){
String aux = new String(""+op3.substring(n,n+1));

textos1[1][n+6].setText(aux.trim());
numeros[1][n+6] = Integer.parseInt(aux);
System.out.println("Bien dentro"+numeros[1][n+6]);
}
int columna = 0;
int longitud = 0;
int pos_cociente = 0;
int valor_cociente = 0;
// Este for para hacer las divisiones

for(int t = 0; t<op3.length(); t++){
String aux = new String(""+op3.substring(t,t+1));
valor_cociente = abajo*Integer.parseInt(aux);
String st_cociente = new String(""+valor_cociente);
for(int y = 0; y<st_cociente.length(); y++){
String au = new
String(""+st_cociente.substring(y,y+1));
numeros[t*2+1][columna+y] = Integer.parseInt(au);
// Para bajar la cifra
if(t>0 && y == 0){
numeros[t*2][columna+y+st_cociente.length()-1]=
numeros[0][columna+y+st_cociente.length()-1];
}
else{
if(t>0) numeros[t*2][columna+y-1] = 99;
}
}
columna++;
} // Cierra for que hace las divisiones
} // Cierra ir validador de entrada de datos
repaint();
} // Cierrra if externo si es boton1
} // Cierra mouseDown()
}
1.13. PROGRAMA QUE MUESTRA LOS MOVIMIENTOS DEL CABALLO EN EL AJEDREZ
Suponga un tablero de ajedrez de ocho por ocho como es lo común. ¿Se acuerda como
se mueve el caballo en un tablero de ajedrez?, pues bien, de lo que se trata es de hacer
la suposición que en el tablero de ajedrez, solamente existe un caballito y que dicho
caballito debe desplazarse por todo el tablero de ajedrez, recorriendo las 64 posiciones
del mismo, sin repetir posición. A continuación se muestra una solución a dicho
problema en el cual la posición inicial está marcada con el número uno (1) y la
posición siguiente que ocupa el mismo caballito es la indicada por el número dos (2),
y así sucesivamente. Veamos pues el cuadro:

37 56 25 2 27 40 15 4
24 1 38 57 14 3 28 41
55 36 13 26 39 58 5 16
12 23 64 59 50 47 42 29
35 54 49 46 63 60 17 6
22 11 62 51 48 45 30 43
53 34 9 20 61 32 7 18
10 21 52 33 8 19 44 31
La implementación es la siguiente.
/******************************************************************
Nombre : caballito.java
Descripcion : El siguiente programa implementa el juego
: del movimiento del caballo en el ajedrez
: de tal suerte que ocupe todas las casillas
Tipo: : El programa utiliza java.awt.* y java.applet.*
: No Maneja apuntadores, no maneja matrices
: Es de tipo Applet
: NO ES RECURSIVO
******************************************************************/
import java.awt.*;

{
int matriz[][] = new int[8][8];
int fila, columna, contador;
{
for(int i = 0; i<8; i++){
for(int j = 0; j<8; j++){
System.out.println("matriz["+i+"]["+j+"]="+matriz[i][j]);
}
public void valida(int fil, int col, int par1, int par2){
if(fil<8 && fil>=0 && col<8 && col>=0 && par1 == par2){
if(matriz[fil][col]==0){
matriz[fil][col] = par1;
System.out.println("fil="+fil+" col = "+col+ " par1 ="+par1);
fila = fil;
columna = col;
contador++;

} // Cierra if interno
} // Cierra if externo
} // Cierra funcion valida
public void init(){

fila = 1;
columna = 2;
contador = 0;
for(int i = 0; i<8; i++){

for(int j = 0; j<8; j++){
matriz[i][j] = 0;
for(int k= 1; k<=64; k++){

contador = k;
if(fila <= columna){
valida(fila-2,columna+1,contador, k);
valida(fila+1,columna+2,contador, k);
valida(fila+2,columna-1,contador, k);
valida(fila-1,columna-2,contador, k);
} // Cierra si fila <= columna
else{
} // Cierra else
}// Cierra for hasta k < 64
}
}
El programa anterior llena la siguiente matriz:
1 2 3 5 1 1 2 40
1 4 7 2 4 7
3 5 1 2 3 4 2 15
6 1 2 5 8 1
2 1 5 5 1 2 3 28
3 0 3 8 3 6 9
5 3 6 6 4 5 1 3
0 5 4 1 2 5 6

9 2 5 5 5 6 2 44
2 7 4 9 2 9
3 4 6 6 5 4 4 17
4 9 0 3 6 3
2 8 4 3 1 6 4 30
1 7 2 9 5
4 3 2 7 4 3 1 5
8 3 0 6 1 8
Bueno, se estará preguntando que este ejercicio soluciona el problema de otra forma,
la pregunta es: ¿existen muchas formas de solucionar el problema?. La respuesta es:
¡Si!, pues todo depende de la posición en la que empiece el movimiento del caballo en
el ajedrez. Surge entonces otra pregunta: ¿qué regla sigue el caballo para moverse por
el ajedrez?. La respuesta no es tan rápida e inmediata como se piensa, pues el
movimiento del caballito en el ajedrez, depende de la posición en la que se encuentre o
mejor dicho de la región del ajedrez en la que se encuentre actualmente el caballo.
Con todo lo expuesto anteriormente, es claro cuál es el problema y animo al amigo

lector / estudiante para que intente solucionar el problema manualmente y se dará
cuenta que no es tan rápido solucionarlo. Pues bien, muchas personas ya han
solucionado dicho problema y después de analizar los resultados han establecido
métodos y normas que debe seguir el caballo para lograr cubrir el ajedrez
completamente. Recordemos que el caballo no puede pasar por la misma posición dos
o más veces
Supongamos el caballo que se encuentra donde está la letra “X” en las casillas
blancas, las celdas sombreadas indican el número de fila o columna respectiva
Col 0 Col 1 Col 2 Col 3 Col 4 Col 5 Col 6 Col 7

Fila 0
Fila 1 X
Fila 2
Fila 3
Fila 4
Fila 5
Fila 6
Fila 7
En dicho tablero el caballo ubicado en esta posición se encuentra en una región que
cumple la siguiente condición: Fila <= Columna, con lo cual los movimientos que
puede hacer el caballo se evaluan en un orden especifico de acuerdo al primero que
sea válido y ese se ejecutará. El orden de los movimientos a evaluar para un caballo

que se encuentre en una posición que cumpla dicha condición es el mostrado en la

siguiente figura:

8 1
Region A
7 2
caballit
o
6 3
5 4
Y para las veces en que el caballo se encuentre en la diagonal inferior del tablero de
ajedrez, se debe seguir la evaluación de posibles movimientos en el orden mostrado
por la siguiente figura:
4 5
3 6
Region B
caballit
o
2 7
1 8
Recordemos que los movimientos se evalúan en este orden, y tan pronto se ejecuta un
movimiento por ser valido (no haber terminado el juego y estar la siguiente posición
sin pisar), los demás movimientos ya no se ejecutan y de acuerdo a la siguiente
posición se vuelve a mirar en que posición del ajedrez se encuentra el caballo y se
procede a continuar evaluando los movimientos según el caso.
Bueno, pero para llegar a ser un poco más didáctico analicemos la siguiente posición
que debe tomar el caballo que venimos trabajando:

Retroceder dos filas y avanzar dos columnas, no lo puede hacer debido a que se saldría
del tablero. El siguiente movimiento a evaluar es retroceder una fila y avanzar dos
columnas y este movimiento si lo puede hacer. A continuación se muestra la posición
resultado de hacer dicho movimiento y se marca con la letra “Y”. Veamos:


Fila 0 Y
Fila 1 X
Fila 2
Fila 3
Fila 4
Fila 5
Fila 6
Fila 7
Dado que el contador de nuestro programa comenzó con cero, es necesario hacer 64
movimientos y el uno se coloca en la posición Y, lo cual produce nuestro resultado:

Fila 0 11 24 37 52 1 14 27 40
Fila 1 36 51 12 25 38 41 2 15
Fila 2 23 10 53 58 13 26 39 28
Fila 3 50 35 64 61 42 55 16 3
Fila 4 9 22 57 54 59 62 29 44
Fila 5 34 49 60 63 56 43 4 17
Fila 6 21 8 47 32 19 6 45 30
Fila 7 48 33 20 7 46 31 18 5
Por el momento, se deja como ejercicio final al amigo lector / estudiante la

implementación de dicho ejercicio en forma gráfica, lo cual es bastante sencillo, pues
es únicamente ir colocando paneles de colores e ir cambiando el color de los paneles
mediante un hilo de acuerdo con los valores que están en dicha matriz, buscando
siempre el valor siguiente (con un hilo para que de la apariencia de irlos colocando
despacio). Bueno hay otras soluciones al problema pero es tarea de usted querido
estudiante / lector implementarlas con el fin de avanzar en el manejo de las matrices y
de java.
Bien, hay algo muy importante que resaltar con respecto al problema del movimiento
del caballo en el ajedrez, y es que no siempre utilizando el mismo algoritmo descrito
anteriormente se llega a una respuesta completa, es decir que cubra todas las casillas
del ajedrez. Osea que el algoritmo descrito funciona solo si la posición inicial está
entre la siguiente lista de posiciones:
(1,2), (2,3), (5,4), (6,5) y (6,7), donde las parejas (x,y) indican fila “x” y columna “y”.

Y para lograr un entendimiento más completo del problema, a continuación se muestra

una tabla en la que se describe el número de posiciones avanzadas por el caballo
cuando se comienza el programa en cada una de las diferentes posiciones del tablero
de ajedrez.
(0,0) = 12 (0,1) = 62 (0,2) = 62 (0,3) = 58 (0,4) = 62 (0,5) = 60 (0,6) = 56 (0,7) = 56

(1,0) = 58 (1,1) = 58 (1,2) = 64 (1,3) = 56 (1,4) = 54 (1,5) = 58 (1,6) = 62 (1,7) = 61
(2,0) = 24 (2,1) = 59 (2,2) = 58 (2,3) = 64 (2,4) = 56 (2,5) = 54 (2,6) = 58 (2,7) = 60
(3,0) = 58 (3,1) = 56 (3,2) = 56 (3,3) = 62 (3,4) = 58 (3,5) = 62 (3,6) = 60 (3,7) = 47
(4,0) = 47 (4,1) = 60 (4,2) = 62 (4,3) = 58 (4,4) = 60 (4,5) = 56 (4,6) = 56 (4,7) = 60
(5,0) = 54 (5,1) = 58 (5,2) = 60 (5,3) = 56 (5,4) = 64 (5,5) = 61 (5,6) = 62 (5,7) = 24
(6,0) = 63 (6,1) = 59 (6,2) = 58 (6,3) = 60 (6,4) = 56 (6,5) = 64 (6,6) = 56 (6,7) = 64
(7,0) = 56 (7,1) = 56 (7,2) = 60 (7,3) = 62 (7,4) = 58 (7,5) = 62 (7,6) = 58 (7,7) = 12
En donde las posiciones sombreadas son las descritas anteriormente.
1.14. MOVIMIENTOS DEL CABALLO EN EL AJEDREZ EN FORMA RECURSIVA
Ahora bien, sería necesario solucionar estos pequeños problemas para lograr que el
juego se pueda desarrollar independientemente de la posición inicial en la que se
comience el juego. La implementación de este juego para que funcione desde
cualquier posición en la que inicie el juego es la siguiente:
/******************************************************************
Nombre : caballito1.java
Descripcion : El siguiente programa implementa el juego
: del movimiento del caballo en el ajedrez
: de tal suerte que ocupe todas las casillas
: Es la mejora a la anterior implementacion
: Independiente de la posicion inicial de juego
Tipo: : El programa utiliza java.awt.* y java.applet.*
: No Maneja apuntadores, no maneja matrices
: Es de tipo Applet
: NO ES RECURSIVO
******************************************************************/
import java.awt.*;

{
int matriz1[][] = new int[8][8];
{
// boolean h = mover(0,0,1);

for(int i = 0; i<8; i++){

for(int j = 0; j<8; j++){
System.out.println("matriz1["+i+"]["+j+"]="+matriz1[i]
[j]);
public boolean mover(int filis, int columnis, int contar){

if(contar<=64)
{
if(filis<0)
return false;
if(filis>7)
return false;
if(columnis<0)
return false;
if(columnis>7)
return false;
matriz1[filis][columnis] = contar;
System.out.println("LF matriz1["+filis+"]
["+columnis+"]="+matriz1[filis][columnis]);
if(filis>columnis)
{
if(mover(filis+2,columnis-1,contar+1)||
mover(filis+1,columnis-2,contar+1)||mover(filis-1,columnis-
2,contar+1)||mover(filis-2,columnis-1,contar+1)||mover(filis-
2,columnis+1,contar+1)||mover(filis-1,columnis+2,contar+1) ||
mover(filis+1,columnis+2,contar+1) ||
mover(filis+2,columnis+1,contar+1))
return true;
} // Cierra if(filis>columnis)
else{
if(mover(filis-2,columnis+1,contar+1)||mover(filis-
1,columnis+2,contar+1)||mover(filis+1,columnis+2,contar+1)||
mover(filis+2,columnis+1,contar+1)||
mover(filis+2,columnis-1,contar+1)||mover(filis+1,columnis-
2,contar+1)||mover(filis-1,columnis-2,contar+1)||mover(filis-
2,columnis-1,contar+1))
return true;
} // Cierra else if(filis>columnis)
return false;
} // cont<=64
else
return true;
} // Cierra mover
public void init(){

boolean h = mover(1,4,1);

} // Cierra funcio init()

} // Cierra class MyApp
Como podrá apreciar estimado lector / estudiante, este ejercicio fue desarrollado
implementando la recursividad y funciona para cualquier posición inicial.
1.15. EJERCICIO DE MULTIPLICACIÓN DE MATRICES
Este programa de Java multiplica una matriz con su matriz

transpuesta. El tamaño de la matriz inicial es de 3*4 y dicha matriz
puede ser digitada por el usuario. Finalmente cuando el usuario
presiona el botón con el rótulo "ELEVAR", se multiplica dicha matriz
por su transpuesta y el resultado se muestra en el panel derecho.
import java.awt.*;
public class MyApp extends Applet implements ActionListener

{
TextField t1[][] = new TextField[3][4];
TextField t2[][] = new TextField[4][4];
int A[][] = new int[3][4];
int B[][] = new int[4][3];
int C[][] = new int[4][4];
GridLayout g0 = new GridLayout(1,3,2,2);
Button b = new Button("ELEVAR");
public void init()

{
setLayout(g0);
add(p1);
add(b);
add(p2);
p1.setLayout(g1);
p2.setLayout(g2);
b.addActionListener(this);
for(int j = 0; j<4; j++){

for(int i = 0; i<3; i++){
t1[i][j] = new TextField(" "+i+""+j);

p1.add(t1[i][j]);
String m_a = t1[i][j].getText().trim();
A[i][j] = Integer.parseInt(m_a);
B[j][i] = A[i][j];
}
}
for(int x = 0; x<4; x++){
for(int y = 0; y<4; y++){
t2[x][y] = new TextField(" "+x +" " +y);
p2.add(t2[x][y]);
}
} // Cierra init

System.out.println("Me poncharon");
if(ev.getSource()==b){
for(int j = 0; j<4; j++){

for(int i = 0; i<3; i++){
String aux = t1[i][j].getText().trim();
A[i][j] = Integer.parseInt(aux);
B[j][i] = A[i][j];
for(int x = 0; x<4; x++){

for(int y = 0; y<4; y++){
C[x][y]= 0;
String aux = "";
for(int k = 0; k<3; k++){
C[x][y] = C[x][y] + A[k][y]*B[x][k];
aux = aux + "A["+k+"]["+y;
aux = aux + "]*B["+x+"]["+k;
aux = aux + "]="+(A[k][y]*B[x][k]);
System.out.println(aux);
}
t2[x][y].setText(""+C[x][y]);
aux = "Resultado de C["+x+"]["+y;
aux = "]"+C[x][y];
}
} // Cierra if
} // Cierra applet
El anterior programa, gráficamente muestra una pantalla similar a la siguiente:

Observe amigo lector / estudiante que en la parte izquierda aparecen

unas cajas de texto ubicadas en una estructura de 4 filas y 3
columnas. En realidad dichas cajas fueron colocadas en el panel
denominado “p1”. De otra parte es interesante que el amigo lector /
estudiante observe que en la parte derecha se muestran otras cajas de
texto en una estructura de 4 filas y de 4 columnas. Estas cajas
fueron pues colocadas en el panel “p2”. Observemos también que en el
centro, se encuentra un botón que tiene el rótulo “ELEVAR”. Dicho
botón está asociado con la función actionPerdormed, de tal suerte que
cuando sea presionado active la ejecución de tal función.
Algunas personas dirán que porqué se crearon dos matrices de objetos

tipo TextField y la razón fundamental, es la simple comodidad de
programación.
Tengamos en cuenta que en la función INIT() del programa anterior se colocan los
objetos de interfaz y esto se hace con el fin de lograr que los objetos aparezcan en el
preciso momento en el que se carga el applet, debido a que la función INIT() es la
primera que se ejecuta cuando se carga el applet.
De otra parte es bueno que se tenga en cuenta que sin importar lo que
el usuario digite en cualquiera de las cajas de texto de la parte
izquierda, en todos los casos siempre será tomado dicho valor como un
valor tipo String, lo cual obliga lógicamente a que sea convertido a
entero mediante las instrucciónes:
for(int j = 0; j<4; j++){

for(int i = 0; i<3; i++){

String aux = t1[i][j].getText().trim();

A[i][j] = Integer.parseInt(aux);
B[j][i] = A[i][j];
En las cuales se puede apreciar que se captura el valor digitado por

el usuario y se tiene la precaución de quitarle los espacios con la
función “trim()”. Después de lo cual, se convierte dicho valor a
entero con la función “parseInt()” de la clase “Integer” y dicho
valor es asignado a la matriz “A”. De otra parte como se decía en el
enunciado del ejercicio, es importante recordar que no se puede
elevar al cuadrado una matriz que no sea cuadrada, razón por la cual
se emplea el artificio de multiplicarla por su inversa. Pero antes de
multiplicar la matriz A por su matriz inversa es importante calcular
los valores de dicha matriz. Esto se logra básicamente con la última
instrucción mostrada anteriormente en el ciclo for.
Finalmente podemos pensar que ya se tienen los datos para multiplicar

la matriz por su inversa, puesto que en la matriz “A” , ha quedado la
matriz original convertida a entera y previamente digitada por el
usuario y en la matriz “B” ha quedado la matriz transpuesta que puede
multiplicarse obviamente con su matriz original.
Y antes de lanzarnos con el algoritmo en código de la multiplicación propiamente

dicha, se harán algunas precisiones que harán que el algoritmo sea lo más claro
posible.
En primera medida se dirá que para una matriz como la siguiente:
1 2 3
4 0 1
2 2 1
0 0 1
Que se multiplique con su inversa, es decir con la matriz siguiente:
1 4 2 0
2 0 2 0
3 1 1 1
Los términos de la matriz multiplicación se obtienen de la siguiente forma:
1*1+2*2+3*3 1*4+2*0+3*1 1*2+2*2+3*1 1*0+2*0+3*1

4*1+0*2+1*3 4*4+0*0+1*1 4*2+0*2+1*1 4*0+0*0+1*1
2*1+2*2+1*3 2*4+2*0+1*1 2*2+2*2+1*1 2*0+2*0+1*1
0*1+0*2+1*3 0*4+0*0+1*1 0*2+0*2+1*1 0*0+0*0+1*1

Con lo cual podemos observar que se dan las siguientes relaciones

teniendo en cuenta las posiciones de filas y columnas que varían y
que no varían. Veamos:
Para la matriz A, se tiene Para la matriz A, se tiene Para la matriz A, se tienePara la matriz A, se tiene
que varía la columna de que varía la columna de que varía la columna de que varía la columna de
la primera matriz y la primera matriz y la primera matriz y la primera matriz y
permanece la fila en 0. permanece la fila en 0. permanece la fila en 0. permanece la fila en 0.
Para la matriz B, se tiene Para la matriz B, se tiene Para la matriz B, se tienePara la matriz B, se tiene
que permanece en todo que permanece en todo que permanece en todo que permanece en todo
momento en la columna momento en la columna momento en la columna momento en la columna
0 y la fila es la que varia 1 y la fila es la que varia 2 y la fila es la que varia
3 y la fila es la que varia
Para la matriz A, se tiene Para la matriz A, se tiene Para la matriz A, se Para la matriz A, se tiene
que varía la columna de que varía la columna de tiene que varía la que varía la columna de
la primera matriz y la primera matriz y la primera matriz y
permanece la fila en 1. permanece la fila en 1.
columna de la permanece la fila en 1.
Para la matriz B, se tiene Para la matriz B, se tiene primera matriz y Para la matriz B, se tiene
que permanece en todo que permanece en todo permanece la fila en que permanece en todo
momento en la columna momento en la columna 1. momento en la columna
0 y la fila es la que varia 1 y la fila es la que variaPara la matriz B, se tiene 3 y la fila es la que varia
que permanece en todo
momento en la columna
Para la matriz A, se Para la matriz A, se tiene Para la matriz A, se tiene Para la matriz A, se tiene
tiene que varía la que varía la columna de que varía la columna de que varía la columna de
columna de la permanece la fila en 2. permanece la fila en 2. permanece la fila en 2.
primera matriz y Para la matriz B, se tiene Para la matriz B, se tiene Para la matriz B, se tiene
permanece la fila en que permanece en todo que permanece en todo que permanece en todo
2. momento en la columna momento en la columna momento en la columna
Para la matriz B, se tiene 0 y la fila es la que varia 2 y la fila es la que varia 3 y la fila es la que varia
Para la matriz A, se tiene Para la matriz A, se tiene Para la matriz A, se Para la matriz A, se tiene
que varía la columna de que varía la columna de tiene que varía la que varía la columna de
permanece la fila en 3. permanece la fila en 3.
columna de la permanece la fila en 3.
Para la matriz B, se tiene Para la matriz B, se tiene primera matriz y Para la matriz B, se tiene
que permanece en todo que permanece en todo permanece la fila en que permanece en todo
momento en la columna momento en la columna 3. momento en la columna
0 y la fila es la que varia 1 y la fila es la que varia Para la matriz B, se tiene 3 y la fila es la que varia
Es bueno que el amigo lector/ estudiante observe detenidamente los

números que se resaltan con negrilla en la anterior tabla para que
logre comprender la relación en términos generales que se presenta en
mencionada tabla de multiplicación:
El número de sumas que se hacen para obtener el valor de cada una de

las posiciones de la matriz multiplicación es igual a tres y de otra

parte se cumple que para todas las multiplicaciones de un término de

la matriz A, con otro término de la matriz B, se presenta que la
columna de la matriz A varía y la fila de la matriz B varía.
Con todo lo dicho anteriormente, podemos concluir que se debe hacer

dos ciclor for para ir recorriendo la matriz completamente y por cada
posición que se esté analizando se deben hacer tres operaciones de
suma teniendo en cuenta la norma anteriormente deducida. Tal
situación se muestra en código como sigue:
for(int x = 0; x<4; x++){

for(int y = 0; y<4; y++){
C[x][y]= 0;
String aux = "";
for(int k = 0; k<3; k++){
C[x][y] = C[x][y] + A[k][y]*B[x][k];
aux = aux + "A["+k+"]["+y;
aux = aux + "]*B["+x+"]["+k;
aux = aux + "]="+(A[k][y]*B[x][k]);
}
}
Obviamente el anterior código se debe ejecutar en alguna de las

funciones que manejen eventos para permitir que se multipliquen las
matrices cuando se presione el botón “ELEVAR” por parte del usuario.
1.16. TALLERES A DESARROLLAR SOBRE MATRICES
Con el fin de lograr que el amigo lector / estudiante profundice sobre las matrices a
continuación se presentan los ejercicios que se deben desarrollar para lograr un
completo cubrimiento del tema de arreglos bidimensionales:
Recordemos que una matriz por ejemplo de tamaño 6*6 tiene el siguiente aspecto:
Estructura de una matriz de 6*6

Columna 1 Columna 2 Columna 3 Columna 4 Columna 5 Columna 6
Fila 1 Poscion(1,1) Poscion(1,2 Poscion(1,3 Poscion(1,4 Poscion(1,5 Poscion(1,6)
) ) ) )
) ) ) )
) ) ) )


) ) ) )
) ) ) )
) ) ) )
También recordemos que las diagonales de una matriz gráficamente son:
DIAGONALES DE UNA MATRIZ

DD DA
DD DA
DD DA
DD DA
DA DD
DA DD
DA DD
DA DD
Donde “DA” = Diagonar ascendente y “DD” = Diagonar descendente

Condiciones:
En la diagonal ascendente
Fila + Columna = máximo valor de indice de la matriz cuadrada
En la diagonal descendente
Fila = columna
También recordemos que las triangulares de una matriz gráficamente son:
DIAGONALES DE UNA MATRIZ

TS TS TS TS TS TS TS
TS TS TS TS TS TS
TI TS TS TS TS TS
TI TI TS TS TS TS
TI TI TI TS TS TS
TI TI TI TI TS TS
TI TI TI TI TI TS
TI TI TI TI TI TI
Donde “TI” = Triangular inferior y “TS” = Triangular superior

Condiciones:
En la triangular superior
Fila - columna < 0

En la triangular inferior
Fila - columna > 0
Dadas las matrices A y B, siguientes:
Matriz A Matriz B
3 65
76 28
43 89
25 86
8 7
5 55
7 67
68 3
29 46
27 36
58 25
9 5
4 53
8 18
2 53
8 35
3 4
7 86
8 86
5 98
8 35
7 19
43 38
92 53
86 64
36 36
8 75
35 64
59 83
54 9
8 57

53 25
85 35
37 71
62 87
79 69
1) Hallar la suma de la matriz A con la matriz B

2) Elevar al cuadrado los elementos de la matriz A que se encuentran en la
triangular superior de la misma.
3) Elevar al cubo los elementos de la matriz B que se encuentran en la triangular
inferior de la misma
4) Hallar la diferencia de la matriz A con la B y de la matriz B con la A.
5) Hallar la multiplicación de la matriz A con la matriz B.
6) Hallar la transpuesta de la matriz A
7) Hallar la inversa de la matriz B
8) Determinar si la matriz A es escalonada
9) Hallar el determinante de la matriz A y el de la matriz B
10) Rotar 90° a la derecha a la matriz B

Los siguiente ejercicios muestran gráficamente en que consiste la rotación de una

matriz
Matriz original Matriz Rotada 90° a la derecha
53 4
5 43
34 35
54 53
35 89
87 68
23 87
25 5
43 93
68 87
87 23
64 34
4 72
89 64
93 24
72 54
Matriz original Matriz Rotada 90° a la izquierda
56 64
46 74
87 65
64 55
46 87
35 99
99 33
74 45
64 46
85 35

33 85
65 35
86 56
35 46
45 64
55 86
Matriz original Matriz rotada 180° (da igual a la

izquierda que a la derecha)
75
74 65
83 39
27 43
87
45
55 44
74 47
95 34
65
65
34 95
47 74
44 55
45
87
43 27
39 83
65 74
75
11) Rotar 180° a la matriz A y a la matriz B

12) Rotar a la izquierda 90° la matriz B
13) Rotar a la derecha 90° la matriz A
14) Encontrar el mayor elemento de la matriz A y de la matriz B y mostrar la
posición en la que se encuentra.
15) Encontrar el menor elemento de la matriz A y de la matriz B y mostrar la
posición en la que se encuentra.

2. EJERCICIO DE MATRIZ TIPO ESPIRAL
2.1. VERSIÓN 1
Este programa genera una matriz espiral:
1 1 1 1 1 1 1 1 1 1 1 1
1
1 2 2 2 2 2 2 2 2 2 2 2
1
1 2 3 3 3 3 3 3 3 3 3 2
1
1 2 3 4 4 4 4 4 4 4 3 2
1
1 2 3 4 5 5 5 5 5 4 3 2
1
1 2 3 4 5 6 6 6 5 4 3 2
1
1 2 3 4 5 6 7 6 5 4 3 2
1
1 2 3 4 5 6 6 6 5 4 3 2
1
1 2 3 4 5 5 5 5 5 4 3 2
1
1 2 3 4 4 4 4 4 4 4 3 2
1
1 2 3 3 3 3 3 3 3 3 3 2
1
1 2 2 2 2 2 2 2 2 2 2 2
1
1 1 1 1 1 1 1 1 1 1 1 1
1

import java.awt.*;
public class MyApp extends Applet implements ActionListener

{
Button b1 = new Button("OK");
TextArea ta = new TextArea(" ");
BorderLayout g1 = new BorderLayout(10,15);
String cad = "";
int N = 13;
int matrix[][] = new int[13][13];
public void init()

{
setLayout(g1);
add("North",b1);
add("Center",ta);
b1.addActionListener(this);
public void actionPerformed(ActionEvent ev)

{
int mitad = N/2;
int cont = 1;
int total=1;
if(i<=mitad){
matrix[i][j] = j+1;
total = i+1;
}
else{
if(j>mitad){
matrix[i][j]= N-i;
total = N-i;
}
}
}// Cierra for medio
for(int x=0;x<N;x++){
if(x<total){
matrix[x][i]=x+1;
// matrix[x][i]=200;
System.out.println("matriz["+x+"]["+i+"]= "+ matrix[x]
[i]);
}
else{
if(x>(N-total)){
matrix[x][i]=N-x;
System.out.println("matriz["+x+"]["+i+"]= "+ matrix[x]
[i]);
}

else{
matrix[x][i]=total;
System.out.println("matrixxz["+x+"]["+i+"]= "+ matrix[x]
[i]);
}
} // Cierra else if(j<total)
} // Cierra for(int x=0;x<N;x++)
System.out.println("re");
System.out.println("matriz["+i+"]["+j+"]= "+ matrix[i][j]);
cad = cad + matrix[i][j];
cad = cad + "\t";
}
cad = cad + "\n";
}
ta.setText(cad);
} // Cierra clase MyApp
El anterior ejercicio muestra una interfaz similar a la siguiente:
De tal suerte que cuando se presiona el botón con la etiqueta “OK”,

se ejecutan las instrucciones que se encuentran en la función
“actionPerformed()” y el resultado de dicha ejecución de
instrucciones, se muestra al amigo lector / usuario en forma similar
a la siguiente:

Obviamente el programa anterior no es óptimo, por cuanto

es posible disminuir el número de líneas de código y el
número de recursos utilizados por el mismo a fin de
conseguir una versión mejor del programa. De deja al
amigo lector / estudiante la tarea de verificar por qué
el programa anterior produce una matriz tipo espiral y de
explicar completamente el programa
2.2. VERSIÓN 2
Como se había comentado en páginas anteriores cuando se mostraban las

primeras versiones del programa que implementaba la matriz en
espiral, se dijo que era posible optimizar dicho algoritmo. Pues
bien, es interesante observar que para desarrollar un algoritmo que
solucione el problema de la matriz en espiral, existen múltiples
formas de hacerlo y en esta sección se muestra una de las posibles
formas de solucionar dicho problema.
En primera medida, se parte diciendo que en una matriz cuadrada se

pueden notar que existen dos diagonales notables. La diagonal
principal que gráficamente es la siguiente:
1 0 0 0 0 0 0
0 1 0 0 0 0 0
0 0 1 0 0 0 0
0 0 0 1 0 0 0
0 0 0 0 1 0 0
0 0 0 0 0 1 0
0 0 0 0 0 0 1
En la que los elementos de dicha diagonal cumplen la condición:

Fila = Columna
Los elementos que se encuentran debajo de la diagonal

principal cumplen la condición: Fila > Columna y los
elementos que se encuentran sobre la diagonal principal
cumplen la condición: Fila < Columna
Y la diagonal secundaria que gráficamente es la siguiente:
0 0 0 0 0 0 1
0 0 0 0 0 1 0
0 0 0 0 1 0 0
0 0 0 1 0 0 0
0 0 1 0 0 0 0
0 1 0 0 0 0 0
1 0 0 0 0 0 0
En la cual los elementos de dicha diagonal cumplen la condición:
Fila + Columna = N, donde el tamaño de la matriz es N x N
Los elementos que se encuentran debajo de la diagonal

secundaria cumplen la condición: Fila + Columna > N y
los elementos que se encuentran sobre la diagonal
secundaria cumplen la condición: Fila + Columna < N
Ahora bien, después de haber comprendido los conceptos fundamentales

de las diagonales y los elementos que se encuentran encima y debajo
de dichas diagonales, es posible deducir que los elementos que se
encuentran en la siguiente matriz:
0 0 0 0 0 0 1
0 0 0 0 0 1 0
0 0 0 0 1 0 0
0 0 0 1 0 0 0
0 0 1 0 0 0 0
0 1 0 0 0 0 0
1 0 0 0 0 0 0

Deben cumplir las siguientes condiciones:
• Fila > =Columna

• Fila + Columna < =N
Por cuanto se encuentran debajo de la diagonal principal y sobre la diagonal

secundaria, incluyendo las diagonales
Para lograr mayor claridad en la aplicación de estos conceptos, a

continuación se muestra un programa sencillo que crea una matriz de
TextField, los coloca en forma cuadriculada sobre un applet y
posteriormente pinta de color turquesa los elementos que se
encuentran debajo de la diagonal principal y sobre la diagonal
secundaria.
Veamos pues el programa:
import java.awt.*;

{
TextField matriz[][] = new TextField[13][13];

{
}
public void init(){

setLayout(grilla);
for(int i = 0; i<13; i++){
for(int j = 0; j<13; j++){
matriz[i][j] = new TextField();
add(matriz[i][j]);
if(i>=j && (i+j)<13){

matriz[i][j].setBackground(Color.cyan);
matriz[i][j].setForeground(Color.black);
matriz[i][j].setText(""+(j+1));
} // Cierra if
} // Cierra init()
} // Cierra class MyApp
Es importante notar que el valor que se coloca en las cajas de texto

es un valor que corresponde al número de la columna, aumentado en

uno, debido a que se debe comenzar con el número “1”, pero por la
naturaleza de las matrices en los diversos lenguajes de programación,
la primera posición es la posición “0”. También es bueno notar que se
pinta dicha caja de texto, pero se muestran todas las cajas de texto.
Obviamente las que no cumplen la condición no se les asigna número y
tampoco se les coloca color de fondo, con lo cual el resultado
producido por el anterior programa es similar al siguiente:
Podríamos pensar en hacerle algunas modificaciones al programa

anterior con el fin de implementar el programa de las matrices en
espiral. Para esto, basta con agregar otras tres condiciones al
programa. A continuación se muestran en mayor detalle dichas
condiciones.
PARA EL TRIANGULO SUPERIOR (Que es diferente a la triangular superior)
1 1 1 1 1 1 1 1 1 1 1 1 1
0 2 2 2 2 2 2 2 2 2 2 2 0
0 0 3 3 3 3 3 3 3 3 3 0 0
0 0 0 4 4 4 4 4 4 4 0 0 0
0 0 0 0 5 5 5 5 5 0 0 0 0
0 0 0 0 0 6 6 6 0 0 0 0 0
0 0 0 0 0 0 7 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
Se debe tener en cuenta que se encuentre sobre la diagonal secundaria y sobre la

diagonal primaria
if(j>=i && (i+j)<13){

matriz[i][j].setBackground(Color.blue);
matriz[i][j].setForeground(Color.white);
matriz[i][j].setText(""+(i+1));
}
PARA EL TRIANGULO DERECHO
0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 2 1
0 0 0 0 0 0 0 0 0 0 3 2 1
0 0 0 0 0 0 0 0 0 4 3 2 1
0 0 0 0 0 0 0 0 5 4 3 2 1
0 0 0 0 0 0 0 6 5 4 3 2 1
0 0 0 0 0 0 7 6 5 4 3 2 1
0 0 0 0 0 0 0 6 5 4 3 2 1
0 0 0 0 0 0 0 0 5 4 3 2 1
0 0 0 0 0 0 0 0 0 4 3 2 1
0 0 0 0 0 0 0 0 0 0 3 2 1
0 0 0 0 0 0 0 0 0 0 0 2 1
0 0 0 0 0 0 0 0 0 0 0 0 1
Se debe tener en cuenta que se encuentre sobre la diagonal primaria y debajo de la

diagonal secundaria
if(j>=i && (i+j+1)>=13){

matriz[i][j].setText(""+(13-j));
}
PARA EL TRIANGULO INFERIOR

0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 7 0 0 0 0 0 0
0 0 0 0 0 6 6 6 0 0 0 0 0
0 0 0 0 5 5 5 5 5 0 0 0 0
0 0 0 4 4 4 4 4 4 4 0 0 0
0 0 3 3 3 3 3 3 3 3 3 0 0
0 2 2 2 2 2 2 2 2 2 2 2 0
1 1 1 1 1 1 1 1 1 1 1 1 1
Se debe tener en cuenta que se encuentre debajo de la diagonal

secundaria y debajo de la diagonal primaria
if(i>=j && (i+j+1)>=13){

matriz[i][j].setText(""+(13-i));
}
Para terminar con esta sección, a continuación se muestra un programa

que tiene en cuenta en que posición o área de la matriz se encuentra
y de acuerdo a esto, le coloca un valor y un color a dicho “TextArea”
de tal suerte que se implemente en forma total el algoritmo para
solucionar el problema de la matriz en espiral. Veamos pues el
programa completo:
import java.awt.*;

{
TextField matriz[][] = new TextField[13][13];

{
}
public void init(){

setLayout(grilla);
for(int i = 0; i<13; i++){
for(int j = 0; j<13; j++){
matriz[i][j] = new TextField();
add(matriz[i][j]);
if(i>=j && (i+j)<13){

}
if(j>=i && (i+j)<13){

matriz[i][j].setText(""+(i+1));
}
if(i>=j && (i+j+1)>=13){

matriz[i][j].setText(""+(13-i));
}
if(j>=i && (i+j+1)>=13){

matriz[i][j].setText(""+(13-j));
}
} // Cierra init()
} // Cierra MyApp
Observe amigo lector / estudiante que no todos los TextField fueron

coloreados del mismo color, con el ánimo de lograr la mayor
comprensión de este programa. A continuación se muestra una gráfica
que nos da una idea sobre los resultados que arroja el anterior
programa. Veamos:
Obsérvese que en este programa se van creando las cajas

de texto y al mismo tiempo se le asigna el valor y se
pinta de un color. A diferencia del programa de la
sección siguiente que implementa la matriz espiral con
matrices, y obviamente puede asignarle un valor a otra
posición de la matriz, sin importar si actualmente se
encuentre posicionado en dicho elemento de la matriz.

2.3. VERSIÓN 3
Este programa se realiza utilizando una matriz de enteros. Se

utilizan dos variables auxiliares de nominadas “izq” y “der”
inicializadas en “0” y “N” respectivamente. La idea es hacer un
recorrido vertical del vector, tal como muestra la siguiente figura:
La posición de la columna varía hasta que llegue a la mitad de la

matriz. Pues bien, si una variable aumenta y la otra disminuye, pues
obviamente se harán N/2 ciclos for. Ahora bien, cada ciclo for
comienza en un elemento ubicado en la diagonal principal, con lo cual
se cumple que:
Fila = Columna
Es decir que dentro del ciclo for, la fila en la que comienza debe
ser la columna en la que se encuentra ubicado. La columna está dada
por la variable “izq”, es decir que la fila en la que comienza el
ciclo for debe ser también la que tiene la variable “izq” y dado que
la variable “der” va disminuyendo conforme aumenta la variable “izq”,
está tendrá el límite hasta el cual se va a recorrer verticalmente el
vector.
Para no ir más lejos con las explicaciones, podemos decir que las
siguientes instrucciones:
int izq = 0;
int der = N;
while (izq < der){
for(int i=izq;i<der;i++){
Espi[i][izq] = izq+1;
}
izq++;
der--;
}
Colocan los números {1,2,3,4,5,6} en algunas posiciones de la matriz,

tal como muestra la siguiente gráfica:
1 0 0 0 0 0 0 0 0 0 0 0 0
1 2 0 0 0 0 0 0 0 0 0 0 0
1 2 3 0 0 0 0 0 0 0 0 0 0

1 2 3 4 0 0 0 0 0 0 0 0 0
1 2 3 4 5 0 0 0 0 0 0 0 0
1 2 3 4 5 6 0 0 0 0 0 0 0
1 2 3 4 5 6 7 0 0 0 0 0 0
1 2 3 4 5 6 0 0 0 0 0 0 0
1 2 3 4 5 0 0 0 0 0 0 0 0
1 2 3 4 0 0 0 0 0 0 0 0 0
1 2 3 0 0 0 0 0 0 0 0 0 0
1 2 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0 0 0 0
El triangulo de la derecha se calcula sacando el

complemento. Es decir, si hay una posición “Espi[i]
[izq]” no su transpuesto, sino su inverso o complemento
es la posición “Espi[N-i-1][N-izq-1]”
De forma análoga, las instrucciones siguientes:
int izq = 0;
int der = N;
while (izq < der){
Espi[izq][i] = izq+1;
}
izq++;
der--;
}

1 1 1 1 1 1 1 1 1 1 1 1 1
0 2 2 2 2 2 2 2 2 2 2 2 0
0 0 3 3 3 3 3 3 3 3 3 0 0
0 0 0 4 4 4 4 4 4 4 0 0 0
0 0 0 0 5 5 5 5 5 0 0 0 0
0 0 0 0 0 6 6 6 0 0 0 0 0
0 0 0 0 0 0 7 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0

Que vendrían a ser los elementos transpuestos con respecto a los

elementos del triangulo de la izquierda anteriormente expuesto.
El triangulo de abajo se calcula sacando el complemento.

Es decir, si hay una posición “Espi[izq][i]” no su
transpuesto, sino su inverso o complemento es la posición
“Espi[N-izq-1][N-i-1]”
Las instrucciones:
int izq = 0;
int der = N;
while (izq < der){
Espi[N-i-1][N-izq-1] = izq+1;
}
izq++;
der--;
}

0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 2 1
0 0 0 0 0 0 0 0 0 0 3 2 1
0 0 0 0 0 0 0 0 0 4 3 2 1
0 0 0 0 0 0 0 0 5 4 3 2 1
0 0 0 0 0 0 0 6 5 4 3 2 1
0 0 0 0 0 0 7 6 5 4 3 2 1
0 0 0 0 0 0 0 6 5 4 3 2 1
0 0 0 0 0 0 0 0 5 4 3 2 1
0 0 0 0 0 0 0 0 0 4 3 2 1
0 0 0 0 0 0 0 0 0 0 3 2 1
0 0 0 0 0 0 0 0 0 0 0 2 1
0 0 0 0 0 0 0 0 0 0 0 0 1
Y finalmente las instrucciones:
int izq = 0;
int der = N;
while (izq < der){
Espi[N-izq-1][N-i-1] = izq+1;

}
izq++;
der--;
}

0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 7 0 0 0 0 0 0
0 0 0 0 0 6 6 6 0 0 0 0 0
0 0 0 0 5 5 5 5 5 0 0 0 0
0 0 0 4 4 4 4 4 4 4 0 0 0
0 0 3 3 3 3 3 3 3 3 3 0 0
0 2 2 2 2 2 2 2 2 2 2 2 0
1 1 1 1 1 1 1 1 1 1 1 1 1
Finalmente, es bueno que el amigo lector / estudiante observe que los

cuatro ciclos while y for expuestos son idénticos, excepto en la
línea que asigna el valor. Con ello se puede notar que es posible
simplificar el algoritmo aún más, incluyendo las cuatro líneas
expuestas anteriormente juntas en el mismo ciclo. Con lo cual la
función, quedaría como se muestra a continuación:
int izq = 0;
int der = N;
while (izq < der){
//Triangulo de la izquierda
// Triangulo de arriba
// Triangulo de abajo
// Triangulo de la derecha
}//Cierra for(int i=izq;i<der;i++)
izq++;
der--;
} // Cierra while
y produciría el resultado:
1 1 1 1 1 1 1 1 1 1 1 1 1
1 2 2 2 2 2 2 2 2 2 2 2 1
1 2 3 3 3 3 3 3 3 3 3 2 1

1 2 3 4 4 4 4 4 4 4 3 2 1
1 2 3 4 5 5 5 5 5 4 3 2 1
1 2 3 4 5 6 6 6 5 4 3 2 1
1 2 3 4 5 6 7 6 5 4 3 2 1
1 2 3 4 5 6 6 6 5 4 3 2 1
1 2 3 4 5 5 5 5 5 4 3 2 1
1 2 3 4 4 4 4 4 4 4 3 2 1
1 2 3 3 3 3 3 3 3 3 3 2 1
1 2 2 2 2 2 2 2 2 2 2 2 1
1 1 1 1 1 1 1 1 1 1 1 1 1
Para terminar se muestra al lector el programa completo más óptimo

para solucionar el problema de la matriz en espiral. Veamos pues:
import java.awt.*;
public class MyApp extends Applet implements ActionListener{

int Espi[][]=new int [13][13];
Button b1=new Button("ESPIRAL");
TextArea ta=new TextArea ( );
BorderLayout g1=new BorderLayout (1,2);
final int N=13;
int fila=1;
int cont1=0;
int i=0;
public void init(){

setLayout(g1);
setBackground(Color.yellow);
add("Center", ta);
add("North", p1);
p1.add(b1);
b1.addActionListener(this);
b1.setBackground(Color.green);
} // Cierra init
public void actionPerformed(ActionEvent ev)

{
if (ev.getSource() == b1){
int izq = 0;
int der = N;
while (izq < der){
//Triangulo de la izquierda
// Triangulo de arriba
// Triangulo de abajo

// Triangulo de la derecha
}//Cierra for(int i=izq;i<der;i++)
izq++;
der--;
} // Cierra while
String cad10= "";

for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
cad10 = cad10 + Espi[i][j];
cad10 = cad10 + "\t";
cad10 = cad10 + "\n";
ta.setText(cad10);
} // if (ev.getSource() == b1)
} // Cierra ActionPerformed
} // Cierra MyApp
Que muestra una interfaz similar a la siguiente:
En la cual el usuario puede presionar el botón con el rótulo

“ESPIRAL” y se obtiene un resultado similar al siguiente:





TABLA DE CONTENIDO
1. PRIMEROS EJERCICIOS CON MATRICES.........................................................11

1.1. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y NO
DINAMICA..............................................................................................................11
1.2. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y
DINAMICA..............................................................................................................12
1.3. PROGRAMA QUE PIDE CADA UNO DE LOS VALORES DE UNA
MATRIZ...................................................................................................................14
1.4. PROGRAMA QUE CALCULA LA TRANSPUESTA DE UNA MATRIZ....17
1.5. MATRIZ MAGICA...........................................................................................24
1.6. MATRIZ DE TEXTFIELD...............................................................................28
1.7. DETALLANDO LAS DIAGONALES DE UNA MATRIZ.............................31
1.8. TRIANGULARES Y DIAGONALES DE UNA MATRIZ..............................34
1.9. PROGRAMA QUE COLOCA 15 MINAS EN UNA MATRIZ.......................36
1.10. PROGRAMA QUE COLOCA UN BUSCAMINAS DESCUBIERTO..........39
1.11. PROGRAMA QUE IMPLEMENTA UN BUSCAMINAS.............................43
1.12. PROGRAMA QUE ENSEÑA A DIVIDIR.....................................................48
1.13. PROGRAMA QUE MUESTRA LOS MOVIMIENTOS DEL CABALLO EN
EL AJEDREZ...........................................................................................................52
1.14. MOVIMIENTOS DEL CABALLO EN EL AJEDREZ EN FORMA
RECURSIVA............................................................................................................60
1.15. EJERCICIO DE MULTIPLICACIÓN DE MATRICES................................62
1.16. TALLERES A DESARROLLAR SOBRE MATRICES.................................67
2. EJERCICIO DE MATRIZ TIPO ESPIRAL............................................................73
2.1. VERSIÓN 1.......................................................................................................73
2.2. VERSIÓN 2.......................................................................................................76
2.3. VERSIÓN 3.......................................................................................................83
TABLA DE CONTENIDO...........................................................................................93

Pais: Colombia
Teléfono principal: 2780615
Teléfono auxiliar: 2004217
Dirección de Correo Permanente: luchofelipe2000@yahoo.com
Dirección de Correo Trabajo: lwanumen@udistrital.edu.co
Dirección física: Facultad Tecnológica – Universidad Distrital
Sitio Personal: Gemini.udistrital.edu.co/comunidad/profesores/lwanumen
Cualquier parecido de esta obra con alguna existente es

pura casualidad, por cuanto el desarrollo de la misma
fue inédita y personal.
Enciclopedia Conociendo
 Luis Felipe Wanumen Silva
Copyright Enero de 2004
ISBN En proceso de registro
Edición autorizada para venta en Colombia
Impreso en Colombia – Printed in Colombia
Derechos Reservados
Los derechos de publicación en cualquier lengua de
cualquier tomo de la Enciclopedia Conociendo, no han
sido transferidos a editor alguno. El editor solamente
está autorizado para imprimir 1000 ejemplares y
vendérselos únicamente al autor.
Prohibida su reproducción parcial o total por cualquier

medio sin permiso escrito del propietario de los
derechos de copyright
NOTA IMPORTANTE
El autor no será jurídicamente responsable por daños y
perjuicios causados en datos, archivos, información o
hardware por el uso directo o indirecto ya sea correcto
o incorrecto del presente material.
Carátula, arte y diseño:

Luis Felipe Wanumen Silva

Impresión
Editorial Kimpres Ltda.
Tels: 260 1680 – 4 13 6884

JAVAMATRICESTOMOLXI

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

JAVAMATRICESTOMOLXI

Încărcat de

Drepturi de autor:

Formate disponibile

Autor: Luis Felipe Wanumen Silva 1

LUIS FELIPE WANUMEN SILVA

PRIMERA VERSIÓN AUN NO REVISADA

Enciclopedia Conociendo Java Matrices

Enciclopedia Conociendo Java Matrices

Incluye un CD con los

Enciclopedia Conociendo Java Matrices

De antemano, quiero decir que mi deseo siempre habia sido el poder

Gracias al Ingeniero Miller por haber confiado en mí y haberme dado

Enciclopedia Conociendo Java Matrices

Ingeniero de Sistemas egresado de la Universidad Distrital Francisco

Luis Felipe es un Ingeniero que se ha caracterizado por ser un

Es una persona muy católica, y esto lo ha demostrado con su

Enciclopedia Conociendo Java Matrices

Este material está enfocado principalmente a personas que no tienen conocimiento de

Enciclopedia Conociendo Java Matrices

En primera medida, gracias a DIOS TODOPODEROSO por haberme dado salud,

Enciclopedia Conociendo Java Matrices

NORMAS PARA CLASE

1) Al final del semestre no se aceptan reclamos

Enciclopedia Conociendo Java Matrices

Enciclopedia Conociendo Java Matrices

Enciclopedia Conociendo Java Matrices

1. PRIMEROS EJERCICIOS CON MATRICES

1.1. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y NO DINAMICA

public class MyApp extends Applet

Enciclopedia Conociendo Java Matrices

public void paint(Graphics g)

y+=22; // avanzo 22 posiciones graficas en y

1.2. CREANDO INICIANDO E IMPRIMIENDO MATRIZ TIPO INT Y DINAMICA

public class MyApp extends Frame

public boolean action(Event evt, Object arg){

Enciclopedia Conociendo Java Matrices

etiqueta.setText("Digite numero filas");

Enciclopedia Conociendo Java Matrices

Panel p = new Panel();

public static void main(String args[])

Uno de los programas más interesantes en la parte de matrices es el relacionado con

Enciclopedia Conociendo Java Matrices

: El tamaño de la matriz es predeterminado

public class MyApp extends Applet

public void init(){

public class almacenar implements ActionListener{

if(pos_x==2 && pos_y==2){

if(pos_x<3 && pos_y<3){

Enciclopedia Conociendo Java Matrices

En términos de interfaz al usuario, el anterior programa tiene un aspecto similar al

Enciclopedia Conociendo Java Matrices

Al insertar el último valor obtenemos una interfaz similar a la siguiente:

1.4. PROGRAMA QUE CALCULA LA TRANSPUESTA DE UNA MATRIZ

Veamos en primera medida el programa:

public class MyApp extends Applet

Enciclopedia Conociendo Java Matrices

public class llena_matriz implements ActionListener{

En primera medida cabe anotar que la disposición de los elementos es la siguiente:

En donde podemos asegurar que en la parte superior se ha colocado un panel y en la

Enciclopedia Conociendo Java Matrices

Esto se logra con las instrucciones:

Enciclopedia Conociendo Java Matrices

Y esto se logra con las instrucciones:

Podríamos pensar que la asociación de un objeto tipo evento al botón se podría

Cuando se presione el boton b1, se activa la

Enciclopedia Conociendo Java Matrices

En primera medida la función “actionPerformed” contiene un primer if con las