AplicacionMatriz2.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * Representa una clase para invertir matrices.
 * @author John Ortiz
 * @version 1.0
 */
public class AplicacionMatriz2
{
    /**
     * matriz con los datos dispuestos tal cual como el usuario los introudc
     */
    private int[][] matrizEnterosOrigen;
    private int[][] matrizEnterosDestino;

    /**
     * Permite ingresar el número filas/columnas.
     */
    public void numeroElementosAInsertar()
    {
        InputStreamReader isr = new InputStreamReader( System.in );

        BufferedReader br = new BufferedReader( isr );

        int filas = 0;
        int columnas = 0;

        try
        {
            System.out.print( "Digite el número de filas: " );
            filas = Integer.parseInt( br.readLine() );

            System.out.println();

            System.out.print( "Digite el número de columnas: " );
            columnas = Integer.parseInt( br.readLine() );
        }
        catch( NumberFormatException nfe )
        {
            nfe.printStackTrace();
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }

        // crea la matriz
        matrizEnterosOrigen = new int[ filas ][ columnas ];
    } // fin del método numeroElementosAInsertar

    /**
     * Lee los datos para el arreglo desde el teclado introducidos por el usuario de la aplicación.
     */
    public void insertarDatos()
    {
        InputStreamReader isr = new InputStreamReader( System.in );
        BufferedReader br = new BufferedReader( isr );

        int dato = 0;

        try
        {
            for (int i = 0; i < matrizEnterosOrigen.length; i++)
            {
                for (int j = 0; j < matrizEnterosOrigen[i].length; j++)
                {
                    System.out.printf( "Da elemento %d, %d : ", ( i + 1 ), ( j + 1 ) );
                    dato = Integer.parseInt( br.readLine() );

                    matrizEnterosOrigen[ i ][ j ] = dato;
                }

                System.out.println();
            }
        }
        catch( NumberFormatException nfe )
        {
            nfe.printStackTrace();
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }
    } // fin del método insertarDatos

    /**
     * Imprime la matriz de origen
     */
    public void imprimirMatrizEnterosOrigen()
    {
        System.out.println( "Contenido de la matriz de enteros origen: \n" );

        for (int i = 0; i < matrizEnterosOrigen.length; i++)
        {
            for (int j = 0; j < matrizEnterosOrigen[i].length; j++)
            {
                System.out.printf( "\t%s", matrizEnterosOrigen[ i ][ j ] );
            } // fin for anidado
            System.out.println();
        } // fin for

        System.out.println();
    } // fin del método imprimirArregloDatos

    /**
     * Imprime la matriz
     */
    public void imprimirMatrizEnterosDestino()
    {
        System.out.println( "Contenido de la matriz de enteros destino: \n" );

        for (int i = 0; i < matrizEnterosDestino.length; i++)
        {
            for (int j = 0; j < matrizEnterosDestino[i].length; j++)
            {
                System.out.printf( "\t%s", matrizEnterosDestino[ i ][ j ] );
            } // fin for anidado
            System.out.println();
        } // fin for

        System.out.println();
    } // fin del método imprimirArregloDatos

    /**
     * Invierte la matriz ( m x n -> n x m )
     */
    public void invertir()
    {
        // crea la matriz destino
        matrizEnterosDestino = new int[ matrizEnterosOrigen[0].length ][ matrizEnterosOrigen.length ];

        // arreglo temporal
        int[] arregloEnterosTemp = new int[ matrizEnterosOrigen.length * matrizEnterosOrigen[ 0 ].length ];

        // contador de elementos insertados en el arreglo de enteros temporal
        int contadorEnterosTemp = 0;

        for (int i = 0; i < matrizEnterosOrigen.length; i++)
        {
            for (int j = 0; j < matrizEnterosOrigen[i].length; j++)
            {
                arregloEnterosTemp[ contadorEnterosTemp++ ] = matrizEnterosOrigen[ i ][ j ];
            }
        }

        for (int i = arregloEnterosTemp.length - 1, m = 0, n = 0; i >= 0; --i)
        {
            matrizEnterosDestino[ m ][ n ] = arregloEnterosTemp[ i ];
            ++n;

            if( n == ( matrizEnterosDestino[ 0 ].length ) )
            {
                n = 0;
                ++m;
            }
        } // fin de for
    } // fin del método invertir

    /**
     * Punto de entrada de la aplicación.
     * @param args Argumentos de entrada desde la consola o terminal
     */
    public static void main( String[] args )
    {
        // crea una instancia de AplicacionMatriz2
        AplicacionMatriz2 appMatriz2 = new AplicacionMatriz2();

        // invoca al método para establecer el tamaño de la matriz orginal
        appMatriz2.numeroElementosAInsertar();

        System.out.println();

        // inserta datos en la matriz
        appMatriz2.insertarDatos();

        System.out.println();

        // imprime la matriz original (sin invertir)
        appMatriz2.imprimirMatrizEnterosOrigen();

        System.out.println();

        // invierte la matriz original
        appMatriz2.invertir();

        System.out.println();

        // imprime la matriz invertida ( n x m )
        appMatriz2.imprimirMatrizEnterosDestino();
    }
}