Writing To Csv File In Java

Writing the list of beans:

import com.opencsv.bean.StatefulBeanToCsv;
import com.opencsv.bean.StatefulBeanToCsvBuilder;
import com.opencsv.exceptions.CsvDataTypeMismatchException;
import com.opencsv.exceptions.CsvRequiredFieldEmptyException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.List;

public class OpenCsvWriter {

    public void writeEmployees(List employees, String filePath) {
        try (Writer writer = new FileWriter(filePath, StandardCharsets.UTF_8)) {
            
           

```java
            StatefulBeanToCsv beanToCsv = new StatefulBeanToCsvBuilder(writer)
                    .withQuotechar(CSVWriter.NO_QUOTE_CHARACTER)   // optional: control quoting
                    .withSeparator(CSVWriter.DEFAULT_SEPARATOR)   // comma by default
                    .withApplyQuotesToAll(false)                  // quote only when necessary
                    .withOrderedResults(false)                    // preserve input order
                    .build();

            beanToCsv.write(employees);
        } catch (IOException | CsvDataTypeMismatchException | CsvRequiredFieldEmptyException e) {
            throw new RuntimeException("Failed to write CSV with OpenCSV", e);
        }
    }
}

When OpenCSV Shines

• Declarative Mapping: Annotations let you keep the CSV layout in sync with your DTO without scattering printRecord calls across service code.
• Custom Converters: Implement Convertible or use @CsvCustomBindByName to handle complex types (e.g., UUID, monetary values with locale‑specific formatting).
• Streaming & Low Memory: Like Apache Commons CSV, StatefulBeanToCsv writes incrementally, making it suitable for million‑row exports.
• Header Control: @CsvBindByName automatically generates the header row; you can suppress it with withSkipHeader(true) if you need a header‑less file.

Quick Usage Example

List dtoList = employeeService.fetchForExport();
new OpenCsvWriter().writeEmployees(dtoList, "target/employees.csv");

After execution, opening target/employees.csv in Excel or LibreOffice will show columns Employee ID, Full Name, Hire Date, and Salary, with dates formatted as yyyy-MM-dd and any embedded commas or quotes properly escaped.

Conclusion

Choosing the right CSV writer depends on the balance between control, convenience, and project constraints:

• Manual StringBuilder – viable for trivial, one‑off scripts but error‑prone and tedious to maintain.
• Apache Commons CSV – offers a lightweight, fluent API with automatic escaping and header handling; ideal when you prefer explicit, procedural writing.
• OpenCSV – excels when you have a rich domain model and want annotation‑driven mapping, custom converters, and minimal boilerplate.

All three approaches produce RFC‑4180‑compliant output, safely handle special characters, and stream data to keep memory usage low. By selecting the library that matches your team’s familiarity and the complexity of your export requirements, you can generate reliable CSV reports with confidence And that's really what it comes down to..

Quick note before moving on.

Performance Considerations at Scale

While all three approaches stream data to avoid OutOfMemoryError on large datasets, their CPU profiles differ significantly:

Tip: For OpenCSV, call beanToCsv.write(Iterable) rather than write(Object[]) or write(Collection). Passing a Stream or custom Iterable that fetches from the database in chunks (e.g., using Spring Data Pageable or Hibernate ScrollableResults) keeps the JVM heap flat regardless of result set size.

// Example: Streaming from DB to CSV without loading all rows into memory
try (var scroll = session.createQuery("from Employee", Employee.class).scroll(ScrollMode.FORWARD_ONLY)) {
    Iterable dtoStream = () -> new Iterator<>() {
        @Override public boolean hasNext() { return scroll.next(); }
        @Override public EmployeeExportDto next() { return map((Employee) scroll.get(0)); }
    };
    beanToCsv.write(dtoStream); // OpenCSV consumes the Iterable lazily
}

Testing CSV Output Reliably

Don’t rely on visual inspection in Excel. Automate verification with assertj-csv or a lightweight parser in your integration tests:

@Test
void shouldExportEmployeesWithCorrectHeadersAndEscaping() throws IOException {
    // Given
    var employees = List.of(
        new EmployeeExportDto(1L, "Smith, John", LocalDate.of(2020, 1, 15), new BigDecimal("50000.00")),
        new EmployeeExportDto(2L, "O'Reilly", LocalDate.of(2021, 6, 20), new BigDecimal("75000.50"))
    );
    File output = File.createTempFile("employees-", ".csv");

    // When
    new OpenCsvWriter().writeEmployees(employees, output.getAbsolutePath());

    // Then (using OpenCSV to parse back for symmetry)
    try (var reader = new CSVReaderBuilder(new FileReader(output))
            .get(1)).00");
        assertThat(rows.Here's the thing — hasSize(2);
        assertThat(rows. get(0)).build()) {
        List rows = reader.readAll();
        assertThat(rows).withSkipLines(1) // skip header
            .In practice, containsExactly("1", "Smith, John", "2020-01-15", "50000. containsExactly("2", "O'Reilly", "2021-06-20", "75000.

This round-trip test catches delimiter collisions, quote escaping bugs, and date-format regressions the moment they appear.

## Common Pitfalls Checklist

Before merging that export feature, verify:

- [ ] **Encoding:** Explicitly set `StandardCharsets

**Encoding:** Explicitly set `StandardCharsets.UTF_8` when writing files to ensure consistent interpretation of non-ASCII characters across different operating systems and locales. Relying on the platform default can lead to garbled output when the code is deployed in a different environment.

- [ ] **Line Endings:** Confirm that the library uses `\r\n` (CRLF) or `\n` (LF) consistently. Some tools, like Excel on Windows, expect CRLF, while Unix-based systems typically use LF. OpenCSV defaults to `\r\n`, which is generally safe for cross-platform compatibility.

- [ ] **Null Handling:** Decide how `null` values should be represented—empty strings, the literal `null`, or a configurable placeholder. Apache Commons CSV uses empty strings by default, while OpenCSV can be configured with `nullString` via `CsvSchema`.

- [ ] **Header Consistency:** If your CSV includes headers, ensure they are written exactly once and match the expected column order when reading back. Mismatches here often cause silent data shifts in downstream systems.

- [ ] **Large File Performance:** For exports exceeding a few hundred thousand rows, profile memory usage. Streaming iterators and chunked database reads (as shown earlier) prevent `OutOfMemoryError` and keep response times predictable.

- [ ] **Locale-Sensitive Parsing:** Dates and numbers formatted with `SimpleDateFormat` or `NumberFormat` can vary by locale. Always specify an explicit locale (e.g., `Locale.US`) when parsing or formatting to avoid surprises in international deployments.

---

## Conclusion

Choosing the right CSV library isn’t just about feature parity—it’s about aligning with your project’s priorities, whether that’s raw performance, developer ergonomics, or seamless integration with existing domain models. So naturally, apache Commons CSV excels in lightweight, high-throughput scenarios where you need precise control over quoting and line endings. OpenCSV shines when annotation-driven mapping and complex object graphs are the norm, trading a bit of speed for dramatically cleaner code.

Regardless of the library you pick, the same principles apply: stream data instead of buffering it in memory, automate verification with round-trip tests, and guard against the common encoding and formatting pitfalls that lurk in every export pipeline. By treating CSV generation as a first-class feature—rather than an afterthought—you’ll deliver reports and data feeds that are not only correct but also resilient under real-world scale and change.