Por que a lógica de programação é tão importante?

Compreendendo a lógica de programação em Java

• Estruturas de controle: if/else, switch/case, for, while, etc.

• Estruturas de dados: arrays, listas, dicionários.

• Orientação a Objetos: classes, objetos, herança, polimorfismo.

Para mais informações e suporte nos conceitos iniciais, explore os seguintes artigos:

• Como começar a aprender Java: Guia para iniciantes

• Estruturas condicionais em Java: Guia para iniciantes

• Trabalhando com métodos em Java

• Java: Guia sobre vetores

• Java: Dominando estruturas de repetição

• Java: Construtores e como usá-los

• Entenda vetores em Java

• Guia completo sobre ordenação com Java

• Java: Por dentro da abstração em POO

Agora, com uma base sólida, vamos explorar alguns problemas de lógica clássicos e suas soluções.

Problemas clássicos de lógica e suas soluções em Java

1. Calculadora básica

import java.util.Scanner;

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

        System.out.println("Digite o primeiro número:");
        double num1 = sc.nextDouble();

        System.out.println("Digite o operador (+, -, *, /):");
        char operador = sc.next().charAt(0);

        System.out.println("Digite o segundo número:");
        double num2 = sc.nextDouble();

        double resultado = 0;
        boolean operacaoValida = true;

        switch (operador) {
            case '+':
                resultado = num1 + num2;
                break;
            case '-':
                resultado = num1 - num2;
                break;
            case '*':
                resultado = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    resultado = num1 / num2;
                } else {
                    System.out.println("Erro: Divisão por zero!");
                    operacaoValida = false;
                }
                break;
            default:
                System.out.println("Operador inválido!");
                operacaoValida = false;
                break;
        }

        if (operacaoValida) {
            System.out.println("Resultado: " + resultado);
        }
    }
}

A estrutura switch utilizada permite organizar operações com base no operador escolhido pelo usuário, facilitando a legibilidade do código.

2. Fatorial de um número

public class Fatorial {
    public static int calcularFatorial(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("Número deve ser não negativo.");
        } else if (n == 0 || n == 1) {
            return 1;
        } else {
            return n * calcularFatorial(n - 1);
        }
    }

    public static void main(String[] args) {
        int numero = 5;
        System.out.println("Fatorial de " + numero + " é: " + calcularFatorial(numero));
    }
}

A recursão, quando bem empregada, traz eficiência e clareza ao código.

3. Sequência de Fibonacci

public class Fibonacci {
    public static void main(String[] args) {
        int n = 10;  // Número de termos
        int a = 0, b = 1;

        if (n <= 0) {
            System.out.println("O número de termos deve ser positivo.");
        } else if (n == 1) {
            System.out.println("Sequência de Fibonacci: " + a);
        } else {
            System.out.print("Sequência de Fibonacci: " + a + " " + b);

            for (int i = 2; i < n; i++) {
                int c = a + b;
                System.out.print(" " + c);
                a = b;
                b = c;
            }
        }
    }
}

A sequência de Fibonacci pode ser observada em padrões da natureza, como na disposição de folhas e espirais.

4. Máximo divisor comum (MDC)

public class MDC {
    public static int calcularMDC(int a, int b) {
        while (b != 0) {
            int resto = a % b;
            a = b;
            b = resto;
        }
        return a;
    }

    public static void main(String[] args) {
        int num1 = 56, num2 = 98;
        System.out.println("MDC de " + num1 + " e " + num2 + " é: " + calcularMDC(num1, num2));
    }
}

Este algoritmo foi desenvolvido por Euclides há mais de 2.000 anos e ainda é amplamente utilizado por sua eficiência.

5. Verificar palíndromo

import java.text.Normalizer;

public class Palindromo {
    public static boolean ePalindromo(String texto) {
        // Remover acentuação e normalizar
        String textoLimpo = Normalizer.normalize(texto, Normalizer.Form.NFD)
                .replaceAll("[^\\p{ASCII}]", "");
        // Remover espaços e caracteres não alfanuméricos
        textoLimpo = textoLimpo.replaceAll("[\\W]", "").toLowerCase();

        String textoInvertido = new StringBuilder(textoLimpo).reverse().toString();
        return textoLimpo.equals(textoInvertido);
    }

    public static void main(String[] args) {
        String palavra = "A grama é amarga";
        System.out.println("\"" + palavra + "\" é palíndromo? " + ePalindromo(palavra));
    }
}

Utilizar StringBuilder para inverter a string é uma escolha eficiente e economiza recursos.

6. Ordenação de palavras (bubble sort)

import java.util.Arrays;

public class BubbleSort {
    public static void bubbleSort(String[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j].compareTo(array[j + 1]) > 0) {
                    String temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        String[] palavras = { "java", "rocketseat", "dev", "foguete" };
        bubbleSort(palavras);
        System.out.println(Arrays.toString(palavras));
    }
}

Embora o bubble sort não seja o algoritmo de ordenação mais eficiente, ele é uma excelente ferramenta didática para compreender algoritmos de ordenação.

Dicas para resolver problemas de lógica em Java

• Decomponha o problema: divida-o em partes menores e resolva passo a passo.

• Use depuração: debugar o código vai te ajudar a entender exatamente o que está acontecendo.

• Escreva testes: garanta que seu código funcione como esperado.

• Explore bibliotecas: Java tem uma rica coleção de bibliotecas que podem facilitar sua vida.

Interessado em aprofundar ainda mais seus conhecimentos? Baixe nosso eBook gratuito "Por Dentro de uma Aplicação Spring Boot" para uma visão completa do desenvolvimento de aplicações robustas. 👉 baixe o eBook.

Conclusão

O que você vai encontrar na formação:

• Desenvolvimento de aplicações completas e escaláveis com Spring Boot;

• Projetos práticos que te colocam no centro de situações reais do mercado;

• Aprendizado das tecnologias mais utilizadas, como Java, Maven, VS Code e Rest API;

• Suporte personalizado com nossa IA da Rocketseat e acesso à equipe de Sucesso do Aluno sempre que precisar.

Além disso, oferecemos:

• Tutorias individuais para tirar dúvidas sobre estudos e carreira;

• Bate-papos em grupo semanais para fortalecer seu networking;

• Café com os instrutores ao vivo, com conteúdos exclusivos sobre estudos e carreira;

• Talent space: uma semana de eventos focados em conexões com empresas, dicas e oportunidades de carreira;

• Mentoria de carreira, com 5 encontros focados em autoconhecimento, LinkedIn, currículo, portfólio e muito mais.

Se o seu objetivo é se tornar um desenvolvedor Java completo e preparado para os desafios do mercado, a formação Java da Rocketseat é o caminho. Vamos juntos?