Melhorar codigo

Programação
#1

Bom dia,

Fiz este codigo, mas queria seaber se é possivel melhorar. Tipo com metodos?!

Muito obrigado pela ajuda. :slight_smile:

package mtdisc;
import java.util.Scanner; 
import java.util.*;
import java.math.BigInteger;
/**
 *
 * @author filip
 */


public class MTDISC {
    
    
    
    // Fatorial de um numero
    
    public static BigInteger fatorial( int numero ){
        
        BigInteger factorial = new BigInteger("1");
        for (int i = 1; i <= numero; i++) {
            factorial = factorial.multiply(new BigInteger(i + ""));
        }
        return factorial;
    }   
    
    
    public static void main(String[] args) {      
        
        Scanner ler = new Scanner(System.in);
        System.out.println("Insira um valor: ");
        long tempoInicial = System.currentTimeMillis();
        int valor = ler.nextInt();
        System.out.println("Fatorial: "+fatorial(valor));
        long tempoFinal = System.currentTimeMillis();
        long tempoExe = tempoFinal - tempoInicial;
        System.out.println("Tempo de execução: "+ tempoExe+" milissegundos");
       
        
// Introdução dos valores da matriz no formato x,y,z,...

        
        Scanner ler1 = new Scanner(System.in);
        System.out.println("Introduza os valores: ");
        String stringDeNumeros = ler1.nextLine();
        

// converte a string para um vetor de strings


        String[] vetorString = stringDeNumeros.split(",");
        int vetorInt[] = new int[vetorString.length];
 
        
// converte de string para inteiros 


        try {
            for(int i = 0; i < vetorString.length; ++i) {
                vetorInt[i] = Integer.parseInt(vetorString[i].trim());
            }
        }catch(NumberFormatException e){
            System.out.println("Erro: Não introduziu apenas numeros! " + e);
        }
        
        
// converte o vetor para uma matriz


        double ordemMatriz=Math.sqrt(vetorInt.length);
        int ordem=(int)ordemMatriz;
        int counter =0;
        int M[][]= new int[ordem][ordem];
        try {
            for(int i = 0; i<ordemMatriz; i++) {
                for(int j =0; j<ordemMatriz; j++){
                    M[i][j]=vetorInt[counter++];
                }
            }
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("Erro: Não introduziu valores correspondentes a uma matriz quadrada! " + e );
        }
        
     
        
// imprime a matriz        
        

        for (int l = 0; l < M.length; l++)  {  
            for (int c = 0; c < M[0].length; c++)     {
                
                // matem o espaçamento entre os valores de acordo com o numero de algarismos
                
                if (M[l][c]<10){
                    System.out.print("  "+M[l][c] + "  "); //imprime caracter a caracter
                }
                else {
                    System.out.print(" "+M[l][c] + " "); //imprime caracter a caracter
                }
            }  
            System.out.println(" "); //muda de linha
        }
        
        
// gerar matrizes aleatoriamente com valores entre [0,100] com as diagonais em zero.


    // definir ordem da matriz    
    
        System.out.println(" ");
        System.out.println("Insira a ordem da matriz a gerar: ");
        int ord= ler1.nextInt();
        Random gerador = new Random();
        int MatAle[][] = new int[ord][ord];
        for(int i=0;i<ord;i++){
            for(int j=0;j<ord;j++){
		if(i==j)
		    MatAle[i][j] = 0;
                else {
                    int ger=gerador.nextInt(100);
                    MatAle[i][j] = ger;
                    MatAle[j][i] = ger;
                         
                }    
            }
        }
        System.out.println(" ");
        
// Imprimir matriz gerada aleatoriamente
        
        System.out.println("Matriz gerada aleatoriamente de ordem "+ord+":");
        System.out.println(" ");
        
        for (int l = 0; l < MatAle.length; l++)  {  
            for (int c = 0; c < MatAle[0].length; c++)     {
                
                // matem o espaçamento entre os valores de acordo com o numero de algarismos
                
                if (MatAle[l][c]<10){
                    System.out.print(MatAle[l][c] + "   "); //imprime caracter a caracter
                }
                else {
                    System.out.print(MatAle[l][c] + "  "); //imprime caracter a caracter
                }
            }  
            System.out.println(" "); //muda de linha
        }
        
    }    
}
#2

Há muitas formas de fazer isso, eis um exemplo:

import java.io.PrintStream;
import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;

/**
 *
 * @author filip
 */
public class MTDISC {

    /**
     * Ponto de entrada do programa Java
     */
    public static void main(String[] args) {
        MTDISC programa = new MTDISC();
        programa.executar();
    }

    private final Scanner entrada = new Scanner(System.in);
    private final PrintStream saida = System.out;

    /**
     * Executa este programa
     */
    public void executar() {
        saida.println("Insira um valor: ");
        long tempoInicial = System.currentTimeMillis();
        int valor = Integer.parseInt(entrada.nextLine());
        saida.println("Fatorial: " + fatorial(valor));
        long tempoFinal = System.currentTimeMillis();
        long tempoExe = tempoFinal - tempoInicial;
        saida.println("Tempo de execução: " + tempoExe + " milissegundos");

        // Introdução dos valores da matriz no formato x,y,z,...
        saida.println("Introduza os valores: ");
        String stringDeNumeros = entrada.nextLine();
        // converte a string para um vetor de strings
        String[] vetorString = stringDeNumeros.split(",");
        int[] vetorInt = stringsParaInts(vetorString);

        // converte o vetor para uma matriz
        int[][] matriz = converteVetorEmMatriz(vetorInt);

        // imprime a matriz
        imprimirMatriz(matriz);

        // definir ordem da matriz
        saida.println(" ");
        saida.println("Insira a ordem da matriz a gerar: ");
        int ordem = Integer.parseInt(entrada.nextLine());

        // gerar matrizes aleatoriamente com valores entre [0,100] com as diagonais em zero.
        int[][] matrizAleatoria = gerarMatriz(ordem, 100);
        saida.println(" ");

        // Imprimir matriz gerada aleatoriamente
        saida.println("Matriz gerada aleatoriamente de ordem " + ordem + ":");
        saida.println(" ");
        imprimirMatriz(matrizAleatoria);
    }

    /**
     * Converte o vetor para uma matriz
     */
    private int[][] converteVetorEmMatriz(int[] vetor) {
        int ordem = (int) Math.sqrt(vetor.length);
        int[][] matriz = new int[ordem][ordem];
        try {
            int posicao = 0;
            for (int linha = 0; linha < ordem; linha++) {
                for (int coluna = 0; coluna < ordem; coluna++) {
                    matriz[linha][coluna] = vetor[posicao++];
                }
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            saida.println("Erro: Não introduziu valores correspondentes a uma matriz quadrada! " + e);
        }
        return matriz;
    }

    /**
     * Fatorial de um numero
     */
    private BigInteger fatorial(int numero) {
        BigInteger factorial = new BigInteger("1");
        for (int i = 1; i <= numero; i++) {
            factorial = factorial.multiply(new BigInteger(String.valueOf(i)));
        }
        return factorial;
    }

    /**
     * Gerar matrizes de ordem informada aleatoriamente com valores entre 0 e o limite informado, com as diagonais em zero.
     */
    private int[][] gerarMatriz(int ordem, int limite) {
        Random gerador = new Random();
        int matriz[][] = new int[ordem][ordem];
        for (int linha = 0; linha < ordem; linha++) {
            for (int coluna = 0; coluna < ordem; coluna++) {
                int valor = linha == coluna ? 0 : gerador.nextInt(limite);
                matriz[linha][coluna] = valor;
            }
        }
        return matriz;
    }

    /**
     * Imprime a matriz passada por parametro
     */
    private void imprimirMatriz(int[][] matriz) {
        for (int linha = 0; linha < matriz.length; linha++) {
            for (int coluna = 0; coluna < matriz[linha].length; coluna++) {
                String espaco = matriz[linha][coluna] < 10 ? "  " : " ";
                saida.print(espaco + matriz[linha][coluna] + espaco);
            }
            saida.println(" ");
        }
    }

    /**
     * Converte um array de String para um array de int
     */
    private int[] stringsParaInts(String[] strings) {
        int ints[] = new int[strings.length];
        try {
            for (int i = 0; i < strings.length; ++i) {
                ints[i] = Integer.parseInt(strings[i].trim());
            }
        } catch (NumberFormatException e) {
            saida.println("Erro: Não introduziu apenas numeros! " + e);
        }
        return ints;
    }
}
1 curtida
#4

Muito obrigado pela ajuda! Só mais uma coisa, pq utiliza o saida.println em vez do System.out.println ?
Obrigado :slight_smile:

#5

Por que o “saida” é a abreviação de System.out, ele declarou para evitar repeticoes e tal.

1 curtida
#6

ah ok! Obrigado :slight_smile:

#7

Pra ficar uma estrutura ortogonal.
Se você tem uma variável para ler do System.in, então faz todo sentido ter uma para escrever no System.out.

1 curtida