Skip to content

Commit 42790fb

Browse files
authored
Adicionado tópico de entrada de dados
1 parent dcc0207 commit 42790fb

File tree

1 file changed

+178
-1
lines changed

1 file changed

+178
-1
lines changed

README.md

Lines changed: 178 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,10 +19,13 @@ meu [Whatsapp apenas clicando aqui.](https://api.whatsapp.com/send?phone=5581997
1919
* [Operadores](#operadores)
2020
* [Estruturas de Controle](#estruturascontrole)
2121
* [Arrays Unidimensionais (Vetores)](#arrays)
22+
* [Entrada de Dados](#input)
2223

2324
*Listas de Exercicios:* (Para verificar as respostas entre no diretório de resoluções na pasta src logo após e selecione a dificuldade, em seguida procure a classe que mais se adepta a questão, por exemplo, a questão de número 1 na dificuldade díficil no arquivo .txt é a questão que envolve números de Mersenne, logo, sua classe será a NumerosMersenne)
25+
2426
* [Estruturas Condicionais](https://github.com/Ivi-SCD/Logica-da-Programacao-1P/tree/main/Listas%20de%20Exercicios/Estruturas%20Condicionais)
25-
* [Arrays](https://github.com/Ivi-SCD/Logica-da-Programacao-1P/tree/main/Listas%20de%20Exercicios/Arrays)
27+
* [Estruturas de Repetição](https://github.com/Ivi-SCD/Programming-Logic-Java/blob/main/Listas%20de%20Exercicios/Estruturas%20de%20Repeti%C3%A7%C3%A3o/01-ListaExercicios-EstruturasRepeticao.md)
28+
* [Arrays](https://github.com/Ivi-SCD/Programming-Logic-Java/blob/main/Listas%20de%20Exercicios/Arrays/01-ListaExercicios-arrays.md)
2629

2730
## Vamos lá, Mão na massa!
2831
Primeiro vamos começar falando sobre a própria linguagem que será utilizada em sala a linguagem Java,
@@ -434,3 +437,177 @@ No entanto, é importante ter cuidado ao trabalhar com arrays para evitar
434437
exceptions (exceções) como a IndexOutOfBounds (Um erro que ocorre quando tentamos
435438
acessar um elemento que excede o tamanho máximo do array ou em algumas outras ocasiões envolvendo
436439
seu índice).
440+
441+
##
442+
443+
### <a name="input"></a> Entrada de Dados (Input)
444+
445+
Uma das tarefas mais comuns em programas Java e em qualquer outra linguagem de programação é a entrada de dados pelo usuário.
446+
Existem muitas maneiras de se fazer isso em Java, mas a mais comum é através da classe Scanner, que irei tratar neste tópico,
447+
ele se encontra disponível na biblioteca padrão do Java, ou seja não precisaremos de dependências externas como baixar algo pela internet.
448+
449+
Pra usar a classe `Scanner`, você precisa primeiro importar a classe (Este conceito de importações você entenderá melhor
450+
com o decorrer no tempo) no início do seu código:
451+
452+
```java
453+
import java.util.Scanner;
454+
```
455+
456+
Em seguida, você pode criar uma instância da classe Scanner (Que nem fizemos na seção de Arrays unidimensionais) e usar seus métodos para obter dados do usuário.
457+
Aqui está um exemplo bem simples que pede ao usuário para inserir seu nome e, em seguida, imprime uma saudação personalizada:
458+
459+
```java
460+
import java.util.Scanner;
461+
462+
public class EntradaDeDados {
463+
public static void main(String[] args) {
464+
Scanner input = new Scanner(System.in);
465+
466+
System.out.print("Digite seu nome: ");
467+
String nome = input.nextLine();
468+
469+
System.out.println("Olá, " + nome + "!");
470+
}
471+
}
472+
```
473+
474+
Nesse exemplo, o método `nextLine()` é usado pra obter uma **linha inteira de entrada do usuário** (A função `nextLine()`
475+
usamos quando queremos obter `Strings`) do usuário que é armazenada na variável `nome`.
476+
A seguir, é impresso uma saudação personalizada na tela usando a concatenação de `String`.
477+
478+
Além do `nextLine()`, a classe Scanner possui vários outros métodos para obter diferentes tipos de entrada do usuário,
479+
incluindo `nextInt()`, `nextDouble()`, `nextBoolean()`, entre outros. Cada método é projetado para lidar com um tipo específico de dados.
480+
481+
É importante lembrar que a classe `Scanner` pode lançar exceções se houver problemas ao ler a entrada do usuário,
482+
como quando o usuário digita um valor que não pode ser convertido pro tipo esperado. Portanto,
483+
é uma boa prática usar as declarações `try-catch` (Trataremos mais sobre este assunto quando o repositório
484+
de Orientação a Objetos estiver disponível) para lidar com essas exceções.
485+
e garantir que o programa não pare de funcionar abruptamente.
486+
487+
##
488+
489+
#### Exemplos Adicionais De Entrada de Dados em Java
490+
491+
Para receber entrada de dados de diferentes tipos em Java,
492+
a classe Scanner possui métodos específicos pra cada tipo de dado. Alguns exemplos são:
493+
494+
`nextInt()`: lê um número inteiro;
495+
`nextFloat()`: lê um número de ponto flutuante de precisão simples;
496+
`nextDouble()`: lê um número de ponto flutuante de precisão dupla;
497+
`nextBoolean()`: lê um valor booleano (true ou false);
498+
`nextLine()`: lê uma linha completa de entrada como uma string.
499+
500+
Veja um exemplo de como usar o método `nextInt()` para ler um número inteiro:
501+
502+
```java
503+
import java.util.Scanner;
504+
505+
public class EntradaDeDados {
506+
public static void main(String[] args) {
507+
Scanner input = new Scanner(System.in);
508+
509+
System.out.print("Digite um número inteiro: ");
510+
int num = input.nextInt();
511+
512+
System.out.println("O número digitado foi " + num);
513+
}
514+
}
515+
```
516+
517+
Este exemplo pede ao usuário para digitar um número inteiro e armazena o valor digitado na variável `num`.
518+
Em seguida, imprime na tela uma mensagem contendo o seu número.
519+
520+
Você também pode usar a classe `Scanner` para ler outros tipos de dados,
521+
como `float`, `double`, `boolean`, entre outros, usando os métodos correspondentes.
522+
523+
#### Mas... Como o Scanner funciona internamente?
524+
525+
O `Scanner` é uma classe da biblioteca padrão do Java que fornece métodos para ler dados do usuário ou de um arquivo
526+
(Sim, podemos ler dados guardados em arquivos com a classe Scanner). Confira aqui um [Artigo adicional da Alura](https://www.alura.com.br/artigos/lendo-arquivos-texto-em-java) que oferece um exemplo de como podemos usar o Scanner para ler arquivos.
527+
528+
Internamente, a classe Scanner usa expressões regulares para encontrar padrões de entrada e converter os dados em valores do tipo apropriado.
529+
530+
Quando você cria uma instância da classe `Scanner`, pode especificar a fonte de entrada de dados,
531+
que pode ser o sistema de entrada padrão (`System.in`) ou um arquivo.
532+
533+
Quando você chama um método de leitura, como `nextInt()` ou `nextLine()`, o Scanner lê a entrada até encontrar um padrão
534+
que corresponda ao tipo de dado solicitado. Por exemplo, ao usar o método `nextInt()`, o Scanner procura o
535+
próximo valor inteiro na entrada. Se encontrar um valor inteiro, converte esse valor para um inteiro e retorna esse valor.
536+
537+
Se a entrada não corresponder ao tipo de dado esperado, o `Scanner` lançará uma exceção do tipo `InputMismatchException`.
538+
Por exemplo, se você chamar o método `nextInt()` para ler um valor inteiro e a entrada contiver um
539+
valor de ponto flutuante, o Scanner lançará essa exceção.
540+
541+
Para lidar com exceções lançadas pelo Scanner, você pode usar uma declaração `try-catch`, como falei anteriormente.
542+
Além disso, é sempre uma boa prática verificar a entrada do usuário antes de tentar
543+
convertê-la pro tipo de dado desejado.
544+
545+
#### Buffering e Possíveis Problemas com o Scanner
546+
547+
O buffering é um conceito importante pra compreender a entrada e saída dos dados. Quando você lê ou escreve dados em Java,
548+
esses dados são armazenados em um buffer temporário antes de serem transferidos pro dispositivo de entrada ou saída.
549+
550+
O Scanner também usa um buffer interno para armazenar os dados de entrada antes de serem lidos pelo programa.
551+
Isso significa que, quando você chama um método de leitura, como `nextInt()` ou `nextLine()`,
552+
o `Scanner` lê dados do buffer em vez de ler diretamente da entrada.
553+
554+
Por isso, é bastante comum problemas ocorrerem com o Scanner devido a como este buffering funciona.
555+
Por exemplo, se você chamar o método `nextLine()` depois de chamar um método de leitura diferente, como `nextInt()`,
556+
pode ocorrer um problema de "quebra de linha". Isso ocorre porque, quando chamamos o método `nextInt()`,
557+
o `Scanner` deixa uma nova linha não lida no buffer. Quando você chama `nextLine()`, o Scanner lê
558+
essa nova linha em vez de esperar que o usuário digite uma nova entrada.
559+
560+
Para resolver esse problema, você pode chamar o método `nextLine()` imediatamente após chamar um método de leitura diferente,
561+
pra consumir a nova linha deixada pelo método anterior. Aqui está um exemplo:
562+
563+
```java
564+
import java.util.Scanner;
565+
566+
public class EntradaDeDados {
567+
public static void main(String[] args) {
568+
Scanner input = new Scanner(System.in);
569+
570+
System.out.print("Digite um número inteiro: ");
571+
int num = input.nextInt();
572+
input.nextLine(); // consome a nova linha deixada pelo nextInt()
573+
574+
System.out.print("Digite uma string: ");
575+
String str = input.nextLine();
576+
577+
System.out.println("Você digitou o número " + num + " e a string \"" + str + "\"");
578+
}
579+
}
580+
```
581+
582+
Neste exemplo, o método `nextLine()` é chamado imediatamente após o `nextInt()` para consumir a nova linha deixada pelo método anterior.
583+
Em seguida, o programa solicita ao usuário que digite uma string usando o método `nextLine()` e armazena a entrada em uma
584+
variável str. Finalmente, o programa imprime na tela os valores digitados pelo usuário.
585+
586+
Outro problema comum que pode ocorrer com o Scanner é o "`NoSuchElementException`". Isso ocorre quando o Scanner tenta ler dados da entrada,
587+
mas não há mais dados para serem lidos. Isso pode acontecer se o usuário pressionar `CTRL+Z ou CTRL+D` (dependendo do sistema operacional)
588+
durante a entrada de dados.
589+
590+
Para evitar essa exceção, você pode usar a condição `hasNext()` antes de chamar um método de leitura
591+
pra verificar se há mais dados para serem lidos. Aqui está um exemplo:
592+
593+
```java
594+
import java.util.Scanner;
595+
596+
public class EntradaDeDados {
597+
public static void main(String[] args) {
598+
Scanner input = new Scanner(System.in);
599+
600+
while(input.hasNext()) {
601+
String line = input.nextLine();
602+
System.out.println("Você digitou: " + line);
603+
}
604+
}
605+
}
606+
```
607+
608+
Nesse exemplo, o programa usa um loop para ler as linhas de entrada até que não haja mais dados para serem lidos.
609+
O método `hasNext()` (TEM PROXIMO?) é usado pra verificar se existe um próximo dado, se houver, o loop continua executando.
610+
Dentro do loop, o programa lê cada linha de entrada usando o método nextLine() e imprime na tela a
611+
String "Você digitou: " seguida pela linha digitada pelo usuário.
612+
613+
Com isso, você pode garantir que o programa não vai tentar ler mais dados do que o usuário inseriu, evitando o `NoSuchElementException`.

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy