AplicacionMatriz3.java

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

/**
 * Clase para representar estadísticas de niveles de ruides de diferentes vehículos a diferentes velocidades.
 * @author John Ortiz
 * @version 1.0
 */
public class AplicacionMatriz3
{
    /**
     * Niveles de ruido de los coches
     */
    private int[][] nivelRuidoEndB = new int[ 6 ][ 7 ];
    private String[] coches = new String[ 6 ];

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

        int dato = 0;

        int velocidad = 20;

        try
        {
            for (int i = 0; i < nivelRuidoEndB.length; i++)
            {
                for (int j = 0; j < nivelRuidoEndB[i].length; j++)
                {
                    System.out.printf( "Decibelios a %d: ", velocidad );
                    dato = Integer.parseInt( br.readLine() );

                    nivelRuidoEndB[ i ][ j ] = dato;
                }

                System.out.println();

                velocidad += 10;
            }
        }
        catch( NumberFormatException nfe )
        {
            nfe.printStackTrace();
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }
    } // fin del método insertarDatos

    /**
     * Carga los niveles de ruido en la matriz correspondiente.
     */
    public void precargarDatosNivelesDeRuido()
    {
        nivelRuidoEndB[ 0 ][ 0 ] = 88;
        nivelRuidoEndB[ 0 ][ 1 ] = 90;
        nivelRuidoEndB[ 0 ][ 2 ] = 94;
        nivelRuidoEndB[ 0 ][ 3 ] = 102;
        nivelRuidoEndB[ 0 ][ 4 ] = 111;
        nivelRuidoEndB[ 0 ][ 5 ] = 122;
        nivelRuidoEndB[ 0 ][ 6 ] = 134;

        nivelRuidoEndB[ 1 ][ 0 ] = 75;
        nivelRuidoEndB[ 1 ][ 1 ] = 77;
        nivelRuidoEndB[ 1 ][ 2 ] = 80;
        nivelRuidoEndB[ 1 ][ 3 ] = 86;
        nivelRuidoEndB[ 1 ][ 4 ] = 94;
        nivelRuidoEndB[ 1 ][ 5 ] = 103;
        nivelRuidoEndB[ 1 ][ 6 ] = 113;

        nivelRuidoEndB[ 2 ][ 0 ] = 80;
        nivelRuidoEndB[ 2 ][ 1 ] = 83;
        nivelRuidoEndB[ 2 ][ 2 ] = 85;
        nivelRuidoEndB[ 2 ][ 3 ] = 94;
        nivelRuidoEndB[ 2 ][ 4 ] = 100;
        nivelRuidoEndB[ 2 ][ 5 ] = 111;
        nivelRuidoEndB[ 2 ][ 6 ] = 121;

        nivelRuidoEndB[ 3 ][ 0 ] = 68;
        nivelRuidoEndB[ 3 ][ 1 ] = 71;
        nivelRuidoEndB[ 3 ][ 2 ] = 76;
        nivelRuidoEndB[ 3 ][ 3 ] = 85;
        nivelRuidoEndB[ 3 ][ 4 ] = 96;
        nivelRuidoEndB[ 3 ][ 5 ] = 110;
        nivelRuidoEndB[ 3 ][ 6 ] = 125;

        nivelRuidoEndB[ 4 ][ 0 ] = 77;
        nivelRuidoEndB[ 4 ][ 1 ] = 84;
        nivelRuidoEndB[ 4 ][ 2 ] = 91;
        nivelRuidoEndB[ 4 ][ 3 ] = 98;
        nivelRuidoEndB[ 4 ][ 4 ] = 105;
        nivelRuidoEndB[ 4 ][ 5 ] = 112;
        nivelRuidoEndB[ 4 ][ 6 ] = 119;

        nivelRuidoEndB[ 5 ][ 0 ] = 81;
        nivelRuidoEndB[ 5 ][ 1 ] = 85;
        nivelRuidoEndB[ 5 ][ 2 ] = 90;
        nivelRuidoEndB[ 5 ][ 3 ] = 96;
        nivelRuidoEndB[ 5 ][ 4 ] = 102;
        nivelRuidoEndB[ 5 ][ 5 ] = 109;
        nivelRuidoEndB[ 5 ][ 6 ] = 120;
    } // fin del método cargarDatosNivelesDeRuido

    /**
     * Carga los nombres de los coches.
     */
    public void cargarNombresCoches()
    {
        InputStreamReader isr = new InputStreamReader( System.in );
        BufferedReader br = new BufferedReader( isr );

        String nombreCoche = "";

        try
        {
            for( int i = 0; i < coches.length; i++ )
            {
                System.out.print( "Dígite nombre de coche: " );
                nombreCoche = br.readLine();

                coches[ i ] = nombreCoche;
            }
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }
    } // fin del método cargarNombresCoches

    /**
     * Precarga los nombres de los coches. Para propósitos de prueba.
     */
    public void precargarNombresCoches()
    {
        coches[ 0 ] = "Focus";
        coches[ 1 ] = "Jetta";
        coches[ 2 ] = "Contour";
        coches[ 3 ] = "Tsuru";
        coches[ 4 ] = "Explorer";
        coches[ 5 ] = "Lobo";
    } // fin del método precargarNombresCoches

    /**
     * Calcula el promedio de nivel de ruido por coche.
     */
    public void calcularPromedioNivelRuido()
    {
        double acumRuido = 0.0;

        System.out.printf( "%-20s%8s\n\n", "Nombre Coche", "Promedio Nivel Ruido (dB)" );

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[i].length; j++)
            {
                acumRuido += nivelRuidoEndB[ i ][ j ];
            }

            System.out.printf( "%-20s%8.2f dB", coches[ i ], ( acumRuido / nivelRuidoEndB[ i ].length ) );
            System.out.println();
        } // fin for

    } // fin del método calcularPromedioNivelRuido

    /**
     * Reporte por velocidad el promedio del nivel de ruido para cada velocidad.
     */
    public void calcularPromedioRuidoPorVelocidad()
    {
        int[] promedioRuidoXVelocidad = new int[ nivelRuidoEndB[ 0 ].length ];

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[ 0 ].length; j++)
            {
                promedioRuidoXVelocidad[ j ] += nivelRuidoEndB[ i ][ j ];
            } // fin for anidado
        }  // fin for anidado

        // muestra el reporte

        int velocidad = 20;

        System.out.printf( "%-15s%7s\n", "Velocidad", "Promedio Ruido (dB)" );

        for (int i = 0; i < promedioRuidoXVelocidad.length; ++i )
        {
            System.out.printf( "%-15d%.2f\n", velocidad, ( promedioRuidoXVelocidad[ i ] / ( nivelRuidoEndB.length * 1.0 ) ) );

            velocidad += 10;
        } // fin for

        System.out.println();

    } // fin del método calcularPromedioRuidoPorVelocidad

    /**
     * Calcula el promedio de nivel de ruido total.
     */
    public double calcularPromedioRuidoTotal()
    {
        double promedioRuido = 0.0;

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[ i ].length; j++)
            {
                promedioRuido += nivelRuidoEndB[ i ][ j ];
            }
        } // fin for exterior

        return( promedioRuido / ( nivelRuidoEndB.length * nivelRuidoEndB[ 0 ].length ) );
    } // fin del método calcularPromedioRuidoTotal

    /**
     * Determina el coche que produjo el mayor nivel de ruido
     * @return Nombre del coche que generó el mayor nivel de ruido.
     */
    public String determinarCocheConMayorNivelDeRuido()
    {
        int numeroCoche = 0;
        int nivelRuidoMayor = 0;

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[ 0 ].length; j++)
            {
                if( i == 0 && j == 0 )
                {
                    nivelRuidoMayor = nivelRuidoEndB[ i ][ j ];
                    continue;
                }

                if( nivelRuidoEndB[ i ][ j ] > nivelRuidoMayor )
                {
                    nivelRuidoMayor = nivelRuidoEndB[ i ][ j ];
                    numeroCoche = i;
                }
            } // fin de for anidado.
        } // fin de for exterior

        return( coches[ numeroCoche ] );
    } // fin del método determinarCocheConMayorNivelDeRuido

    /**
     * Determina la velocidad que generó el mayor nivel de ruido
     */
    public int determinarVelocidadConMayorNivelDeRuido()
    {
        int[] velocidades = { 20, 30, 40, 50, 60, 70, 80 };
        int nivelRuidoMayor = 0;
        int indiceVelocidad = 0;

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[ i ].length; j++ )
            {
                if( i == 0 && j == 0 )
                {
                    nivelRuidoMayor = nivelRuidoEndB[ i ][ j ];
                    continue;
                }

                if( nivelRuidoEndB[ i ][ j ] > nivelRuidoMayor )
                {
                    nivelRuidoMayor = nivelRuidoEndB[ i ][ j ];
                    indiceVelocidad = j;
                }
            }
        } // fin for exterior

        return( velocidades[ indiceVelocidad ] );
    } // fin del método determinarVelocidadConMayorNivelDeRuido

    /**
     * Determina el coche que produjo el mayor nivel de ruido
     * @return Nombre del coche que generó el mayor nivel de ruido.
     */
    public String determinarCocheConMenorNivelDeRuido()
    {
        int numeroCoche = 0;
        int nivelRuidoMenor = 0;

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[ 0 ].length; j++)
            {
                if( i == 0 && j == 0 )
                {
                    nivelRuidoMenor = nivelRuidoEndB[ i ][ j ];
                    continue;
                }

                if( nivelRuidoEndB[ i ][ j ] < nivelRuidoMenor )
                {
                    nivelRuidoMenor = nivelRuidoEndB[ i ][ j ];
                    numeroCoche = i;
                }
            } // fin de for anidado.
        } // fin de for exterior

        return( coches[ numeroCoche ] );
    } // fin del método determinarCocheConMenorNivelDeRuido

    /**
     * Determina la velocidad que generó el menor nivel de ruido
     */
    public int determinarVelocidadConMenorNivelDeRuido()
    {
        int[] velocidades = { 20, 30, 40, 50, 60, 70, 80 };
        int nivelRuidoMenor = 0;
        int indiceVelocidad = 0;

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            for (int j = 0; j < nivelRuidoEndB[ i ].length; j++ )
            {
                if( i == 0 && j == 0 )
                {
                    nivelRuidoMenor = nivelRuidoEndB[ i ][ j ];
                    continue;
                }

                if( nivelRuidoEndB[ i ][ j ] < nivelRuidoMenor )
                {
                    nivelRuidoMenor = nivelRuidoEndB[ i ][ j ];
                    indiceVelocidad = j;
                }
            }
        } // fin for exterior

        return( velocidades[ indiceVelocidad ] );
    } // fin del método determinarVelocidadConMenorNivelDeRuido

    /**
    * Imprime los nivel de ruido
    */
    public void imprimirNivelesDeRuido()
    {
        System.out.printf( "%-20s%7s%7s%7s%7s%7s%7s%7s\n", "Coche", "20", "30", "40", "50", "60", "70", "80" );

        System.out.println();

        for (int i = 0; i < nivelRuidoEndB.length; i++)
        {
            System.out.printf( "%-20s", coches[ i ] );
            for (int j = 0; j < nivelRuidoEndB[i].length; j++)
            {
                if( j == 0 )
                {
                    System.out.printf( "%7s", nivelRuidoEndB[ i ][ j ] );
                }
                else
                {
                    System.out.printf( "%7s", nivelRuidoEndB[ i ][ j ] );
                }
            } // fin for anidado
            System.out.println();
        } // fin for

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

    /**
    *
    */
    public static void main( String[] args )
    {
        // Crea una instancia de AplicacionMatriz3
        AplicacionMatriz3 appMatriz3 = new AplicacionMatriz3();

        System.out.println();

        // datos de prueba basados en los propuestos en el ejercicio
        appMatriz3.precargarDatosNivelesDeRuido();
        appMatriz3.precargarNombresCoches();

        // imprime el contenido de la matriz
        appMatriz3.imprimirNivelesDeRuido();

        System.out.println();

        // Reporte por coche: Los nombres de los modelos de los coches con su correspondiente promedio del nivel de
        // para cada coche.
        appMatriz3.calcularPromedioNivelRuido();

        System.out.println();

        // promedio del nivel de ruido por cada velocidad
        System.out.print( "\nPromedio de Ruido (dB) por Velocidad: \n\n" );
        appMatriz3.calcularPromedioRuidoPorVelocidad();

        System.out.println();

        // promedio de nivel de ruido total
        System.out.printf( "El promedio de ruido total es: %.2f", appMatriz3.calcularPromedioRuidoTotal() );

        System.out.println();

        // coche con mayor nivel de ruido
        System.out.printf( "\n\nEl coche con mayor nivel de ruido es: %s", appMatriz3.determinarCocheConMayorNivelDeRuido() );

        // velocidad con mayor nivel de ruido
        System.out.printf( "\n\n\nLa velocidad con mayor nivel de ruido es: %s", appMatriz3.determinarVelocidadConMayorNivelDeRuido() );

        // coche con menor nivel de ruido
        System.out.printf( "\n\n\nEl coche con menor nivel de ruido es: %s", appMatriz3.determinarCocheConMenorNivelDeRuido() );

        // velocidad con mayor nivel de ruido
        System.out.printf( "\n\n\nLa velocidad con menor nivel de ruido es: %s", appMatriz3.determinarVelocidadConMenorNivelDeRuido() );
    }

} // fin de la clase AplicacionMatriz3