JAVA - Comparar colunas de uma matriz int[][]

Programação
#1

Tenho que comparar as linhas e colunas de uma matriz e ver se elas se repetem.

Comparar as linhas foi “fácil”, mas estou tendo problemas para comparar as colunas.

Para resolver temporariamente, estou transpondo a matriz, ou seja, transformando as linhas em colunas e as colunas em linhas para poder usar o mesmo conceito de comparação de linhas. Eu gostaria de uma solução mais elegante, já que se parece com gambiarra.

Alguém pode me ajudar?

import java.util.Arrays;

public class CompararLinhasColunas {

public static void main(String[] args) {

	// MATRIZ PARA TESTE 
	// Linhas 0 e 5 sao iguais
	// Colunas 1 e 3 sao iguais
	int[][] matriz = {{0, 4, 1, 4, 0, 0}, 
					  {0, 6, 1, 6, 3, 0},
					  {0, 3, 1, 3, 0, 8}, 
					  {1, 7, 0, 7, 0, 1},
					  {0, 5, 0, 5, 1, 0},
					  {0, 4, 1, 4, 0, 0}};

	int linhaParaComparar = 0;
	int colunaParaComparar = 1;

	compararLinhas(matriz, linhaParaComparar);	
	comparaColunas(matriz, colunaParaComparar);
}


/**
 * Compara a linha passada como parametro com as demais da matriz
 * 
 * @param matriz
 * @param linhaParaComparar
 */
public static void compararLinhas(int[][] matriz, int linhaParaComparar) {

	for (int i = 0; i < matriz.length; i++) {

		// Compara a linhas passada em parametro com as demais, excluindo
		// ela mesmo
		if(Arrays.equals(matriz[linhaParaComparar], matriz[i]) 
				&& matriz[linhaParaComparar] != matriz[i]) {

			System.out.println("Linha " + linhaParaComparar + " é igual a " + i);
		}
	}
}

/**
 * Compara a coluna passada como parametro com as demais da matriz
 *
 * MAS ANTES
 *
 * Transforma as linhas da matriz em colunas e colunas em linhas para
 * usar a mesma solucao da comparacao de linhas do metodo 
 * "compararLinhas"
 * 
 * @param matriz
 * @param colunaParaComparar
 */
public static void comparaColunas(int[][] matriz, int colunaParaComparar) {

	// Criando uma nova matriz temporaria
	// Matriz temporaria para comparacao. A quantidade de linhas é igual ao de 
	// colunas da matriz original e a quantidade de colunas é igual ao de 
	// linhas da original
	int[][] matrizTemp = new int[matriz[0].length][matriz.length];

	// Ttansformando linhas em colunas e colunas em linhas
	for (int i = 0; i < matrizTemp.length; i++) {
		for (int j = 0; j < matrizTemp.length; j++) {

			matrizTemp[i][j] = matriz[j][i];

			//System.out.print(Temp[i][j] + " ");
		}
	}

	// Mesmo processo de comparar as linhas. O metodo "compararLinhas" poderia
	// ter sido chamado, mas por enquanto, para fins de entendimento, o codigo
	// foi reescrito.
	for (int i = 0; i < matrizTemp.length; i++) {

		if(Arrays.equals(matrizTemp[colunaParaComparar], matrizTemp[i]) 
				&& matrizTemp[colunaParaComparar] != matrizTemp[i]) {

			System.out.println("Coluna " + colunaParaComparar + " é igual a " + i);
		}
	}
}

}

#2

Fala cara! Eu consegui resolver a questão das linhas ou colunas repetidas sem transpor matrizes, percebi não houve resposta até agora então vou deixar os dois métodos que fiz aqui.

public boolean linhasIguais() {
boolean resultado;
int cont, linha, coluna, cont1;

	cont = 0;
	cont1 = 0;
	resultado = false;
	
	while(cont < this.getTamanhoLinha() && resultado == false) {
		for(linha = 0; linha < this.getTamanhoLinha(); linha++) {
			for(coluna = 0; coluna < this.getTamanhoColuna(); coluna++) {
				if(this.getValor(cont, coluna) == this.getValor(linha, coluna) && linha != cont) {
					cont1++;
				}
				if(cont1 == this.getTamanhoLinha()) {
					resultado = true;
				}
			}
			cont1 = 0;
		}
		cont++;
	}
	return resultado;
}

public boolean colunasIguais() {
	boolean resultado;
	int cont, linha, coluna, cont1;

	cont = 0;
	cont1 = 0;
	resultado = false;
	while(cont < this.getTamanhoColuna() && resultado == false) {
		for(coluna = 0; coluna < this.getTamanhoColuna(); coluna++) {
			for(linha = 0; linha < this.getTamanhoLinha(); linha++) {
				if(this.getValor(linha, cont) == this.getValor(linha, coluna) && coluna != cont) {
					cont1++;
				}
				if(cont1 == this.getTamanhoColuna()) {
					resultado = true;
				}
			}
			cont1 = 0;
		}
		cont++;
	}
	return resultado;
}

Quando os métodos verificam que uma coluna ou linha se repete ele termina o ciclo while e retorna true! é claro que com pequenas alterações é possível pegar a endereço das linhas ou colunas repetidas e seus valores, mas isso não vem ao caso.