Development Class Java

  1. Home
  2. Java
  3. Development Class
  4. CSV file writer
/*
 *  Copyright (C) 2010 takaji
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see .
 */
//package dakside.csv;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
 * CSV file writer
 * 
 * @author takaji
 * 
 */
public final class CSVFileWriter {
    protected CSVFormat format;
    protected final BufferedWriter writer;
    int row = 1;
    // 
    public CSVFileWriter(Writer writer) {
        this.writer = new BufferedWriter(writer);
        this.format = new CSVFormat();
    }
    public CSVFileWriter(Writer writer, CSVFormat format)
            throws FileNotFoundException {
        this.writer = new BufferedWriter(writer);
        this.format = format;
    }
    public CSVFileWriter(BufferedWriter writer) {
        this.writer = writer;
        this.format = new CSVFormat();
    }
    public CSVFileWriter(BufferedWriter writer, CSVFormat format)
            throws FileNotFoundException {
        this.writer = writer;
        this.format = format;
    }
    public CSVFileWriter(String filename) {
        try {
            this.writer = new BufferedWriter(new FileWriter(new File(filename)));
            this.format = new CSVFormat();
        } catch (IOException ex) {
            Logger.getLogger(CSVFileWriter.class.getName()).log(Level.SEVERE, null, ex);
            throw new CSVException(ex);
        }
    }
    public CSVFileWriter(File f) {
        try {
            this.writer = new BufferedWriter(new FileWriter(f));
            this.format = new CSVFormat();
        } catch (IOException ex) {
            Logger.getLogger(CSVFileWriter.class.getName()).log(Level.SEVERE, null, ex);
            throw new CSVException(ex);
        }
    }
    public CSVFileWriter(OutputStream input) {
        writer = new BufferedWriter(new OutputStreamWriter(input));
        this.format = new CSVFormat();
    }
    public CSVFileWriter(String filename, CSVFormat format) {
        try {
            this.writer = new BufferedWriter(new FileWriter(filename));
            this.format = format;
        } catch (IOException ex) {
            Logger.getLogger(CSVFileWriter.class.getName()).log(Level.SEVERE, null, ex);
            throw new CSVException(ex);
        }
    }
    public CSVFileWriter(File f, CSVFormat format) throws IOException {
        this.writer = new BufferedWriter(new FileWriter(f));
        this.format = format;
    }
    public CSVFileWriter(OutputStream input, CSVFormat format) {
        writer = new BufferedWriter(new OutputStreamWriter(input));
        this.format = format;
    }
    // 
    /**
     * Write a line to CSV
     *
     * @throws IOException
     */
    public CSVFileWriter writeLine(CSVLine line) throws CSVException {
        if (line == null) {
            return this;
        }
        synchronized (this) {
            // if current line index > 1
            // terminate previous line first
            if (row > 1) {
                carriageReturn();
            }
            if (!line.isEmpty()) {
                // try to write each cell in line
                try {
                    Object[] elements = line.getElements();
                    for (int i = 0; i < elements.length; i++) {
                        // not first element -> write field delimiter
                        if (i > 0) {
                            writer.append(format.getFieldDelimiter());
                        }
                        // write cell content
                        Object cell = elements[i];
                        if (cell != null) {
                            writer.append(escapeString(cell.toString()));
                        } else {
                            writer.append("");
                        }
                        row++;
                    }
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    throw new CSVException(e);
                }
            } else {
                row++;
            }
        }
        return this;
    }
    /**
     * Return carriage
     *
     * @throws IOException
     */
    public CSVFileWriter carriageReturn() throws CSVException {
        try {
            synchronized (writer) {
                writer.append(format.getLineTerminator());
            }
        } catch (IOException e) {
            throw new CSVException("Error while returning carriage.", e);
        }
        return this;
    }
    /**
     * Write a file to underline CSV file
     *
     * @param file
     */
    public void writeFile(CSVFile file) throws CSVException {
        if (file == null) {
            // no need to write
            return;
        }
        CSVLine[] lines = file.getLines();
        synchronized (this) {
            for (int i = 0; i < lines.length; i++) {
                CSVLine line = lines[i];
                writeLine(line);
            }
        }
    }
    /**
     * escape a string with text delimiter if needed
     *
     * @param str
     * @return
     */
    private String escapeString(String str) {
        if (str.indexOf(format.getTextDelimiter()) >= 0
                || str.indexOf(format.getLineTerminator()) >= 0
                || str.indexOf(format.getFieldDelimiter()) >= 0) {
            return format.getTextDelimiter()
                    + str.replace("" + format.getTextDelimiter(), ""
                    + format.getTextDelimiter()
                    + format.getTextDelimiter())
                    + format.getTextDelimiter();
        } else {
            // no need to escape
            return str;
        }
    }
    /**
     * close session
     */
    public void close() {
        try {
            flush();
        } catch (CSVException ex) {
            //do nothing
        }
        try {
            //auto flush
            if (writer != null) {
                writer.close();
            }
        } catch (Exception ex) {
            Logger.getLogger(CSVFileWriter.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    /**
     * Flush buffer to underline stream
     */
    public void flush() {
        try {
            synchronized (writer) {
                writer.flush();
            }
        } catch (Exception ex) {
            Logger.getLogger(CSVFileWriter.class.getName()).log(Level.SEVERE, null, ex);
            throw new CSVException("Cannot flush", ex);
        }
    }
}
class CSVFile {
    private ArrayList lines; //lines inside a CSV file
    /**
     * Default constructor
     */
    public CSVFile() {
        this.lines = new ArrayList();
    }
    public CSVLine[] getLines() {
        return this.lines.toArray(new CSVLine[0]);
    }
    /**
     * Get line at a specified index
     * @param idx
     * @return
     * @throws IndexOutOfBoundsException
     */
    public CSVLine getLine(int idx) throws IndexOutOfBoundsException{
        return this.lines.get(idx);
    }
    /**
     * Add a new line to current csv
     * @return new line object
     */
    public CSVLine newLine() {
        CSVLine line = new CSVLine();
        this.lines.add(line);
        return line;
    }
    /**
     * get number of line
     * @return number of line
     */
    public int size() {
        return this.lines.size();
    }
    /**
     * discard a line at the specified index
     * @param idx
     */
    public void discard(int idx) {
        if (idx >= 0 && idx < size()) {
            this.lines.remove(idx);
        }
    }
    /**
     * discard empty record
     */
    public void discardEmpty() {
        for (int i = this.lines.size() - 1; i > -1; i--) {
            if (this.lines.get(i) == null || this.lines.get(i).isEmpty()) {
                discard(i);
            }
        }
    }
    /**
     * append a CSV line to file (line is ignored if null)
     * @param line
     */
    void append(CSVLine line) {
        if (line == null) {
            return;
        }
        this.lines.add(line);
    }
}
class CSVException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public CSVException() {
    }
    public CSVException(Throwable throwable) {
        super(throwable);
    }
    public CSVException(String message) {
        super(message);
    }
    public CSVException(String message, Throwable throwable) {
        super(message, throwable);
    }
}
class CSVLine {
    private ArrayList elements;
    /**
     * Default constructor
     */
    public CSVLine() {
        this.elements = new ArrayList();
    }
    /**
     * Get all elements (cells) inside a line
     * @return empty String array if there's no element found inside
     */
    public Object[] getElements() {
        return this.elements.toArray();
    }
    /**
     * Get element at index
     * @param idx
     * @return
     * @throws IndexOutOfBoundsException
     */
    public Object getElementAt(int idx) throws IndexOutOfBoundsException {
        return elements.get(idx);
    }
    /**
     * Set element at
     * @param idx
     * @param value
     * @throws IndexOutOfBoundsException
     */
    public void setElementAt(int idx, Object value) throws IndexOutOfBoundsException {
        elements.set(idx, value);
    }
    /**
     * count elements inside this line
     * @return
     */
    public int size() {
        return elements.size();
    }
    /**
     * Add a new element
     */
    public CSVLine add(Object obj) {
        this.elements.add(obj);
        return this;
    }
    /**
     * if CSV line is empty
     * @return
     */
    public boolean isEmpty() {
        return this.elements.isEmpty();
    }
    /**
     * Remove all elements
     */
    public void clear() {
        this.elements.clear();
    }
    /**
     * Remove element at a specified index
     * @param idx
     * @throws IndexOutOfBoundsException
     */
    public void remove(int idx) throws IndexOutOfBoundsException {
        elements.remove(idx);
    }
    /**
     * Trim down or expand with null cell to a new length
     * @param newLength
     */
    public void setLength(int newLength) {
        if (elements.size() > newLength) {
            //trim down
            while (elements.size() > newLength) {
                elements.remove(elements.size() - 1);
            }
        } else {
            //add more
            while (elements.size() < newLength) {
                add(null);
            }
        }
    }
}
class CSVFormat {
    private String charset;
    private char fieldDelimiter;
    private char textDelimiter;
    private char lineTerminator;
    private char[] ignoreCharacters;
    /**
     * Construct a standard CSV format
     */
    public CSVFormat() {
        this.setCharset("UTF-8");
        this.setFieldDelimiter(',');
        this.setTextDelimiter('"');
        //auto detect line separator
        String s = System.getProperty("line.separator");
        if (s.length() > 0) {
            this.setLineTerminator(s.charAt(0));
            char[] ignoreChars = new char[s.length() - 1];
            for (int i = 1; i < s.length(); i++) {
                ignoreChars[i-1] = s.charAt(i);
            }
            this.setIgnoreCharacters(ignoreChars);
        } else {
            this.setLineTerminator('\n');
            this.setIgnoreCharacters(new char[]{'\r'});
        }
    }
    /**
     * @param lineTerminator
     *            the lineTerminator to set
     */
    public void setLineTerminator(char lineTerminator) {
        this.lineTerminator = lineTerminator;
    }
    /**
     * @return the lineTerminator
     */
    public char getLineTerminator() {
        return lineTerminator;
    }
    /**
     * @param ignoreCharacters
     *            the ignoreCharacters to set
     */
    public void setIgnoreCharacters(char[] ignoreCharacters) {
        this.ignoreCharacters = ignoreCharacters;
    }
    /**
     * @return the ignoreCharacters
     */
    public char[] getIgnoreCharacters() {
        return ignoreCharacters;
    }
    /**
     * @param charset
     *            the charset to set
     */
    public void setCharset(String charset) {
        this.charset = charset;
    }
    /**
     * @return the charset
     */
    public String getCharset() {
        return charset;
    }
    /**
     * @param fieldDelimiter
     *            the fieldDelimiter to set
     */
    public void setFieldDelimiter(char fieldDelimiter) {
        this.fieldDelimiter = fieldDelimiter;
    }
    /**
     * @return the fieldDelimiter
     */
    public char getFieldDelimiter() {
        return fieldDelimiter;
    }
    /**
     * @param textDelimiter
     *            the textDelimiter to set
     */
    public void setTextDelimiter(char textDelimiter) {
        this.textDelimiter = textDelimiter;
    }
    /**
     * @return the textDelimiter
     */
    public char getTextDelimiter() {
        return textDelimiter;
    }
    /**
     * is ignored characters
     * @param c
     * @return
     */
    public boolean isIgnored(char c) {
        return Arrays.binarySearch(ignoreCharacters, c) >= 0;
    }
}