Java CSV reader like Python's csv.DictReader

DictReader.java

/*
 * (c) 2015 mike10004@users.noreply.github.com
 * MIT License
 */
package com.github.mike10004.csvdictreader;

import com.google.common.base.Function;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import com.opencsv.CSVReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public class DictReader extends CSVReader {

    private transient final Object columnNamesLock = new Object();
    private ImmutableList<String> columnNames;
    
    public DictReader(Reader reader, Iterable<String> columnNames) {
        super(reader);
        Set<String> columnNamesSet = ImmutableSet.copyOf(columnNames);
        this.columnNames = ImmutableList.copyOf(columnNamesSet);
    }
    
    public DictReader(Reader reader) {
        super(reader);
        // leave columnNames null
    }

    @Override
    public String[] readNext() throws IOException {
        maybeReadNames();
        return super.readNext();
    }

    @Override
    public List<String[]> readAll() throws IOException {
        return super.readAll();
    }

    public ImmutableMap<String, String> readNextMap() throws IOException {
        maybeReadNames();
        return rowToMap(readNext());
    }

    public List<ImmutableMap<String, String>> readAllMaps() throws IOException {
        return Lists.newArrayList(Iterables.transform(readAll(), newRowToMapFunction()));
    }
    
    public Iterator<ImmutableMap<String, String>> mapIterator() {
        return Iterators.transform(iterator(), newRowToMapFunction());
    }
    
    protected void maybeReadNames() throws IOException {
        synchronized (columnNamesLock) {
            if (columnNames == null) {
                String[] firstRow = super.readNext();
                Set<String> firstRowValues = new TreeSet<>(Arrays.asList(firstRow));
                if (firstRow.length != firstRowValues.size()) {
                    throw new IOException("invalid csv file for DictReader: "
                            + "column names must be unique");
                }
                columnNames = ImmutableList.copyOf(firstRow);
            }
        }
    }
    
    protected Function<String[], ImmutableMap<String, String>> newRowToMapFunction() {
        return new Function<String[], ImmutableMap<String, String>>() {
            @Override
            public ImmutableMap<String, String> apply(String[] input) {
                return rowToMap(input);
            }
        };
    }
    
    protected ImmutableMap<String, String> rowToMap(String[] row) {
        checkState(columnNames != null);
        checkArgument(row.length == columnNames.size(), "expected same number "
                + "of cells in row as there are column names, but row has %d "
                + "and columnNames.size=%d", row.length, columnNames.size());
        ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
        for (int i = 0; i < row.length; i++) {
            builder.put(columnNames.get(i), row[i]);
        }
        return builder.build();
    }
    
    public ImmutableList<String> readColumnNames() throws IOException {
        maybeReadNames();
        checkState(columnNames != null);
        return columnNames;
    }
}

DictReaderTest-good1.csv

DictReaderTest.java

/*
 * (c) 2015 mike10004@users.noreply.github.com
 * MIT License
 */
package com.github.mike10004.csvdictreader;

import com.google.common.base.Charsets;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.io.Resources;
import java.net.URL;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import static org.junit.Assert.*;

public class DictReaderTest {
    
    static final List<String> goodCsvExpectedColumnNames = ImmutableList.of("msa","name_msa","fipstate","fipscty","name_county");
    static final List<String> goodCsvExpectedFirstDataRow = ImmutableList.of("10100","Aberdeen, SD Micro Area","46","013","Brown County, South Dakota");
    static final List<String> goodCsvExpectedLastDataRow = ImmutableList.of("49820","Zapata, TX Micro Area","48","505","Zapata County, Texas");
    static final int goodCsvExpectedNumDataRows = 1808;
    
    public DictReaderTest() {
    }

    static final URL goodCsvResource = DictReaderTest.class.getResource("/DictReaderTest-good1.csv");
    static final Charset charset = Charsets.UTF_8;
    
    @Test
    public void testReadColumnNames_good()  throws Exception {
        System.out.println("testReadColumnNames");
        try (DictReader reader = new DictReader(Resources.asCharSource(goodCsvResource, charset).openStream())) {
            List<String> columnNames = reader.readColumnNames();
            System.out.println(columnNames);
            assertEquals(goodCsvExpectedColumnNames, columnNames);
        }
    }
    
    @Test
    public void testReadNextMap_good() throws Exception {
        System.out.println("testReadNextMap_good");
        Map<String, String> firstDataRow;
        try (DictReader reader = new DictReader(Resources.asCharSource(goodCsvResource, charset).openStream())) {
             firstDataRow = reader.readNextMap();
        }
        System.out.println(firstDataRow);
        assertEquals(goodCsvExpectedFirstDataRow, new ArrayList<>(firstDataRow.values()));
        
    }

    @Test
    public void testReadAllMaps_good() throws Exception {
        System.out.println("testReadAllMaps_good");
        List<ImmutableMap<String, String>> dataRows;
        try (DictReader reader = new DictReader(Resources.asCharSource(goodCsvResource, charset).openStream())) {
             dataRows = reader.readAllMaps(); 
        }
        assertEquals(goodCsvExpectedNumDataRows, dataRows.size());
        System.out.println(dataRows.size() + " rows read from csv file");
        Map<String, String> first = dataRows.get(0), last = dataRows.get(dataRows.size() - 1);
        assertEquals(goodCsvExpectedFirstDataRow, ImmutableList.copyOf(first.values()));
        assertEquals(goodCsvExpectedLastDataRow, ImmutableList.copyOf(last.values()));
        
    }

    @Test
    public void testMapIterator_good() throws Exception {
        System.out.println("testMapIterator_good");
        List<ImmutableMap<String, String>> dataRows = new ArrayList<>();
        try (DictReader reader = new DictReader(Resources.asCharSource(goodCsvResource, charset).openStream())) {
             Iterator<ImmutableMap<String, String>> maps = reader.mapIterator();
             while (maps.hasNext()) {
                 dataRows.add(maps.next());
             }
        }
        assertEquals(goodCsvExpectedNumDataRows, dataRows.size());
        System.out.println(dataRows.size() + " rows read from csv file");
        Map<String, String> first = dataRows.get(0), last = dataRows.get(dataRows.size() - 1);
        assertEquals(goodCsvExpectedFirstDataRow, ImmutableList.copyOf(first.values()));
        assertEquals(goodCsvExpectedLastDataRow, ImmutableList.copyOf(last.values()));
        
    }
    
}

TODO:

• add tests for malformed CSVs
• add tests where custom column names are specified