O detalhe que separa um código comum de um sistema profissional: vírgulas decimais em Java com Scanner

Existe um momento curioso na vida de todo desenvolvedor que trabalha com Java. Você escreve seu código, testa tudo, recebe os dados corretamente… e então percebe um pequeno detalhe que muda completamente a percepção do seu sistema: os números estão sendo exibidos com ponto, quando o usuário espera vírgula.

Pode parecer algo insignificante à primeira vista. Afinal, o valor numérico está correto. Mas, na prática, esse tipo de detalhe comunica muito sobre a qualidade da aplicação. Para quem está no Brasil, ver “1234.56” em vez de “1234,56” gera estranhamento imediato. Em sistemas financeiros, relatórios ou até mesmo interfaces simples, isso pode transmitir uma sensação de descuido.

E é exatamente aqui que entra a importância de entender como lidar com entrada de dados via teclado usando Scanner e como exibir esses dados de forma adequada com System.out.println.

Quando utilizamos o Scanner, estamos abrindo uma porta direta entre o usuário e o sistema. É o momento em que a pessoa interage com o programa, digita informações, participa ativamente.

E essa interação precisa ser fluida. Um pequeno erro na forma como os dados são interpretados pode quebrar completamente essa experiência.

Imagine o seguinte cenário: você pede para o usuário digitar um valor decimal. Ele, naturalmente, digita no padrão que está acostumado — com vírgula. E o que acontece? O programa simplesmente quebra ou lança uma exceção. Frustrante, não é?

Isso acontece porque, por padrão, o Scanner no Java espera números no formato internacional, ou seja, com ponto como separador decimal. Então, se você não fizer nenhum ajuste, seu sistema estará preparado para um padrão… enquanto seu usuário utiliza outro.

Vamos observar um exemplo simples para entender melhor:

import java.util.Scanner;
public class Sistema {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Digite um valor decimal:");
        double valor = sc.nextDouble();
        System.out.println("Valor informado: " + valor);
    }
}

Esse código funciona perfeitamente — desde que o usuário digite algo como:

1234.56

Mas no contexto brasileiro, o mais comum seria:

1234,56

E nesse caso, o programa falha.

A solução para isso não é improvisar nem tentar “corrigir depois”. A solução correta é alinhar o sistema ao contexto do usuário desde o início.

E o Java já oferece isso de forma elegante através da classe Locale.

Ao configurar o Scanner com o Locale brasileiro, você está basicamente dizendo: “ei, sistema, agora você está falando com um usuário do Brasil — se comporte como tal”.

O código ajustado fica assim:

import java.util.Scanner;
import java.util.Locale;
public class Sistema {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in).useLocale(new Locale("pt", "BR"));
        System.out.println("Digite um valor decimal:");
        double valor = sc.nextDouble();
        System.out.println("Valor informado: " + valor);
    }
}

Agora o programa aceita naturalmente entradas como:

1234,56

Mas ainda existe um segundo ponto importante — talvez até mais visível: a forma como o número é exibido.

Mesmo após ler corretamente o valor com vírgula, o Java ainda imprime o número com ponto. Isso acontece porque o tipo double internamente não “guarda” formatação, apenas o valor numérico.

Ou seja, a responsabilidade de exibir corretamente é sua.

E aqui entra uma das soluções mais elegantes e profissionais da linguagem: o uso do String.format com Locale.

Ao aplicar isso, você transforma a saída do sistema em algo muito mais alinhado com a realidade do usuário:

import java.util.Scanner;
import java.util.Locale;
public class Sistema {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in).useLocale(new Locale("pt", "BR"));
        System.out.println("Digite um valor decimal:");
        double valor = sc.nextDouble();
        String valorFormatado = String.format(new Locale("pt", "BR"), "%.2f", valor);
        System.out.println("Valor formatado: " + valorFormatado);
    }
}

Agora sim, o ciclo está completo.

O usuário digita no formato que ele conhece. O sistema interpreta corretamente. E a saída respeita o padrão esperado. Sem gambiarras, sem substituições manuais, sem risco de comportamento inesperado.

Esse tipo de cuidado mostra maturidade no desenvolvimento. Mostra que você não está apenas preocupado em fazer o código funcionar, mas sim em criar uma experiência consistente.

E aqui vai um ponto interessante: esse mesmo conceito se aplica a sistemas muito maiores. Aplicações financeiras, ERPs, sistemas bancários e plataformas de análise de dados lidam com isso o tempo todo. A diferença é que, nesses casos, um pequeno erro de formatação pode gerar confusão real — ou até prejuízo.

Por isso, dominar esse detalhe desde cedo faz uma enorme diferença na sua evolução como desenvolvedor.

Outro ponto importante é evitar soluções improvisadas, como substituir ponto por vírgula manualmente em uma string. Pode até funcionar em um cenário simples, mas rapidamente se torna um problema quando você precisa lidar com milhares, internacionalização ou diferentes formatos.

O caminho profissional é sempre trabalhar com Locale e as ferramentas que a própria linguagem oferece.

No fim das contas, o que parece ser apenas uma vírgula é, na verdade, um reflexo direto da qualidade do seu software. É o tipo de detalhe que o usuário não percebe conscientemente quando está correto… mas percebe imediatamente quando está errado.

E é exatamente aí que mora a diferença entre um sistema comum e um sistema bem construído.