Post
Ask Question

How to use Scanner in Java

Java Scanner

 
Input and output are the two most important operations of a computer. Input is the process of taking data in and output is the process of data out. The third part, the processing is the process of input data and generating the desired output. Input is taken through various devices such as a mouse, keyboard, and touch. So to map this input from the keyboard to the machine-understandable form, there are some libraries in Java for the same. One of the libraries is Scanner which is a part of the java.utill package.
 
Java Scanner reads text from the console and can parse the input into Java language primitive types and strings using regular expressions. 
 

Features of Java Scanner 

  1. Java Scanner class breaks the input into tokens using a delimiter which is whitespace by default. 
  2. It is the easiest way to read input in Java program, 
  3. With the help of Scanner in Java, we can get input from the user in primitive types such as int, long, double, byte, float, short, etc.
  4. The Java Scanner class extends the Object class and implements Iterator and Closeable interfaces.

Shortcomings of Java Scanner 

  1. The problem with Java Scanner arises when we are using any of the nextXXX() method, i.e. whenever the nextLine() method is called after anyone of the nextXXX() method then the method nextLine() does not read values from the console and it skips that step. So the input from the nextLine() which you want to read is ignored. 
  2. Java Scanner is not Synchronized.
  3. Java Scanner is not Thread Safe
  4. Java Scanner has smaller buffer memory i.e. 1024 char
  5. As Java Scanner parses the input data, so it is a bit slower

Console Input Using Java Scanner

 
Java Scanner is a special Java Class that is used to take inputs from all kinds of input stream be it console, files, StringBuilder, StringBuffers to name a few.
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;  
  3.   
  4. /** 
  5. * An example program to read a String from console input in Java 
  6. */  
  7. public class CSharpCorner  
  8. {  
  9.    public static void main(String[] args)  
  10.   {  
  11.        out.print("Enter a string : ");  
  12.        Scanner scanner = new Scanner(System. in);  
  13.        String inputString = scanner. nextLine();  
  14.        out.println("String read from console is : \n"+inputString);  
  15.    }  
  16. }  
'System.in' means console, we are creating an object of Java Scanner Class by the name of 'scanner' and then we are telling Java compiler to accept input from the console, and save the accepted input into a String variable named 'inputString'.

Java Scanner Constructors

  1.  Scanner(File Source)
     
    It constructs a new Scanner that produces values scanned from the specified file
    1. import java.io.File;    
    2. import java.io.FileNotFoundException;    
    3. import java.util.Scanner;
    4. import static java.lang.System.out;    
    5.       
    6. class Csharpcorner      
    7. {      
    8.     public static void main(String[] args) throws FileNotFoundException      
    9.     {      
    10.         Scanner sc = new Scanner(new File("example.txt"));    
    11.             
    12.         while(sc.hasNext())    
    13.         {    
    14.             out.print(sc.next());    
    15.         }    
    16.     }      
    17. }   
  2. Scanner( File Source, String charsetName)
     
    It constructs a new Scanner that produces values scanned from the specified file  using the given decoding technique
    1. import java.io.File;    
    2. import java.io.FileNotFoundException;    
    3. import java.nio.charset.StandardCharsets;    
    4. import java.util.Scanner; 
    5. import static java.lang.System.out;    
    6.       
    7. class Csharpcorner      
    8. {      
    9.     public static void main(String[] args) throws FileNotFoundException      
    10.     {      
    11.         Scanner sc = new Scanner(new File("example.txt", StandardCharsets.US_ASCII.name()));    
    12.             
    13.         while(sc.hasNext())    
    14.         {    
    15.             out.print(sc.next());    
    16.         }    
    17.     }      
    18. }     
  3. Scanner(InputStream source)
     
    It constructs a new Scanner that produces values scanned from the specified input Stream.
    1. import java.io.File;    
    2. import static java.lang.System.out;    
    3. import java.util.Scanner;    
    4.       
    5. class Csharpcorner      
    6. {      
    7.     public static void main(String[] args)     
    8.     {      
    9.       Scanner myObj = new Scanner (System.in);    
    10.       out.println("Enter");    
    11.           
    12.       String user = myObj.nextLine();    
    13.       out.print(user);    
    14.     }      
    15. }     
  4. Scanner(InputStream source, String charsetName)
     
    It constructs a new Scanner that produces values scanned from the specified input stream using the given decoding technique.
    1. import java.nio.charset.StandardCharsets;    
    2. import java.io.File;    
    3. import java.util.Scanner;   
    4. import static java.lang.System.out;    
    5.       
    6. class Csharpcorner      
    7. {      
    8.     public static void main(String[] args)     
    9.     {      
    10.       Scanner myObj = new Scanner (System.in, StandardCharsets.US_ASCII.name());    
    11.       out.println("Enter");    
    12.           
    13.       String user = myObj.nextLine();    
    14.       out.print(user);    
    15.     }      
    16. }      
  5. Scanner( Readable source)
     
    It constructs a new Scanner that produces values scanned from the specified source.
    1. import java.io.File;    
    2. import java.io.FileNotFoundException;    
    3. import java.io.FileReader;    
    4. import java.util.Scanner;   
    5. import static java.lang.System.out;    
    6.       
    7. class Csharpcorner      
    8. {      
    9.     public static void main(String[] args) throws FileNotFoundException      
    10.     {      
    11.         FileReader reader = new FileReader(new File("example.txt"));    
    12.         Scanner sc = new Scanner(reader);    
    13.             
    14.         while(sc.hasNext())    
    15.         {    
    16.             out.print(sc.next());    
    17.         }    
    18.     }      
    19. }      
  6. Scanner(String source)
     
    It constructs a new Scanner that produces values scanned from the specified string.
    1. import java.util.Scanner;  
    2. import static java.lang.System.out;    
    3.     
    4. class Csharpcorner        
    5. {        
    6.     public static void main(String[] args)       
    7.     {        
    8.         String reader = " CSharpCorner";      
    9.         Scanner sc = new Scanner(reader);      
    10.               
    11.         while(sc.hasNext())      
    12.         {      
    13.             out.print(sc.next());      
    14.         }      
    15.     }        
    16. }   
  7. Scanner(ReadableByteChannel source)
     
    It constructs a new Scanner that produces value scanned from the specified channel.
    1. import java.io.FileInputStream;      
    2. import java.io.FileNotFoundException;      
    3. import java.nio.charset.StandardCharsets;      
    4. import java.util.Scanner;    
    5. import static java.lang.System.out;    
    6.         
    7. class Csharpcorner        
    8. {        
    9.     public static void main(String[] args) throws FileNotFoundException        
    10.     {        
    11.         Scanner scanner = new Scanner(new FileInputStream("example.txt").getChannel());      
    12.         out.println(scanner.nextLine());    
    13.            
    14.     }        
    15. }     
  8. Scanner(ReadableByteChannel source, String charsetName)
     
    It constructs a new Scanner that produces value scanned from the specified channel.
    1. import java.io.FileInputStream;    
    2. import java.io.FileNotFoundException;    
    3. import java.nio.charset.StandardCharsets;    
    4. import java.util.Scanner;   
    5. import static java.lang.System.out;    
    6.       
    7. class Csharpcorner      
    8. {      
    9.     public static void main(String[] args) throws FileNotFoundException      
    10.     {      
    11.         Scanner scanner = new Scanner(new FileInputStream("example.txt").getChannel(),StandardCharsets.US_ASCII.name() );    
    12.         out.println(scanner.nextLine());  
    13.          
    14.     }      
    15. }       
  9. Scanner(Path source)
     
     It constructs a new Scanner that produces values scanned from the specified file.
    1. import java.io.IOException;  
    2. import java.nio.file.FileSystems;  
    3. import java.util.Scanner; 
    4. import static java.lang.System.out;    
    5.       
    6. class Csharpcorner      
    7. {      
    8.     public static void main(String[] args) throws IOException  
    9.     {      
    10.         try (Scanner scanner = new Scanner(FileSystems.getDefault().getPath("lib","jdk.lib")))   
    11.         {  
    12.             out.println(scanner.nextLine());  
    13.         }  
    14.     }      
    15. }    
  10. Scanner(Path Source, String charsetName)
     
    It constructs a new Scanner that produces values scanned from the specified file.
    1. import java.io.IOException;  
    2. import java.nio.charset.StandardCharsets;  
    3. import java.nio.file.FileSystems;  
    4. import java.util.Scanner; 
    5. import static java.lang.System.out;    
    6.       
    7. class Csharpcorner      
    8. {      
    9.     public static void main(String[] args) throws IOException  
    10.     {      
    11.         try (Scanner scanner = new Scanner(FileSystems.getDefault().getPath("lib","jdk.lib"),StandardCharsets.US_ASCII.name()))   
    12.         {  
    13.             out.println(scanner.nextLine());  
    14.         }  
    15.     }      
    16. }    

Java Scanner Class Methods

 

1. Scanner.close()

 
Syntax
 
void close()
 
It is used to close the scanner
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.       
  4. class Csharpcorner      
  5. {      
  6.     public static void main(String[] args)  
  7.     {      
  8.         Scanner scan =  new Scanner("CsharpCorner");  
  9.           
  10.         scan.close();  
  11.     }      
  12. }     
In the above code, we are demonstrating the use of close() method.

2. Scanner.delimiter()

 
Syntax
 
pattern delimiter()
 
It is used to get the Pattern which the Scanner class is currently using to match delimiters.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.       
  4. class Csharpcorner      
  5. {      
  6.     public static void main(String[] args)  
  7.     {      
  8.         Scanner scan =  new Scanner("CsharpCorner");  
  9.         out.println(""+scan.nextLine());  
  10.         out.println(""+scan.delimiter());   
  11.         scan.close();  
  12.     }      
  13. }      
In the above code, we will be printing the delimiter used by the Scanner object i.e. \p{javaWhitespace}+

3. Scanner.findlnLine()

 
Syntax 
 
1. String findlnLine(String pattern)
 
It is used to find the next occurrence of a pattern constructed from the specified string, ignoring delimiters.
 
2. String findlnLine(Pattern pattern) 
 
This is an inbuilt method that is used to find the next occurrence of the specified pattern ignoring delimiters
  1. import java.util.Scanner;  
  2. import java.util.regex.Pattern; 
  3. import static java.lang.System.out;    
  4.       
  5. class Csharpcorner      
  6. {      
  7.     public static void main(String[] args)  
  8.     {      
  9.         Scanner scan =  new Scanner("CsharpCorner");  
  10.         out.println(scan.findInLine("sharp"));  
  11.           
  12.         out.println(scan.findInLine(Pattern.compile("sharp")));  
  13.         scan.close();  
  14.     }      
  15. }    
In the above code, in the first version, we are finding whether we are able to find the given substring from the String. In the second version, we are finding whether the given string has a pattern of the "sharp".
 

4. Scanner.findWithinHorizon()

 
Syntax 
 
1. String findWithinHorizon(Pattern pattern, int horizon)
 
This is an inbuilt method of Java Scanner class which is used to find the next occurrence of a specified pattern, it searches through the input up to the specified search horizon, ignoring delimiters.
 
2. String findWithinHorizon(String pattern, int horizon)
 
This is an inbuilt method of Java Scanner class which is used to find the next occurrence of a specified string, it searches through the input up to the specified search horizon, ignoring delimiters.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3. import java.util.regex.Pattern;  
  4.       
  5. class Csharpcorner      
  6. {      
  7.     public static void main(String[] args)  
  8.     {      
  9.         Scanner scan =  new Scanner("1111, 2222, 33333, 45556");  
  10.         Pattern pattern =  Pattern.compile("[0-9]+");  
  11.         while(scan.hasNext())  
  12.         {  
  13.             out.println(scan.findWithinHorizon(pattern, 18));  
  14.         }  
  15.           
  16.         while(scan.hasNext())  
  17.         {  
  18.             out.println(scan.findWithinHorizon("[0-9]+", 10));  
  19.         }  
  20.         scan.close();  
  21.     }      
  22. }       
In the above code, in the first version, we used a pattern and in the second version, we are using a String. The output of both will be exactly the same.
 

5. Scanner.hasNext() 

 
Syntax
 
1. boolean hasNext()
 
It returns true if this scanner has another token in its input. This method may be used for busy waiting i.e it may block while waiting for input to scan 
 
2. boolean hasNext(String pattern)
 
It returns true if the next token matches the pattern constructed from the specified String
 
3. boolean hasNext(Pattern pattern)
 
It returns true if the next token matches the specified pattern.
  1. import java.util.Scanner;  
  2. import java.util.regex.Pattern; 
  3. import static java.lang.System.out;    
  4.       
  5. class Csharpcorner      
  6. {      
  7.     public static void main(String[] args)  
  8.     {      
  9.         Scanner scan =  new Scanner("CSharpCorner");  
  10.         while(scan.hasNext())  
  11.         {  
  12.             out.print(scan);  
  13.         }  
  14.         String pattern = "Sharp";  
  15.         if(scan.hasNext(pattern))  
  16.         {  
  17.             out.println("Pattern Found");  
  18.         }  
  19.         Pattern pattern1 =  Pattern.compile("[[A-Za-z]*");  
  20.         while(scan.hasNext(pattern1))  
  21.         {  
  22.            out.println(scan.next());  
  23.         }  
  24.         scan.close();  
  25.     }      
  26. }          
The above code demonstrates all 3 versions of hasNext() methods.
 

6. Scanner.hasNextBigDecimal() 

 
Syntax
 
boolean hasNextBigDecimal()
 
It is used to check if the next token in this scanner's input can be interpreted as BigDecimal or not. It returns true if the scanner's input can be interpreted as a BigDecimal, otherwise returns false.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.       
  4. class Csharpcorner      
  5. {      
  6.     public static void main(String[] args)  
  7.     {      
  8.         Scanner scan =  new Scanner("CSharpCorner");  
  9.         if(scan.hasNextBigDecimal())  
  10.         {  
  11.             out.println("true");  
  12.         }  
  13.         else  
  14.         {  
  15.             out.println("false");  
  16.         }  
  17.         scan.close();  
  18.     }      
  19. }   
In the above code, since the text cannot be represented as BigDecimal hence the result will be "false"
 

7. Scanner.hasNextBigInteger()  

 
Syntax
 
1. boolean hasNextBigInteger()
 
It is used to check if the next token in this scanner's input can be interpreted as BigInteger using the default radix or not. It returns true if the scanner's input can be interpreted as a BigInteger, otherwise returns false.
 
2. boolean hasNextBigInteger(int radix)
  
It is used to check if the next token in this scanner's input can be interpreted as BigInteger using the specified radix or not. It returns true if the scanner's input can be interpreted as a BigInteger, otherwise returns false.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.       
  4. class Csharpcorner      
  5. {      
  6.     public static void main(String[] args)  
  7.     {      
  8.         Scanner scan =  new Scanner("CSharpCorner");  
  9.         if(scan.hasNextBigInteger())  
  10.         {  
  11.             out.println(scan.nextBigInteger());  
  12.         }  
  13.         if(scan.hasNextBigInteger(6))  
  14.         {  
  15.             out.println(scan.nextBigInteger());  
  16.         }  
  17.         scan.close();  
  18.     }      
  19. }   
In the above code, we are demonstrating the implementation of both versions of the method.
 

8. Scanner.hasNextBoolean()

 
Syntax
 
boolean hasNextBoolean()
 
It returns true if and only if this scanner's next token is a valid boolean value.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.       
  4. class Csharpcorner      
  5. {      
  6.     public static void main(String[] args)  
  7.     {      
  8.         Scanner scan =  new Scanner("CSharpCorner");  
  9.         if(scan.hasNextBoolean())  
  10.         {  
  11.             out.println(scan.nextBigInteger());  
  12.         }  
  13.         scan.close();  
  14.     }      
  15. }       
 In the above code, we are checking the given scanner input has a boolean value in it
 

9. Scanner.hasNextByte()

 
Syntax
 
1. boolean hasNextByte()
 
It is used to check if the next token in this scanner's input can be interpreted as Byte using the default radix or not. It returns true if the scanner's input can be interpreted as a Byte, otherwise returns false.
 
2. boolean hasNextByte(int radix)
 
It is used to check if the next token in this scanner's input can be interpreted as Byte using the specified radix or not. It returns true if the scanner's input can be interpreted as a Byte, otherwise returns false.
  1. import java.util.Scanner;   
  2. import static java.lang.System.out;    
  3.         
  4. class Csharpcorner        
  5. {        
  6.     public static void main(String[] args)    
  7.     {        
  8.         Scanner scan =  new Scanner("CSharpCorner");    
  9.         if(scan.hasNextByte())    
  10.         {    
  11.             out.println(scan.nextByte());    
  12.         }    
  13.         if(scan.hasNextByte(6))    
  14.         {    
  15.             out.println(scan.nextByte());    
  16.         }    
  17.         scan.close();    
  18.     }        
  19. }      
In the above code, we are demonstrating both the version of the methods with default radix and with a user-defined radix
 

10. Scanner.hasNextDouble()

 
Syntax
 
boolean hasNextDouble()
 
It returns true if and only if this scanner's next token is a valid double value
  1. import java.util.Scanner;   
  2. import static java.lang.System.out;    
  3.         
  4. class Csharpcorner        
  5. {        
  6.     public static void main(String[] args)    
  7.     {        
  8.         Scanner scan =  new Scanner("CSharpCorner");    
  9.         if(scan.hasNextDouble())    
  10.         {    
  11.             out.println(scan.nextDouble());    
  12.         }    
  13.         scan.close();    
  14.     }        
  15. }   
In the above code, we are checking if the scanner input has double values
 

11. Scanner.hasNextFloat()

 
Syntax
 
boolean hasNextFloat()
 
It returns true if and only if this scanner's next token is a valid float value
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.       
  4. class Csharpcorner      
  5. {      
  6.     public static void main(String[] args)  
  7.     {      
  8.         Scanner scan =  new Scanner("CSharpCorner");  
  9.         if(scan.hasNextFloat())  
  10.         {  
  11.             out.println(scan.nextFloat());  
  12.         }  
  13.         scan.close();  
  14.     }      
  15. }   
In the above code, we are finding whether the next token is float value or not.
 

12. Scanner.hasNextInt()

 
Syntax
1. boolean hasNextInt()
 
It is used to check if the next token in this scanner's input can be interpreted as an Integer using the default radix or not. It returns true if the scanner's input can be interpreted as an Integer, otherwise returns false.
 
2. boolean hasNextInt(int radix)
 
It is used to check if the next token in this scanner's input can be interpreted as Integer using the specified radix or not. It returns true if the scanner's input can be interpreted as an Integer, otherwise returns false.
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;    
  3.           
  4. class Csharpcorner          
  5. {          
  6.     public static void main(String[] args)      
  7.     {          
  8.         Scanner scan =  new Scanner("CSharpCorner");      
  9.         if(scan.hasNextInt())      
  10.         {      
  11.             out.println(scan.nextInt());      
  12.         }      
  13.         if(scan.hasNextInt(6))      
  14.         {      
  15.             out.println(scan.nextInt());      
  16.         }      
  17.         scan.close();      
  18.     }          
  19. }         
In the above code, we are demonstrating the use of both the versions of the method i.e with default radix and user-defined radix
 

13. Scanner.hasNextLine()

 
Syntax
 
boolean hasNextLine()
 
It returns true if and only if this scanner has another line of input
  1. import java.util.Scanner;    
  2. import static java.lang.System.out;    
  3.           
  4. class Csharpcorner          
  5. {          
  6.     public static void main(String[] args)      
  7.     {          
  8.         Scanner scan =  new Scanner("CSharpCorner");      
  9.         out.println(scan.hasNextLine());  
  10.         scan.close();      
  11.     }          
  12. }     
In the above code, we are checking if the scanner has another input, and if yes then we print that
 

14. Scanner..hasNextLong()

 
Syntax 
1. boolean hasNextLong()
 
It is used to check if the next token in this scanner's input can be interpreted as Long using the default radix or not. It returns true if the scanner's input can be interpreted as a Long, otherwise returns false.
 
2. boolean hasNextLong(int radix)
 
It is used to check if the next token in this scanner's input can be interpreted as Long using the specified radix or not. It returns true if the scanner's input can be interpreted as a Long, otherwise returns false.
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");        
  9.         if(scan.hasNextLong())        
  10.         {        
  11.             out.println(scan.nextLong());        
  12.         }        
  13.         if(scan.hasNextLong(6))        
  14.         {        
  15.             out.println(scan.nextLong());        
  16.         }        
  17.         scan.close();        
  18.     }            
  19. }    
In the above code, we are implementing both versions of the method i.e with default radix and with user-defined radix.
 

15. Scanner.hasNextshort() 

 
Syntax
 
1. boolean hasNextShort()
 
It is used to check if the next token in this scanner's input can be interpreted as Short using the default radix or not. It returns true if the scanner's input can be interpreted as a Short, otherwise returns false.
 
2. boolean hasNextShort(int radix)
 
It is used to check if the next token in this scanner's input can be interpreted as Short using the specified radix or not. It returns true if the scanner's input can be interpreted as a short, otherwise returns false.
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");        
  9.         if(scan.hasNextShort())        
  10.         {        
  11.             out.println(scan.nextShort());        
  12.         }        
  13.         if(scan.hasNextShort(6))        
  14.         {        
  15.             out.println(scan.nextShort());        
  16.         }        
  17.         scan.close();        
  18.     }            
  19. }          
In the above code, we are implementing both versions of the method i.e with default radix and with user-defined radix.
 

16. Scanner.ioException()

 
Syntax
 
IOException ioException()
 
It returns the last exception thrown by this scanner's readable
  1. import java.util.Scanner;     
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");        
  9.         out.println(scan.ioException());   
  10.     }            
  11. }   
In the above code, since there no IOException generated hence, the output wil be "null"
 

17. Scanner.locale()

 
Syntax
 
Locale locale()
 
It returns the scanner's locale
  1. import java.util.Scanner;       
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");        
  9.         out.println(scan.locale());   
  10.     }            
  11. }   
In the above code, the output we will be getting will be  "en_IN" or your system's language
 

18. Scanner.match()

 
Syntax 
 
MatchResult match()
 
It returns a match result for the last match operation
  1. import java.util.Scanner;       
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.print(scan.hasNext("Csharp"));  
  10.         out.println(scan.match());   
  11.     }            
  12. }    
In the above code, we return the last match, here the match is not done.
 

19. Scanner.next()

 
Syntax
 
It returns the next token if it matches the specified pattern.
  1. import java.util.Scanner;        
  2. import java.util.regex.Pattern; 
  3. import static java.lang.System.out;    
  4.             
  5. class Csharpcorner            
  6. {            
  7.     public static void main(String[] args)        
  8.     {            
  9.         Scanner scan =  new Scanner("CSharpCorner");     
  10.         out.println(scan.next());  
  11.         String pattern = "[0-9]";  
  12.         out.println(scan.next(pattern));  
  13.         out.println(scan.next(Pattern.compile("[0-9]")));  
  14.     }            
  15. }     
In the above code, we have implemented all the 3 versions of the method.
 

20. Scanner.nextBigDecimal()

 
Syntax
 
BigDecimal nextBigDecimal()
 
It returns the BigDecimal Scanned from the output.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextBigDecimal());  
  10.     }            
  11. }       
In the above code, we will be printing the next BigDecimal value
 

21. Scanner.nextBigInteger()

Syntax
 
1. BigInteger nextBigInteger()
 
It scans the next token of the input as a BigInteger in the default radix
 
2. BigInteger nextBigInteger(int radix)
 
It scans the next token of the input as a BigInteger in the specified radix
  1. import java.util.Scanner;    
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextBigInteger());  
  10.         out.println(scan.nextBigInteger(6));  
  11.     }            
  12. }    
In the above code, we will be printing the next BigInteger value
 

22. Scanner.nextBoolean()

Syntax
 
boolean nextBoolean()
 
It returns the boolean Scanned from the output.
  1. import java.util.Scanner;   
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextBoolean());  
  10.     }            
  11. }    
In the above code, we will be printing the next boolean value
 

23. Scanner.nextByte()

 
Syntax
 
1. byte nextByte()
 
It scans the next token of the input as a byte in the default radix
 
2. byte nextByte(int radix)
 
It scans the next token of the input as a byte in the specified radix
  1. import java.util.Scanner;    
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextByte());  
  10.         out.println(scan.nextByte(6));  
  11.     }            
  12. }   
In the above code, we will be printing the next byte value 
 

24. Scanner.nextDouble()

 
Syntax
 
boolean nextDouble()
 
It returns the double Scanned from the output.
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextDouble());  
  10.     }            
  11. }    
In the above code, we will be printing the next Double value
 

25. Scanner.nextFloat()

 
Syntax
 
boolean nextFloat()
 
It returns the float Scanned from the output.
  1. import java.util.Scanner;   
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextFloat());  
  10.     }            
  11. }    
In the above code, we will be printing the next Float value
 

26. Scanner.nextInt()

 
Syntax
 
1. boolean nextInt()
 
It scans the next token of the input as an Int in the default radix
 
2. boolean nextInt(int radix)
 
It scans the next token of the input as an Int in the specified radix
  1. import java.util.Scanner;    
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextInt());  
  10.         out.println(scan.nextInt(6));  
  11.     }            
  12. }   
 In the above code, we are printing the next Int value
 

27. Scanner.nextLine()

 
Syntax
 
String nextLine()
 
It returns the String Scanned from the output.
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextLine());  
  10.     }  
  11. }   
In the above code, we are printing the next String value
 

28. Scanner.nextLong()

 
Syntax
 
1. boolean nextLong()
 
It scans the next token of the input as a Long in the default radix
 
2. boolean nextLong(int radix)
 
It scans the next token of the input as a Long in the specified radix
  1. import java.util.Scanner;       
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextLong());  
  10.         out.println(scan.nextLong(6));  
  11.     }            
  12. }    
 In the above code, we are printing the next Long value.
 

29. Scanner.nextShort()

Syntax
 
1. boolean nextShort()
 
It scans the next token of the input as a Short in the default radix
 
2. boolean nextShort(int radix)
 
It scans the next token of the input as a Short in the specified radix
  1. import java.util.Scanner;    
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.nextShort());  
  10.         out.println(scan.nextShort(6));  
  11.     }            
  12. }   
In the above code, we are printing the next Short value.
 

30. Scanner.radix()

 
Syntax
 
int radix()
 
It returns the default radix of the Scanner.
  1. import java.util.Scanner; 
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.radix());  
  10.    }            
  11. }     
In the above, we will get 10 as the default radix
 

31. Scanner.remove()

 
Syntax
 
void remove()
 
It is used when the remove operation is not supported by this implementation of Iterator
  1. import java.util.Scanner;    
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.next());  
  10.         scan.remove();  
  11.         out.println(scan.next());  
  12.    }            
  13. }   
In the above, we are basically removing the content of Scanner
 

32. Scanner. reset()

 
Syntax
 
Scanner reset()
 
It is used to reset the Scanner in use.
  1. import java.util.Scanner;      
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.next());  
  10.         out.println(scan.reset());  
  11.    }            
  12. }   
In the above code, we are resetting the contents of the Scanner
 

33. Scanner.skip()

 
Syntax
 
1. Scanner skip(Pattern pattern)
 
It is a method that skips input that matches the specified pattern, ignoring delimiters.
 
2. Scanner skip(String pattern)
 
It is a method that skips input that matches a pattern constructed from the specified string
  1. import java.util.Scanner;        
  2. import java.util.regex.Pattern; 
  3. import static java.lang.System.out;    
  4.             
  5. class Csharpcorner            
  6. {            
  7.     public static void main(String[] args)        
  8.     {            
  9.         Scanner scan =  new Scanner("CSharpCorner");     
  10.         out.println(scan.next());  
  11.         String pattern = "[A-Z]*";  
  12.         while(scan.hasNext())  
  13.         {  
  14.             scan.skip(pattern);  
  15.             out.println(scan.next());  
  16.         }  
  17.         Scanner scan1 =  new Scanner("CSharpCorner");    
  18.         scan1.skip(Pattern.compile("...ar"));  
  19.         out.println(scan1.nextLine());  
  20.    }            
  21. }           
In the above code, we are demonstrating the use of the method
 

34. Scanner.toString()

 
Syntax
 
String toString()
 
It returns the String representation of this Scanner
  1. import java.util.Scanner;  
  2. import static java.lang.System.out;    
  3.             
  4. class Csharpcorner            
  5. {            
  6.     public static void main(String[] args)        
  7.     {            
  8.         Scanner scan =  new Scanner("CSharpCorner");     
  9.         out.println(scan.toString());  
  10.    }            
  11. }     
The above code returns the String representation of the Scanner
 

35. Scanner.useDelimiter() 

 
Syntax 
 
1. Scanner useDelimiter(Pattern pattern)
 
It is used to set the delimiting pattern of the Scanner which is in use.
 
2. Scanner useDelimiter(String pattern)
 
It is used to set the delimiting pattern of the Scanner which is in use.
  1. import java.util.Scanner;        
  2. import java.util.regex.Pattern; 
  3. import static java.lang.System.out;    
  4.             
  5. class Csharpcorner            
  6. {            
  7.     public static void main(String[] args)        
  8.     {            
  9.         Scanner scan =  new Scanner("CSharpCorner").useDelimiter(Pattern.compile("\\s*\\s"));     
  10.         out.println(scan.delimiter());  
  11.           
  12.         Scanner scan1 =  new Scanner("CSharpCorner").useDelimiter("\n");     
  13.         out.println(scan1.delimiter());  
  14.    }            
  15. }  
In the above code, we first gave patterns as the delimiter and then a string 
 

36. Scanner.useLocale()

 
Syntax
 
Scanner useLocale(Locale locale)
 
The function is used to change the current locale of the Scanner to the specified locale
  1. import java.util.Locale;  
  2. import java.util.Scanner;    
  3. import static java.lang.System.out;    
  4.             
  5. class Csharpcorner            
  6. {            
  7.     public static void main(String[] args)        
  8.     {            
  9.         Scanner scan =  new Scanner("CSharpCorner").useLocale(Locale.ITALY);     
  10.         out.println(scan.locale());  
  11.          
  12.    }            
  13. }   
In the above code, we are changing the locale to Italy locale
 

37. Scanner.useRadix()

 
Syntax
 
Scanner useRadix(int radix)
 
The function is used to change the current radix of the Scanner to the specified radix
  1. import java.util.Locale;  
  2. import java.util.Scanner;  
  3. import static java.lang.System.out;    
  4.             
  5. class Csharpcorner            
  6. {            
  7.     public static void main(String[] args)        
  8.     {            
  9.         Scanner scan =  new Scanner("CSharpCorner").useRadix(6);     
  10.         out.println(scan.radix());  
  11.          
  12.    }            
  13. }   
In the above code, we are changing the radix from 10 to 6
 

Conclusion

 
In this article, we learned about Java Scanner, the features of Scanner, the shortcomings of Scanner, Java Scanner Constructors, Java Scanner Methods, and implementation using Java.
 
     Next Tutorial in this Series >> Java List 


Similar Articles