How to use

org.supercsv.io.CsvMapReader

constructor

private static CsvPOJO readWithCsvMapReader(String file) throws Exception {
  CsvPOJO csvPojo = new CsvPOJO();
  Map<String, String> readMap = null;
  ICsvMapReader mapReader = null;
  try {
    mapReader = new CsvMapReader(new FileReader(file), CsvPreference.STANDARD_PREFERENCE);
    String[] headers = mapReader.getHeader(true);
    List<CsvRow> rows = new ArrayList<CsvRow>();
    while ((readMap = mapReader.read(headers)) != null) {
      CsvRow row = new CsvRow();
      List<String> columns = new ArrayList<String>();
      for (String h : headers) {
        if (!StrUtil.isEmpty(h)) {
          columns.add(readMap.get(h));
        }
      }
      row.setCols(columns);
      rows.add(row);
    }
    csvPojo.setHeaders(headers);
    csvPojo.setRows(rows);
  } finally {
    if (mapReader != null) {
      mapReader.close();
    }
  }
  return csvPojo;
}

/**
 * Create a typical CSV writer -- Excel compliant
 *
 * @param file
 * @return
 * @throws IOException
 */
public CsvMapReader open(String file) throws IOException {
  InputStreamReader rdr = FileUtility.getInputStream(file, "UTF-8");
  CsvMapReader R = new CsvMapReader(rdr, CsvPreference.STANDARD_PREFERENCE);
  return R;
}

/**
 * This method creates an instance of csvMapReader.
 *
 * @param reader
 * @param preference
 * @return CSV Map Reader
 */
@Override
protected ICsvMapReader getReader(ReusableStringReader reader, CsvPreference preference)
{
 csvReader = new CsvMapReader(reader, preference);
 return csvReader;
}

protected List<Map<String, Object>> readCsvFile(URI fileUrl) {
 List<Map<String, Object>> result = Lists.newArrayList();
 ICsvMapReader mapReader = null;
 try {
  mapReader = new CsvMapReader(new FileReader(new File(fileUrl)), CsvPreference.STANDARD_PREFERENCE);
  // the header columns are used as the keys to the Map
  String[] headers = getHeaders();
  CellProcessor[] processors = getProcessors();
  Map<String, Object> contentsMap;
  while( (contentsMap = mapReader.read(headers, processors)) != null ) {
   result.add(contentsMap);
  }
 } catch (Exception e) {
  LOGGER.error("Fail to read result file : {}", e.getMessage());
  throw new RuntimeException("Fail to read result file.");
 } finally {
  if( mapReader != null ) {
   try {
    mapReader.close();
   } catch (IOException e) {}
  }
 }
 LOGGER.info("Query Result Count : " + result.size());
 return result;
}

public static Map<String, String> readWithCsvMapReader(Path dicoFile) throws Exception {
  try (ICsvMapReader mapReader = new CsvMapReader(Files.newBufferedReader(dicoFile, StandardCharsets.UTF_8), CsvPreference.EXCEL_NORTH_EUROPE_PREFERENCE)) {
    final String[] header = mapReader.getHeader(true);
    LOGGER.debug(" cvsheader length: " + header.length);

private Map<String, String> readWithCsvMapReader(Path mappingFile) throws IOException {
  Map<String, String> retMap = new HashMap<>();
  try (ICsvMapReader mapReader = new CsvMapReader(Files.newBufferedReader(mappingFile, StandardCharsets.UTF_8), CsvPreference.STANDARD_PREFERENCE)) {
    final String[] header = mapReader.getHeader(true);
    log.info(" cvsheader length: " + header.length);

private static void parseCsv(InputStream is, Set<HistoDbAttributeId> ids, Table<Integer, String, Float> hdTable, int expectedRowCount) throws IOException {
  int rowcount = 0;
  try (ICsvMapReader mapReader = new CsvMapReader(new InputStreamReader(is), new CsvPreference.Builder('"', ',', "\r\n").build())) {

private JsonNode readCsvFile(URI fileUrl) {
 ArrayNode resultNode = GlobalObjectMapper.getDefaultMapper().createArrayNode();
 ICsvMapReader mapReader = null;
 try {
  mapReader = new CsvMapReader(new FileReader(new File(fileUrl)), CsvPreference.STANDARD_PREFERENCE);
  // the header columns are used as the keys to the Map
  String[] headers = getHeaders();
  CellProcessor[] processors = getProcessors();
  Map<String, Object> contentsMap;
  while( (contentsMap = mapReader.read(headers, processors)) != null ) {
   LOGGER.debug(String.format("lineNo=%s, rowNo=%s, customerMap=%s", mapReader.getLineNumber(),
       mapReader.getRowNumber(), contentsMap));
   resultNode.add(GlobalObjectMapper.getDefaultMapper().convertValue(contentsMap, JsonNode.class));
  }
 } catch (Exception e) {
  LOGGER.error("Fail to read result file : {}", e.getMessage());
  throw new RuntimeException("Fail to read result file.");
 } finally {
  if( mapReader != null ) {
   try {
    mapReader.close();
   } catch (IOException e) {}
  }
 }
 return resultNode;
}

  throw new IOException("No mapping file found: " + getMappingFile());
CsvMapReader reader = new CsvMapReader(
    WpIOUtils.openBufferedReader(getMappingFile()),
    CsvPreference.STANDARD_PREFERENCE

  throw new IOException("No mapping file found: " + getMappingFile());
CsvMapReader reader = new CsvMapReader(
    WpIOUtils.openBufferedReader(getMappingFile()),
    CsvPreference.STANDARD_PREFERENCE

@Override
public List<CSVRepresentation> parse(InputStream inputStream, Class<CSVRepresentation> clazz) {
  if (inputStream == null || clazz == null) {
    throw new NullPointerException();
  }
  ICsvMapReader mapReader = null;
  InputStreamReader inputStreamReader = null;
  List<CSVRepresentation> CSVRepresentations = new ArrayList<>();
  try {
    inputStreamReader = new InputStreamReader(inputStream, template.getCharsetName());
    mapReader = new CsvMapReader(inputStreamReader, template.getPreferences());
    String[] headers = mapReader.getHeader(true);
    if (fileIsNotEmpty(headers)) {
      CSVRepresentations = parseLines(mapReader, headers);
    }
  } catch (IOException e) {
    LOGGER.error(e.getMessage(), e);
  } finally {
    closeQuietly(inputStreamReader);
    closeQuietly(mapReader);
  }
  return CSVRepresentations;
}

private void init()
{
 delimitedParserSchema = new DelimitedSchema(schema);
 preference = new CsvPreference.Builder(delimitedParserSchema.getQuoteChar(),
   delimitedParserSchema.getDelimiterChar(), delimitedParserSchema.getLineDelimiter()).build();
 nameMapping = delimitedParserSchema.getFieldNames()
   .toArray(new String[delimitedParserSchema.getFieldNames().size()]);
 header = StringUtils.join(nameMapping, (char)delimitedParserSchema.getDelimiterChar() + "");
 processors = getProcessor(delimitedParserSchema.getFields());
 csvStringReader = new ReusableStringReader();
 csvMapReader = new CsvMapReader(csvStringReader, preference);
}

private void init()
{
 delimitedParserSchema = new DelimitedSchema(schema);
 preference = new CsvPreference.Builder(delimitedParserSchema.getQuoteChar(),
   delimitedParserSchema.getDelimiterChar(), delimitedParserSchema.getLineDelimiter()).build();
 nameMapping = delimitedParserSchema.getFieldNames()
   .toArray(new String[delimitedParserSchema.getFieldNames().size()]);
 header = StringUtils.join(nameMapping, (char)delimitedParserSchema.getDelimiterChar() + "");
 processors = getProcessor(delimitedParserSchema.getFields());
 csvStringReader = new ReusableStringReader();
 csvMapReader = new CsvMapReader(csvStringReader, preference);
}

static
public TableEvaluationRequest readTable(BufferedReader reader, CsvPreference format) throws IOException {
  CsvMapReader parser = new CsvMapReader(reader, format);
  String[] header = parser.getHeader(true);
  List<String> columns = Arrays.asList(header);
  TableEvaluationRequest tableRequest = new TableEvaluationRequest()
    .setColumns(columns);
  String idColumn = tableRequest.getIdColumn();
  List<EvaluationRequest> requests = new ArrayList<>();
  while(true){
    Map<String, String> row = parser.read(header);
    if(row == null){
      break;
    }
    String id = null;
    if(idColumn != null){
      id = row.remove(idColumn);
    }
    EvaluationRequest request = new EvaluationRequest(id)
      .setArguments(row);
    requests.add(request);
  }
  tableRequest.setRequests(requests);
  parser.close();
  return tableRequest;
}

final CellProcessor[] cellProcessors = s.makeProcessorsForResponse();
try{
  ICsvMapReader reader = new CsvMapReader(r, CsvPreference.STANDARD_PREFERENCE);
  final String[] header = reader.getHeader(true);
  Map<String, Object> headerMap;

/**
 * TODO: keep track of duplicate or missing keys with special status codes
 * @param shapeFile
 * @return
 * @throws IOException
 */
private Map<String, MappingInfo> readExisting(WikiBrainShapeFile shapeFile) throws IOException {
  HashMap<String, MappingInfo> mapping = new HashMap<String, MappingInfo>();
  if (!shapeFile.hasMappingFile()) {
    return mapping;
  }
  CsvMapReader reader = new CsvMapReader(
      WpIOUtils.openBufferedReader(shapeFile.getMappingFile()),
      CsvPreference.STANDARD_PREFERENCE
  );
  String [] header = reader.getHeader(true);
  while (true) {
    Map<String, String> row = reader.read(header);
    if (row == null) {
      break;
    }
    MappingInfo info = new MappingInfo(row);
    if (!info.isUnknown()) {
      mapping.put(info.key, info);
    }
  }
  return mapping;
}

/**
 * TODO: keep track of duplicate or missing keys with special status codes
 * @param shapeFile
 * @return
 * @throws IOException
 */
private Map<String, MappingInfo> readExisting(WikiBrainShapeFile shapeFile) throws IOException {
  HashMap<String, MappingInfo> mapping = new HashMap<String, MappingInfo>();
  if (!shapeFile.hasMappingFile()) {
    return mapping;
  }
  CsvMapReader reader = new CsvMapReader(
      WpIOUtils.openBufferedReader(shapeFile.getMappingFile()),
      CsvPreference.STANDARD_PREFERENCE
  );
  String [] header = reader.getHeader(true);
  while (true) {
    Map<String, String> row = reader.read(header);
    if (row == null) {
      break;
    }
    MappingInfo info = new MappingInfo(row);
    if (!info.isUnknown()) {
      mapping.put(info.key, info);
    }
  }
  return mapping;
}

@Override
public void setup(OperatorContext context)
{
 delimitedParserSchema = new DelimitedSchema(schema);
 preference = new CsvPreference.Builder(delimitedParserSchema.getQuoteChar(),
   delimitedParserSchema.getDelimiterChar(), delimitedParserSchema.getLineDelimiter()).build();
 nameMapping = delimitedParserSchema.getFieldNames().toArray(
   new String[delimitedParserSchema.getFieldNames().size()]);
 header = StringUtils.join(nameMapping, (char)delimitedParserSchema.getDelimiterChar() + "");
 processors = getProcessor(delimitedParserSchema.getFields());
 csvStringReader = new ReusableStringReader();
 csvMapReader = new CsvMapReader(csvStringReader, preference);
 csvBeanReader = new CsvBeanReader(csvStringReader, preference);
}

@Override
public void setup(OperatorContext context)
{
 delimitedParserSchema = new DelimitedSchema(schema);
 preference = new CsvPreference.Builder(delimitedParserSchema.getQuoteChar(),
   delimitedParserSchema.getDelimiterChar(), delimitedParserSchema.getLineDelimiter()).build();
 nameMapping = delimitedParserSchema.getFieldNames().toArray(
   new String[delimitedParserSchema.getFieldNames().size()]);
 header = StringUtils.join(nameMapping, (char)delimitedParserSchema.getDelimiterChar() + "");
 processors = getProcessor(delimitedParserSchema.getFields());
 csvStringReader = new ReusableStringReader();
 csvMapReader = new CsvMapReader(csvStringReader, preference);
 csvBeanReader = new CsvBeanReader(csvStringReader, preference);
}

public List<Map<String, Object>> readCsv(String fileName, List<Field> fieldList, int index, int length) {
 ICsvMapReader mapReader = null;
 List<Map<String, Object>> returnList = new ArrayList<>();
 try {
  mapReader = new CsvMapReader(new FileReader(fileName)
      , new CsvPreference.Builder('"', ',', "\r\n")
      .ignoreEmptyLines(false)
      .build());
  // the header columns are used as the keys to the Map
  final String[] header = mapReader.getHeader(true);
  Map<String, Object> rowMap;
  while( (rowMap = mapReader.read(header, getProcessors(fieldList))) != null && mapReader.getRowNumber() - 1 < index + length + 1) {
   if(mapReader.getRowNumber() - 1 > index){
    returnList.add(rowMap);
   }
  }
 } catch (FileNotFoundException e){
  throw new WorkbenchException(CSV_FILE_NOT_FOUND, "CSV File Not Founded.", e);
 } catch (IOException e){
  throw new WorkbenchException(CSV_FILE_NOT_FOUND, "read CSV IOException.", e);
 } finally {
  try {
   if(mapReader != null)
    mapReader.close();
  } catch (Exception e){}
 }
 return returnList;
}