### Perform high-level operations with CsvRoutines

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Simplifies common parsing and writing tasks by abstracting configuration and iteration logic.

```java
import com.univocity.parsers.csv.*;
import java.io.*;
import java.util.*;

CsvRoutines routines = new CsvRoutines();

// Parse all beans from CSV
List<Product> products = routines.parseAll(Product.class, new FileReader("products.csv"));

// Iterate over beans
for (Product product : routines.iterate(Product.class, new FileReader("products.csv"))) {
    System.out.println(product);
}

// Write beans to CSV
routines.writeAll(products, Product.class, new FileWriter("output.csv"));

// Parse with custom settings
CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);
CsvRoutines customRoutines = new CsvRoutines(settings);
List<Product> customParsed = customRoutines.parseAll(Product.class, new FileReader("products.csv"));
```

--------------------------------

### Perform Basic CSV Parsing in Java

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Demonstrates parsing all rows at once, using an iterator for memory efficiency, and utilizing Java for-each loops.

```java
import com.univocity.parsers.csv.*;
import java.io.*;
import java.util.*;

// Basic parsing - parse all rows at once
CsvParserSettings settings = new CsvParserSettings();
settings.getFormat().setLineSeparator("\n");

CsvParser parser = new CsvParser(settings);
List<String[]> allRows = parser.parseAll(new FileReader("data.csv"));

for (String[] row : allRows) {
    System.out.println(Arrays.toString(row));
}

// Iterator-style parsing - memory efficient for large files
parser.beginParsing(new FileReader("data.csv"));
String[] row;
while ((row = parser.parseNext()) != null) {
    System.out.println(Arrays.toString(row));
}
parser.stopParsing();

// Using Java for-each iteration
for (String[] row : parser.iterate(new FileReader("data.csv"))) {
    System.out.println(Arrays.toString(row));
}
```

--------------------------------

### Write Fixed-Width Files

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Define field specifications and write rows to a fixed-width file. Ensure the line separator is configured if necessary.

```java
import com.univocity.parsers.fixed.*;
import java.io.*;

FixedWidthFields fields = new FixedWidthFields();
fields.addField("ID", 5, FieldAlignment.RIGHT, '0');
fields.addField("Name", 20, FieldAlignment.LEFT, ' ');
fields.addField("Amount", 10, FieldAlignment.RIGHT, ' ');

FixedWidthWriterSettings settings = new FixedWidthWriterSettings(fields);
settings.getFormat().setLineSeparator("\n");

FixedWidthWriter writer = new FixedWidthWriter(new FileWriter("output.txt"), settings);

writer.writeHeaders();
writer.writeRow("1", "John Doe", "1500.00");
writer.writeRow("2", "Jane Smith", "2300.50");
writer.writeRow("123", "Bob Wilson", "750.25");

writer.close();
// Output:
// 00001John Doe                  1500.00
// 00002Jane Smith                2300.50
// 00123Bob Wilson                  750.25
```

--------------------------------

### Define advanced bean mapping with annotations

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Demonstrates complex transformations including trimming, case conversion, date formatting, regex replacement, and validation.

```java
import com.univocity.parsers.annotations.*;
import java.util.*;

public class Account {
    @Parsed
    private Long id;

    @Parsed
    @Trim
    @LowerCase
    private String username;

    @Parsed(field = "created_at")
    @Format(formats = {"yyyy-MM-dd", "dd/MM/yyyy"}, options = "timezone=UTC")
    private Date createdAt;

    @Parsed
    @Replace(expression = "\\$", replacement = "")
    @Format(formats = {"#,##0.00"})
    private BigDecimal balance;

    @Parsed
    @NullString(nulls = {"N/A", "null", "-"})
    private String notes;

    @Parsed
    @EnumOptions(customElement = "code")
    private AccountType type;

    @Parsed
    @Validate(nullable = false, allowBlanks = false)
    private String email;
}

enum AccountType {
    STANDARD("S"),
    PREMIUM("P"),
    ADMIN("A");

    public final String code;
    AccountType(String code) { this.code = code; }
}
```

--------------------------------

### Parse Fixed-Width Files with Named Fields

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Configure field names, lengths, and alignment to parse fixed-width data. Requires a FileReader for the input source.

```java
import com.univocity.parsers.fixed.*;

// Create fields with names
FixedWidthFields fields = new FixedWidthFields();
fields.addField("id", 10, FieldAlignment.RIGHT, '0');      // Right-aligned, padded with zeros
fields.addField("name", 30, FieldAlignment.LEFT, ' ');     // Left-aligned, padded with spaces
fields.addField("balance", 15, FieldAlignment.RIGHT, ' '); // Right-aligned

FixedWidthParserSettings settings = new FixedWidthParserSettings(fields);
settings.setHeaderExtractionEnabled(true);
settings.setSkipTrailingCharsUntilNewline(true);  // Skip extra characters after last field
settings.setRecordEndsOnNewline(true);            // Records end at newline

FixedWidthParser parser = new FixedWidthParser(settings);
List<String[]> rows = parser.parseAll(new FileReader("accounts.txt"));

for (String[] row : rows) {
    System.out.println(Arrays.toString(row));
}
```

--------------------------------

### Parse fixed-width files

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Parse fixed-width data by defining field lengths and padding characters.

```java
import com.univocity.parsers.fixed.*;
import java.util.*;

// Define field lengths (4, 5, 40, 40, 8 characters respectively)
FixedWidthFields lengths = new FixedWidthFields(4, 5, 40, 40, 8);

FixedWidthParserSettings settings = new FixedWidthParserSettings(lengths);
settings.getFormat().setPadding('_');  // Character used for padding
settings.getFormat().setLineSeparator("\n");

FixedWidthParser parser = new FixedWidthParser(settings);

// Parse all rows
List<String[]> allRows = parser.parseAll(new FileReader("data.txt"));

// Or iterate
parser.beginParsing(new FileReader("data.txt"));
String[] row;
while ((row = parser.parseNext()) != null) {
    System.out.println(Arrays.toString(row));
}
parser.stopParsing();
```

--------------------------------

### Select and Reorder CSV Columns

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Configure CsvParserSettings to select specific columns by name or index, exclude others, and reorder the output. Ensure header extraction is enabled if using column names.

```java
import com.univocity.parsers.csv.*;

CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);

// Select only specific columns by name
settings.selectFields("make", "model", "price");

// Or select by index
settings.selectIndexes(0, 2, 4);

// Exclude specific columns
settings.excludeFields("description", "notes");

// Reorder columns - output will follow the selection order
settings.setColumnReorderingEnabled(true);

CsvParser parser = new CsvParser(settings);
List<String[]> rows = parser.parseAll(new FileReader("products.csv"));

// Each row contains only: make, model, price (in that order)
for (String[] row : rows) {
    System.out.println(Arrays.toString(row));
}
```

--------------------------------

### Extract Headers and Process Rows in Java

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Configures the parser to detect line separators, extract headers, and use a RowListProcessor to store parsed data.

```java
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.processor.*;

CsvParserSettings settings = new CsvParserSettings();
settings.setLineSeparatorDetectionEnabled(true);
settings.setHeaderExtractionEnabled(true);

// RowListProcessor stores all parsed rows in a List
RowListProcessor rowProcessor = new RowListProcessor();
settings.setProcessor(rowProcessor);

CsvParser parser = new CsvParser(settings);
parser.parse(new FileReader("data.csv"));

// Get headers and rows
String[] headers = rowProcessor.getHeaders();
List<String[]> rows = rowProcessor.getRows();

System.out.println("Headers: " + Arrays.toString(headers));
for (String[] row : rows) {
    System.out.println(Arrays.toString(row));
}
```

--------------------------------

### Configure CSV quoting behavior

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Customize how fields are quoted, escaped, and triggered during CSV writing.

```java
import com.univocity.parsers.csv.*;

CsvWriterSettings settings = new CsvWriterSettings();
settings.getFormat().setQuote('\'');
settings.getFormat().setQuoteEscape('\'');

// Enable quote escaping
settings.setQuoteEscapingEnabled(true);

// Force quotes around values containing specific characters
settings.setQuotationTriggers('$', '%', '\t');

// Quote all fields regardless of content
settings.setQuoteAllFields(true);

// Quote specific columns by name or index
settings.quoteFields("Description", "Notes");
settings.quoteIndexes(2, 3);

CsvWriter writer = new CsvWriter(settings);
String result = writer.writeRowToString(new Object[]{"Normal", "Has 'quotes'", "Has\ttab"});
System.out.println(result);
// Output: 'Normal','Has ''quotes''','Has	tab'
```

--------------------------------

### Map Data to Java Beans with Annotations

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Use @Parsed and other annotations to map input data directly to bean properties. Requires a BeanListProcessor to collect the results.

```java
import com.univocity.parsers.annotations.*;
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.processor.*;
import java.math.*;
import java.util.*;

// Define a bean class with annotations
public class Product {
    @Parsed(index = 0)
    private Integer year;

    @Parsed(field = "make")
    @Trim
    @UpperCase
    private String manufacturer;

    @Parsed(field = "model")
    private String model;

    @Parsed(field = "price")
    @Format(formats = {"#,##0.00"}, options = "decimalSeparator=.")
    private BigDecimal price;

    @Parsed(field = "available")
    @BooleanString(trueStrings = {"yes", "Y", "1"}, falseStrings = {"no", "N", "0"})
    private boolean available;

    // Getters and setters...
}

// Parse CSV to beans
CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);

BeanListProcessor<Product> beanProcessor = new BeanListProcessor<>(Product.class);
settings.setProcessor(beanProcessor);

CsvParser parser = new CsvParser(settings);
parser.parse(new FileReader("products.csv"));

List<Product> products = beanProcessor.getBeans();
for (Product product : products) {
    System.out.println(product.getManufacturer() + " - " + product.getPrice());
}
```

--------------------------------

### Detect CSV Format Automatically in Java

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Enables automatic detection of delimiters, quotes, and line separators for unknown file formats.

```java
import com.univocity.parsers.csv.*;

CsvParserSettings settings = new CsvParserSettings();

// Enable automatic format detection
settings.detectFormatAutomatically();
// Or configure individually:
// settings.setDelimiterDetectionEnabled(true);
// settings.setQuoteDetectionEnabled(true);
// settings.setLineSeparatorDetectionEnabled(true);

// Optionally specify possible delimiters in order of priority
settings.setDelimiterDetectionEnabled(true, ',', ';', '\t', '|');

CsvParser parser = new CsvParser(settings);
parser.beginParsing(new FileReader("unknown_format.csv"));

// After parsing begins, get the detected format
CsvFormat detectedFormat = parser.getDetectedFormat();
System.out.println("Detected delimiter: " + detectedFormat.getDelimiter());
System.out.println("Detected quote: " + detectedFormat.getQuote());

String[] row;
while ((row = parser.parseNext()) != null) {
    System.out.println(Arrays.toString(row));
}
```

--------------------------------

### Write CSV files with CsvWriter

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Configure and write CSV data to files or strings using CsvWriter.

```java
import com.univocity.parsers.csv.*;
import java.io.*;

CsvWriterSettings settings = new CsvWriterSettings();
settings.getFormat().setLineSeparator("\n");

// Write to a file
CsvWriter writer = new CsvWriter(new FileWriter("output.csv"), settings);

// Write headers
writer.writeHeaders("Year", "Make", "Model", "Price");

// Write rows as arrays
writer.writeRow(new Object[]{2012, "Honda", "Civic", 19500.00});
writer.writeRow(new Object[]{2015, "Toyota", "Camry", 24000.00});

// Write rows as varargs
writer.writeRow(2018, "Ford", "Mustang", 35000.00);

writer.close();

// Write directly to String
CsvWriter stringWriter = new CsvWriter(settings);
String csvLine = stringWriter.writeRowToString(new Object[]{"Value 1", "Value 2", "Value 3"});
System.out.println(csvLine);
```

--------------------------------

### Parse and Write TSV Files

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Use TsvParser and TsvWriter to handle tab-separated values. These classes follow the same configuration patterns as CSV parsers.

```java
import com.univocity.parsers.tsv.*;
import java.io.*;
import java.util.*;

// TSV Parser
TsvParserSettings parserSettings = new TsvParserSettings();
parserSettings.setHeaderExtractionEnabled(true);

TsvParser parser = new TsvParser(parserSettings);
List<String[]> rows = parser.parseAll(new FileReader("data.tsv"));

for (String[] row : rows) {
    System.out.println(Arrays.toString(row));
}

// TSV Writer
TsvWriterSettings writerSettings = new TsvWriterSettings();
TsvWriter writer = new TsvWriter(new FileWriter("output.tsv"), writerSettings);

writer.writeHeaders("Name", "Age", "City");
writer.writeRow("Alice", 30, "New York");
writer.writeRow("Bob", 25, "Los Angeles");

writer.close();
```

--------------------------------

### Convert CSV values with ObjectRowProcessor

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Use ObjectRowProcessor to apply type conversions and transformations during CSV parsing.

```java
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.*;
import com.univocity.parsers.common.processor.*;
import com.univocity.parsers.conversions.*;
import java.math.*;

ObjectRowProcessor rowProcessor = new ObjectRowProcessor() {
    @Override
    public void rowProcessed(Object[] row, ParsingContext context) {
        System.out.println(Arrays.toString(row));
    }
};

// Convert column at index 4 (Price) to BigDecimal
rowProcessor.convertIndexes(Conversions.toBigDecimal()).set(4);

// Convert specific columns to lowercase, and replace "N/A" with null
rowProcessor.convertFields(Conversions.toLowerCase(), Conversions.toNull("N/A"))
    .set("Make", "Model", "Description");

// Convert year column to BigInteger with default value of ZERO
rowProcessor.convertFields(new BigIntegerConversion(BigInteger.ZERO, "0"))
    .set("year");

CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);
settings.setProcessor(rowProcessor);

CsvParser parser = new CsvParser(settings);
parser.parse(new FileReader("products.csv"));
```

--------------------------------

### Access CSV records with Record API

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Utilize the Record API for convenient, type-safe access to parsed CSV data by column name or index.

```java
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.record.*;
import java.math.*;

CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);

CsvParser parser = new CsvParser(settings);

for (Record record : parser.iterateRecords(new FileReader("products.csv"))) {
    // Access values by column name with automatic type conversion
    Integer year = record.getInt("year");
    String make = record.getString("make");
    BigDecimal price = record.getBigDecimal("price");

    // Access by index
    String firstColumn = record.getString(0);

    // Get all values as array
    String[] values = record.getValues();

    System.out.printf("Year: %d, Make: %s, Price: %s%n", year, make, price);
}
```

--------------------------------

### Write Java beans to CSV using BeanWriterProcessor

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Uses @Parsed annotations to map bean fields to CSV columns and BeanWriterProcessor to handle the serialization process.

```java
import com.univocity.parsers.annotations.*;
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.processor.*;
import java.io.*;
import java.util.*;

public class Person {
    @Parsed
    private String name;

    @Parsed
    private int age;

    @Parsed(field = "email_address")
    private String email;

    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    // Getters...
}

// Create beans
List<Person> people = Arrays.asList(
    new Person("John Doe", 30, "john@example.com"),
    new Person("Jane Smith", 25, "jane@example.com")
);

// Write beans to CSV
CsvWriterSettings settings = new CsvWriterSettings();
settings.setHeaders("name", "age", "email_address");

BeanWriterProcessor<Person> processor = new BeanWriterProcessor<>(Person.class);
settings.setRowWriterProcessor(processor);

CsvWriter writer = new CsvWriter(new FileWriter("people.csv"), settings);
writer.writeHeaders();

for (Person person : people) {
    writer.processRecord(person);
}
writer.close();
```

--------------------------------

### Implement error handling during parsing

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Uses RowProcessorErrorHandler to intercept and log errors without stopping the entire parsing process.

```java
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.*;
import com.univocity.parsers.common.processor.*;

CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);

BeanListProcessor<Product> processor = new BeanListProcessor<>(Product.class);
settings.setProcessor(processor);

// Set error handler to continue on errors
settings.setProcessorErrorHandler(new RowProcessorErrorHandler() {
    @Override
    public void handleError(DataProcessingException error, Object[] inputRow, ParsingContext context) {
        System.err.println("Error on row " + context.currentRecord() + ": " + error.getMessage());
        System.err.println("Problematic row: " + Arrays.toString(inputRow));
        // Don't rethrow - continue processing remaining rows
    }
});

CsvParser parser = new CsvParser(settings);
parser.parse(new FileReader("data_with_errors.csv"));

// Successfully parsed beans (errors were skipped)
List<Product> products = processor.getBeans();
System.out.println("Successfully parsed: " + products.size() + " products");
```

--------------------------------

### Concurrent CSV File Processing

Source: https://context7.com/univocity/univocity-parsers/llms.txt

Utilize ConcurrentRowProcessor to process large CSV files in parallel across multiple CPU cores. Wrap your custom RowProcessor with ConcurrentRowProcessor and set it in CsvParserSettings.

```java
import com.univocity.parsers.csv.*;
import com.univocity.parsers.common.*;
import com.univocity.parsers.common.processor.*;
import java.util.concurrent.atomic.*;

CsvParserSettings settings = new CsvParserSettings();
settings.setHeaderExtractionEnabled(true);

AtomicInteger counter = new AtomicInteger(0);

// Wrap your processor with ConcurrentRowProcessor for parallel execution
RowProcessor myProcessor = new AbstractRowProcessor() {
    @Override
    public void rowProcessed(String[] row, ParsingContext context) {
        // Process row - this will be called from multiple threads
        counter.incrementAndGet();
        // Do your processing here
    }
};

ConcurrentRowProcessor concurrentProcessor = new ConcurrentRowProcessor(myProcessor);
settings.setProcessor(concurrentProcessor);

CsvParser parser = new CsvParser(settings);
parser.parse(new FileReader("large_file.csv"));

System.out.println("Processed " + counter.get() + " rows");
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.