You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: README.md
+178-1Lines changed: 178 additions & 1 deletion
Original file line number
Diff line number
Diff line change
@@ -19,10 +19,13 @@ meu [Whatsapp apenas clicando aqui.](https://api.whatsapp.com/send?phone=5581997
19
19
*[Operadores](#operadores)
20
20
*[Estruturas de Controle](#estruturascontrole)
21
21
*[Arrays Unidimensionais (Vetores)](#arrays)
22
+
*[Entrada de Dados](#input)
22
23
23
24
*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)
*[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)
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
434
437
exceptions (exceções) como a IndexOutOfBounds (Um erro que ocorre quando tentamos
435
438
acessar um elemento que excede o tamanho máximo do array ou em algumas outras ocasiões envolvendo
436
439
seu índice).
440
+
441
+
##
442
+
443
+
### <aname="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
+
importjava.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
+
importjava.util.Scanner;
461
+
462
+
publicclassEntradaDeDados {
463
+
publicstaticvoidmain(String[] args) {
464
+
Scanner input =newScanner(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
+
importjava.util.Scanner;
504
+
505
+
publicclassEntradaDeDados {
506
+
publicstaticvoidmain(String[] args) {
507
+
Scanner input =newScanner(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
+
importjava.util.Scanner;
565
+
566
+
publicclassEntradaDeDados {
567
+
publicstaticvoidmain(String[] args) {
568
+
Scanner input =newScanner(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
+
importjava.util.Scanner;
595
+
596
+
publicclassEntradaDeDados {
597
+
publicstaticvoidmain(String[] args) {
598
+
Scanner input =newScanner(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