Read one word java

In this article we will be discussing about ways and techniques to read word documents in Java using Apache POI library. The word document may contain images, tables or plain text. Apart from this a standard word file has header and footers too. Here in the following examples we will be parsing a word document by reading its different paragraph, runs, images, tables along with headers and footers. We will also take a look into identifying different styles associated with the paragraphs such as font-size, font-family, font-color etc.

Maven Dependencies

Following is the poi maven depedency required to read word documents. For latest artifacts visit here

pom.xml

	<dependencies>
		<dependency>
                     <groupId>org.apache.poi</groupId>
                     <artifactId>poi-ooxml</artifactId>
		     <version>3.16</version>
                 </dependency>
	</dependencies>

Reading Complete Text from Word Document

The class XWPFDocument has many methods defined to read and extract .docx file contents. getText() can be used to read all the texts in a .docx word document. Following is an example.

TextReader.java

public class TextReader {
	
	public static void main(String[] args) {
	 try {
		   FileInputStream fis = new FileInputStream("test.docx");
		   XWPFDocument xdoc = new XWPFDocument(OPCPackage.open(fis));
		   XWPFWordExtractor extractor = new XWPFWordExtractor(xdoc);
		   System.out.println(extractor.getText());
		} catch(Exception ex) {
		    ex.printStackTrace();
		}
 }

}

Reading Headers and Foooters of Word Document

Apache POI provides inbuilt methods to read headers and footers of a word document. Following is an example that reads and prints header and footer of a word document. The example .docx file is available in the source which can be downloaded at the end of thos article.

HeaderFooter.java

public class HeaderFooterReader {

	public static void main(String[] args) {
		
		try {
			FileInputStream fis = new FileInputStream("test.docx");
			XWPFDocument xdoc = new XWPFDocument(OPCPackage.open(fis));
			XWPFHeaderFooterPolicy policy = new XWPFHeaderFooterPolicy(xdoc);

			XWPFHeader header = policy.getDefaultHeader();
			if (header != null) {
				System.out.println(header.getText());
			}

			XWPFFooter footer = policy.getDefaultFooter();
			if (footer != null) {
				System.out.println(footer.getText());
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}

	}

}

Output

This is Header

This is footer

 Other Interesting Posts
Java 8 Lambda Expression
Java 8 Stream Operations
Java 8 Datetime Conversions
Random Password Generator in Java

Read Each Paragraph of a Word Document

Among the many methods defined in XWPFDocument class, we can use getParagraphs() to read a .docx word document paragraph wise.This method returns a list of all the paragraphs(XWPFParagraph) of a word document. Again the XWPFParagraph has many utils method defined to extract information related to any paragraph such as text alignment, style associated with the paragrpahs.

To have more control over the text reading of a word document,each paragraph is again divided into multiple runs. Run defines a region of text with a common set of properties.Following is an example to read paragraphs from a .docx word document.

ParagraphReader.java

public class ParagraphReader {

	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("test.docx");
			XWPFDocument xdoc = new XWPFDocument(OPCPackage.open(fis));

			List paragraphList = xdoc.getParagraphs();

			for (XWPFParagraph paragraph : paragraphList) {

				System.out.println(paragraph.getText());
				System.out.println(paragraph.getAlignment());
				System.out.print(paragraph.getRuns().size());
				System.out.println(paragraph.getStyle());

				// Returns numbering format for this paragraph, eg bullet or lowerLetter.
				System.out.println(paragraph.getNumFmt());
				System.out.println(paragraph.getAlignment());

				System.out.println(paragraph.isWordWrapped());

				System.out.println("********************************************************************");
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

Reading Tables from Word Document

Following is an example to read tables present in a word document. It will print all the text rows wise.

TableReader.java

public class TableReader {

	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("test.docx");
			XWPFDocument xdoc = new XWPFDocument(OPCPackage.open(fis));
			Iterator bodyElementIterator = xdoc.getBodyElementsIterator();
			while (bodyElementIterator.hasNext()) {
				IBodyElement element = bodyElementIterator.next();

				if ("TABLE".equalsIgnoreCase(element.getElementType().name())) {
					List tableList = element.getBody().getTables();
					for (XWPFTable table : tableList) {
						System.out.println("Total Number of Rows of Table:" + table.getNumberOfRows());
						for (int i = 0; i < table.getRows().size(); i++) {

							for (int j = 0; j < table.getRow(i).getTableCells().size(); j++) {
								System.out.println(table.getRow(i).getCell(j).getText());
							}
						}
					}
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

Reading Styles from Word Document

Styles are associated with runs of a paragraph. There are many methods available in the XWPFRun class to identify the styles associated with the text.There are methods to identify boldness, highlighted words, capitalized words etc.

StyleReader.java

public class StyleReader {

	public static void main(String[] args) {
		try {
			FileInputStream fis = new FileInputStream("test.docx");
			XWPFDocument xdoc = new XWPFDocument(OPCPackage.open(fis));

			List paragraphList = xdoc.getParagraphs();

			for (XWPFParagraph paragraph : paragraphList) {

				for (XWPFRun rn : paragraph.getRuns()) {

					System.out.println(rn.isBold());
					System.out.println(rn.isHighlighted());
					System.out.println(rn.isCapitalized());
					System.out.println(rn.getFontSize());
				}

				System.out.println("********************************************************************");
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}

	}

}

Reading Image from Word Document

Following is an example to read image files from a word document.

public class ImageReader {

	public static void main(String[] args) {

		try {
			FileInputStream fis = new FileInputStream("test.docx");
			XWPFDocument xdoc = new XWPFDocument(OPCPackage.open(fis));
			List pic = xdoc.getAllPictures();
			if (!pic.isEmpty()) {
				System.out.print(pic.get(0).getPictureType());
				System.out.print(pic.get(0).getData());
			}

		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

}

Conclusion

I hope this article served you that you were looking for. If you have anything that you want to add or share then please share it below in the comment section.

Download source

The Java IO API provides two kinds of interfaces for reading files, streams and readers. The streams are used to read binary data and readers to read character data. Since a text file is full of characters, you should be using a Reader implementations to read it. There are several ways to read a plain text file in Java e.g. you can use FileReader, BufferedReader or Scanner to read a text file. Every utility provides something special e.g. BufferedReader provides buffering of data for fast reading, and Scanner provides parsing ability. 

public static void readTextFileUsingFileReader(String fileName) {
    try {
      FileReader textFileReader = new FileReader(fileName);
      char[] buffer = new char[8096];
      int numberOfCharsRead = textFileReader.read(buffer);
      while (numberOfCharsRead != -1) {
        System.out.println(String.valueOf(buffer, 0, numberOfCharsRead));
        numberOfCharsRead = textFileReader.read(buffer);
      }
      textFileReader.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

Output
Once upon a time, we wrote a program to read data from a text file.
The program failed to read a large file but then Java 8 come to
rescue, which made reading file lazily using Streams. 

public static void readTextFileUsingBufferdReader(String fileName) {
    try {
      FileReader textFileReader = new FileReader(fileName);
      BufferedReader bufReader = new BufferedReader(textFileReader);

      char[] buffer = new char[8096];

      int numberOfCharsRead = bufReader.read(buffer); // read will be from
      // memory
      while (numberOfCharsRead != -1) {
        System.out.println(String.valueOf(buffer, 0, numberOfCharsRead));
        numberOfCharsRead = textFileReader.read(buffer);
      }

      bufReader.close();

    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

Output
[From File] Java provides several ways to read file

public static void readTextFileUsingScanner(String fileName) {
    try {
      Scanner sc = new Scanner(new File(fileName));
      while (sc.hasNext()) {
        String str = sc.nextLine();
        System.out.println(str);
      }
      sc.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
Output
[From File] Java provides several ways to read the file.

Files.lines(Paths.get("newfile.txt")).forEach(System.out::println);

Output
This is the first line of file

something is better than nothing

this is the last line of the file

Files.lines(new File("newfile.txt").toPath())
.map(s -> s.trim()) 
.filter(s -> !s.isEmpty()) 
.forEach(System.out::println);

Output
This is the first line of file
something is better than nothing
this is the last line of the file

public static String readFileAsString(String fileName) {
    String data = "";
    try {
      data = new String(Files.readAllBytes(Paths.get("file.txt")));
    } catch (IOException e) {
      e.printStackTrace();
    }

    return data;
  }
Output
[From File] Java provides several ways to read file

public static List<String> readFileInList(String fileName) {
    List<String> lines = Collections.emptyList();
    try {
      lines = Files.readAllLines(Paths.get("file.txt"), StandardCharsets.UTF_8);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return lines;
}

public static String[] readFileIntoArray(String fileName) {
    List<String> list = readFileInList(fileName);
    return list.toArray(new String[list.size()]);
}

public static void readFileLineByLine(String fileName) {
    try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
      String line = br.readLine();
      while (line != null) {
        System.out.println(line);
        line = br.readLine();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

/*
 * Java Program read a text file in multiple way.
 * This program demonstrate how you can use FileReader,
 * BufferedReader, and Scanner to read text file,
 * along with newer utility methods added in JDK 7
 * and 8. 
 */

public class FileReadingDemo {

  public static void main(String[] args) throws Exception {

    // Example 1 - reading a text file using FileReader in Java
    readTextFileUsingFileReader("sample.txt");
    
    // Example 2 - reading a text file in Java using BufferedReader
    readTextFileUsingBufferdReader("file.txt");
    
    // Example 3 - reading a text file in Java using Scanner
    readTextFileUsingScanner("file.txt");
    
    // Example 4 - reading a text file using Stream in Java 8
    Files.lines(Paths.get("newfile.txt")).forEach(System.out::println);    
    
    // Example 5 - filtering empty lines from a file in Java 8
    Files.lines(new File("newfile.txt").toPath())
    .map(s -> s.trim()) 
    .filter(s -> !s.isEmpty()) 
    .forEach(System.out::println);
    
    
    // Example 6 - reading a text file as String in Java
    readFileAsString("file.txt");
    
    
    // Example 7 - reading whole file in a List
    List<String> lines = readFileInList("newfile.txt");
    System.out.println("Total number of lines in file: " + lines.size());
    
    // Example 8 - how to read a text file in java into an array
    String[] arrayOfString = readFileIntoArray("newFile.txt");
    for(String line: arrayOfString){
    System.out.println(line);
    }
    
    // Example 9 - how to read a text file in java line by line
    readFileLineByLine("newFile.txt");
    
    // Example 10 - how to read a text file in java using eclipse
    // all examples you can run in Eclipse, there is nothing special about it. 
    
  }

  public static void readTextFileUsingFileReader(String fileName) {
    try {
      FileReader textFileReader = new FileReader(fileName);
      char[] buffer = new char[8096];
      int numberOfCharsRead = textFileReader.read(buffer);
      while (numberOfCharsRead != -1) {
        System.out.println(String.valueOf(buffer, 0, numberOfCharsRead));
        numberOfCharsRead = textFileReader.read(buffer);
      }
      textFileReader.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

  public static void readTextFileUsingBufferdReader(String fileName) {
    try {
      FileReader textFileReader = new FileReader(fileName);
      BufferedReader bufReader = new BufferedReader(textFileReader);

      char[] buffer = new char[8096];

      int numberOfCharsRead = bufReader.read(buffer); // read will be from
      // memory
      while (numberOfCharsRead != -1) {
        System.out.println(String.valueOf(buffer, 0, numberOfCharsRead));
        numberOfCharsRead = textFileReader.read(buffer);
      }

      bufReader.close();

    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

  public static void readTextFileUsingScanner(String fileName) {
    try {
      Scanner sc = new Scanner(new File(fileName));
      while (sc.hasNext()) {
        String str = sc.nextLine();
        System.out.println(str);
      }
      sc.close();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

  public static String readFileAsString(String fileName) {
    String data = "";
    try {
      data = new String(Files.readAllBytes(Paths.get("file.txt")));
    } catch (IOException e) {
      e.printStackTrace();
    }

    return data;
  }

  public static List<String> readFileInList(String fileName) {
    List<String> lines = Collections.emptyList();
    try {
      lines = Files.readAllLines(Paths.get("file.txt"), StandardCharsets.UTF_8);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return lines;
  }

  public static String[] readFileIntoArray(String fileName) {
    List<String> list = readFileInList(fileName);
    return list.toArray(new String[list.size()]);

  }

  public static void readFileLineByLine(String fileName) {
    try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
      String line = br.readLine();
      while (line != null) {
        System.out.println(line);
        line = br.readLine();
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

There are several ways present in java to read the text file like BufferReader, FileReader, and Scanner.  Each and every method provides a unique way of reading the text file.

Methods:

1. Using Files class
2. Using FileReader class
3. Using BufferReader class
4. Using Scanner class

Let’s see each and every method in detail with an example to get a better understanding of the methods to, later on, implement the same to extract the content from a text document.

Method 1: Using Files class

As Java provides java.nio.file. API we can use java.nio.file.Files class to read all the contents of a file into an array. To read a text file we can use the readAllBytes() method of Files class with which using this method, when you need all the file contents in memory as well as when you are working on small files.

Example:

Output:

Method 2: Using FileReader class 

We can use java.io.FileReader can be used to read data (in characters) from files. This is a very efficient method to read the file line by line.

Syntax:

FileReader input = new FileReader(String name);

Example:

Output:

Method 3: Using BufferedReader class 

If you want to read the file line by line and If you want to process on that file then you have to use BufferedReader. It is also used for processing the large file, and it supports encoding also. Reading operation is very efficient on BufferReader.

Note: Either specify the size of the BufferReader or keep the size as a Default size of BufferReader which is 8KB.  
 

Syntax:

BufferedReader in = new BufferedReader(Reader in, int size);

Implementation:

Hello I am learning web- development.
I am writing article for GFG.
I am cloud enthusiast.
I am an open-source contributor.

Note: Before starting create a text file by using .txt extension on your local machine and use the path of that file whenever you necessary while practicing. 

Example:

 Output:

Method 4: Using Scanner class 

If we want to read the document based on some expression & If you want to read the document line by line then we use Scanner class. A Scanner breaks the input into tokens, which by default matches the white space. 

Example :

Output:

Implementation: 

Here “my_file.txt” is a demo file used for the program demonstrated below where sample lines are as follows:

Hello I am learning web- development.
I am writing article of GFG.
I am cloud enthusiast.
I am an open-source contributor.

Example 1:

 
Example 2: Reading specific lines from a text file

Now If you want to read the specific lines from the given document then we use the BufferReader method. Depending on the file BufferReader() method is used so that our code works faster and efficiently. In this program, the Text file stored in BufferReader is a traverse through all the lines by using for loop, and when if the condition becomes true we will print that lines 

Implementation: 

“myfile.txt” is the demo file to be used. 

This is the sample lines been contained in this file which is consisting of random arbitral words composed in lines 

3D printing or additive manufacturing is a process of making three dimensional solid objects from a digital file.

The creation of a 3D printed object is achieved using additive processes. In an additive process an object is created by laying down successive layers of material until the object is created. Each of these layers can be seen as a thinly sliced cross-section of the object.

3D printing is the opposite of subtractive manufacturing which is cutting out / hollowing out a piece of metal or plastic with for instance a milling machine.

3D printing enables you to produce complex shapes.

It uses less material than traditional manufacturing methods.

 
Output: The specific Line is:

3D printing enables you to produce complex shapes.

This java example shows how to read the contents of a file word by word.

Source: (ReadWords.java)

import java.util.Scanner;
import java.io.*;
 
public class ReadWords {
  public static void main(String[] args) throws IOException {
 
    File file = new File("words.txt");
    Scanner input = new Scanner(file); 
 
    int count = 0;
    while (input.hasNext()) {
      String word  = input.next();
      System.out.println(word);
      count = count + 1;
    }
    System.out.println("Word count: " + count);
  }
}
 

Output:

$ cat words.txt 
The cat in the hat

$ java ReadWords
The
cat
in
the
hat
Word count: 5

This is one of the articles from our Java Tutorial for Beginners.

We suggest that you recall two real-world examples which will help you understand the topic of this article.

1. When we’re about to go on a flight, the staff at the airport first check your luggage with a scanner machine. The machine scans your bag and the airport employee finds out exactly what you have in it.
2. Scanners in stores work the same way. An employee at a check-out stand scans a bar code and sees all the information that is listed under that bar code.

There are similar tasks in the world of Java programming. For example, it’s often necessary to carry out the following tasks:

• A user enters some number in the console and then the program has to read out the number which the user entered in the console.
• A user enters some word in the console and then the program has to read out the word which the user entered in the console.

To carry out these tasks, Java uses the scanner. Remember: if something is entered in the console and you want to read what was entered, then you need to use the scanner.

We will examine several examples of code, after which you will:

1. understand how the scanner works in practice. There are 6 examples of code in this article. We recommend that you run all of them on your computer and learn how they work in practice.
2. master four scanner methods:

next ();

nextLine ();

nextInt ();

nextDouble ();

Methods are, roughly speaking, the actions that the Scanner can perform. In fact, there are many scanner methods. But at this stage, it will be sufficient to know just 4. Let’s get started!

Example No. 1 – The nextInt () method

Let’s suppose that we want the user to enter any integer from 1 to 10 in the console, and we want the program to display the number that the user entered.

Since we need to “scan” the number entered the user entered, we need to use the scanner. You can see the solution below, as well as comments on it.

Solution:

If you run this code on your computer, you will see the following in the console:

Enter any integer from 1 to 10:

And if you enter, for example, the number 5, you will see the following in the console:

Enter any integer from 1 to 10: 5

You entered 5

Commentary:

In the article “What is the Java Class library?” we learned that Java has a huge library of tested code – ready-made frameworks for many problems that programmers face in their daily work. We also talked about various packages, classes, and methods. So, now we are going to work with the java.util package. This package includes the Scanner class, which has methods (actions) which allow us to work with the input and output of information in the console.

In order to be able to use the Scanner class, we first need to take 3 steps.

Step No. 1 – Write the following line in the code:

Why did we write this line? It helped us import the Scanner class from the java.util package. If we had forgotten to write it, the scanner simply wouldn’t work. Also, take note of where we wrote the line.

Then we asked the user to enter any whole number (integer) from 1 to 10. To do this, we wrote:

Step No. 2 – Declare the scanner

1. With the help of Scanner scan, we declared that the variable will be called “scan” and it will fall into the Scanner class. It’s necessary to write the word Scanner in front of the name of the variable. By the way, you can call it whatever you want; you don’t need to call it “scan.”
2. Then we wrote = new Scanner (System.in);

When you get to the topic of classes, you will gain a greater understanding of this construction.

Step No. 3 – Read the number from the console

1. 1. With the help of int number, we declared the variable number of the int type. Why did we choose the int type for the variable? Because, according to the condition of the task, the user has to enter any integer from 1 to 10. And since we expect that the number entered by the user will be a whole number (an integer), we chose the int type for the variable «number.»
   2. = scan. nextInt ();  this method of the nextInt () scanner is responsible for reading out the whole number which the user entered in the console. With the help of scan.nextInt () we read the entered whole number from the console and assign it to the variable «number.»

That’s it. From now on, the variable «number» will have the number entered by the user. Hurray!

Then we needed to enter the number that the user entered in the console and we did it with the help of this line:

Example No. 2 – The nextInt () method

Ask the user to enter any two whole numbers (integers). After that, you need to display the sum of these two numbers in the console.

Solution:

If run this code on your computer, you will see the following in the console:

Enter any two integers:

And if you enter, for example, the numbers 2 and 3, you will see the following in the console:

Enter any two integers:

2

3

5

Commentary:

Again, it takes 3 steps to use the scanner.

Step No. 1 – Import the scanner from the java.util package:

Then we asked the user to enter two any integers:

Step No. 2 – Declare the scanner

1. With the help of Scanner k, we declared that the variable will be called “k” and will fall into the «Scanner» class. It’s necessary to write the word «Scanner» in front of the name of the variable. By the way, you can call it whatever you want; you don’t need to call it “k.”
2. Then we wrote = new Scanner (System.in);

Step No. 3 – Read out the number from the console

Actually, we did this two times, because we asked the user to enter two different numbers:

That’s it. From now on, the variables «number1» and «number2» will have the two numbers that the user entered.

And then we displayed the sum of «number1» and «number2»:

Example No. 3 – The nextLine () method

Let’s suppose that we want the user to enter any word or phrase in the console and we want the program to display the word or phrase the user entered.

Solution:

If you run this code on your computer, you will see the following in the console:

Enter any word or phrase:

And if the user enters “I’m the Lord of the Scanner”, you will see the following in the console:

Enter any word or phrase:

I’m the Lord of the Scanner

I’m the Lord of the Scanner

Commentary:

Again, it takes 3 steps to use the scanner.

Step No. 1 – Import the scanner from the java.util package:

Then we asked the user to enter any word or phrase:

Step No. 2 – Declare the scanner

Step No. 3 – Read out the word or phrase from the console

1. With the help of String phrase1 we assigned the variable c of the String type the name «phrase1.» Why did we choose the String type for the variable? Because, according to the condition of the task, the user needs to enter any word or phrase. Since we expect the user to enter a word or phrase, we chose the String type for the variable phrase1.
2. = sc. nextLine (); is responsible for reading out the word or phrase which the user entered in the console. With the help of the nextLine () method, we read out the entered word or phrase from the console and assign it to the variable phrase1.

From now on, the variable «phrase1» will have the phrase or word entered by the user.

Note: In examples 1 and 2, we used the nextInt (); method for whole numbers. In this example, we expected the user to enter a phrase or word (instead of whole numbers), so we used the nextLine (); method.

Then we displayed the word or phrase which the user entered in the console:

Example No. 4 – The nextLine () method

Let’s suppose that we want the user to enter several words or phrases at the same time and we want the program to display them in the one line.

Solution:

If you run this code on your computer, you will see the following in the console:

Enter any two words or phrases:

And if the user enters the phrase “I love” and then the word “Java”, you will see the following in the console:

I love

Java

I love Java

Commentary:

Again, it takes 3 steps to be able to use the scanner.

Step No. 1 – Import the scanner from the java.util package

Then we asked the user to enter any two words or phrases:

Step No. 2 – Declare the scanner

Step No. 3 – Read out the word or phrase from the console

1. 1. With the help of String phrase1 and String phrase2, we declared the variables phrase1 and phrase2 of the String type. Why did we choose the String type for the variable? Because, according to the condition of the task, the user needs to enter any two words or phrases. So we expect that the user will enter two words or phrases. And that’s why we chose the String type for the variables phrase1 and phrase2.
   2. = sc. nextLine (); is responsible for reading out the words or phrases from the console. With the help of the nextLine () method, we read out the entered word or phrase from the console and assign it to the variables phrase1 and phrase2.

Then we displayed the 2 words or phrases entered by the user:

Note: We added “ “ between phrase1 and phrase2. If we hadn’t done this, we would see the following in the console:

I love

Java

I loveJava

Example No. 5 – The next () method

Let’s suppose that we want the user to enter any word or phrase and we want the program to display everything in the console up to the first space.

For example, if the user enters “Working with the scanner is cool”, then the program will only read out the word “Working”, because the first space appears after this word.

Or if, for example, the user enters “I love Java”, then the program will only read out the word “I”, because the first space appears after this word.

Anyway, you got the idea. Let’s take a look at the code.

Solution:

If you run this code on your computer, you will see the following in the console:

Enter any word or phrase:

And if the user enters “I’m the Lord of the Scanner”, you will see the following in the console:

Enter any word or phrase:

I’m the Lord of the Scanner

I’m

Commentary:

Again, it takes 3 steps to be able to use the scanner.

Step No. 1 – Import the scanner from the java.util package:

Step No. 2 – Declare the scanner

Then we asked the user to enter any word or phrase:

Step No. 3 – Read out the word or phrase from the console

1. 1. With the help of String phrase1, we declared the variable c of the String type and named it phrase1. Why did we choose the String type for the variable? Because, according to the condition of the problem, the user needs to enter a word or a phrase. Since we expect the user to enter a word or a phrase, we chose the String type for variable phrase1.
   2. = sc. next (); is responsible for reading out the word or phrase up to the first space in the console. With the help of the next () method, we read out the entered word or phrase which appeared up to the first space from the console and assign it to variable phrase1.

From now on, variable phrase1 will have everything up to the first space.

Then we displayed everything up to the first space in the console:

Example No. 6 – The nextDouble () method

Let’s suppose you want the user to enter any fraction and for the program to read out the number the user entered and then display it in the console.

Solution:

If you run this code on your computer, you will see the following in the console:

Enter any fraction:

And if you enter the number 2,0 you will see the following in the console:

Enter any fraction:

2,0

You entered 2.0

Commentary:

WARNING: BUG!!!

Note that in the code, all numbers of the «double» type are always written in the format “2.0”, i.e. separated by a point instead of comma.

And we intentionally entered the number of the double type in the format “2,0” – with the comma. Then the program displayed the number in the correct format: “2.0” – “You entered the number 2.0”

This is a bug. You just need to remember that when you enter the number of the double type in the console, you need to write it separated by the comma. If you enter the number in the console (not in the code) in the format “2.0”, the program will give you an error code!

Again, it takes 3 steps to use the scanner.

Step No. 1 – Import the scanner from the java.util package

Then we asked the user to enter any fraction:

Step No. 2 – Declare the scanner

Step No. 3 — Read out the number from the console

1. 1. With the help of double number, we declared the variable number of the double type. Why did we choose the double type for the variable? Because according to the condition of the problem, the user needs to enter any fraction. So we expect the user to enter any fraction. That’s why we chose the double type for the variable number.
   2. = sc. nextDouble (); the method of the nextDouble() scanner is responsible for reading out the fraction which the user entered in the console. i.e. with the help of the scan.nextDouble () method, we read out the entered fraction from the console and assign it to the variable «number.»

That’s it. From now on, the variable «number» will have the number entered by the user.

Then we needed to display the number entered by the user in the console, and we did it with the help of:

LET’S SUMMARIZE

In order to use the scanner, you need to take 3 steps:

Step No. 1 — Import the scanner from the java.util package

Step No. 2 – Declare the scanner. For example:

Step No. 3 – Set the appropriate method for reading out from the console. For example:

Scanner methods that you already know:

next (); — reads the entered line up to the first space

nextLine (); — reads the whole entered line

nextInt (); — reads the entered number of the int type

nextDouble (); — reads the entered number of the double type

Keep in mind that if you use the nextDouble () methods for fractions, you need to write the numbers separated by a comma, instead of period. For example: 7,5

You can find more articles in our Java Tutorial for Beginners.