JAVA学习提高之－－－－JAVA开源项目之操作csv文件

 JAVA操作csv文件的开源项目很多，如想查可看下面链接
http://sourceforge.net/search/?type_of_search=soft&words=csv

看到网上有人认为不错的一个，地址是：
http://opencsv.sourceforge.net/

下载源码地址：http://sourceforge.net/project/showfiles.php?group_id=148905&package_id=164539
最新的是1.8版的，因为最近项目要用到CSV文件的读写，所以对有关内容进行学习，主要是对CSV文件分析器类的学习，下面只是发布出来的API，具体的类下载的资源里面有。

具体思路：因为csv file本身可以当作文件文件来操作，所以只需使用BufferedReader的readLine方法即可读取一行了。

2. opencsv
4. An Open Source Java csv library under commercial-friendly license... committed to changing the world, one comma at a time...
5. What is opencsv?
7. opencsv is a very simple csv (comma-separated values) parser library for Java. It was developed because all of current csv parsers I've come across don't have commercial-friendly licenses.
8. Where can I get it?
10. Source and binaries are available from Sourceforge.
11. What features does opencsv support?
13. opencsv supports all the basic csv-type things you're likely to want to do:
15.     * Arbitrary numbers of values per line
16.     * Ignoring commas in quoted elements
17.     * Handling quoted entries with embedded carriage returns (ie entries that span multiple lines)
18.     * Configurable separator and quote characters (or use sensible defaults)
19.     * Read all the entries at once, or use an Iterator style model
20.     * Creating csv files from String[] (ie. automatic escaping of embedded quote chars)
22. How do I read and parse a CSV file?
24. If you want to use an Iterator style pattern, you might do something like this:
26.     CSVReader reader = new CSVReader(new FileReader("yourfile.csv"));
27.     String [] nextLine;
28.     while ((nextLine = reader.readNext()) != null) {
29.         // nextLine[] is an array of values from the line
30.         System.out.println(nextLine[0] + nextLine[1] + "etc...");
31.     }
32.             
34. Or, if you might just want to slurp the whole lot into a List, just call readAll()...
36.     CSVReader reader = new CSVReader(new FileReader("yourfile.csv"));
37.     List myEntries = reader.readAll();
38.             
40. which will give you a List of String[] that you can iterate over. If all else fails, check out the Javadoc.
41. Can I use my own separators and quote characters?
43. Yes. There are constructors that cater for supplying your own separator and quote characters. Say you're using a tab for your separator, you can do something like this:
45.     CSVReader reader = new CSVReader(new FileReader("yourfile.csv"), '/t');
46.                 
48. And if you single quoted your escaped characters rather than double quote them, you can use the three arg constructor:
50.     CSVReader reader = new CSVReader(new FileReader("yourfile.csv"), '/t', '/'');
51.             
53. You may also skip the first few lines of the file if you know that the content doesn't start till later in the file. So, for example, you can skip the first two lines by doing:
55.     CSVReader reader = new CSVReader(new FileReader("yourfile.csv"), '/t', '/'', 2);
56.             
58. Can I write csv files with opencsv?
60. Yes. There is a CSVWriter in the same package that follows the same semantics as the CSVReader. For example, to write a tab separated file:
62.      CSVWriter writer = new CSVWriter(new FileWriter("yourfile.csv"), '/t');
63.      // feed in your array (or convert your data to an array)
64.      String[] entries = "first#second#third".split("#");
65.      writer.writeNext(entries);
66.     writer.close();
67.                 
69. If you'd prefer to use your own quote characters, you may use the three arg version of the constructor, which takes a quote character (or feel free to pass in CSVWriter.NO_QUOTE_CHARACTER).
71. You can also customise the line terminators used in the generated file (which is handy when you're exporting from your Linux web application to Windows clients). There is a constructor argument for this purpose.
72. Can I dump out SQL tables to CSV?
74. Yes you can. Sean Sullivan added a neat feature to CSVWriter so you can pass writeAll() a ResultSet.
76.       java.sql.ResultSet myResultSet = ....
77.       writer.writeAll(myResultSet, includeHeaders);
78.             
80. Is there a way to bind my CSV file to a list of Javabeans?
82. Yes there is. Kyle Miller added a new set of classes to allow you to bind a CSV file to a list of JavaBeans based on column name, column position, or a custom mapping strategy. You can find the new classes in the au.com.bytecode.opencsv.bean package. Here's how you can map to a java bean based on the field positions in your CSV file:
84.       ColumnPositionMappingStrategy strat = new ColumnPositionMappingStrategy();
85.       strat.setType(YourOrderBean.class);
86.       String[] columns = new String[] {"name", "orderNumber", "id"}; // the fields to bind do in your JavaBean
87.       strat.setColumnMapping(columns);
89.       CsvToBean csv = new CsvToBean();
90.       List list = csv.parse(strat, yourReader);
91.             
93. For more detailed examples, check out the test cases for each of the available mapping strategies under the /test/au/com/bytecode/opencsv/bean/.
94. Can I use opencsv in my commercial applications?
96. Yes. opencsv is available under a commercial-friendly Apache 2.0 license. You are free to include it in your commericial applications without any fee or charge, and you are free to modify it to suit your circumstances. To find out more details of the license, read the Apache 2.0 license agreement.
97. Can I get the source? More example code?
99. Yes. The download from the SourceForge page includes the full source in the /src directory. It's one file, so go crazy. There is also a sample addressbook csv reader in the /examples directory. And for extra marks, there's a JUnit test suite in the /test directory.
100. Who maintains opencsv?
102. opencsv was developed in a couple of hours by Glen Smith. You can read his blog for more info and contact details.
104. If you've found a bug, you can report it on the project page at Sourceforge. Please post a sample file that demonstrates your issue. For bonus marks, post a patch too. :-)

对应的方法为：

1. package au.com.bytecode.opencsv;
3. /**
4.  Copyright 2005 Bytecode Pty Ltd.
6.  Licensed under the Apache License, Version 2.0 (the "License");
7.  you may not use this file except in compliance with the License.
8.  You may obtain a copy of the License at
10.  http://www.apache.org/licenses/LICENSE-2.0
12.  Unless required by applicable law or agreed to in writing, software
13.  distributed under the License is distributed on an "AS IS" BASIS,
14.  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15.  See the License for the specific language governing permissions and
16.  limitations under the License.
17.  */
19. import java.io.BufferedReader;
20. import java.io.IOException;
21. import java.io.Reader;
22. import java.util.ArrayList;
23. import java.util.List;
25. /**
26.  * A very simple CSV reader released under a commercial-friendly license.
27.  * 
28.  * @author Glen Smith
29.  * 
30.  */
31. public class CSVReader {
33.     private BufferedReader br;
35.     private boolean hasNext = true;
37.     private char separator;
39.     private char quotechar;
40.     
41.     private int skipLines;
43.     private boolean linesSkiped;
45.     /** The default separator to use if none is supplied to the constructor. */
46.     public static final char DEFAULT_SEPARATOR = ',';
48.     /**
49.      * The default quote character to use if none is supplied to the
50.      * constructor.
51.      */
52.     public static final char DEFAULT_QUOTE_CHARACTER = '"';
53.     
54.     /**
55.      * The default line to start reading.
56.      */
57.     public static final int DEFAULT_SKIP_LINES = 0;
59.     /**
60.      * Constructs CSVReader using a comma for the separator.
61.      * 
62.      * @param reader
63.      *            the reader to an underlying CSV source.
64.      */
65.     public CSVReader(Reader reader) {
66.         this(reader, DEFAULT_SEPARATOR);
67.     }
69.     /**
70.      * Constructs CSVReader with supplied separator.
71.      * 
72.      * @param reader
73.      *            the reader to an underlying CSV source.
74.      * @param separator
75.      *            the delimiter to use for separating entries.
76.      */
77.     public CSVReader(Reader reader, char separator) {
78.         this(reader, separator, DEFAULT_QUOTE_CHARACTER);
79.     }
80.     
81.     
83.     /**
84.      * Constructs CSVReader with supplied separator and quote char.
85.      * 
86.      * @param reader
87.      *            the reader to an underlying CSV source.
88.      * @param separator
89.      *            the delimiter to use for separating entries
90.      * @param quotechar
91.      *            the character to use for quoted elements
92.      */
93.     public CSVReader(Reader reader, char separator, char quotechar) {
94.         this(reader, separator, quotechar, DEFAULT_SKIP_LINES);
95.     }
96.     
97.     /**
98.      * Constructs CSVReader with supplied separator and quote char.
99.      * 
100.      * @param reader
101.      *            the reader to an underlying CSV source.
102.      * @param separator
103.      *            the delimiter to use for separating entries
104.      * @param quotechar
105.      *            the character to use for quoted elements
106.      * @param line
107.      *            the line number to skip for start reading 
108.      */
109.     public CSVReader(Reader reader, char separator, char quotechar, int line) {
110.         this.br = new BufferedReader(reader);
111.         this.separator = separator;
112.         this.quotechar = quotechar;
113.         this.skipLines = line;
114.     }
116.     /**
117.      * Reads the entire file into a List with each element being a String[] of
118.      * tokens.
119.      * 
120.      * @return a List of String[], with each String[] representing a line of the
121.      *         file.
122.      * 
123.      * @throws IOException
124.      *             if bad things happen during the read
125.      */
126.     public List readAll() throws IOException {
128.         List allElements = new ArrayList();
129.         while (hasNext) {
130.             String[] nextLineAsTokens = readNext();
131.             if (nextLineAsTokens != null)
132.                 allElements.add(nextLineAsTokens);
133.         }
134.         return allElements;
136.     }
138.     /**
139.      * Reads the next line from the buffer and converts to a string array.
140.      * 
141.      * @return a string array with each comma-separated element as a separate
142.      *         entry.
143.      * 
144.      * @throws IOException
145.      *             if bad things happen during the read
146.      */
147.     public String[] readNext() throws IOException {
149.         String nextLine = getNextLine();
150.         return hasNext ? parseLine(nextLine) : null;
151.     }
153.     /**
154.      * Reads the next line from the file.
155.      * 
156.      * @return the next line from the file without trailing newline
157.      * @throws IOException
158.      *             if bad things happen during the read
159.      */
160.     private String getNextLine() throws IOException {
161.         if (!this.linesSkiped) {
162.             for (int i = 0; i < skipLines; i++) {
163.                 br.readLine();
164.             }
165.             this.linesSkiped = true;
166.         }
167.         String nextLine = br.readLine();
168.         if (nextLine == null) {
169.             hasNext = false;
170.         }
171.         return hasNext ? nextLine : null;
172.     }
174.     /**
175.      * Parses an incoming String and returns an array of elements.
176.      * 
177.      * @param nextLine
178.      *            the string to parse
179.      * @return the comma-tokenized list of elements, or null if nextLine is null
180.      * @throws IOException if bad things happen during the read
181.      */
182.     private String[] parseLine(String nextLine) throws IOException {
184.         if (nextLine == null) {
185.             return null;
186.         }
188.         List tokensOnThisLine = new ArrayList();
189.         StringBuffer sb = new StringBuffer();
190.         boolean inQuotes = false;
191.         do {
192.             if (inQuotes) {
193.                 // continuing a quoted section, reappend newline
194.                 sb.append("/n");
195.                 nextLine = getNextLine();
196.                 if (nextLine == null)
197.                     break;
198.             }
199.             for (int i = 0; i < nextLine.length(); i++) {
201.                 char c = nextLine.charAt(i);
202.                 if (c == quotechar) {
203.                     // this gets complex... the quote may end a quoted block, or escape another quote.
204.                     // do a 1-char lookahead:
205.                     if( inQuotes  // we are in quotes, therefore there can be escaped quotes in here.
206.                         && nextLine.length() > (i+1)  // there is indeed another character to check.
207.                         && nextLine.charAt(i+1) == quotechar ){ // ..and that char. is a quote also.
208.                         // we have two quote chars in a row == one quote char, so consume them both and
209.                         // put one on the token. we do *not* exit the quoted text.
210.                         sb.append(nextLine.charAt(i+1));
211.                         i++;
212.                     }else{
213.                         inQuotes = !inQuotes;
214.                         // the tricky case of an embedded quote in the middle: a,bc"d"ef,g
215.                         if(i>2 //not on the begining of the line
216.                                 && nextLine.charAt(i-1) != this.separator //not at the begining of an escape sequence 
217.                                 && nextLine.length()>(i+1) &&
218.                                 nextLine.charAt(i+1) != this.separator //not at the end of an escape sequence
219.                         ){
220.                             sb.append(c);
221.                         }
222.                     }
223.                 } else if (c == separator && !inQuotes) {
224.                     tokensOnThisLine.add(sb.toString());
225.                     sb = new StringBuffer(); // start work on next token
226.                 } else {
227.                     sb.append(c);
228.                 }
229.             }
230.         } while (inQuotes);
231.         tokensOnThisLine.add(sb.toString());
232.         return (String[]) tokensOnThisLine.toArray(new String[0]);
234.     }
236.     /**
237.      * Closes the underlying reader.
238.      * 
239.      * @throws IOException if the close fails
240.      */
241.     public void close() throws IOException{
242.         br.close();
243.     }
244.     
245. }

 

1. package au.com.bytecode.opencsv;
3. /**
4.  Copyright 2005 Bytecode Pty Ltd.
6.  Licensed under the Apache License, Version 2.0 (the "License");
7.  you may not use this file except in compliance with the License.
8.  You may obtain a copy of the License at
10.  http://www.apache.org/licenses/LICENSE-2.0
12.  Unless required by applicable law or agreed to in writing, software
13.  distributed under the License is distributed on an "AS IS" BASIS,
14.  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15.  See the License for the specific language governing permissions and
16.  limitations under the License.
17.  */
19. import java.io.IOException;
20. import java.io.PrintWriter;
21. import java.io.Reader;
22. import java.io.Writer;
23. import java.math.BigDecimal;
24. import java.sql.Clob;
25. import java.sql.ResultSet;
26. import java.sql.ResultSetMetaData;
27. import java.sql.SQLException;
28. import java.sql.Time;
29. import java.sql.Timestamp;
30. import java.sql.Types;
31. import java.text.SimpleDateFormat;
32. import java.util.Iterator;
33. import java.util.List;
35. /**
36.  * A very simple CSV writer released under a commercial-friendly license.
37.  *
38.  * @author Glen Smith
39.  *
40.  */
41. public class CSVWriter {
42.     
43.     private Writer rawWriter;
45.     private PrintWriter pw;
47.     private char separator;
49.     private char quotechar;
50.     
51.     private char escapechar;
52.     
53.     private String lineEnd;
55.     /** The character used for escaping quotes. */
56.     public static final char DEFAULT_ESCAPE_CHARACTER = '"';
58.     /** The default separator to use if none is supplied to the constructor. */
59.     public static final char DEFAULT_SEPARATOR = ',';
61.     /**
62.      * The default quote character to use if none is supplied to the
63.      * constructor.
64.      */
65.     public static final char DEFAULT_QUOTE_CHARACTER = '"';
66.     
67.     /** The quote constant to use when you wish to suppress all quoting. */
68.     public static final char NO_QUOTE_CHARACTER = '/u0000';
69.     
70.     /** The escape constant to use when you wish to suppress all escaping. */
71.     public static final char NO_ESCAPE_CHARACTER = '/u0000';
72.     
73.     /** Default line terminator uses platform encoding. */
74.     public static final String DEFAULT_LINE_END = "/n";
76.     private static final SimpleDateFormat
77.         TIMESTAMP_FORMATTER = 
78.             new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");
80.     private static final SimpleDateFormat
81.         DATE_FORMATTER = 
82.             new SimpleDateFormat("dd-MMM-yyyy");
83.     
84.     /**
85.      * Constructs CSVWriter using a comma for the separator.
86.      *
87.      * @param writer
88.      *            the writer to an underlying CSV source.
89.      */
90.     public CSVWriter(Writer writer) {
91.         this(writer, DEFAULT_SEPARATOR);
92.     }
94.     /**
95.      * Constructs CSVWriter with supplied separator.
96.      *
97.      * @param writer
98.      *            the writer to an underlying CSV source.
99.      * @param separator
100.      *            the delimiter to use for separating entries.
101.      */
102.     public CSVWriter(Writer writer, char separator) {
103.         this(writer, separator, DEFAULT_QUOTE_CHARACTER);
104.     }
106.     /**
107.      * Constructs CSVWriter with supplied separator and quote char.
108.      *
109.      * @param writer
110.      *            the writer to an underlying CSV source.
111.      * @param separator
112.      *            the delimiter to use for separating entries
113.      * @param quotechar
114.      *            the character to use for quoted elements
115.      */
116.     public CSVWriter(Writer writer, char separator, char quotechar) {
117.         this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER);
118.     }
120.     /**
121.      * Constructs CSVWriter with supplied separator and quote char.
122.      *
123.      * @param writer
124.      *            the writer to an underlying CSV source.
125.      * @param separator
126.      *            the delimiter to use for separating entries
127.      * @param quotechar
128.      *            the character to use for quoted elements
129.      * @param escapechar
130.      *            the character to use for escaping quotechars or escapechars
131.      */
132.     public CSVWriter(Writer writer, char separator, char quotechar, char escapechar) {
133.         this(writer, separator, quotechar, escapechar, DEFAULT_LINE_END);
134.     }
135.     
136.     
137.     /**
138.      * Constructs CSVWriter with supplied separator and quote char.
139.      *
140.      * @param writer
141.      *            the writer to an underlying CSV source.
142.      * @param separator
143.      *            the delimiter to use for separating entries
144.      * @param quotechar
145.      *            the character to use for quoted elements
146.      * @param lineEnd
147.      *            the line feed terminator to use
148.      */
149.     public CSVWriter(Writer writer, char separator, char quotechar, String lineEnd) {
150.         this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER, lineEnd);
151.     }   
152.     
153.     
154.     
155.     /**
156.      * Constructs CSVWriter with supplied separator, quote char, escape char and line ending.
157.      *
158.      * @param writer
159.      *            the writer to an underlying CSV source.
160.      * @param separator
161.      *            the delimiter to use for separating entries
162.      * @param quotechar
163.      *            the character to use for quoted elements
164.      * @param escapechar
165.      *            the character to use for escaping quotechars or escapechars
166.      * @param lineEnd
167.      *            the line feed terminator to use
168.      */
169.     public CSVWriter(Writer writer, char separator, char quotechar, char escapechar, String lineEnd) {
170.         this.rawWriter = writer;
171.         this.pw = new PrintWriter(writer);
172.         this.separator = separator;
173.         this.quotechar = quotechar;
174.         this.escapechar = escapechar;
175.         this.lineEnd = lineEnd;
176.     }
177.     
178.     /**
179.      * Writes the entire list to a CSV file. The list is assumed to be a
180.      * String[]
181.      *
182.      * @param allLines
183.      *            a List of String[], with each String[] representing a line of
184.      *            the file.
185.      */
186.     public void writeAll(List allLines)  {
188.         for (Iterator iter = allLines.iterator(); iter.hasNext();) {
189.             String[] nextLine = (String[]) iter.next();
190.             writeNext(nextLine);
191.         }
193.     }
195.     protected void writeColumnNames(ResultSetMetaData metadata)
196.         throws SQLException {
197.         
198.         int columnCount =  metadata.getColumnCount();
199.         
200.         String[] nextLine = new String[columnCount];
201.         for (int i = 0; i < columnCount; i++) {
202.             nextLine[i] = metadata.getColumnName(i + 1);
203.         }
204.         writeNext(nextLine);
205.     }
206.     
207.     /**
208.      * Writes the entire ResultSet to a CSV file.
209.      *
210.      * The caller is responsible for closing the ResultSet.
211.      *
212.      * @param rs the recordset to write
213.      * @param includeColumnNames true if you want column names in the output, false otherwise
214.      *
215.      */
216.     public void writeAll(java.sql.ResultSet rs, boolean includeColumnNames)  throws SQLException, IOException {
217.         
218.         ResultSetMetaData metadata = rs.getMetaData();
219.         
220.         
221.         if (includeColumnNames) {
222.             writeColumnNames(metadata);
223.         }
225.         int columnCount =  metadata.getColumnCount();
226.         
227.         while (rs.next())
228.         {
229.             String[] nextLine = new String[columnCount];
230.             
231.             for (int i = 0; i < columnCount; i++) {
232.                 nextLine[i] = getColumnValue(rs, metadata.getColumnType(i + 1), i + 1);
233.             }
234.             
235.             writeNext(nextLine);
236.         }
237.     }
238.     
239.     private static String getColumnValue(ResultSet rs, int colType, int colIndex)
240.             throws SQLException, IOException {
242.         String value = "";
243.         
244.         switch (colType)
245.         {
246.             case Types.BIT:
247.                 Object bit = rs.getObject(colIndex);
248.                 if (bit != null) {
249.                     value = String.valueOf(bit);
250.                 }
251.             break;
252.             case Types.BOOLEAN:
253.                 boolean b = rs.getBoolean(colIndex);
254.                 if (!rs.wasNull()) {
255.                     value = Boolean.valueOf(b).toString();
256.                 }
257.             break;
258.             case Types.CLOB:
259.                 Clob c = rs.getClob(colIndex);
260.                 if (c != null) {
261.                     value = read(c);
262.                 }
263.             break;
264.             case Types.BIGINT:
265.             case Types.DECIMAL:
266.             case Types.DOUBLE:
267.             case Types.FLOAT:
268.             case Types.REAL:
269.             case Types.NUMERIC:
270.                 BigDecimal bd = rs.getBigDecimal(colIndex);
271.                 if (bd != null) {
272.                     value = "" + bd.doubleValue();
273.                 }
274.             break;
275.             case Types.INTEGER:
276.             case Types.TINYINT:
277.             case Types.SMALLINT:
278.                 int intValue = rs.getInt(colIndex);
279.                 if (!rs.wasNull()) {
280.                     value = "" + intValue;
281.                 }
282.             break;
283.             case Types.JAVA_OBJECT:
284.                 Object obj = rs.getObject(colIndex);
285.                 if (obj != null) {
286.                     value = String.valueOf(obj);
287.                 }
288.             break;
289.             case Types.DATE:
290.                 java.sql.Date date = rs.getDate(colIndex);
291.                 if (date != null) {
292.                     value = DATE_FORMATTER.format(date);;
293.                 }
294.             break;
295.             case Types.TIME:
296.                 Time t = rs.getTime(colIndex);
297.                 if (t != null) {
298.                     value = t.toString();
299.                 }
300.             break;
301.             case Types.TIMESTAMP:
302.                 Timestamp tstamp = rs.getTimestamp(colIndex);
303.                 if (tstamp != null) {
304.                     value = TIMESTAMP_FORMATTER.format(tstamp);
305.                 }
306.             break;
307.             case Types.LONGVARCHAR:
308.             case Types.VARCHAR:
309.             case Types.CHAR:
310.                 value = rs.getString(colIndex);
311.             break;
312.             default:
313.                 value = "";
314.         }
316.         
317.         if (value == null)
318.         {
319.             value = "";
320.         }
321.         
322.         return value;
323.         
324.     }
326.     private static String read(Clob c) throws SQLException, IOException
327.     {
328.         StringBuffer sb = new StringBuffer( (int) c.length());
329.         Reader r = c.getCharacterStream();
330.         char[] cbuf = new char[2048];
331.         int n = 0;
332.         while ((n = r.read(cbuf, 0, cbuf.length)) != -1) {
333.             if (n > 0) {
334.                 sb.append(cbuf, 0, n);
335.             }
336.         }
337.         return sb.toString();
338.     }
339.     
340.     /**
341.      * Writes the next line to the file.
342.      *
343.      * @param nextLine
344.      *            a string array with each comma-separated element as a separate
345.      *            entry.
346.      */
347.     public void writeNext(String[] nextLine) {
348.         
349.         if (nextLine == null)
350.             return;
351.         
352.         StringBuffer sb = new StringBuffer();
353.         for (int i = 0; i < nextLine.length; i++) {
355.             if (i != 0) {
356.                 sb.append(separator);
357.             }
359.             String nextElement = nextLine[i];
360.             if (nextElement == null)
361.                 continue;
362.             if (quotechar !=  NO_QUOTE_CHARACTER)
363.                 sb.append(quotechar);
364.             for (int j = 0; j < nextElement.length(); j++) {
365.                 char nextChar = nextElement.charAt(j);
366.                 if (escapechar != NO_ESCAPE_CHARACTER && nextChar == quotechar) {
367.                     sb.append(escapechar).append(nextChar);
368.                 } else if (escapechar != NO_ESCAPE_CHARACTER && nextChar == escapechar) {
369.                     sb.append(escapechar).append(nextChar);
370.                 } else {
371.                     sb.append(nextChar);
372.                 }
373.             }
374.             if (quotechar != NO_QUOTE_CHARACTER)
375.                 sb.append(quotechar);
376.         }
377.         
378.         sb.append(lineEnd);
379.         pw.write(sb.toString());
381.     }
383.     /**
384.      * Flush underlying stream to writer.
385.      * 
386.      * @throws IOException if bad things happen
387.      */
388.     public void flush() throws IOException {
390.         pw.flush();
392.     } 
394.     /**
395.      * Close the underlying stream writer flushing any buffered content.
396.      *
397.      * @throws IOException if bad things happen
398.      *
399.      */
400.     public void close() throws IOException {
401.         pw.flush();
402.         pw.close();
403.         rawWriter.close();
404.     }
406. }

以下是达人对此API做的测试：
http://blog.csdn.net/lord_is_layuping/archive/2008/02/14/2095766.aspx

我也做了测试，实际上直接调用API中的方法即可，不过还是应该看懂源码，感觉写的不错，对提高水平有很大的帮助，以后在开源项目方面要多看看。。。