Java Criar, preencher e listar e buscar no vetor

[Visitante]

Tal exercicio foi proposto 

 

1-Criar um vetor: 

A elaboração deve permitir a criação de um vetor cujo tamanho deve ser informado pelo usuário.

Um vetor pode ser criado tantas vezes quantas o usuário desejar 

 

2-Preenchimento do vetor

O vetor deve ser preenchido com valores aleatórios, inteiros, mas o valor máximo deve ser informado pelo usuário.

O vetor pode ser preenchido tantas vezes quantas esta opção for selecionada 

 

3-Listar o vetorDeve ser possível listar os valores de 3 formas: (a) todos, (b) acima da média, (c) acima de valor específico

Todos: Deve ser possível listar o conteúdo do vetor, mostrando a posição e o valor contido naquela posição

Acima da média: Deve-se calcular o valor médio e apresentar os elementos que superam este valor

Acima de valor específico: Deve-se solicitar ao usuário um valor e em seguida listar os valores q o superam

4-Ordenar o vetor

Deve ser possível fazer o ordenamento do vetor, tanto em ordem crescente quanto decrescente, conforme solicitação do usuário

 

5-Buscar os picos do vetor

O usuário pode solicitar o valor máximo ou o valor mínimo. O resultado deve mostrar a posição onde o valor se encontra e o valor de fato

 

 

Meu codigo:

import java.util.Random;
import java.util.Scanner;

public class TrabalhoComVetores {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int tamanhoArray, valorMaximo, opcao = 0;
        
        do {
            System.out.println("*Para encerrar a aplicação, defina o tamanho\ndo array para um valor menor ou igual a 0.*\n");
            
            System.out.print("Tamanho do Vetor: ");
            tamanhoArray = in.nextInt();

            if(tamanhoArray <= 0){
                System.exit(0);
            }
            
            System.out.print("\nValor Máximo: ");
            valorMaximo = in.nextInt();

            int[] array = new int[tamanhoArray];
            Random r = new Random();

            for (int i = 0; i < array.length; i++) {
                array[i] = r.nextInt(valorMaximo);
            }

            do {
                System.out.print("\nOpções do Vetor:\n\n(0) - Novo vetor\n(1) - Listar valores\n(2) - Ordenar\n(3) - Visualizar picos\n\n>>> ");
                opcao = in.nextInt();

                switch (opcao) {
                    case 0:
                        System.out.print("\nReiniciando a aplicação...\n\n");
                        break;
                    case 1: // Listar valores do vetor
                        char opc = ' ';
                        do {
                            System.out.print("\n(a) - Todos os valores\n(b) - Acima da média\n(c) - Acima de valor específico\n\n>>> ");
                            String op = in.next();
                            
                            opc = op.charAt(0);
                            switch (opc) {
                                case 'a':
                                    System.out.print("\n[");
                                    for (int i = 0; i < array.length; i++) {
                                        if (i < array.length - 1) {
                                            System.out.print(array[i] + ", ");
                                        } else {
                                            System.out.print(array[i]);
                                        }
                                    }
                                    System.out.print("]\n");
                                    break;
                                case 'b':
                                    int soma = 0;
                                    for (int i = 0; i < array.length; i++) {
                                        soma += array[i];
                                    }
                                    double media = (double) soma / array.length;

                                    System.out.println("\nMedia: " + media);
                                    
                                    System.out.print("\n[");
                                    for (int i = 0; i < array.length; i++) {
                                        if (array[i] > media) {
                                            if (i < array.length - 1) {
                                                System.out.print(array[i] + ", ");
                                            } else {
                                                System.out.print(array[i]);
                                            }
                                        }
                                    }
                                    System.out.print("]\n");
                                    break;
                                case 'c':
                                    System.out.print("\nValor: ");
                                    int valor = in.nextInt();
                                    
                                    System.out.print("\n[");
                                    for (int i = 0; i < array.length; i++) {
                                        if (array[i] > valor) {
                                            if (i < array.length - 1) {
                                                System.out.print(array[i] + ", ");
                                            } else {
                                                System.out.print(array[i]);
                                            }
                                        }
                                    }
                                    System.out.print("]\n");
                                    break;
                            }
                        } while (opc != 'a' && opc != 'b' && opc != 'c');
                        break;
                    case 2: // Ordenar vetor
                        do {
                            System.out.print("\n(1) - Crescente\n(2) - Decrescente\n\n>>> ");
                            opcao = in.nextInt();
                            
                            int aux;
                            switch (opcao) {
                                case 1:
                                    for (int i = 0; i < array.length; i++) {
                                        for (int j = 0; j < array.length; j++) {
                                            if (array[i] < array[j]) {
                                                aux = array[i];
                                                array[i] = array[j];
                                                array[j] = aux;
                                            }
                                        }
                                    }
                                    System.out.print("\n[");
                                    for (int i = 0; i < array.length; i++) {
                                        if (i < array.length - 1) {
                                            System.out.print(array[i] + ", ");
                                        } else {
                                            System.out.print(array[i]);
                                        }
                                    }
                                    System.out.print("]\n");
                                    break;
                                case 2:
                                    for (int i = 0; i < array.length; i++) {
                                        for (int j = 0; j < array.length; j++) {
                                            if (array[i] > array[j]) {
                                                aux = array[i];
                                                array[i] = array[j];
                                                array[j] = aux;
                                            }
                                        }
                                    }
                                    System.out.print("\n[");
                                    for (int i = 0; i < array.length; i++) {
                                        if (i < array.length - 1) {
                                            System.out.print(array[i] + ", ");
                                        } else {
                                            System.out.print(array[i]);
                                        }
                                    }
                                    System.out.print("]\n");
                                    break;
                            }
                        } while (opcao != 1 && opcao != 2);
                        break;
                    case 3: // Visualizar picos do vetor
                        int maior = Integer.MIN_VALUE;
                        int menor = Integer.MAX_VALUE;
                        int indexMin = 0, indexMax = 0;
                        
                        for (int i = 0; i < array.length; i++) {
                            if (array[i] < menor) {
                                menor = array[i];
                                indexMin = i;
                            }
                        }
                        for (int i = 0; i < array.length; i++) {
                            if (array[i] > maior) {
                                maior = array[i];
                                indexMax = i;
                            }
                        }
                        System.out.print("\nPicos do Vetor:\nMínimo: " + menor + "\tIndex: " + indexMin + "\nMáximo: " + maior + "\tIndex: " + indexMax + "\n");
                        break;
                }
            } while (opcao != 0);
        } while (true);
    }
}     

 

 

As sugestoes podem ser tanto organizacionais quanto do codigo mesmo.

[AdrianoSiqueira]

Uma alternativa usando métodos:

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;
import java.util.StringJoiner;

public class App implements Runnable {

    private static final Scanner SCANNER = new Scanner(System.in);

    public static void main(String[] args) {
        new App().run();
    }


    private void buscar(int[] vetor) {
        if (vetor == null) {
            System.out.println("[ E ]: O vetor não foi criado.");
            return;
        }

        System.out.print(">> Buscar valor\n" +
                         "[ 1 ] - Mínimo\n" +
                         "[ 2 ] - Máximo\n" +
                         "[ 0 ] - Cancelar\n" +
                         "> ");

        String buffer = SCANNER.nextLine();
        int    opcao  = -1;

        try {
            opcao = Integer.parseInt(buffer);
        } catch (NumberFormatException e) {
            System.out.println("[ E ]: Entrada inválida.");
        }

        switch (opcao) {
            case 0:
                break;
            case 1:
                buscarMinimo(vetor);
                break;
            case 2:
                buscarMaximo(vetor);
                break;
            default:
                System.out.println("[ E ]: A opção não é válida.");
                buscar(vetor);
                break;
        }
    }

    private void buscarMaximo(int[] vetor) {
        int posicao = 0;

        for (int i = 1; i < vetor.length; i++) {
            if (vetor[i] > vetor[posicao]) {
                posicao = i;
            }
        }

        System.out.printf("Posição: %-2d    Valor: %d\n", posicao, vetor[posicao]);
    }

    private void buscarMinimo(int[] vetor) {
        int posicao = 0;

        for (int i = 1; i < vetor.length; i++) {
            if (vetor[i] < vetor[posicao]) {
                posicao = i;
            }
        }

        System.out.printf("Posição: %-2d    Valor: %d\n", posicao, vetor[posicao]);
    }

    private int[] criarVetor() {
        System.out.print(">> Criar vetor\n" +
                         "Informe o tamanho: ");

        String buffer  = SCANNER.nextLine();
        int    tamanho = -1;

        try {
            tamanho = Integer.parseInt(buffer);
        } catch (NumberFormatException e) {
            System.out.println("[ E ]: Entrada inválida.");
        }

        if (tamanho <= 0) {
            System.out.println("[ E ]: O tamanho não é válido.");
            return criarVetor();
        }

        return new int[tamanho];
    }

    private void listar(int[] vetor) {
        if (vetor == null) {
            System.out.println("[ E ]: O vetor não foi criado.");
            return;
        }

        System.out.print(">> Listar elementos\n" +
                         "[ 1 ] - Tudo\n" +
                         "[ 2 ] - Acima da média\n" +
                         "[ 3 ] - Acima do valor informado\n" +
                         "[ 0 ] - Cancelar\n" +
                         "> ");

        String buffer = SCANNER.nextLine();
        int    opcao  = -1;

        try {
            opcao = Integer.parseInt(buffer);
        } catch (NumberFormatException e) {
            System.out.println("[ E ]: Entrada inválida.");
        }

        switch (opcao) {
            case 0:
                break;
            case 1:
                listarTodos(vetor);
                break;
            case 2:
                listarAcimaMedia(vetor);
                break;
            case 3:
                listarAcimaValor(vetor);
                break;
            default:
                System.out.println("[ E ]: A opção não é válida.");
                listar(vetor);
        }
    }

    private void listarAcimaMedia(int[] vetor) {
        double media = 0;

        for (int i : vetor) media += i;

        media /= vetor.length;


        StringJoiner joiner = new StringJoiner(", ", "[", "]");

        for (int i : vetor) {
            if (i > media) {
                joiner.add(String.valueOf(i));
            }
        }

        System.out.println(joiner);
    }

    private void listarAcimaValor(int[] vetor) {
        System.out.print("Informe o valor: ");

        String buffer = SCANNER.nextLine();
        int    valor  = -1;

        try {
            valor = Integer.parseInt(buffer);
        } catch (NumberFormatException e) {
            System.out.println("[ E ]: Entrada inválida.");
            listarAcimaValor(vetor);
        }


        StringJoiner joiner = new StringJoiner(", ", "[", "]");

        for (int i : vetor) {
            if (i > valor) {
                joiner.add(String.valueOf(i));
            }
        }

        System.out.println(joiner);
    }

    private void listarTodos(int[] vetor) {
        System.out.println(Arrays.toString(vetor));
    }

    private int menuPrincipal() {
        System.out.print(">> Menu Principal\n" +
                         "[ 1 ] - Criar\n" +
                         "[ 2 ] - Preencher\n" +
                         "[ 3 ] - Listar\n" +
                         "[ 4 ] - Ordenar\n" +
                         "[ 5 ] - Buscar\n" +
                         "[ 0 ] - Sair\n" +
                         "> ");

        String buffer = SCANNER.nextLine();
        int    opcao  = -1;

        try {
            opcao = Integer.parseInt(buffer);
        } catch (NumberFormatException ignored) {
            System.out.println("[ E ]: Entrada inválida");
        }

        if (opcao < 0 || opcao > 5) {
            System.out.println("[ E ]: Opção inválida.");
            return menuPrincipal();
        }

        return opcao;
    }

    private void ordenar(int[] vetor) {
        if (vetor == null) {
            System.out.println("[ E ]: O vetor não foi criado.");
            return;
        }

        System.out.print(">> Ordenar vetor\n" +
                         "[ 1 ] - Crescente\n" +
                         "[ 2 ] - Decrescente\n" +
                         "[ 0 ] - Cancelar\n" +
                         "> ");

        String buffer = SCANNER.nextLine();
        int    opcao  = -1;

        try {
            opcao = Integer.parseInt(buffer);
        } catch (NumberFormatException e) {
            System.out.println("[ E ]: Entrada inválida.");
        }

        switch (opcao) {
            case 0:
                break;
            case 1:
                ordenarCrescente(vetor);
                break;
            case 2:
                ordenarDecrescente(vetor);
                break;
            default:
                System.out.println("[ E ]: A opção não é válida.");
                ordenar(vetor);
                break;
        }
    }

    private void ordenarCrescente(int[] vetor) {
        Integer[] array = new Integer[vetor.length];

        for (int i = 0; i < vetor.length; i++) {
            array[i] = vetor[i];
        }

        Arrays.sort(array, Comparator.naturalOrder());
        System.out.println(Arrays.toString(array));
    }

    private void ordenarDecrescente(int[] vetor) {
        Integer[] array = new Integer[vetor.length];

        for (int i = 0; i < vetor.length; i++) {
            array[i] = vetor[i];
        }

        Arrays.sort(array, Comparator.reverseOrder());
        System.out.println(Arrays.toString(array));
    }

    private void preencherVetor(int[] vetor) {
        if (vetor == null) {
            System.out.println("[ E ]: O vetor não foi criado.");
            return;
        }

        System.out.print(">> Preencher vetor\n" +
                         "Informe o valor máximo do vetor: ");

        String buffer = SCANNER.nextLine();
        int    valor  = -1;

        try {
            valor = Integer.parseInt(buffer);
        } catch (NumberFormatException e) {
            System.out.println("[ E ]: Entrada inválida.");
        }

        if (valor < 0) {
            System.out.println("[ E ]: O valor não é válido.");
            preencherVetor(vetor);
        }

        Random random = new Random();

        for (int i = 0; i < vetor.length; i++) {
            vetor[i] = random.nextInt(valor + 1);
        }
    }


    @Override
    public void run() {
        int[] vetor = null;
        int   opcao;

        do {
            opcao = menuPrincipal();

            switch (opcao) {
                case 1:
                    vetor = criarVetor();
                    break;
                case 2:
                    preencherVetor(vetor);
                    break;
                case 3:
                    listar(vetor);
                    break;
                case 4:
                    ordenar(vetor);
                    break;
                case 5:
                    buscar(vetor);
                    break;
                default:
                    break;
            }
        } while (opcao != 0);
    }
}