import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
@Override
public Stream<Row> parse(FileSource source) {
	InputStreamReader csvStreamReader = new InputStreamReader(source.toInputStream(), csvParserConfiguration.getCharset());
	Iterator<String[]> csvRowIterator = new CSVReaderBuilder(csvStreamReader)
		.withCSVParser(
			new CSVParserBuilder()
				.withEscapeChar(csvParserConfiguration.getEscapeChar())
				.withFieldAsNull(csvParserConfiguration.getNullFieldIndicator())
				.withIgnoreLeadingWhiteSpace(csvParserConfiguration.isIgnoreLeadingWhiteSpace())
				.withIgnoreQuotations(csvParserConfiguration.isIgnoreQuotations())
				.withQuoteChar(csvParserConfiguration.getQuoteChar())
				.withSeparator(csvParserConfiguration.getSeparator())
				.withStrictQuotes(csvParserConfiguration.isStrictQuotes())
				.build()
		)
		.withKeepCarriageReturn(csvParserConfiguration.isKeepCr())
		.build()
		.iterator();

	return IteratorStreams
		.stream(new CsvRowIterator(csvRowIterator))
		.onClose(() -> IteratorStreams.close(csvStreamReader));
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
private static TimeSeries getHourlyData() throws IOException {
	final String path = "./fortran_benchmark/hourly_stl_test.csv";

	CSVReaderBuilder builder = new CSVReaderBuilder(new FileReader(path));

	TimeSeries ts = new TimeSeries();

	try (CSVReader reader = builder.build()) {

		String[] nextLine;
		long time = 1492457959000L;
		while ((nextLine = reader.readNext()) != null) {
			ts.times.add(time);
			time += 3600 * 1000;
			double value = Double.parseDouble(nextLine[0]);
			ts.values.add(value);
		}
	}
	return ts;
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
@SuppressWarnings("Duplicates")
private static TimeSeries getCo2Data() throws IOException {

	final String path =  "../StlDemoRestServer/co2.csv";

	CSVReaderBuilder builder = new CSVReaderBuilder(new FileReader(path));

	TimeSeries ts = new TimeSeries();

	try (CSVReader reader = builder.withSkipLines(1).build()) {

		String[] nextLine;
		while ((nextLine = reader.readNext()) != null) {
			double dateAsYear = Double.parseDouble(nextLine[1]);
			long time = (long) ((dateAsYear - 1970.0) * 365.25 * 24 * 60 * 60 * 1000);
			ts.times.add(time);

			double value = Double.parseDouble(nextLine[2]);
			ts.values.add(value);
		}
	}
	return ts;
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
@SuppressWarnings("Duplicates")
public static TimeSeries getTimeSeries(String fileName) throws IOException {
	CSVReaderBuilder builder = new CSVReaderBuilder(new FileReader(fileName));

	TimeSeries ts = new TimeSeries();

	try (CSVReader reader = builder.withSkipLines(1).build()) {

		String[] nextLine;
		while ((nextLine = reader.readNext()) != null) {
			double dateAsYear = Double.parseDouble(nextLine[1]);
			long time = (long) ((dateAsYear - 1970.0) * 365.25 * 24 * 60 * 60 * 1000);
			ts.times.add(time);

			double value = Double.parseDouble(nextLine[2]);
			ts.values.add(value);
		}
	}
	return ts;
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
@Override
protected void configure(InputStream inputStream, Map<String, String> metadata, final Long lastOffset) throws IOException {
  log.trace("configure() - creating csvParser");
  this.csvParser = this.config.createCSVParserBuilder().build();
  this.streamReader = new InputStreamReader(inputStream, this.config.charset);
  CSVReaderBuilder csvReaderBuilder = this.config.createCSVReaderBuilder(this.streamReader, csvParser);
  this.csvReader = csvReaderBuilder.build();

  String[] fieldNames;

  if (this.config.firstRowAsHeader) {
    log.trace("configure() - Reading the header row.");
    fieldNames = this.csvReader.readNext();
    log.info("configure() - field names from header row. fields = {}", Joiner.on(", ").join(fieldNames));
  } else {
    log.trace("configure() - Using fields from schema {}", this.config.valueSchema.name());
    fieldNames = new String[this.config.valueSchema.fields().size()];
    int index = 0;
    for (Field field : this.config.valueSchema.fields()) {
      fieldNames[index++] = field.name();
    }
    log.info("configure() - field names from schema order. fields = {}", Joiner.on(", ").join(fieldNames));
  }

  if (null != lastOffset) {
    log.info("Found previous offset. Skipping {} line(s).", lastOffset.intValue());
    String[] row = null;
    while (null != (row = this.csvReader.readNext()) && this.csvReader.getLinesRead() < lastOffset) {
      log.trace("skipped row");
    }
  }

  this.fieldNames = fieldNames;
  this.fileMetadata = metadata;
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
public CSVReaderBuilder createCSVReaderBuilder(Reader reader, CSVParser parser) {
  return new CSVReaderBuilder(reader)
      .withCSVParser(parser)
      .withKeepCarriageReturn(this.keepCarriageReturn)
      .withSkipLines(this.skipLines)
      .withVerifyReader(this.verifyReader)
      .withFieldAsNull(nullFieldIndicator);
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
private CSVReader openInputData() throws FileNotFoundException, UnsupportedEncodingException {
    return new CSVReaderBuilder(new InputStreamReader(new FileInputStream(dataInPath + scenarioName + "." + CSV_TYPE), DEFAULT_ENDODING))
            .withCSVParser(new CSVParserBuilder().withSeparator(CSV_CHAR_SEPARATOR).build()).build();
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
private CSVReader openOutputData() throws FileNotFoundException, UnsupportedEncodingException {
    return new CSVReaderBuilder(new InputStreamReader(new FileInputStream(dataOutPath + scenarioName + "." + CSV_TYPE), DEFAULT_ENDODING))
            .withCSVParser(new CSVParserBuilder().withSeparator(CSV_CHAR_SEPARATOR).build()).build();
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
public static Table read(CsvReadOptions options) throws IOException {
    ColumnType[] types = options.columnTypes();
    byte[] bytes = options.reader() != null
        ? CharStreams.toString(options.reader()).getBytes() : null;
    if (types == null) {
      InputStream detectTypesStream = options.reader() != null
          ? new ByteArrayInputStream(bytes)
          : new FileInputStream(options.file());
      types = detectColumnTypes(detectTypesStream, options.header(), options.separator(), options.sample()); 
    }

    // All other read methods end up here, make sure we don't have leading Unicode BOM
    InputStream stream = options.reader() != null
        ? new ByteArrayInputStream(bytes)
        : new FileInputStream(options.file());
    UnicodeBOMInputStream ubis = new UnicodeBOMInputStream(stream);
    ubis.skipBOM();

    Table table;
    CSVParser csvParser = new CSVParserBuilder()
            .withSeparator(options.separator())
            .build();

    try (CSVReader reader = new CSVReaderBuilder(new InputStreamReader(ubis)).withCSVParser(csvParser).build()) {
        String[] nextLine;
        String[] columnNames;
        List<String> headerRow;
        if (options.header()) {
            nextLine = reader.readNext();
            headerRow = Lists.newArrayList(nextLine);
            columnNames = selectColumnNames(headerRow, types);
        } else {
            columnNames = makeColumnNames(types);
            headerRow = Lists.newArrayList(columnNames);
        }

        table = Table.create(options.tableName());
        cleanNames(headerRow);
        for (int x = 0; x < types.length; x++) {
            if (types[x] != SKIP) {
                String columnName = headerRow.get(x);
                if (Strings.isNullOrEmpty(columnName)) {
                    columnName = "Column " + table.columnCount();
                }
                Column newColumn = TypeUtils.newColumn(columnName, types[x]);
                table.addColumn(newColumn);
            }
        }
        int[] columnIndexes = new int[columnNames.length];
        for (int i = 0; i < columnIndexes.length; i++) {
            // get the index in the original table, which includes skipped fields
            columnIndexes[i] = headerRow.indexOf(columnNames[i]);
        }
        // Add the rows
        long rowNumber = options.header() ? 1L : 0L;
        while ((nextLine = reader.readNext()) != null) {
            // for each column that we're including (not skipping)
            int cellIndex = 0;
            for (int columnIndex : columnIndexes) {
                Column column = table.column(cellIndex);
                try {
                    column.appendCell(nextLine[columnIndex]);
                } catch (Exception e) {
                    throw new AddCellToColumnException(e, columnIndex, rowNumber, columnNames, nextLine);
                }
                cellIndex++;
            }
            rowNumber++;
        }
    }
    return table;
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
/**
 * Returns a Table constructed from a CSV File with the given file name
 * <p>
 * The @code{fileName} is used as the initial table name for the new table
 *
 * @param types           An array of the types of columns in the file, in the order they appear
 * @param header          Is the first row in the file a header?
 * @param columnSeparator the delimiter
 * @param file        The fully specified file name. It is used to provide a default name for the table
 * @return A Relation containing the data in the csv file.
 * @throws IOException if file cannot be read
 */
public static Table headerOnly(ColumnType types[], boolean header, char columnSeparator, File file)
        throws IOException {

    FileInputStream fis = new FileInputStream(file);       
    // make sure we don't have leading Unicode BOM
    UnicodeBOMInputStream ubis = new UnicodeBOMInputStream(fis);
    ubis.skipBOM();
    
    Reader reader = new InputStreamReader(ubis);
    BufferedReader streamReader = new BufferedReader(reader);

    Table table;
    CSVParser csvParser = new CSVParserBuilder()
            .withSeparator(columnSeparator)
            .build();
    try (CSVReader csvReader = new CSVReaderBuilder(streamReader).withCSVParser(csvParser).build()) {

        String[] nextLine;
        String[] columnNames;
        List<String> headerRow;
        if (header) {
            nextLine = csvReader.readNext();
            headerRow = Lists.newArrayList(nextLine);
            columnNames = selectColumnNames(headerRow, types);
        } else {
            columnNames = makeColumnNames(types);
            headerRow = Lists.newArrayList(columnNames);
        }

        table = Table.create(file.getName());
        for (int x = 0; x < types.length; x++) {
            if (types[x] != SKIP) {
                Column newColumn = TypeUtils.newColumn(headerRow.get(x).trim(), types[x]);
                table.addColumn(newColumn);
            }
        }
        int[] columnIndexes = new int[columnNames.length];
        for (int i = 0; i < columnIndexes.length; i++) {
            // get the index in the original table, which includes skipped fields
            columnIndexes[i] = headerRow.indexOf(columnNames[i]);
        }
    }
    return table;
}
 

import com.opencsv.CSVReaderBuilder; //导入依赖的package包/类
/**
 * Estimates and returns the type for each column in the delimited text file {@code file}
 * <p>
 * The type is determined by checking a sample of the data in the file. Because only a sample of the data is
 * checked,
 * the types may be incorrect. If that is the case a Parse Exception will be thrown.
 * <p>
 * The method {@code printColumnTypes()} can be used to print a list of the detected columns that can be
 * corrected and
 * used to explicitly specify the correct column types.
 */
protected static ColumnType[] detectColumnTypes(InputStream stream, boolean header, char delimiter, boolean skipSampling)
        throws IOException {

    int linesToSkip = header ? 1 : 0;

    // to hold the results
    List<ColumnType> columnTypes = new ArrayList<>();

    // to hold the data read from the file
    List<List<String>> columnData = new ArrayList<>();

    int rowCount = 0; // make sure we don't go over maxRows

    // make sure we don't have leading Unicode BOM
    UnicodeBOMInputStream ubis = new UnicodeBOMInputStream(stream);
    ubis.skipBOM();

    CSVParser csvParser = new CSVParserBuilder()
            .withSeparator(delimiter)
            .build();
    try (CSVReader reader = new CSVReaderBuilder(new InputStreamReader(ubis))
            .withCSVParser(csvParser)
            .withSkipLines(linesToSkip)
            .build()) {
        String[] nextLine;
        int nextRow = 0;
        while ((nextLine = reader.readNext()) != null) {
            // initialize the arrays to hold the strings. we don't know how many we need until we read the first row
            if (rowCount == 0) {
                for (int j = 0; j < nextLine.length; j++) {
                    columnData.add(new ArrayList<>());
                }
            }
            int columnNumber = 0;
            if (rowCount == nextRow) {
                for (String field : nextLine) {
                    columnData.get(columnNumber).add(field);
                    columnNumber++;
                }
            }
            if (rowCount == nextRow) {
                if (skipSampling) {
                    nextRow = nextRowWithoutSampling(nextRow);
                } else {
                    nextRow = nextRow(nextRow);
                }
            }
            rowCount++;
        }
    }

    // now detect
    for (List<String> valuesList : columnData) {
        ColumnType detectedType = detectType(valuesList);
        columnTypes.add(detectedType);
    }
    return columnTypes.toArray(new ColumnType[columnTypes.size()]);
}