A classe Scanner no pacote java.util fornece métodos para ler entrada do usuário a partir do console. Introduzida no Java 5, ela facilita a captura de dados formatados.

• Sintaxe básica para instanciar: Scanner leitor = new Scanner(System.in);
• É uma boa prática liberar o recurso após o uso com leitor.close();

Para ler strings, os métodos next() e nextLine() são comuns, frequentemente precedidos por verificações como hasNext() e hasNextLine().

• next(): Lê até encontrar um delimitador (como espaço ou nova linha). Ignora espaços iniciais e não captura strings com espaços internos.
• nextLine(): Lê toda a linha até a tecla Enter, incluindo espaços em branco.

Exemplos de código modificdaos para ilustrar o uso:

import java.util.Scanner;

public class LeituraDados {
    public static void main(String[] args) {
        Scanner leitor = new Scanner(System.in);
        System.out.println("Digite uma frase:");
        if (leitor.hasNext()) {
            String texto1 = leitor.next();
            System.out.println("Saída (next): " + texto1);
        }
        leitor.close();
    }
}

public class LeituraLinha {
    public static void main(String[] args) {
        Scanner leitor = new Scanner(System.in);
        System.out.println("Digite uma linha completa:");
        if (leitor.hasNextLine()) {
            String texto2 = leitor.nextLine();
            System.out.println("Saída (nextLine): " + texto2);
        }
        leitor.close();
    }
}

public class LeituraNumeros {
    public static void main(String[] args) {
        Scanner leitor = new Scanner(System.in);
        int inteiro = 0;
        float decimal = 0.0f;

        System.out.println("Insira um valor inteiro:");
        if (leitor.hasNextInt()) {
            inteiro = leitor.nextInt();
            System.out.println("Inteiro recebido: " + inteiro);
        } else {
            System.out.println("Entrada não é um inteiro válido.");
        }

        System.out.println("Insira um valor decimal:");
        if (leitor.hasNextFloat()) {
            decimal = leitor.nextFloat();
            System.out.println("Decimal recebido: " + decimal);
        } else {
            System.out.println("Entrada não é um decimal válido.");
        }
        leitor.close();
    }
}

public class CalculoSoma {
    public static void main(String[] args) {
        Scanner leitor = new Scanner(System.in);
        double total = 0.0;
        int contador = 0;

        System.out.println("Insira números decimais (digite algo não numérico para parar):");
        while (leitor.hasNextDouble()) {
            double valor = leitor.nextDouble();
            contador++;
            total += valor;
            System.out.printf("Valor %d adicionado. Soma parcial: %.2f%n", contador, total);
        }
        System.out.printf("Total de %d números. Soma: %.2f. Média: %.2f%n", contador, total, total / contador);
        leitor.close();
    }
}

Estrutura Sequencial

Na estrutura sequencial, as instruções são executadas uma após a outra, na ordem em que aparecem no código. É a base de qualquer algoritmo.

public class ExemploSequencial {
    public static void main(String[] args) {
        System.out.println("Passo 1: Inicialização");
        System.out.println("Passo 2: Processamento");
        System.out.println("Passo 3: Finalização");
    }
}

Estruturas de Seleção

Estrutura if Simples

import java.util.Scanner;

public class VerificarEntrada {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Digite um texto:");
        String entrada = teclado.nextLine();

        if (entrada.equalsIgnoreCase("iniciar")) {
            System.out.println("Comando reconhecido: " + entrada);
        }
        System.out.println("Fim da verificação.");
        teclado.close();
    }
}

Estrutura if-else

import java.util.Scanner;

public class AvaliarNota {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Informe a nota:");
        int nota = teclado.nextInt();

        if (nota >= 60) {
            System.out.println("Aprovado");
        } else {
            System.out.println("Reprovado");
        }
        teclado.close();
    }
}

Estrutura if-else Encadeada

import java.util.Scanner;

public class ClassificarNota {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Insira a pontuação:");
        int pontuacao = teclado.nextInt();

        if (pontuacao == 100) {
            System.out.println("Excelente!");
        } else if (pontuacao >= 90) {
            System.out.println("Nível A");
        } else if (pontuacao >= 80) {
            System.out.println("Nível B");
        } else if (pontuacao >= 70) {
            System.out.println("Nível C");
        } else if (pontuacao >= 60) {
            System.out.println("Nível D");
        } else if (pontuacao >= 0) {
            System.out.println("Abaixo da média");
        } else {
            System.out.println("Pontuação inválida");
        }
        teclado.close();
    }
}

Estrutura if Aninhada

import java.util.Scanner;

public class VerificacaoDupla {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.println("Digite a nota final:");
        int notaFinal = teclado.nextInt();

        if (notaFinal > 0 && notaFinal <= 100) {
            if (notaFinal >= 90) {
                System.out.println("Desempenho superior");
            }
        }
        teclado.close();
    }
}

Estrutura switch-case

A instrução switch avalia uma expressão e executa o bloco correspondente a um caso. Aceita tipos como byte, short, int, char e String.

public class MapearDia {
    public static void main(String[] args) {
        char dia = 'Q';

        switch (dia) {
            case 'S':
                System.out.println("Segunda-feira");
                break;
            case 'T':
                System.out.println("Terça-feira");
                break;
            case 'Q':
                System.out.println("Quarta-feira");
                break;
            case 'R':
                System.out.println("Quinta-feira");
                break;
            case 'F':
                System.out.println("Sexta-feira");
                break;
            default:
                System.out.println("Dia inválido ou fim de semana");
        }
    }
}

public class BuscarNome {
    public static void main(String[] args) {
        String nome = "Ana";

        switch (nome) {
            case "Ana":
                System.out.println("Usuário Ana identificada.");
                break;
            case "João":
                System.out.println("Usuário João identificado.");
                break;
            default:
                System.out.println("Usuário não reconhecido.");
        }
    }
}

Estruturas de Repetição

Laço while

O laço while repete um bloco enquanto a condição booleana for verdadeira. É crucial garantir que a condição se torne falsa para evitar loops infinitos.

public class SomaSequencia {
    public static void main(String[] args) {
        int acumulador = 0;
        int iterador = 1;
        
        while (iterador <= 50) {
            acumulador += iterador;
            iterador++;
        }
        System.out.println("A soma de 1 a 50 é: " + acumulador);
    }
}

Laço do-while

O laço do-while executa o bloco pelo menos uma vez antes de verificar a condição.

public class SomaDoWhile {
    public static void main(String[] args) {
        int valor = 0;
        int resultado = 0;

        do {
            valor++;
            resultado += valor;
        } while (valor < 25);
        System.out.println("Soma de 1 a 25: " + resultado);
    }
}

Laço for

O laço for é compacto e ideal quando o número de iterações é conhecido.

public class SomaParesImpares {
    public static void main(String[] args) {
        int somaPares = 0;
        int somaImpares = 0;

        for (int num = 0; num <= 100; num++) {
            if (num % 2 == 0) {
                somaPares += num;
            } else {
                somaImpares += num;
            }
        }
        System.out.println("Soma dos pares: " + somaPares);
        System.out.println("Soma dos ímpares: " + somaImpares);
    }
}

public class MultiplosDeCinco {
    public static void main(String[] args) {
        int coluna = 0;
        for (int n = 1; n <= 500; n++) {
            if (n % 5 == 0) {
                System.out.print(n + "\t");
                coluna++;
                if (coluna % 3 == 0) {
                    System.out.println();
                }
            }
        }
    }
}

public class TabuadaMultiplicacao {
    public static void main(String[] args) {
        for (int fator1 = 1; fator1 <= 5; fator1++) {
            for (int fator2 = 1; fator2 <= fator1; fator2++) {
                System.out.printf("%d*%d=%d\t", fator2, fator1, fator2 * fator1);
            }
            System.out.println();
        }
    }
}

Laço for aprimorado (for-each)

Introduzido no Java 5, este laço simplifica a iteração sobre coleções e arrays.

public class IterarArray {
    public static void main(String[] args) {
        double[] valores = {1.5, 2.7, 3.9, 4.1, 5.3};

        System.out.println("Usando for convencional:");
        for (int idx = 0; idx < valores.length; idx++) {
            System.out.println(valores[idx]);
        }

        System.out.println("Usando for-each:");
        for (double elemento : valores) {
            System.out.println(elemento);
        }
    }
}

Instruções break e continue

• break: Interrompe imediatamente a execução do laço corrente.
• continue: Pula para a próxima iteração do laço, ignorando o restante do bloco atual.

public class InterromperLaço {
    public static void main(String[] args) {
        int i = 0;
        while (i < 50) {
            i++;
            if (i == 20) {
                System.out.println("Interrompendo no valor 20.");
                break;
            }
            System.out.print(i + " ");
        }
    }
}

public class PularIteracao {
    public static void main(String[] args) {
        for (int k = 1; k <= 30; k++) {
            if (k % 7 == 0) {
                System.out.println(); // Nova linha a cada múltiplo de 7
                continue;
            }
            System.out.print(k + " ");
        }
    }
}

Uso de Rótulos (labels)

Rótulos permitem direcionar break ou continue para laços exterons em estruturas aninhadas.

public class NumerosPrimosComRotulo {
    public static void main(String[] args) {
        externo: for (int candidato = 50; candidato <= 80; candidato++) {
            for (int divisor = 2; divisor <= candidato / 2; divisor++) {
                if (candidato % divisor == 0) {
                    continue externo;
                }
            }
            System.out.print(candidato + " ");
        }
    }
}

Exercício Prático: Desenhar um Triângulo

Considere imprimir um triângulo de asteriscos usando três laços aninhados: um para espaços, um para a primeira metade dos asteriscos e outro para a segunda metade.

public class GerarTriangulo {
    public static void main(String[] args) {
        int linhas = 6;
        
        for (int i = 1; i <= linhas; i++) {
            for (int espaco = linhas; espaco >= i; espaco--) {
                System.out.print(" ");
            }
            for (int ast1 = 1; ast1 <= i; ast1++) {
                System.out.print("*");
            }
            for (int ast2 = 1; ast2 < i; ast2++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}