import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
/**
 *
 * @param reader
 * @param delimiter
 * @return a CSV reader which uses the delimiter provided
 */
private static CSVReader<String[]> buildCSVReader(Reader reader, char delimiter) {
    try {
        // Mark the reader stream to read 1 character ahead, so that we can reset to that point if the first character is not UTF-8 BOM
        reader.mark(1);

        int read = reader.read();

        if (read != 0xFEFF) {
            reader.reset();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    return new CSVReaderBuilder<String[]>(reader).entryParser(new DefaultCSVEntryParser()).strategy(SimpleBulkObjectReader.createStrategyWithDelimiter(delimiter)).build();
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
@Override
   public List<PostCSV> getPosts() {

List<PostCSV> posts_list = null;
try {
    reader = new FileReader(filePath);

    CSVEntryParser<PostCSV> entryParser = new AnnotationEntryParser<PostCSV>(PostCSV.class, provider);
    CSVReader<PostCSV> csvPostReader = new CSVReaderBuilder<PostCSV>(reader).entryParser(entryParser).build();

    posts_list = csvPostReader.readAll();
} catch (IOException e) {
    System.out.println("Exception while reading" + e);
    e.printStackTrace();
}

return posts_list;
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
@Override
   public List<UserCSV> getUsers() {
List<UserCSV> userList = null;
try {
    reader = new FileReader(filePath);
    
    CSVEntryParser<UserCSV> entryUserParser = new AnnotationEntryParser<UserCSV>(UserCSV.class, provider);
    CSVReader<UserCSV> csvUserReader = new CSVReaderBuilder<UserCSV>(reader)
	    .entryParser(entryUserParser).build();

    userList = csvUserReader.readAll();
} catch (IOException e) {
    e.printStackTrace();
}
return userList;
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public static void testeTempo() throws IOException{
	int ano = 2014, mes = 05, dia = 21;
	String local = "LPFR";
	URL oracle = new URL("http://www.wunderground.com/history/airport/"+local+"/"+ano+"/"+mes+"/"+dia+"/DailyHistory.html?format=1");
	//http://www.wunderground.com/history/airport/KSAN/2012/10/1/MonthlyHistory.html?format=1
       BufferedReader reader = new BufferedReader(new InputStreamReader(oracle.openStream()));
	CSVReader<String[]> csvParser = CSVReaderBuilder.newDefaultReader(reader);
	List<String[]> data = csvParser.readAll();
	
	for(String[] strs : data){
		for(String str : strs){
			System.out.print(str+";");
		}
		System.out.println();
	}
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public CoolRecord[] read() throws Exception {

		ArrayList<CoolRecord> records = new ArrayList<CoolRecord>();
		Reader reader = new FileReader(csvFileURI);
		CSVReader<String[]> csvReader = new CSVReaderBuilder<String[]>(reader)
				.entryParser(new DefaultCSVEntryParser())
				.strategy(CSVStrategy.UK_DEFAULT).build();

		boolean hasColumnRowSkipped = false;
		for (String[] csvReaderRecord : csvReader.readAll()) {

			if (!hasColumnRowSkipped) {
				hasColumnRowSkipped = true;
				continue;
			}

			CoolRecord record = null;

			// Column Detail is not provided by user. So, default is set to
			// String for all columns
			if (columns == null || columns.length < 0) {

				columns = new CoolColumn[csvReaderRecord.length];
				for (int i = 0; i < columns.length; i++) {
					columns[i] = new CoolColumn(null, i, String.class);
				}
			}
			record = new CoolRecord(columns, csvReaderRecord);

			records.add(record);
		}

		return records.toArray(new CoolRecord[records.size()]);
	}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
protected List<T> readAllUsing(CSVEntryParser<T> csvEntryParser, InputStream content) throws IOException {
    checkArgument(csvEntryParser != null, "Expected non-null csvEntryParser argument");
    checkArgument(content != null, "Expected non-null content argument");
    Reader reader = new InputStreamReader(content);
    CSVReader<T> csvReader = new CSVReaderBuilder<T>(reader)
            .strategy(csvStrategy)
            .entryParser(csvEntryParser)
            .build();
    return csvReader.readAll();
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
private List<TweetToSchedule> parseCsvFile(String pathToCsvFile) {
    List<TweetToSchedule> csvData = null;
    Reader reader = inputReader.getInputReader(pathToCsvFile);
    CSVReader<TweetToSchedule> csvParser = createCSVReader(reader);
    try {
        csvData = csvParser.readAll();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return csvData;
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public static void create(){
try {
	//URI uri = DatabaseConnection.class.getResource("/db").toURI();
	//File folder = new File("db");
          InputStream listInputStream = DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/db/list.txt");
          BufferedReader listReader = new BufferedReader(new InputStreamReader(listInputStream));

          Map<String,InputStream> inputStreamMap = new HashMap<>();
          String name;
          while ((name = listReader.readLine()) != null) {
              inputStreamMap.put(name, DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/db/" + name));
          }

	anos = new String[inputStreamMap.size()];
          int idx = 0;
          for (Map.Entry<String, InputStream> entry : inputStreamMap.entrySet()){
              InputStream is = entry.getValue();
              String fName = entry.getKey();
              anos[idx] = fName.substring(0, 4);
              idx++;
              Reader reader = new InputStreamReader(is);
              CSVReader<String[]> csvParser = CSVReaderBuilder.newDefaultReader(reader);
              List<String[]> data = csvParser.readAll();
              db.add(data);
          }
	
	itemsToAdd = CSVReaderBuilder.newDefaultReader(new InputStreamReader(DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/knap/items.csv"))).readAll();
	equipas = CSVReaderBuilder.newDefaultReader(new InputStreamReader(DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/knap/equipas.csv"))).readAll();
	sites = CSVReaderBuilder.newDefaultReader(new InputStreamReader(DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/knap/sites.csv"))).readAll();
	neuralScores = CSVReaderBuilder.newDefaultReader(new InputStreamReader(DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/knap/neural.csv"))).readAll();
	resultados = CSVReaderBuilder.newDefaultReader(new InputStreamReader(DatabaseConnection.class.getResourceAsStream("/main/resources/tsi/knap/resultados.csv"))).readAll();
} catch (IOException e) {
	e.printStackTrace();
}
  }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
protected CSVReader<SeriesValue> createReader() throws IOException
{
    CSVReaderBuilder<SeriesValue> builder = new CSVReaderBuilder<SeriesValue>(new InputStreamReader(storage.read()));

    builder.strategy(UK_DEFAULT);
    builder.entryParser(new AnnotationEntryParser<SeriesValue>(SeriesValue.class, new ValueProcessorProvider()));

    return builder.build();
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
/**
    * This method finally creates the CSVReaderImpl using the specified configuration.
    * 
    * @return the CSVReaderImpl instance
    */
   @Override
   public CSVReader<E> build() {
if (this.entryParser == null) {
    throw new IllegalStateException("you have to specify a csv entry parser");
}

return new CSVReaderImpl<E>(this);
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
/**
    * This method finally creates the CSVReaderImpl using the specified configuration.
    * 
    * @return the CSVReaderImpl instance
    */
   @Override
   public CSVReader<E> build() {
if (this.entryParser == null) {
    throw new IllegalStateException("you have to specify a csv entry parser");
}

return new CSVHeaderAwareReader<E>(this);
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
@Before
   public void setUp() throws Exception {
Reader reader = new InputStreamReader(this.getClass().getResourceAsStream("/persons.csv"));
CSVStrategy strategy = new CSVStrategy(';', '"', '#', true, true);
CSVReader<Person> csvReader = new CSVReaderBuilder<Person>(reader).entryParser(new PersonEntryParser())
        .strategy(strategy).build();
this.cachedReader = new CachedCSVReaderImpl<Person>(csvReader);
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
private CSVReader<?> createNextEntityReader() {
    LOGGER.info("Loading file [{}]", this.currentEntityClass);
    String path = getEntityFilePath();
    InputStream stream = getClass().getClassLoader().getResourceAsStream(path);
    Reader csv = new InputStreamReader(stream);
    ValueProcessorProvider processor = new ValueProcessorProvider();
    CSVHeaderAwareEntryParser<Object> entryParser = new CSVHeaderAwareEntryParser<Object>(this.currentEntityClass, processor);
    return new CSVHeaderAwareReaderBuilder<Object>(csv).entryParser(entryParser).build();
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public static BulkFileReader createBulkFileReader(CSVReader<String[]> csvReader, BulkObjectFactory factory) throws FileNotFoundException {
    BulkFileReader fileReader = new BulkFileReader(new SimpleBulkStreamReader(new SimpleBulkObjectReader(csvReader, factory)), ResultFileType.PARTIAL_DOWNLOAD);

    return fileReader;
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
private CSVReader<TweetToSchedule> createCSVReader(Reader reader) {
       return (CSVReader<TweetToSchedule>) new CSVReaderBuilder(reader)
               .strategy(CSVStrategy.UK_DEFAULT)
               .entryParser(new TweetToScheduleEntryParser()).build();
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public List<SeriesValue> read() throws IOException
{
    CSVReader<SeriesValue> reader = createReader();

    return reader.readAll();
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
@Override
protected List<SeriesValue> loadSeries(AbstractBuild build) throws IOException
{
    List<SeriesValue> values = new ArrayList<SeriesValue>();

    FilePath seriesFile = new FilePath(build.getWorkspace(), getFile());

    try
    {
        if (!seriesFile.exists())
        {
            return values;
        }

        CSVReader<String[]> reader = null;

        try
        {
            reader = new CSVReaderBuilder<String[]>(new InputStreamReader(seriesFile.read())).strategy(CSVStrategy.UK_DEFAULT).entryParser(new DefaultCSVEntryParser()).build();

            List<String> headers = reader.readHeader();

            for (String[] row; (row = reader.readNext()) != null;)
            {
                if (row.length == 0 || row[0].isEmpty())
                {
                    continue;
                }

                for (Integer columnIndex = 0; columnIndex < row.length; columnIndex++)
                {
                    String header = headers.get(columnIndex);

                    if (shouldIncludeColumn(header, columnIndex.toString()))
                    {
                        values.add(new SeriesValue(row[columnIndex], header, build));
                    }
                }

                break;
            }
        }
        finally
        {
            if (reader != null)
            {
                reader.close();
            }
        }

        return values;
    }
    catch (InterruptedException e)
    {
        throw new RuntimeException(e);
    }
}
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public CSVIterator(CSVReader<E> reader) {
this.reader = reader;
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
public CachedCSVReaderImpl(CSVReader<E> reader) {
this.reader = reader;
this.cachedEntries = new ArrayList<E>();

this.currentIndex = -1;
   }
 

import com.googlecode.jcsv.reader.CSVReader; //导入依赖的package包/类
private CSVReader<String[]> createFakeCsvReader(Iterator<String[]> iterator) {
    CSVReader<String[]> reader = createNiceMock(CSVReader.class);
    
    expect(reader.iterator()).andReturn(iterator);
    
    replay(reader);

    return reader;
}