import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
@Override
   public String joinColumns(String[] data, CSVStrategy strategy) {
final String delimiter = String.valueOf(strategy.getDelimiter());
final String quote = String.valueOf(strategy.getQuoteCharacter());
final String doubleQuote = quote + quote;

// check each column for delimiter or quote characters
// and escape them if neccessary
for (int i = 0; i < data.length; i++) {
    if (data[i].contains(delimiter) || data[i].contains(quote)) {
	if (data[i].contains(quote)) {
	    data[i] = data[i].replaceAll(Pattern.quote(quote), doubleQuote);
	}
	
	data[i] = quote + data[i] + quote;
    }
}

return CSVUtil.implode(data, delimiter);
   }
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
@Test
public void testJoinColumns() {
	CSVColumnJoiner columnJoiner = new SimpleCSVColumnJoiner();

	// uses ; as delimiter
	final CSVStrategy strategy = CSVStrategy.DEFAULT;

	String[] data = {"A", "B", "C"};
	String result = columnJoiner.joinColumns(data, strategy);
	String expected = "A;B;C";
	assertEquals(expected, result);

	data = new String[]{"A"};
	result = columnJoiner.joinColumns(data, strategy);
	expected = "A";
	assertEquals(expected, result);

	data = new String[0];
	result = columnJoiner.joinColumns(data, strategy);
	expected = "";
	assertEquals(expected, result);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的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.CSVStrategy; //导入依赖的package包/类
public static <T> void exportCSV(String fileName, CSVEntryConverter<T> headerConverter,
                                 CSVEntryConverter<T> contentConverter, T emptyItem,
                                 List<T> list, Stage stage) {

    FileChooser fileChooser = new FileChooser();
    fileChooser.setInitialFileName(fileName);
    File file = fileChooser.showSaveDialog(stage);
    if (file != null) {
        try (OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(file, false), Charsets.UTF_8)) {
            CSVWriter<T> headerWriter = new CSVWriterBuilder<T>(outputStreamWriter)
                    .strategy(CSVStrategy.UK_DEFAULT)
                    .entryConverter(headerConverter)
                    .build();
            headerWriter.write(emptyItem);

            CSVWriter<T> contentWriter = new CSVWriterBuilder<T>(outputStreamWriter)
                    .strategy(CSVStrategy.UK_DEFAULT)
                    .entryConverter(contentConverter)
                    .build();
            contentWriter.writeAll(list);
        } catch (RuntimeException | IOException e) {
            e.printStackTrace();
            log.error(e.getMessage());
            new Popup<>().error(Res.get("guiUtil.accountExport.exportFailed", e.getMessage()));
        }
    }
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
/**
    * Performs a split() on the input string. Uses the delimiter specified in the csv strategy.
    */
   @Override
   public List<String> tokenizeLine(String line, CSVStrategy strategy, BufferedReader reader) throws IOException {
if (line.equals("")) {
    return new ArrayList<String>();
}

// split the line and preserve all tokens
List<String> tokens = Arrays.asList(CSVUtil.split(line, strategy.getDelimiter(), true));

return tokens;
   }
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
@Test
public void testJoinColumns() {
	CSVColumnJoiner columnJoiner = new CSVColumnJoinerImpl();

	// uses ; as delimiter
	final CSVStrategy strategy = CSVStrategy.DEFAULT;

	// simple test cases
	String[] data = {"A", "B", "C"};
	String result = columnJoiner.joinColumns(data, strategy);
	String expected = "A;B;C";
	assertEquals(expected, result);

	// single token test
	data = new String[]{"A"};
	result = columnJoiner.joinColumns(data, strategy);
	expected = "A";
	assertEquals(expected, result);

	// empty array test
	data = new String[0];
	result = columnJoiner.joinColumns(data, strategy);
	expected = "";
	assertEquals(expected, result);

	// more complex test cases
	// delimiter in token test case
	data = new String[]{"A", "B", "C;D"};
	result = columnJoiner.joinColumns(data, strategy);
	expected = "A;B;\"C;D\"";
	assertEquals(expected, result);

	// quote in token
	data = new String[]{"A", "B", "C\";\"D"};
	result = columnJoiner.joinColumns(data, strategy);
	expected = "A;B;\"C\"\";\"\"D\"";
	assertEquals(expected, result);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的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.CSVStrategy; //导入依赖的package包/类
public WynikCsvDtoReader(CSVStrategy csvStrategy) {
    super(csvStrategy);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
public OkregowaCsvDtoReader(CSVStrategy csvStrategy) {
    super(csvStrategy);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
/**
 * @param csvStrategy {@link https://code.google.com/p/jcsv/wiki/CSVStrategy}
 */
public AbstractCSVReader(CSVStrategy csvStrategy) {
    this.csvStrategy = csvStrategy;
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
public UserCsvDtoReader(CSVStrategy csvStrategy) {
    super(csvStrategy);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
public ObwodowaCsvDtoReader(CSVStrategy csvStrategy) {
    super(csvStrategy);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的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.CSVStrategy; //导入依赖的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.CSVStrategy; //导入依赖的package包/类
/**
    * Performs a CSVUtil.implode() to concat the columns, it uses the delimiter specified by the
    * csv strategy.
    */
   @Override
   public String joinColumns(String[] data, CSVStrategy strategy) {
return CSVUtil.implode(data, String.valueOf(strategy.getDelimiter()));
   }
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
@Override
   public List<String> tokenizeLine(String line, CSVStrategy strategy, BufferedReader reader) throws IOException {
final char DELIMITER = strategy.getDelimiter();
final char QUOTE = strategy.getQuoteCharacter();
final char NEW_LINE = '\n';

final StringBuilder sb = new StringBuilder(30);
final List<String> token = new ArrayList<String>();

line += NEW_LINE;
State state = State.NORMAL;

int pointer = 0;
while (true) {
    final char c = line.charAt(pointer);
    
    switch (state) {
	case NORMAL:
	    if (c == DELIMITER) {
		token.add(sb.toString());
		sb.delete(0, sb.length());
	    } else if (c == NEW_LINE) {
		if (!((token.size() == 0) && (sb.length() == 0))) {
		    token.add(sb.toString());
		}
		return token;
	    } else if (c == QUOTE) {
		if (sb.length() == 0) {
		    state = State.QUOTED;
		} else if ((line.charAt(pointer + 1) == QUOTE) && (sb.length() > 0)) {
		    sb.append(c);
		    pointer++;
		} else if (line.charAt(pointer + 1) != QUOTE) {
		    state = State.QUOTED;
		}
	    } else {
		sb.append(c);
	    }
	    break;
	
	case QUOTED:
	    if (c == NEW_LINE) {
		sb.append(NEW_LINE);
		pointer = -1;
		line = reader.readLine();
		if (line == null) {
		    throw new IllegalStateException("unexpected end of file, unclosed quotation");
		}
		line += NEW_LINE;
	    } else if (c == QUOTE) {
		if (line.charAt(pointer + 1) == QUOTE) {
		    sb.append(c);
		    pointer++;
		    break;
		} else {
		    state = State.NORMAL;
		}
	    } else {
		sb.append(c);
	    }
	    break;
    }
    
    pointer++;
}
   }
 

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

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
@Test
@SuppressWarnings("serial")
public void testTokenizeLine() throws IOException {
	CSVTokenizer tokenizer = new SimpleCSVTokenizer();

	// uses ; as delimiter
	final CSVStrategy strategy = CSVStrategy.DEFAULT;
	final String delimiter = String.valueOf(strategy.getDelimiter());

	// we only do simple tests
	String line = "A;B;C";
	List<String> token = tokenizer.tokenizeLine(line, strategy, null);
	List<String> expected = new ArrayList<String>() {{
		add("A"); add("B"); add("C");
	}};
	assertEquals(expected, token);

	line = "A";
	token = tokenizer.tokenizeLine(line, strategy, null);
	expected = new ArrayList<String>() {{
		add("A");
	}};
	assertEquals(expected, token);

	line = "A;";
	token = tokenizer.tokenizeLine(line, strategy, null);
	expected = new ArrayList<String>() {{
		add("A"); add("");
	}};
	assertEquals(expected, token);

	line = delimiter + delimiter;
	token = tokenizer.tokenizeLine(line, strategy, null);
	expected = new ArrayList<String>() {{
		add(""); add(""); add("");
	}};
	assertEquals(expected, token);

	line = "";
	token = tokenizer.tokenizeLine(line, strategy, null);
	expected = new ArrayList<String>();
	assertEquals(expected, token);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
/**
 *
 * @param delimiter
 * @return a strategy for writing the CSV using the delimiter provided
 */
private CSVStrategy createStrategyWithDelimiter(char delimiter) {
    return new CSVStrategy(delimiter, '"', '#', false, true);
}
 

import com.googlecode.jcsv.CSVStrategy; //导入依赖的package包/类
/**
 * Create a parsing strategy using the delimiter provided
 *
 * @param delimiter The character used to separate records in the same line
 * @return a csv parsing strategy
 */
private static CSVStrategy createStrategyWithDelimiter(char delimiter) {
    return new CSVStrategy(delimiter, '"', '#', false, true);
}