Create directories within directories (as many layers as you want).

Create text files in some of these directories while leaving some directories empty for more excitement.

We are going to create a static method that takes a File argument, which is eventually the root directory or the directory to start with. The method will return a set of files that are found within this root directory (and in all other subsequent directories):

        public static Set<File> listFiles(File rootDir) {  

First, create a HashSet that will contain the file information:

        Set<File> fileSet = new HashSet<File>(); 

Once the HashSet is created, we need to check whether the root directory or the directories within it are null. For such cases, we do not need to proceed further:

        if (rootDir == null || rootDir.listFiles() == null){ 
                     return fileSet; 
           } 

We consider one directory (or file) from the root directory at a time and check whether we are dealing with a file or with a directory. In the case of a file, we add that to our HashSet. In the case of a directory, we recursively call this method again by sending the path and name of the directory:

        for (File fileOrDir : rootDir.listFiles()) { 
                     if (fileOrDir.isFile()){ 
                       fileSet.add(fileOrDir); 
                     } 
                     else{ 
                       fileSet.addAll(listFiles(fileOrDir)); 
                     } 
             } 

Finally, we return the HashSet to the caller of this method:

       return fileSet; 
          } 

The complete method, with the class and the driver method to run it, is as follows:

import java.io.File; 
import java.util.HashSet; 
import java.util.Set; 
 
public class TestRecursiveDirectoryTraversal { 
   public static void main(String[] args){ 
      System.out.println(listFiles(new File("Path for root 
          directory")).size()); 
   } 
    
   public static Set<File> listFiles(File rootDir) { 
       Set<File> fileSet = new HashSet<File>(); 
       if(rootDir == null || rootDir.listFiles()==null){ 
           return fileSet; 
       } 
       for (File fileOrDir : rootDir.listFiles()) { 
             if (fileOrDir.isFile()){ 
               fileSet.add(fileOrDir); 
             } 
             else{ 
               fileSet.addAll(listFiles(fileOrDir)); 
             } 
     } 
 
       return fileSet; 
   } 
} 

In this recipe, we will be using a Java library from Apache named Commons IO. Throughout the book, we will be using version 2.5. Download the JAR file of your choice from here: https://commons.apache.org/proper/commons-io/download_io.cgi

Include the JAR file in your project an external JAR in Eclipse.

Create a method that takes the root directory in the hierarchy of directories as input:

        public void listFiles(String rootDir){ 

Create a file object with the root directory name:

        File dir = new File(rootDir); 

The FileUtils class of the Apache Commons library contains a method named listFiles(). Use this method to retrieve all the file names, and put the names in a list variable with <File> generics. Use TrueFileFilter.INSTANCE to match all directories:

        List<File> files = (List<File>) FileUtils.listFiles(dir,   
          TrueFileFilter.INSTANCE, TrueFileFilter.INSTANCE); 

The file names can be displayed on the standard output as follows. As we now have the names in a list, we have a means to process the data in these files further:

        for (File file : files) { 
           System.out.println("file: " + file.getAbsolutePath()); 
        } 

Close the method:

       } 

The method in this recipe, the class for it, and the driver method to run it are as follows:

import java.io.File; 
import java.util.List; 
import org.apache.commons.io.FileUtils; 
import org.apache.commons.io.filefilter.TrueFileFilter; 
 
public class FileListing{ 
   public static void main (String[] args){ 
      FileListing fileListing = new FileListing(); 
      fileListing.listFiles("Path for the root directory here"); 
   } 
   public void listFiles(String rootDir){ 
      File dir = new File(rootDir); 
 
      List<File> files = (List<File>) FileUtils.listFiles(dir,  
        TrueFileFilter.INSTANCE, TrueFileFilter.INSTANCE); 
      for (File file : files) { 
         System.out.println("file: " + file.getAbsolutePath()); 
      } 
   } 

First, create a String object to hold the path and name of the text file you are going to read:

        String file = "C:/dummy.txt";  

Using the get() method of the Paths class, we get to the path of the file we are trying to read. The parameter for this method is the String object that points to the name of the file. The output of this method is fed to another method named lines(), which is in the Files class. This method reads all lines from a file as a Stream, and therefore, the output of this method is directed to a Stream variable. Because our dummy.txt file contains string data, the generics of the Stream variable is set to String.

In this recipe, we will be using a Java library from Apache named Commons IO. Download the version of your choice from here: https://commons.apache.org/proper/commons-io/download_io.cgi

Include the JAR file in your project an external JAR in Eclipse.

Say, you are trying to read the contents of a file located in your C:/ drive named dummy.txt. First, you need to create a file object for accessing this file as follows:

        File file = new File("C:/dummy.txt");  

Next, create a string object to hold the text contents of your file. The method we will be using from Apache Commons IO library is called readFileToString, which is a member of the class named FileUtils. There are many different ways you can call this method. But for now, just know that we need to send two arguments to this method. First, the file object, which is the file we will be reading, and then the encoding of the file, which in this example is UTF-8:

        String text = FileUtils.readFileToString(file, "UTF-8"); 

The preceding two lines will be enough to read text file content and put that in a variable. However, you are not only a data scientist, you are a smart data scientist. Therefore, you need to add a few lines before and after the code just to handle exceptions thrown by Java methods if you try to read a file that does not exist, or is corrupted, and so on. The completeness of the preceding code can be achieved by introducing a try...catch block as follows:

       File file = new File("C:/dummy.txt"); 
       try { 
       String text = FileUtils.readFileToString(file, "UTF-8"); 
       } catch (IOException e) { 
       System.out.println("Error reading " + file.getAbsolutePath()); 
       } 

Download Apache Tika 1.10 JAR file from http://archive.apache.org/dist/tika/tika-app-1.10.jar, and include it in your Eclipse project as an external Java library.

Have any unlocked PDF file saved as testPDF.pdf on your C: drive.

Create a method named convertPdf(String), which takes the name of the PDF file to be converted as parameter:

        public void convertPDF(String fileName){ 

Create an input stream that will contain the PDF data as a stream of bytes:

        InputStream stream = null; 

Create a try block as follows:

        try{ 

Assign the file to the stream you have just created:

        stream = new FileInputStream(fileName); 

There are many different parsers offered in the Apache Tika package. If you do not know which parser you are going to use, or say you have not only PDFs but also other types of documents to get converted, you should use an AutoDetectParser as follows:

        AutoDetectParser parser = new AutoDetectParser(); 

Create a handler to handle the body content of the file. Note the -1 as the parameter of the constructor. Usually, Apache Tika is limited to handling files with at most 100,000 characters. The -1 value ensures that this limitation is overlooked by the body handler:

        BodyContentHandler handler = new BodyContentHandler(-1); 

Create a metadata object:

        Metadata metadata = new Metadata(); 

Call the parser() method of the parser object with all these objects you just created:

        parser.parse(stream, handler, metadata, new ParseContext()); 

Use the tostring() method of the handler object to get the body text extracted from the file:

        System.out.println(handler.toString()); 

Close the try block and complement it with a catch block and finally block, and close the method as follows:

        }catch (Exception e) { 
                      e.printStackTrace(); 
                 }finally { 
                     if (stream != null) 
                          try { 
                               stream.close(); 
                          } catch (IOException e) { 
                            System.out.println("Error closing stream"); 
                          } 
                   } 
        } 

The full method with the driver method in a class will be as follows. The method you have just created can be called by sending it the path and the name of the PDF file you need to convert, which is in your C: drive saved as testPDF.pdf:

import java.io.FileInputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import org.apache.tika.metadata.Metadata; 
import org.apache.tika.parser.AutoDetectParser; 
import org.apache.tika.parser.ParseContext; 
import org.apache.tika.sax.BodyContentHandler; 
 
public class TestTika { 
     public static void main(String args[]) throws Exception { 
          TestTika tika = new TestTika(); 
          tika.convertPdf("C:/testPDF.pdf"); 
     } 
     public void convertPdf(String fileName){ 
          InputStream stream = null; 
          try { 
              stream = new FileInputStream(fileName); 
              AutoDetectParser parser = new AutoDetectParser(); 
              BodyContentHandler handler = new BodyContentHandler(-1); 
              Metadata metadata = new Metadata(); 
              parser.parse(stream, handler, metadata, new 
                  ParseContext()); 
              System.out.println(handler.toString()); 
          }catch (Exception e) { 
              e.printStackTrace(); 
          }finally { 
              if (stream != null) 
                   try { 
                        stream.close(); 
                   } catch (IOException e) { 
                        System.out.println("Error closing stream"); 
                   } 
          } 
     } 
} 

Create a method named cleanText(String) that takes the text to be cleaned in the String format:

        public String cleanText(String text){ 

Add the following lines in your method, return the cleaned text, and close the method. The first line strips off non-ASCII characters. The line next to it replaces continuous white spaces with a single white space. The third line erases all the ASCII control characters. The fourth line strips off the ASCII non-printable characters. The last line removes non-printable characters from Unicode:

        text = text.replaceAll("[^p{ASCII}]",""); 
        text = text.replaceAll("s+", " "); 
        text = text.replaceAll("p{Cntrl}", ""); 
        text = text.replaceAll("[^p{Print}]", ""); 
        text = text.replaceAll("p{C}", ""); 
 
        return text; 
        } 

The full method with the driver method in a class will look as follows:

public class CleaningData { 
   public static void main(String[] args) throws Exception { 
      CleaningData clean = new CleaningData(); 
      String text = "Your text here you have got from some file"; 
      String cleanedText = clean.cleanText(text); 
      //Process cleanedText 
   } 
    
   public String cleanText(String text){ 
      text = text.replaceAll("[^p{ASCII}]",""); 
        text = text.replaceAll("s+", " "); 
        text = text.replaceAll("p{Cntrl}", ""); 
        text = text.replaceAll("[^p{Print}]", ""); 
        text = text.replaceAll("p{C}", ""); 
        return text; 
   } 
} 

Download the Univocity JAR file from http://oss.sonatype.org/content/repositories/releases/com/univocity/univocity-parsers/2.2.1/univocity-parsers-2.2.1.jar. Include the JAR file in your project in Eclipse as external library.

Create a CSV file from the following data using Notepad. The extension of the file should be .csv. You save the file as C:/testCSV.csv:

        Year,Make,Model,Description,Price 
        1997,Ford,E350,"ac, abs, moon",3000.00 
        1999,Chevy,"Venture ""Extended Edition""","",4900.00 
        1996,Jeep,Grand Cherokee,"MUST SELL! 
        air, moon roof, loaded",4799.00 
        1999,Chevy,"Venture ""Extended Edition, Very Large""",,5000.00 
        ,,"Venture ""Extended Edition""","",4900.00 

Create a method named parseCsv(String) that takes the name of the file as a String argument:

        public void parseCsv(String fileName){ 

Then create a settings object. This object provides many configuration settings options:

        CsvParserSettings parserSettings = new CsvParserSettings(); 

You can configure the parser to automatically detect what line separator sequence is in the input:

        parserSettings.setLineSeparatorDetectionEnabled(true); 

Create a RowListProcessor that stores each parsed row in a list:

        RowListProcessor rowProcessor = new RowListProcessor(); 

You can configure the parser to use a RowProcessor to process the values of each parsed row. You will find more RowProcessors in the com.univocity.parsers.common.processor package, but you can also create your own:

        parserSettings.setRowProcessor(rowProcessor); 

If the CSV file that you are going to parse contains headers, you can consider the first parsed row as the headers of each column in the file:

        parserSettings.setHeaderExtractionEnabled(true); 

Now, create a parser instance with the given settings:

        CsvParser parser = new CsvParser(parserSettings); 

The parse() method will parse the file and delegate each parsed row to the RowProcessor you defined:

        parser.parse(new File(fileName)); 

If you have parsed the headers, the headers can be found as follows:

        String[] headers = rowProcessor.getHeaders(); 

You can then easily process this String array to get the header values.

On the other hand, the row values can be found in a list. The list can be printed using a for loop as follows:

        List<String[]> rows = rowProcessor.getRows(); 
        for (int i = 0; i < rows.size(); i++){ 
           System.out.println(Arrays.asList(rows.get(i))); 
        } 

Finally, close the method:

       } 

The entire method can be written as follows:

import java.io.File; 
import java.util.Arrays; 
import java.util.List; 
 
import com.univocity.parsers.common.processor.RowListProcessor; 
import com.univocity.parsers.csv.CsvParser; 
import com.univocity.parsers.csv.CsvParserSettings; 
 
public class TestUnivocity { 
      public void parseCSV(String fileName){ 
          CsvParserSettings parserSettings = new CsvParserSettings(); 
          parserSettings.setLineSeparatorDetectionEnabled(true); 
          RowListProcessor rowProcessor = new RowListProcessor(); 
          parserSettings.setRowProcessor(rowProcessor); 
          parserSettings.setHeaderExtractionEnabled(true); 
          CsvParser parser = new CsvParser(parserSettings); 
          parser.parse(new File(fileName)); 
 
          String[] headers = rowProcessor.getHeaders(); 
          List<String[]> rows = rowProcessor.getRows(); 
          for (int i = 0; i < rows.size(); i++){ 
            System.out.println(Arrays.asList(rows.get(i))); 
          } 
      } 
       
      public static void main(String[] args){ 
         TestUnivocity test = new TestUnivocity(); 
         test.parseCSV("C:/testCSV.csv"); 
      } 
} 

Download the Univocity JAR file from http://oss.sonatype.org/content/repositories/releases/com/univocity/univocity-parsers/2.2.1/univocity-parsers-2.2.1.jar. Include the JAR file in your project in Eclipse an external library.

Create a TSV file from the following data using Notepad. The extension of the file should be .tsv. You save the file as C:/testTSV.tsv:

Create a method named parseTsv(String) that takes the name of the file as a String argument:

        public void parseTsv(String fileName){ 

The line separator for the TSV file in this recipe is a newline character or n. To set this character as the line separator, modify the settings:

        settings.getFormat().setLineSeparator("n"); 

Using these settings, create a TSV parser:

        TsvParser parser = new TsvParser(settings); 

Parse all rows of the TSV file at once as follows:

        List<String[]> allRows = parser.parseAll(new File(fileName)); 

Iterate over the list object to print/process the rows as follows:

        for (int i = 0; i < allRows.size(); i++){ 
                 System.out.println(Arrays.asList(allRows.get(i))); 
               } 

Finally, close the method:

Download version 2.06 of the JAR file for JDOM from http://www.jdom.org/downloads/index.html.

In Eclipse, create a project and include the JAR file an external JAR.

Open up notepad. Create a new file named xmldummy with the .xml extension. The content of the file will be as simple as follows:

Create a SAXBuilder object named builder:

       SAXBuilder builder = new SAXBuilder(); 

Now you need to create a File object to point to the XML file that you will be parsing. If you have saved your XML file in the C:/ drive, then type in the following code segment:

        File file = new File("c:/dummyxml.xml"); 

In a try block, you are going to create a Document object, which will be your XML file:

        try { 
          Document document = (Document) builder.build(file); 

When you are parsing an XML, as it is tree structured, you need to know the root element of the file to start traversing the tree (in other words, to start parsing systematically). So, you are creating a rootNode object of type Element to hold the root element, which in our example is <book> node:

        Element rootNode = document.getRootElement(); 

Then, you will be retrieving all the children nodes of your root node that have the name author. The names come as a list, and therefore, you will be using a list variable to hold them:

        List list = rootNode.getChildren("author"); 

Next, you will be iterating over this list using a for loop to get the elements of the entries in this list. Each element will be kept in an Element type variable named node. This variable has a method named getChildText(), which takes the name of its child as parameter; the method returns the textual content of the named child element, or null if there is no such child. This method is convenient because calling getChild().getText() can throw a NullPointerException:

        for (int i = 0; i < list.size(); i++) { 
           Element node = (Element) list.get(i); 
        System.out.println("First Name : " + 
          node.getChildText("firstname")); 
        System.out.println("Last Name : " +             
          node.getChildText("lastname")); 
        } 

Finally, you will be closing the try block; put the following catch blocks to handle exceptions:

        } catch (IOException io) { 
              System.out.println(io.getMessage()); 
        } catch (JDOMException jdomex) { 
              System.out.println(jdomex.getMessage()); 
        }  

The complete code for the recipe is as follows:

import java.io.File; 
import java.io.IOException; 
import java.util.List; 
 
import org.jdom2.Document; 
import org.jdom2.Element; 
import org.jdom2.JDOMException; 
import org.jdom2.input.SAXBuilder; 
 
public class TestJdom { 
 
   public static void main(String[] args){ 
      TestJdom test = new TestJdom(); 
      test.parseXml("C:/dummyxml.com"); 
 
   } 
   public void parseXml(String fileName){ 
      SAXBuilder builder = new SAXBuilder(); 
      File file = new File(fileName); 
      try { 
         Document document = (Document) builder.build(file); 
         Element rootNode = document.getRootElement(); 
         List list = rootNode.getChildren("author"); 
         for (int i = 0; i < list.size(); i++) { 
            Element node = (Element) list.get(i); 
            System.out.println("First Name : " + 
                node.getChildText("firstname")); 
            System.out.println("Last Name : " + 
                node.getChildText("lastname")); 
         } 
      } catch (IOException io) { 
         System.out.println(io.getMessage()); 
      } catch (JDOMException jdomex) { 
         System.out.println(jdomex.getMessage()); 
      } 
   } 
} 

Download json-simple-1.1.1.jar from https://code.google.com/archive/p/json-simple/downloads and include the JAR file as external library to your Eclipse project.

Create a method named writeJson(String outFileName) that takes the name of the JSON file we will be generating as output with the JSON information in this recipe.

Create a JSON object and use the object's put() method to populate a few fields. For instance, say your fields will be books and their authors. The following code will be creating a JSON object and populate a book name from the Harry Potter series and its author's name:

        JSONObject obj = new JSONObject(); 
          obj.put("book", "Harry Potter and the Philosopher's Stone"); 
          obj.put("author", "J. K. Rowling");

Next, say that we have three reviewer comments for this book. They can be put together in a JSON array. The array can be populated as follows. First, we use add() of the array object to add the reviews. When all the reviews are added to the array, we will be putting the array to the JSON object we created in the previous step:

JSONArray list = new JSONArray(); 
 
list.add("There are characters in this book that will remind us of all the people we have met. Everybody knows or knew a spoilt, overweight boy like Dudley or a bossy and interfering (yet kind-hearted) girl like Hermione"); 
 
list.add("Hogwarts is a truly magical place, not only in the most obvious way but also in all the detail that the author has gone to describe it so vibrantly."); 
 
list.add("Parents need to know that this thrill-a-minute story, the first in the Harry Potter series, respects kids' intelligence and motivates them to tackle its greater length and complexity, play imaginative games, and try to solve its logic puzzles. "); 
 
obj.put("messages", list); 

We will be writing down the information in the JSON object to an output file because this file will be used to demonstrate how we can read/parse a JSON file. The following try...catch code blocks write down the information to a JSON file:

        try { 
 
                 FileWriter file = new FileWriter("c:test.json"); 
                 file.write(obj.toJSONString()); 
                 file.flush(); 
                 file.close(); 
 
        } catch (IOException e) { 
                 //your message for exception goes here. 
        } 

The content of the JSON object can also be displayed on the standard output as follows:

        System.out.print(obj); 

Finally, close the method:

Use the previous recipe to create a JSON file with book, author, and reviewer comments information. This file will be used as an input for parsing/reading in this recipe.

As we will be reading or parsing a JSON file, first, we will be creating a JSON parser:

        JSONParser parser = new JSONParser(); 

Then, in a try block, we will be retrieving the values in the fields book and author. However, to do that, we first use the parse() method of the parser to read the input JSON file. The parse() method returns the content of the file as an object. Therefore, we will need an Object variable to hold the content. Then, the object will be assigned to a JSON object for further processing. Notice the type cast of the Object variable during the assignment:

       try { 
 
         Object obj = parser.parse(new FileReader("c:test.json")); 
         JSONObject jsonObject = (JSONObject) obj; 
 
         String name = (String) jsonObject.get("book"); 
         System.out.println(name); 
 
         String author = (String) jsonObject.get("author"); 
         System.out.println(author); 
       }

The next field to retrieve from the input JSON file is the review field, which is an array. We iterate over this field as follows:

 
       JSONArray reviews = (JSONArray) jsonObject.get("messages"); 
         Iterator<String> iterator = reviews.iterator(); 
         while (iterator.hasNext()) { 
            System.out.println(iterator.next()); 
       } 

Finally, we create catch blocks to handle three types of exceptions that may occur during the parsing, and then close the method:

Go to https://jsoup.org/download, and download the jsoup-1.9.2.jar file. Add the JAR file to your Eclipse project an external library.

If you are a Maven fan, please follow the instructions on the download page to include the JAR file into your Eclipse project.

Create a method named extractDataWithJsoup(String url). The parameter is the URL of any webpage that you need to call the method. We will be extracting web data from this URL:

        public void extractDataWithJsoup(String href){  

Use the connect() method by sending the URL where we want to connect (and extract data). Then, we will be chaining a few more methods with it. First, we will chain the timeout() method that takes milliseconds as parameters. The methods after that define the user-agent name during this connection and whether attempts will be made to ignore connection errors. The next method to chain with the previous two is the get() method that eventually returns a Document object. Therefore, we will be holding this returned object in doc of the Document class:

        doc = 
          Jsoup.connect(href).timeout(10*1000).userAgent
            ("Mozilla").ignoreHttpErrors(true).get();

As this code throws IOException, we will be using a try...catch block as follows:

        Document doc = null; 
        try { 
         doc = Jsoup.connect(href).timeout(10*1000).userAgent
           ("Mozilla").ignoreHttpErrors(true).get(); 
           } catch (IOException e) { 
              //Your exception handling here 
        } 

A large number of methods can be found for a Document object. If you want to extract the title of the URL, you can use title method as follows:

         if(doc != null){ 
          String title = doc.title(); 

To only extract the textual part of the web page, we can chain the body() method with the text() method of a Document object, as follows:

        String text = doc.body().text();

If you want to extract all the hyperlinks in a URL, you can use the select() method of a Document object with the a[href]parameter. This gives you all the links at once:

        Elements links = doc.select("a[href]"); 

Perhaps you wanted to process the links in a web page individually? That is easy, too--you need to iterate over all the links to get the individual links:

        for (Element link : links) { 
            String linkHref = link.attr("href"); 
            String linkText = link.text(); 
            String linkOuterHtml = link.outerHtml(); 
            String linkInnerHtml = link.html();  
        System.out.println(linkHref + "t" + linkText + "t"  +  
          linkOuterHtml + "t" + linkInnterHtml);       
        }  

Finally, close the if-condition with a brace. Close the method with a brace:

Download selenium-server-standalone-2.53.1.jar and selenium-java-2.53.1.zip from http://selenium-release.storage.googleapis.com/index.html?path=2.53/. From the latter, extract the selenium-java-2.53.1.jar file. Include these two JAR files in your eclipse project an external Java library.

Download and install Firefox 47.0.1 from https://ftp.mozilla.org/pub/firefox/releases/47.0.1/ by selecting the version appropriate for your operating system.

Create a method named extractDataWithSelenium(String) that takes a String as a parameter, which eventually is the URL from where we are going to extract data. There can be many different types of data that we can extract from URLs, such as the title, the headers, and the values in a selection drop-down box. This recipe only concentrates on extracting the text part of the webpage:

        public String extractDataWithSelenium(String url){ 

Next, create a Firefox web driver using the following code:

        WebDriver driver = new FirefoxDriver(); 

Use the get() method of the WebDriver object by passing the URL:

        driver.get("http://cogenglab.csd.uwo.ca/rushdi.htm"); 

The text of the webpage can be found using xpath, where the value of id is content:

Find this particular element with the findElement() method. This method returns a WebElement object. Create a WebElement object named webElement to hold the returned value:

        WebElement webElement = driver.findElement(By.xpath("//* 
          [@id='content']")); 

The WebElement object has a method named getText(). Call this method to retrieve the text of the web page, and put the text into a String variable as follows:

        String text = (webElement.getText()); 

Finally, return the String variable and close the method:

        }

The complete code segment with the driver main() method for the recipe looks like the following:

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.WebElement; 
import org.openqa.selenium.firefox.FirefoxDriver; 
 
public class TestSelenium { 
   public String extractDataWithSelenium(String url) { 
      WebDriver driver = new FirefoxDriver(); 
      driver.get("http://cogenglab.csd.uwo.ca/rushdi.htm"); 
      WebElement webElement = driver.findElement(By.xpath("//*
        [@id='content']")); 
      System.out.println(webElement.getText()); 
      return url;    
   } 
 
   public static void main(String[] args){ 
      TestSelenium test = new TestSelenium(); 
      String webData = test.extractDataWithSelenium
        ("http://cogenglab.csd.uwo.ca/rushdi.htm"); 
      //process webData 
   } 
} 

Download and install MySQL community server from http://dev.mysql.com/downloads/mysql/. The version used in this recipe is 5.7.15.

Create a database named data_science. In this database, create a table named books that contains data as follows:

The choice of the field types does not matter for this recipe, but the names of the fields need to exactly match those from the exhibit shown here.

Download the platform independent MySql JAR file from http://dev.mysql.com/downloads/connector/j/, and add it an external library into your Java project. The version used in this recipe is 5.1.39.

Create a method as public void readTable(String user, String password, String server) that will take the user name, password, and server name for your MySQL database as parameters:

        public void readTable(String user, String password, String   
          server){ 

Create a MySQL data source, and using the data source, set the user name, password, and server name:

        MysqlDataSource dataSource = new MysqlDataSource(); 
          dataSource.setUser(user); 
          dataSource.setPassword(password); 
          dataSource.setServerName(server); 

In a try block, create a connection for the database. Using the connection, create a statement that will be used to execute a SELECT query to get information from the table. The results of the query will be stored in a result set:

        try{ 
          Connection conn = dataSource.getConnection(); 
          Statement stmt = conn.createStatement(); 
          ResultSet rs = stmt.executeQuery("SELECT * FROM  
            data_science.books"); 

Now, iterate over the result set, and retrieve each column data by mentioning the column name. Note the use of the method that gives us the data you need to know the field type before you can use them. For instance, as we know that the ID filed is integer, we are able to use the getInt() method:

        while (rs.next()){ 
          int id = rs.getInt("id"); 
          String book = rs.getString("book_name"); 
          String author = rs.getString("author_name"); 
          Date dateCreated = rs.getDate("date_created"); 
          System.out.format("%s, %s, %s, %sn", id, book, author, 
            dateCreated); 
        }

Close the result set, the statement, and connection after iteration:

        rs.close(); 
          stmt.close(); 
          conn.close(); 

Catch some exceptions as you can have during this reading data from the table and close the method: