Welcome to this lesson on writing table data to text files using Java. In today's digital world, storing and sharing data efficiently is essential. Text files are a common means to achieve this due to their simplicity and compatibility with various systems. In this lesson, our goal is to learn how to write formatted table data into a text file using Java, making use of java.nio.file for path handling and the Jackson library for CSV operations.

By the end of this lesson, you will be able to take a structured data format and write it to both text and CSV files using Java. Let’s dive into this skill and build on what you've learned about parsing tables from text and CSV files.

Before we proceed, let's briefly recall two key concepts: Java collections and basic file handling.

• Java Collections: Java provides the List<T> interface, which allows you to store a collection of items, such as rows in a table. This step is crucial as it helps organize your data into a structured format.

• File Handling: We have previously covered basic reading operations. Now, we move to writing data. Java provides a straightforward API within java.nio.file and java.io packages. Using classes like BufferedWriter and FileWriter, we can efficiently handle file output.

These foundational concepts will guide us in the process of writing table data into a text file.

First, we'll define the Person class, which will serve as the blueprint for our data entries. In this class, each Person object will have properties corresponding to the columns in our table:

Java
Copy to clipboard
1public class Person {
2    public String name;
3    public String age;
4    public String occupation;
5
6    public Person(String name, String age, String occupation) {
7        this.name = name;
8        this.age = age;
9        this.occupation = occupation;
10    }
11}

With our structure in place, we can now create a list of Person objects. This list, data, acts as a collection of rows where each Person instance signifies an individual record:

Java
Copy to clipboard
1List<Person> data = Arrays.asList(
2    new Person("John", "28", "Engineer"),
3    new Person("Alice", "34", "Doctor"),
4    new Person("Bob", "23", "Artist")
5);

In this example, we've added three Person objects to our list, each representing a row with fields for name, age, and occupation. This structured approach not only simplifies the process of adding or modifying rows but also facilitates the seamless writing of data to files.

To write data to a text file using tab delimiters in Java, we need to import the necessary classes and then employ BufferedWriter, which efficiently handles the data writing process. Here's how you can implement this:

First, we import BufferedWriter from the java.io package:

Java
Copy to clipboard
1import java.io.BufferedWriter;

With BufferedWriter, we can open a stream to our target file, here named "output.txt". This class reduces the number of I/O operations by temporarily holding data in a buffer before writing it to the file. Once the buffer is full or the writer is closed, the contents are flushed to the file all at once.

Now, let’s look at the code that does this:

Java
Copy to clipboard
1// Define the path for the output text file
2Path outputTxtFilePath = Paths.get("output.txt");
3
4// Open a BufferedWriter to write to the file
5BufferedWriter writer = new BufferedWriter(new FileWriter(outputTxtFilePath.toFile()));
6
7// Write the header with tabs as delimiters
8writer.write("Name\tAge\tOccupation\n");
9
10// Iterate through each Person object
11for (Person person : data) {
12    // Write the Person object as a tab-delimited line
13    writer.write(String.format("%s\t%s\t%s\n", person.name, person.age, person.occupation));
14}
15
16// Close the writer to release resources
17writer.close();

In this code:

• The outputTxtFilePath is defined to specify where the file will be created and stored.
• A BufferedWriter is initiated in a try-with-resources statement for automatic resource management. It layers over a FileWriter to efficiently handle buffered output to the specified file.
• We write a header line, using tabs as delimiters.
• We loop through our list of Person objects, crafting each into a tab-separated format using String.format.
• Each formatted line is efficiently written to "output.txt" using the BufferedWriter.

In addition to writing to a text file with tab delimiters, you may also need to write the data in CSV (Comma-Separated Values) format. Here's how you can achieve this in Java using the Jackson library:

Java
Copy to clipboard
1// Define the output path for the CSV file
2Path outputCsvFilePath = Paths.get("output.csv");
3
4// Create an instance of CsvMapper to handle CSV operations
5CsvMapper csvMapper = new CsvMapper();
6
7// Define the schema based on Person class and include headers
8CsvSchema schema = csvMapper.schemaFor(Person.class).withHeader();
9
10// Write the data to the CSV file using the defined schema
11csvMapper.writer(schema).writeValue(outputCsvFilePath.toFile(), data);

In this code, csvMapper.writer(schema) creates a writer specifically configured with the schema that reflects the structure of the Person class, including headers. This setup ensures that each Person object is converted to CSV format accurately, with each attribute aligned with the corresponding header. The writeValue() method takes care of the actual writing process, serializing the list of Person objects into the output CSV file located at the specified path, ensuring efficient and structured data output.

In this lesson, you learned how to effectively structure, write, and verify data stored in text and CSV files using Java. We started by preparing data using Lists and classes, then utilized Java's file-handling techniques to write this data with tabs and commas as delimiters, respectively.

We encourage you to engage with the practice exercises that follow this lesson. Apply what you've learned to reinforce your understanding and gain confidence. Keep experimenting with different data structures, adapt them, and ensure your outputs meet your expectations. Well done on progressing through this important lesson.