public class Matriz { //Atributos
int[][] matriz;
//Constructor
public Matriz(int dim1, int dim2) { matriz = new int[dim1][dim2];
//Hacemos que la matriz se autorellene con numeros al azar
for (int i = 0; i < dim1; i++)
for (int j = 0; j < dim2; j++)
matriz[i][j] = (int)(Math.random()*100);
}
//Metodos
/**
* Este método recibe otro objeto de la clase Matriz y construye un vector
* con los valores que existen en esta Matriz, pero que no existen en la Matriz
* recibida como parametro.
* @param matrizB Objeto Matriz con el que compararemos valores.
* @return vector de enteros con los valores existente en esta matriz,
* y no existentes en la segunda matriz.
*/
public int[] getValoresNoRepetidos(Matriz matrizB) { /*
* La mecánica será recorrer esta matriz.
* Por cada valor, comprobaremos si existe en la otra matriz, que llamaremos matrizB.
* Para agilizar esta comprobación, nos apoyaremos en el método contieneValor()
* que se encargará de recorrer la matrizB cada vez que le pasemos un valor de esta matriz.
*
* Si el valor no existe en la matrizB, entonces este valor irá al vector que estamos construyendo.
* Aquí se nos presenta un problema: NO sabemos de antemano cuanto ha de medir el vector que estamos construyendo,
* porque no sabemos cuantos valores vamos a encontrar válidos para introducir en el vector.
* Podrían ser 5 valores, podrian ser 50, 10... o podría ser ninguno...
*
* Para esquivar este problema, podemos solucionarlo haciendo dos recorridos a las matrices A y B.
* El primer recorrido contaremos cuantos valores son válidos para introducir en el vector.
* Tras haber contado, ya podemos establecer el tamaño al vector.
* El segundo recorrido, introduciremos los valores en el vector.
*/
int contador = 0;
//Primer recorrido. Contar valores no existentes en matrizB para decidir el tamaño del vector.
for (int i = 0; i < matriz.length; i++)
for (int j = 0; j < matriz[0].length; j++)
if (!matrizB.contieneValor(matriz[i][j]))//Si matrizB NO contiene el valor de nuestra matriz...
contador++; //Aumentamos contador
//YA hemos contado. Ya sabemos que tamaño ha de tener el vector
int[] valores = new int[contador];
//Segundo recorrido.Los valores antes contados, ahora los introducimos en el vector.
//Necesitaremos un tercer indice para señalar las posiciones del vector donde hay que introducir los valores
int z = 0;
for (int i = 0; i < matriz.length; i++)
for (int j = 0; j < matriz[0].length; j++)
if (!matrizB.contieneValor(matriz[i][j]))
{ valores[z] = matriz[i][j];//Guardamos valor en el vector.
z++;//El indice del vector apunta al siguiente elemento para el próximo valor que haya que guardar
}
//Listo, podemos retornar el vector con los valores que existen en esta matriz, pero no existen en la matrizB
return valores;
}
/**
* Este método recibe un valor entero y comprueba si existe en la matriz.
* @param valor entero que queremos saber si está contenido.
* @return true si el valor existe en la matriz, false en caso contrario.
*/
public boolean contieneValor(int valor) { for (int i = 0; i < matriz.length; i++)
for (int j = 0; j < matriz[0].length; j++)
if (matriz[i][j] == valor)
return true;
//Si tras recorrer la matriz no se ha retornado true, es que el valor no existe en la matriz
return false;
}
/**
* Este metodo muestra los valores de la matriz en pantalla.
*/
public void mostrarMatriz() { for (int i = 0; i < matriz.length; i++)
{ for (int j = 0; j < matriz[0].length; j++)
System.out.printf("%2d ", matriz[i][j]);//Formateamos para que todos lo valores ocupen dos cifras en pantalla
System.out.println(); //Salto de linea
}
}
public static void main(String[] args) {
/*
* Creamos dos objetos de nuestra clase Matriz.
* Cada uno tendrá distintas dimensiones y se
* autorellenan ellos solos con números al azar
*/
Matriz matrizA = new Matriz(15, 35);
Matriz matrizB = new Matriz(10, 20);
//Mostramos matrices en pantalla.
System.out.println("Valores de la matriz A\n"); matrizA.mostrarMatriz();
System.out.println("\nValores de la matriz B\n"); matrizB.mostrarMatriz();
//Usamos el metodo de nuestra clase Matriz para que nos genere un vector con los valores no repetidos
int[] noRepetidos = matrizA.getValoresNoRepetidos(matrizB);
//Mostramos los valores obtenidos en el vector
System.out.println("\n\nValores de Matriz A no existentes en Matriz B"); for (int num: noRepetidos)
System.out.print(num + " ");
}
}
