PDF de programación - Clase adicional 8

Clase adicional 8

Temas

Métodos de matrices
o La clase Matrix
o Método de suma de matrices
o Método de producto de matrices

Sistemas lineales
Colas y pilas

o Biblioteca java.util
o La clase Stack
o Marco para las colecciones de Java
o Interfaz Queue

Métodos de matrices

En esta sección analizaremos algunos de los métodos de la clase Matrix tratados en el
material de clase.

La clase Matrix La clase Matrix es una clase de Java creada para representar y llenar
matrices. Se utiliza sobre todo para preparar matrices para su uso en la resolución de
sistemas lineales. Consta de:

§

Un array 2D de m filas por n columnas

private double[ ][ ] data = new double[m][n];

int nrows = data.length;

int ncols = data[0].length;

§ Métodos para operaciones con matrices, como la suma, la resta o la
multiplicación

Public Matrix addMatrices (Matrix b)

Public Matrix multMatrices (Matrix b)

Public void print ();

Suma de matrices

Dos matrices (a y b) se pueden sumar sólo si tienen el mismo número de filas y
columnas. El resultado es una nueva matriz. La base del proceso de suma es:

c[i][j] = a[i][j] + b[i][j];

Éste es el código

Public Matrix addMatrices (Matrix b)

{

//La matriz resultante

Matrix result = new Matrix(nrows, ncols);

//Sólo se suman si tienen el mismo número de filas y de columnas

if (b.nrows == nrows && b.ncols == ncols)

{

for (int i=0; i<nrows; i++)

for (int j=0; j<ncols; j++)

result.data[i][j] = data[i][j] + b.data[i][j];

}

return result;

}

Producto de matrices

Dos matrices se pueden multiplicar sólo si se cumple a.ncols = b.nrow. El resultado es
una nueva matriz. La base del proceso de multiplicación es:

Por ejemplo:

c[0][0] = a[0][0]* b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0] + …. +
a[0][ncols]*b[nrows][0];

Éste es el código

Public Matrix multMatrices (Matrix b)

{

//La matriz resultante tiene a.nrows por b.ncols

Matrix result = new Matrix(nrows, b.ncols);

//Se multiplica sólo si a.ncols = b.nrow

if (b.nrows == ncols)

{

for (int i=0; i<nrows; i++)

for (int j=0; j<b.ncols; j++)

for (int k=0; k<ncols; k++)

result.data[i][j]+= data[i][k] * b.data[k][j];

}

return result;

}

Sistemas lineales

En muchos problemas de ingeniería, se obtienen varias ecuaciones simultáneas: se
trata de un sistema de n ecuaciones con n incógnitas. Las matrices se suelen utilizar
para resolver sistemas lineales. La formulación es la siguiente:

AX=B

donde A es la siguiente matriz,

X = (x1, x2, ..., xn)

B = (b1, b2, ..., bn)'

Por ejemplo: 2X0 + 3X1 + 5X2 = 10

X0 + 2X1 + 4X2 = 5

4X0 + 7X1 + 3X2 = 15

A es una matriz de 3 por 3: 2 3 5

1 2 4

4 7 3

X es una matriz de 3 por 1: X0

X1

X2

B es una matriz de 3 por 1: 10

5

15

En el material de clase ya se abordó el proceso para derivar programas de Java y
poder resolver un sistema lineal. En esta ocasión, le enseñaremos cómo utilizarlo.
Básicamente, se divide en tres pasos:

1. Crear la matriz a de la izquierda
2. Crear la matriz b de la derecha
3.

Interconectar a y b en el método gaussiano de la clase Gauss

Sigamos ahora los pasos necesarios para resolver el problema anterior:

1.

Crear la matriz a de la izquierda

(Para simplificar el código, asumiremos que todos los arrays de las matrices son
públicos)

Matrix a = new Matrix(3,3);
a.data[0][0] = 2.0;
a.data[0][1] = 3.0;
a.data[0][2] = 5.0;
a.data[1][0] = 1.0;
a.data[1][0] = 2.0;
a.data[1][2] = 4.0;
a.data[2][0] = 4.0;
a.data[2][1] = 7.0;
a.data[2][2] = 3.0;

2.

Crear la matriz b de la derecha

Matrix b = new Matrix(3,1);
b.data[0][0] = 10.0;
b.data[1][0] = 5.0;
b.data[2][0] = 15.0;

3.

Interconectar a y b en el método gaussiano de la clase Gauss

Matrix result = new Matrix(3,1);
GaussMain.gaussian (a, b, result);

//Imprimir la solución

result.print();

Éste es el resultado

X0 = 6.0

X1 = -1.5

X2 = 0.5

Como puede ver, resolver un sistema lineal con la clase Gauss es realmente sencillo. Si
está interesado en saber más sobre el modo en que hemos derivado el método
gaussiano, consulte el apéndice

Colas y pilas

Una estructura de datos es una forma sistemática de organizar los datos y acceder a
ellos; ya hemos visto varias estructuras de datos simples en este curso (por ejemplo, los
arrays y los vectores). En esta sección (y en la siguiente clase adicional), le enseñaremos
a implementar algunas de las estructuras de datos tradicionales (Queue, Stack, Linked
List y Tree) con Java.

Biblioteca java.util

Antes del lanzamiento de la plataforma Java 2, la biblioteca java.util proporcionaba
un pequeño conjunto de clases para las estructuras de datos más útiles, como son
Vector, Stack y Hashtable:

La clase Vector implementa un array de objetos que crece con el tiempo. Al
igual que ocurre con un array, contiene componentes a los que se puede
acceder utilizando un índice integer. Sin embargo, el tamaño de un vector
puede crecer o reducirse tanto como sea necesario para poder agregar y
eliminar elementos una vez creado el vector.

La clase Stack representa una pila de objetos LIFO (el último en entrar es el
primero en salir). Proporciona un método de empuje para agregar un objeto en
la parte superior de la pila y un método de extracción para sacarlo.

Por su parte, la clase Hashtable almacena objetos como pares de clave y valor
a los que se puede tener acceso de forma aleatoria mediante la clave.

Clase Stack

Una pila es un contenedor de objetos que se insertan y se extraen siguiendo el principio
LIFO (el último en entrar es el primero en salir). Un ejemplo de este principio podría
ser una lata de pelotas de tenis. La última pelota introducida en la lata será la primera
que se pueda sacar. La clase java.util.Stack contiene los métodos siguientes:

void push(elemento Object)
introduce un elemento en la pila. Parámetros: el elemento que se va a agregar
Object pop()
extrae y devuelve el elemento superior de la pila. No llame a este método si la
pila está vacía.
Object peek()
devuelve la parte superior de la fila sin extraerla. No llame a este método si
la pila está vacía.

En el siguiente ejemplos, simularemos una lata de pelotas de tenis con dos clases:
TennisBall y TennisBallCan. En primer lugar, definiremos una clase simple TennisBall
que contenga un solo atributo: color.

class TennisBall{
String color;

TennisBall (String color){
this.color = color;
}

String getColor() {

return color;

}
}

A continuación, definiremos la clase TennisBallCan que utiliza una pila para organizar
las pelotas.

import java.util.*;
import TennisBall; class TennisBallCan {

public static void main (String args[]) {

//Crear 3 objetos de TennisBall

TennisBall t1 = new TennisBall ("roja") ;
TennisBall t2 = new TennisBall ("verde");

TennisBall t3 = new TennisBall ("amarilla")
Stack can = new Stack();

//Introducir las pelotas en la lata

System.out.println ("Pelota " + t1.getColor() + " dentro");
can.push (t1);
System.out.println ("Pelota " + t2.getColor() + " dentro");
can.push (t2) ;
System.out.println ("Pelota " + t3.getColor() + " dentro");
can.push (t3);
System.out.println ("Contenido de la lata: " + can.size());

//Echar un vistazo a la última pelota

System.out.println ("Color de la última pelota: color = " +

((TennisBall)can.peek()).getColor());

System.out.println ("Contenido de la lata tras el análisis: " + can.size());

//Extraer las pelotas

for (int i=0; i<3; i++)
System.out.println (("Pelota " + (TennisBall)can.pop()).getColor() + " fuera" );

}
}

Éste es el resultado

Pelota roja dentro

Pelota verde dentro

Pelota amarilla dentro

Contenido de la lata: 3

Color de la última pelota: amarilla

Contenido de la lata tras el análisis: 3

Pelota amarilla fuera

Pelota verde

fuera

Pelota roja fuera

Contenido de la lata tras la extracción: 0

Marco para las colecciones de Java

Presentado con la plataforma JavaTM 2, el marco para las colecciones de Java
proporciona un conjunto bien diseñado de interfaces y clases para almacenar y
manipular grupos de datos como una sola unidad: una colección. El marco ofrece una
API adecuada para muchos de los tipos de datos abstractos: mapas, conjuntos, listas,
árboles, arrays, tablas hash y otras colecciones. Por su diseño orientado a objetos, las
clases de Java de este marco de colecciones agrupan tanto las estructuras de datos
como los algoritmos asociados con estas abstracciones.

Tal como suele suceder con las bibliotecas de estructuras de datos actuales, la
biblioteca de la colección de Java separa las interfaces y las implementaciones. A
continuación, estudiaremos dicha separación con una estructura de datos familiar: la
cola. La biblioteca de Java no proporciona una clase de cola ni una interfaz, pero aun
así es un buen ejemplo para presentar los conceptos básicos.

Interfaz Queue

Una interfaz de cola especifica que se pueden añadir elementos al final de la cola,
eliminarlos de la cabecera y saber cuántos elementos existen en la cola. Utilizará la
cola cuando necesite recopilar objetos y recuperarlos según la secuencia “el primero
en entrar es el primero en salir”.

La interfaz Queue debe realizar las operaciones siguientes:

interface Queue{

void add(Object obj);
Object remove();
int size();
}

Observe que la interfaz no aporta ninguna información sobre el modo de
implementación de la cola. A continuación presentamos un ejemplo para ilustrar cómo
se puede implementar la interfaz Queue:

class TennisBallQueue implements Queue {

public void add(Object obj) { . . . }

public Object remove() { . . . }

public int size() { . . . }

}

NOTA: Si realmente necesita una cola, simplemente puede utilizar la clase
LinkedList de la biblioteca java.util. Entre otros métodos, LinkedList proporciona
las siguientes operaciones "similares a las de las colas":

void addLast(Object o)

Añade un elemento dado al final de la lista.

Object removeFirst()

Elimina y devuelve el primer elemento de la lista.

Hablare