Java Language
Scanner

Syntaxis

• Scannerscanner = nieuwe scanner (bronbron);
• Scannerscanner = nieuwe scanner (System.in);

parameters

Opmerkingen

Systeeminvoer lezen met behulp van Scanner

Scanner scanner = new Scanner(System.in); //Scanner obj to read System input
String inputTaken = new String();
while (true) {
    String input = scanner.nextLine(); // reading one line of input
    if (input.matches("\\s+"))         // if it matches spaces/tabs, stop reading
        break;
    inputTaken += input + " ";
}
System.out.println(inputTaken);

Het scannerobject wordt geïnitialiseerd om invoer van het toetsenbord te lezen. Dus voor de onderstaande invoer van keyboar, zal het de uitvoer produceren als Reading from keyboard

Reading
from
keyboard
  //space

Bestandsinvoer lezen met behulp van Scanner

Scanner scanner = null;
try {
    scanner = new Scanner(new File("Names.txt"));
    while (scanner.hasNext()) {
        System.out.println(scanner.nextLine());
    }
} catch (Exception e) {
    System.err.println("Exception occurred!");
} finally {
    if (scanner != null)
        scanner.close();
}

Hier wordt een Scanner object gemaakt door een File object met de naam van een tekstbestand als invoer door te geven. Dit tekstbestand wordt geopend door het File-object en ingelezen door het scannerobject in de volgende regels. scanner.hasNext() controleert of er een volgende regel met gegevens in het tekstbestand staat. Door dat te combineren met een while lus, kunt u alle gegevens in het bestand Names.txt . Om de gegevens zelf op te halen, kunnen we methoden gebruiken zoals nextLine() , nextInt() , nextBoolean() , etc. In het bovenstaande voorbeeld wordt scanner.nextLine() gebruikt. nextLine() verwijst naar de volgende regel in een tekstbestand en door deze te combineren met een scanner kunt u de inhoud van de regel afdrukken. Als u een scannerobject wilt sluiten, gebruikt u .close() .

Met try met bronnen (vanaf Java 7) kan de hierboven genoemde code elegant worden geschreven zoals hieronder.

try (Scanner scanner = new Scanner(new File("Names.txt"))) {
    while (scanner.hasNext()) {
        System.out.println(scanner.nextLine());
    }
} catch (Exception e) {
    System.err.println("Exception occurred!");
}

Lees de hele invoer als een string met behulp van Scanner

U kunt Scanner gebruiken om alle tekst in de invoer als een tekenreeks te lezen, door \Z (gehele invoer) als scheidingsteken te gebruiken. Dit kan bijvoorbeeld worden gebruikt om alle tekst in een tekstbestand op één regel te lezen:

String content = new Scanner(new File("filename")).useDelimiter("\\Z").next();
System.out.println(content);

Vergeet niet dat u de scanner moet sluiten en de IoException vangen IoException dit kan veroorzaken, zoals beschreven in het voorbeeld Bestand lezen met Scanner lezen .

Aangepaste scheidingstekens gebruiken

U kunt aangepaste scheidingstekens (reguliere expressies) gebruiken met Scanner, met .useDelimiter(",") , om te bepalen hoe de invoer wordt gelezen. Dit werkt op dezelfde manier als String.split(...) . U kunt Scanner bijvoorbeeld gebruiken om te lezen uit een lijst met door komma's gescheiden waarden in een tekenreeks:

Scanner scanner = null;
try{
    scanner = new Scanner("i,like,unicorns").useDelimiter(",");;
    while(scanner.hasNext()){
        System.out.println(scanner.next());
    }
}catch(Exception e){
    e.printStackTrace();
}finally{
    if (scanner != null)
        scanner.close();
}

Hiermee kunt u elk element in de invoer afzonderlijk lezen. Merk op dat u dit niet moet gebruiken om CSV-gegevens te parseren. Gebruik in plaats daarvan een juiste CSV-parserbibliotheek, zie CSV-parser voor Java voor andere mogelijkheden.

Algemeen patroon dat het meest wordt gevraagd over taken

Het volgende is hoe de java.util.Scanner klasse correct kan worden gebruikt om gebruikersinvoer van System.in correct te lezen (soms stdin , vooral in C, C ++ en andere talen, evenals in Unix en Linux). Het toont idiomatisch de meest voorkomende dingen aan die moeten worden gedaan.

package com.stackoverflow.scanner;

import javax.annotation.Nonnull;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
import java.util.regex.Pattern;

import static java.lang.String.format;

public class ScannerExample
{
    private static final Set<String> EXIT_COMMANDS;
    private static final Set<String> HELP_COMMANDS;
    private static final Pattern DATE_PATTERN;
    private static final String HELP_MESSAGE;

    static
    {
        final SortedSet<String> ecmds = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        ecmds.addAll(Arrays.asList("exit", "done", "quit", "end", "fino"));
        EXIT_COMMANDS = Collections.unmodifiableSortedSet(ecmds);
        final SortedSet<String> hcmds = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        hcmds.addAll(Arrays.asList("help", "helpi", "?"));
        HELP_COMMANDS = Collections.unmodifiableSet(hcmds);
        DATE_PATTERN = Pattern.compile("\\d{4}([-\\/])\\d{2}\\1\\d{2}"); // http://regex101.com/r/xB8dR3/1
        HELP_MESSAGE = format("Please enter some data or enter one of the following commands to exit %s", EXIT_COMMANDS);
    }

    /**
     * Using exceptions to control execution flow is always bad.
     * That is why this is encapsulated in a method, this is done this
     * way specifically so as not to introduce any external libraries
     * so that this is a completely self contained example.
     * @param s possible url
     * @return true if s represents a valid url, false otherwise
     */
    private static boolean isValidURL(@Nonnull final String s)
    {
        try { new URL(s); return true; }
        catch (final MalformedURLException e) { return false; }
    }

    private static void output(@Nonnull final String format, @Nonnull final Object... args)
    {
        System.out.println(format(format, args));
    }

    public static void main(final String[] args)
    {
        final Scanner sis = new Scanner(System.in);
        output(HELP_MESSAGE);
        while (sis.hasNext())
        {
            if (sis.hasNextInt())
            {
                final int next = sis.nextInt();
                output("You entered an Integer = %d", next);
            }
            else if (sis.hasNextLong())
            {
                final long next = sis.nextLong();
                output("You entered a Long = %d", next);
            }
            else if (sis.hasNextDouble())
            {
                final double next = sis.nextDouble();
                output("You entered a Double = %f", next);
            }
            else if (sis.hasNext("\\d+"))
            {
                final BigInteger next = sis.nextBigInteger();
                output("You entered a BigInteger = %s", next);
            }
            else if (sis.hasNextBoolean())
            {
                final boolean next = sis.nextBoolean();
                output("You entered a Boolean representation = %s", next);
            }
            else if (sis.hasNext(DATE_PATTERN))
            {
                final String next = sis.next(DATE_PATTERN);
                output("You entered a Date representation = %s", next);
            }
            else // unclassified
            {
                final String next = sis.next();
                if (isValidURL(next))
                {
                    output("You entered a valid URL = %s", next);
                }
                else
                {
                    if (EXIT_COMMANDS.contains(next))
                    {
                        output("Exit command %s issued, exiting!", next);
                        break;
                    }
                    else if (HELP_COMMANDS.contains(next)) { output(HELP_MESSAGE); }
                    else { output("You entered an unclassified String = %s", next); }
                }
            }
        }
        /*
           This will close the underlying Readable, in this case System.in, and free those resources.
           You will not be to read from System.in anymore after this you call .close().
           If you wanted to use System.in for something else, then don't close the Scanner.
        */
        sis.close();
        System.exit(0);
    }
}

Lees een int van de opdrachtregel

import java.util.Scanner;

Scanner s = new Scanner(System.in);
int number = s.nextInt();

Gebruik dit fragment als u een int van de opdrachtregel wilt lezen. Allereerst moet u een Scanner-object maken dat luistert naar System.in, dat standaard de opdrachtregel is, wanneer u het programma start vanaf de opdrachtregel. Daarna leest u met behulp van het Scanner-object de eerste int die de gebruiker op de opdrachtregel invoert en slaat u deze op in het variabele nummer. Nu kun je doen wat je wilt met die opgeslagen int.

Een scanner voorzichtig sluiten

het kan gebeuren dat u een scanner gebruikt met de System.in als parameter voor de constructor, dan moet u zich ervan bewust zijn dat het sluiten van de scanner de InputStream zal sluiten en geeft als volgende dat elke poging om de input daarover te lezen (of een andere scannerobject) gooit een java.util.NoSuchElementException of een java.lang.IllegalStateException

voorbeeld:

    Scanner sc1 = new Scanner(System.in);
    Scanner sc2 = new Scanner(System.in);
    int x1 = sc1.nextInt();
    sc1.close();
    // java.util.NoSuchElementException
    int x2 = sc2.nextInt();
    // java.lang.IllegalStateException
    x2 = sc1.nextInt();