Noções básicas de Java - classe Scanner

1. Visão Geral

(1) ScannerClasse é uma classe de ferramenta em Java para leitura de entradas do usuário . Ele pode ler dados de uma variedade de fontes de entrada , como entrada padrão, arquivos ou strings. A classe Scanner fornece uma série de métodos para lidar com a entrada de diferentes tipos de dados, como inteiros, números de ponto flutuante, valores booleanos, caracteres e strings.

(2) Existem dois métodos importantes na classe Scanner:

• Métodos começando com hasNext: usados ​​para verificar se a próxima tag está disponível na fonte de entrada, comumente usados ​​são:
  • hasNext(): Retorna verdadeiro se houver um próximo token (caractere sem espaço) restante na fonte de entrada.
  • hasNextLine(): Retorna verdadeiro se houver uma próxima linha (linha não vazia) na fonte de entrada.
  • hasNextInt(): Retorna verdadeiro se houver o próximo número inteiro na fonte de entrada.
  • hasNextDouble(): Retorna verdadeiro se houver outro ponto flutuante na fonte de entrada.
  • hasNextBoolean(): Retorna verdadeiro se houver um próximo valor booleano na fonte de entrada.
• Os métodos que começam com next: usados ​​para obter a próxima tag da fonte de entrada e retornar o tipo de dados correspondente, comumente usados ​​são:
  • next(): obtém e retorna uma string da fonte de entrada. Por padrão, um espaço é usado como separador e Enter é usado como caractere final. O conteúdo após Enter é colocado no buffer.
  • nextLine(): busca e retorna uma linha de strings (delimitada por novas linhas) da fonte de entrada.
  • nextInt(): Obtém e retorna um número inteiro da fonte de entrada.
  • nextDouble(): obtém e retorna um número de ponto flutuante da fonte de entrada.
  • nextBoolean(): obtém e retorna um valor booleano ("true" ou "false") da fonte de entrada.

(3) next()e nextLine()Existem algumas diferenças nos métodos de processamento e cenários de uso:

• next()método:
  • A string lida não contém delimitadores, se houver mais de uma palavra separada por espaço na entrada, next()o método retornará apenas a primeira palavra .
  • Os espaços em branco iniciais na entrada são ignorados antes da leitura .
• nextLine()método:
  • Lê e retorna uma linha completa de string da fonte de entrada, incluindo newlines \n.
  • Ele lê todo o conteúdo da fonte de entrada até que um caractere de nova linha seja encontrado ou a entrada termine.
  • nextLine()A string retornada pelo método pode conter espaços e outros caracteres especiais.

2. Exemplo de uso

2.1. Lendo dados de diferentes fontes de entrada

Ao usar a classe Scanner, os dados podem ser lidos de várias fontes de entrada, incluindo entrada padrão, arquivos e strings. Aqui estão alguns exemplos usando diferentes fontes de entrada:

(1) Ler dados do fluxo de entrada padrão

public class Example {
    
    
    public static void main(String[] args) {
    
    
        // 创建 Scanner 对象，使用标准输入流作为输入源
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个整数：");
        int number = scanner.nextInt(); // 从标准输入流读取整数

        System.out.println("你输入的整数是：" + number);

        scanner.close();
    }
}

Neste exemplo, criamos um objeto Scanner com o fluxo de entrada padrão (System.in) como fonte de entrada. Em seguida, usamos nextInt()o método para ler um número inteiro do fluxo de entrada padrão.

(2) Ler dados do arquivo

public class Example {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            // 创建 Scanner 对象，使用文件作为输入源
            Scanner scanner = new Scanner(new File("input.txt"));

            while (scanner.hasNextLine()) {
    
    
                String line = scanner.nextLine(); // 从文件读取一行数据
                System.out.println(line);
            }

            scanner.close();
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        }
    }
}

Neste exemplo, criamos um objeto Scanner com o arquivo "input.txt" como fonte de entrada. Em seguida, usamos o método hasNextLine()and nextLine()para percorrer cada linha de dados do arquivo e imprimi-lo.

(3) Ler dados da string

public class Example {
    
    
    public static void main(String[] args) {
    
    
        String input = "Hello World 123";
        // 创建 Scanner 对象，使用字符串作为输入源
        Scanner scanner = new Scanner(input);
        while (scanner.hasNext()) {
    
    
            if (scanner.hasNextInt()) {
    
    
                int number = scanner.nextInt(); // 从字符串读取整数
                System.out.println("整数：" + number);
            } else {
    
    
                String word = scanner.next(); // 从字符串读取单词
                System.out.println("单词：" + word);
            }
        }
        scanner.close();
    }
}

Neste exemplo, criamos um objeto Scanner com a string "Hello World 123" como fonte de entrada. hasNext()Em seguida , usamos os métodos hasNextInt()e next()para percorrer cada palavra ou número inteiro na string e imprimi-la.

2.2. A diferença entre next() e nextLine()

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

        // next() && nextLine()
        System.out.println("请输入一个字符串 nextLine():");
        String str1 = scanner.nextLine();
        System.out.println(str1);

        System.out.println("请输入一个字符串 next():");
        String str2 = scanner.next();
        System.out.println(str2);
    }
}

O resultado é o seguinte:

请输入一个字符串 nextLine():
   Hello World  
nextLine() 的读取结果为: 
   Hello World  

请输入一个字符串 next():
   Hello   World
next() 的读取结果为: 
Hello

2.3. Leia uma matriz unidimensional de tamanho conhecido

Descrição: A entrada na primeira linha é um inteiro n, representando o comprimento do array nums, a entrada na segunda linha é n inteiros e os inteiros são separados por espaços. Armazene esses números inteiros no array nums e imprima-os. Por exemplo:

7
4 9 0 -1 6 8 9

(1) Use para nextInt()ler um por um:

class Solution {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        //数组的长度
        int n = scanner.nextInt();
        int[] nums = new int[n];
        //数组中的 n 个数
        for (int i = 0; i < n; i++) {
    
    
            nums[i] = scanner.nextInt();
        }
        System.out.println("数组 nums 的元素为:");
        for (int num : nums) {
    
    
            System.out.print(num + " ");
        }
        scanner.close();
    }
}

O resultado é o seguinte:

7
4 9 0 -1 6 8 9
数组 nums 的元素为:
4 9 0 -1 6 8 9 

(2) Use nextLine()para ler todos eles primeiro e depois interpretá-los um por um:

class Solution {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        //清除缓冲区中的换行符
        scanner.nextLine();
        int[] nums = new int[n];
        String input = scanner.nextLine();
        //以一个或者多个空格为分隔符
        String[] numStrings = input.split("\\s+");
        for (int i = 0; i < n; i++) {
    
    
            nums[i] = Integer.parseInt(numStrings[i]);
        }
        System.out.println("数组 nums 的元素为：");
        for (int num : nums) {
    
    
            System.out.print(num + " ");
        }
        scanner.close();
    }
}

Precauções:

• Observe que nextInt()depois de ler um número inteiro usando o método, o buffer ainda conterá uma nova linha \n. Isso ocorre porque nextInt()apenas a parte inteira é lida, não o caractere de nova linha. Quando o método é chamado next nextLine(), ele lê o restante do buffer, a parte que contém apenas os caracteres de nova linha. Portanto, para garantir que nextLine()o método possa ler toda a linha da string inserida pelo usuário, precisamos nextLine()limpar o caractere de nova linha no buffer antes de chamar o método.
• Ao chamar, scanner.nextLine()mas não armazenar seu resultado em uma variável, estamos na verdade dizendo que queremos apenas ler o buffer e descartar a nova linha. Dessa forma, nextLine()quando o método for chamado em seguida, ele lerá o conteúdo da linha inserida pelo usuário e o salvará na string inputsem ser perturbado pelas quebras de linha anteriores. É uma prática comum garantir que as novas linhas no buffer sejam limpas para evitar situações em que ocorra entrada incorreta ou entrada ignorada devido a novas linhas persistentes.
• scanner.nextLine()Se não houver tal linha de instrução no código acima , ocorrerá o seguinte erro:

7
Exception in thread "main" java.lang.NumberFormatException: For input string: ""
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:592)
	at java.lang.Integer.parseInt(Integer.java:615)
	at Solution.main(Solution.java:15)

2.4. Leia um array unidimensional de tamanho desconhecido

Descrição: Insira vários números inteiros, separados por espaços. Armazene esses números inteiros no array nums e imprima-os. Por exemplo:

1 12 3 4 5 6 

(1) Use para nextInt()ler um por um:

class Solution {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        List<Integer> nums = new ArrayList<>();
        while (scanner.hasNextInt()) {
    
    
            nums.add(scanner.nextInt());
        }
        System.out.println("数组 nums 的元素为：");
        for (int num : nums) {
    
    
            System.out.print(num + " ");
        }
        scanner.close();
    }
}

Precauções:

• Se você inserir manualmente vários números inteiros no console e esperar que o programa termine de ler os números inteiros após interromper manualmente a entrada, você poderá usar outros métodos para indicar as condições para encerrar a entrada. Uma forma comum é indicar o final inserindo um caractere ou string específico;
• Como é lido um por um, o comprimento do array não é conhecido antecipadamente, então o código acima usa lista para armazenar;

(2) Use nextLine()para ler todos eles primeiro e depois interpretá-los um por um:

class Solution {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        input = input.trim();
        String[] numStrings = input.split("\\s+");
        int[] nums = new int[numStrings.length];
        for (int i = 0; i < numStrings.length; i++) {
    
    
            nums[i] = Integer.parseInt(numStrings[i]);
        }
        System.out.println("数组 nums 的元素为：");
        for (int num : nums) {
    
    
            System.out.print(num + " ");
        }
        scanner.close();
    }
}

O resultado é o seguinte:

1 12 3 4 5 6 
数组 nums 的元素为：
1 12 3 4 5 6 

2.5. Ler matriz bidimensional com comprimento conhecido

Descrição: A primeira linha de entrada é um inteiro m, indicando o comprimento do array bidimensional nums, seguido por m linhas, cada linha possui n inteiros e os inteiros são separados por espaços. Por exemplo:

3
1 8 7 3
2 3 4 5
4 5 6 7

class Solution {
    
    
    public static void main(String[] args) {
    
    
        Scanner scanner = new Scanner(System.in);
        // 读取整数 m 作为二维数组的长度
        int m = scanner.nextInt();
        scanner.nextLine(); // 读取换行符
        //创建二维数组 nums
        int[][] nums = new int[m][];
        //读取m行数据到二维数组 nums
        for (int i = 0; i < m; i++) {
    
    
            //读取整行数据
            String line = scanner.nextLine();
            //将每个整数分割保存到一维数组
            String[] values = line.split("\\s+");
            //创建长度为 n 的一维数组
            int n = values.length;
            nums[i] = new int[n];
            //保存每个整数到一维数组
            for (int j = 0; j < n; j++) {
    
    
                nums[i][j] = Integer.parseInt(values[j]);
            }
        }
        //打印二维数组 nums
        System.out.println("数组 nums 的元素为:");
        for (int i = 0; i < m; i++) {
    
    
            for (int j = 0; j < nums[i].length; j++) {
    
    
                System.out.print(nums[i][j] + " ");
            }
            System.out.println();
        }
    }
}

O resultado é o seguinte:

3
1 8 7 3
2 3 4 5
4 5 6 7
数组 nums 的元素为:
1 8 7 3 
2 3 4 5 
4 5 6 7 

2.6. Leia uma matriz bidimensional irregular de comprimento desconhecido

Descrição: Insira várias linhas, cada linha possui vários números inteiros, os números inteiros são separados por espaços e os números inteiros em cada linha não são necessariamente iguais. Por exemplo:

1 2 3 45 
3 4 
9 0 -1 2 
1 4 6 
4 6 7 8 7 

class Solution {
    
    
    public static void main(String[] args) {
    
    
    	//也可选择使用字符串作为输入，方便测试
        String input = "1 2 3 45\n" +
                "3 4\n" +
                "9 0 -1 2\n" +
                "1 4 6\n" +
                "4 6 7 8 7";
                
        Scanner scanner = new Scanner(System.in);
        List<List<Integer>> nums = new ArrayList<>();
        // 逐行读取数据并保存到二维数组锯齿 nums
        while (scanner.hasNextLine()) {
    
    
            String line = scanner.nextLine();
            if (line.isEmpty()) {
    
    
                break; // 输入结束
            }
            String[] values = line.split("\\s+");
            List<Integer> row = new ArrayList<>();
            for (String value : values) {
    
    
                row.add(Integer.parseInt(value));
            }
            nums.add(row);
        }
        //打印二维锯齿数组 nums
        for (List<Integer> row : nums) {
    
    
            for (Integer value : row) {
    
    
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

O resultado é o seguinte:

1 2 3 45
3 4
9 0 -1 2
1 4 6
4 6 7 8 7

数组 nums 的元素为:
1 2 3 45 
3 4 
9 0 -1 2 
1 4 6 
4 6 7 8 7