Les fichiers CSV avec Java

public class CsvFileHelper {

    public static String getResourcePath(String fileName) {
       final File f = new File("");
       final String dossierPath = f.getAbsolutePath() + File.separator + fileName;
       return dossierPath;
   }

   public static File getResource(String fileName) {
       final String completeFileName = getResourcePath(fileName);
       File file = new File(completeFileName);
       return file;
   }
}

private final static String FILE_NAME = "src/test/resources/chien-test-01.csv";

@Test
public void testGetResource() {
    // Param
    final String fileName = FILE_NAME;

    // Result
    // ...

    // Appel
    final File file = CsvFileHelper.getResource(fileName);

    // Test
    // On sait que le fichier existe bien puisque c'est avec lui qu'on travaille depuis le début.
    assertTrue(file.exists());
}

public class CsvFileHelper {

    public static List<String> readFile(File file) {

        List<String> result = new ArrayList<String>();

        FileReader fr = new FileReader(file);
        BufferedReader br = new BufferedReader(fr);

        for (String line = br.readLine(); line != null; line = br.readLine()) {
            result.add(line);
        }

        br.close();
        fr.close();

        return result;
    }

    ...
}

@Test
public void testReadFile() {
    // Param
    final String fileName = FILE_NAME;

    // Result
    final int nombreLigne = 11;

    // Appel
    final File file = CsvFileHelper.getResource(fileName);
    List<String> lines = CsvFileHelper.readFile(file);

    // Test
    Assert.assertEquals(nombreLigne, lines.size());
}

public interface CsvFile {

    File getFile();

    List<String[] > getData();
}

public class CsvFile01 implements CsvFile {

    public final static char SEPARATOR = ',';

    private File file;
    private List<String> lines;
    private List<String[] > data;

    private CsvFile01() {
    }

    public CsvFile01(File file) {
        this.file = file;

        // Init
        init();
    }

    private void init() {
        lines = CsvFileHelper.readFile(file);

        data = new ArrayList<String[] >(lines.size());
        String sep = new Character(SEPARATOR).toString();
        for (String line : lines) {
            String[] oneData = line.split(sep);
            data.add(oneData);
        }
    }

    // GETTERS ...
    }

public class CsvFile01Test {

    private static final String FILE_NAME = "src/test/resources/chien-test-01.csv";
    private static File file;

    @BeforeClass
    public static void beforeClass() {
        file = CsvFileHelper.getResource(FILE_NAME);
    }

    @Test
    public void testFile() {

        // Appel
        final CsvFile csvFile = new CsvFile01(file);
        final File f = csvFile.getFile();

        // Test
        assertEquals(file, f);
    }

    @Test
    public void testCsvFile() {

        // Result
        final int nombreLigne = 11;

        // Appel
        final CsvFile01 csvFile01 = new CsvFile01(file);
        final List<String> lines = csvFile01.getLines();

        // Test
        assertEquals(nombreLigne, lines.size());
    }

    @Test
    public void testData() {

        // Result
        final int nombreLigne = 11;
        final int nombreColonnes = 4;

        // Appel
        final CsvFile csvFile = new CsvFile01(file);
        final List<String[] > data = csvFile.getData();

        // Test
        assertEquals(nombreLigne, data.size());

        for (String[] oneData : data) {
            assertEquals(nombreColonnes, oneData.length);
        }

    }
}

public interface Chien {
    Integer getId();

    String getPrenom();

    String getCouleur();

    Integer getAge();
}

public class SimpleChien implements Chien {

    private Integer id;
    private String prenom;
    private String couleur;
    private Integer age;

    @Override
    public String toString() {
        return prenom + "(" + id + ")";
    }

    // plus GETTERS / SETTERS 
    ...
}

public interface ChienDao {

    List<Chien> findAllChiens();
}

public class CsvChienDao1 implements ChienDao{

    @Override
    public List<Chien> findAllChiens() {

        List<Chien> chiens = new ArrayList<Chien>();

        // Du code ici...

        return chiens;
    }
}

public class CsvChienDao1 implements ChienDao {

    private File file;
    private CsvFile csvFile;

    private CsvChienDao1() {
        super();
    }

    public CsvChienDao1(File file) {
        this();
        this.file = file;
        this.csvFile = new CsvFile01(file);
    }

    ...

@Override
public List<Chien> findAllChiens() {

    List<Chien> chiens = new ArrayList<Chien>();

    List<String[]> data = csvFile.getData();
    for(String[] oneData : data) {
        Chien chien = tabToChien(oneData);
        chiens.add(chien);
    }

    return chiens;
}

private Chien tabToChien(String[] tab) {
    SimpleChien chien = new SimpleChien();

    chien.setId(Integer.parseInt(tab[0]));
    chien.setPrenom(tab[1]);
    chien.setCouleur(tab[2]);
    chien.setAge(Integer.parseInt(tab[3]));

    return chien;
}

@Override
public List<Chien> findAllChiens() {

    final List<Chien> chiens = new ArrayList<Chien>();

    final List<String[]> data = csvFile.getData();
    final List<String[]> dataSansTitre = data; // juste data
    dataSansTitre.remove(0);

    for(String[] oneData : dataSansTitre) {
        final Chien chien = tabToChien(oneData);
        chiens.add(chien);
    }

    return chiens;

}

public class CsvChienDao1Test {

    private static final String FILE_NAME = "src/test/resources/chien-test-01.csv";
    private static File file;
    private static ChienDao chienDao;

    @BeforeClass
    public static void beforeClass() {
        file = CsvFileHelper.getResource(FILE_NAME);
        chienDao = new CsvChienDao1(file);
    }

    @Test
    public void testFindAllChiens() {

        // Param
        // ...

        // Result
        final int nombreChien = 10;

        // Appel
        List<Chien> chiens = chienDao.findAllChiens();

        // Test
        assertEquals(nombreChien, chiens.size());
    }

    @Test
    public void testIdefix() {
        // Param
        final String prenom = "Idefix";

        // Result
        final Integer id = 8;

        // Appel
        List<Chien> chiens = chienDao.findAllChiens();
        Chien idefix = null;

        for (Chien chien : chiens) {
            if (chien.getPrenom().equals(prenom)) {
                idefix = chien;
                break;
            }
        }

        // Test
        assertNotNull(idefix);
        assertEquals(id, idefix.getId());
    }
}

public class CsvFile04 implements CsvFile {

    public final static char DEFAULT_SEPARATOR = ',';

    private char separator = DEFAULT_SEPARATOR;

    private File file;
    private List<String> lines;
    private List<String[] > data;
    private String[] titles;
    private List<Map<String, String>> mappedData;

    private CsvFile04() {
    }

    public CsvFile04(File file) {
        this(file, DEFAULT_SEPARATOR);
    }

    public CsvFile04(File file, char separator) {

        this.file = file;
        this.separator = separator;

        // Init
        init();
    }

    private void init() {
        lines = CsvFileHelper.readFile(file);

        data = new ArrayList<String[] >(lines.size());
        String regex = new Character(separator).toString();
        boolean first = true;
        for (String line : lines) {
            ...
        }

        mapData();
    }

    ...
}

    public final static List<Character> AVAILABLE_SEPARATORS = Collections.unmodifiableList(new ArrayList<Character>(
            Arrays.asList(',', ';', '\t', '|')));

    private boolean isValidSeparator(char separator) {
        return AVAILABLE_SEPARATORS.contains(separator);
    }

    public CsvFile04(File file, char separator) {

        if (file == null) {
            throw new IllegalArgumentException("Le fichier file ne peut pas être null");
        }
        this.file = file;

        if(!isValidSeparator(separator)) {
            throw new IllegalArgumentException("Le séparateur spécifié n'est pas pris en charge.");
        }
        this.separator = separator;

        // Init
        init();
    }

public class CsvFile04Test {

    private static final String FILE_NAME = "src/test/resources/chien-test-04.csv";
    private static File file;

    @BeforeClass
    public static void beforeClass() {
        file = CsvFileHelper.getResource(FILE_NAME);
    }

    ...

    @Test(expected = IllegalArgumentException.class)
    public void testIllegalSeparator() {
        // Param
        final char separator = '-';

        // Result
        // ...

        // Appel
        final CsvFile csvFile = new CsvFile04(file, separator);
    }

    @Test
    public void testMappedData() {

        // Param
        final char separator = ';';

        // Result
        final int nombreLigne = 10;
        final int nombreColonnes = 4;

        // Appel
        final CsvFile csvFile = new CsvFile04(file, separator);
        final List<Map<String, String>> mappedData = csvFile.getMappedData();

        // Test
        assertEquals(nombreLigne, mappedData.size());

        for (Map<String, String> oneMappedData : mappedData) {
            assertEquals(nombreColonnes, oneMappedData.size());
        }
    }

}

public class CsvChienDao4 implements ChienDao {

    public final static char FRENCH_SEPARATOR = ';';

    private CsvFile csvFile;

    public CsvChienDao4(File file) {

        if (file == null) {
            throw new IllegalArgumentException("Le fichier file ne peut pas être null");
        }

        this.csvFile = new CsvFile04(file, FRENCH_SEPARATOR);
    }

    ...

}

public class CsvChienDao4Test {

    private static final String FILE_NAME = "src/test/resources/chien-test-04.csv";
    private static File file;
    private static ChienDao chienDao;

    @BeforeClass
    public static void beforeClass() {
        file = CsvFileHelper.getResource(FILE_NAME);
        chienDao = new CsvChienDao4(file);
    }

    ...

    @Test
    public void testFindAllChiens() {

        // Param
        // ...

        // Result
        final int nombreChien = 10;

        // Appel
        List<Chien> chiens = chienDao.findAllChiens();
        for (Chien chien : chiens) {
            System.out.println(chien);
        }
        // --> Titi(1)
        // --> Médor(2)
        // --> Pitié(3)
        // --> Juju(4)
        // --> Vanille(5)
        // --> Chocolat(6)
        // --> Milou(7)
        // --> Idefix(8)
        // --> Pluto(9)
        // --> Dingo(10)

        // Test
        assertEquals(nombreChien, chiens.size());
    }

    ...
}

public class CsvFile05 implements CsvFile {

    public final static char DEFAULT_SEPARATOR = ',';

    public final static List<Character> AVAILABLE_SEPARATORS = Collections.unmodifiableList(new ArrayList<Character>(
            Arrays.asList(',', ';', '\t', '|')));

    private boolean autoDetectSeparatorMode = false;
    private int numberOfLinesForAutoDetectSeparator = 5;
    private char separator = DEFAULT_SEPARATOR;

    private List<String> lines;
    private List<String> cleanedLines;
    ...

    public CsvFile05(File file) {
        this(file, DEFAULT_SEPARATOR);
    }

    public CsvFile05(File file, char separator) {
        this(file, separator, false);
    }

    public CsvFile05(File file, char separator, boolean autoDetectSeparatorMode) {

        if (file == null) {
            throw new IllegalArgumentException("Le fichier file ne peut pas être null");
        }

        this.file = file;

        if (!autoDetectSeparatorMode) {
            if (!isValidSeparator(separator)) {
                throw new IllegalArgumentException("Le séparateur spécifié n'est pas pris en charge.");
            }
            this.separator = separator;
        }

        this.autoDetectSeparatorMode = autoDetectSeparatorMode;

        // Init
        init();
    }

    public Character selectBestSeparator() {

        if (lines.size() == 0) {
            // Exception ?...
        }

        // Ajustement du nombre de lignes dispo
        if (cleanedLines.size() < numberOfLinesForAutoDetectSeparator) {
            numberOfLinesForAutoDetectSeparator = cleanedLines.size();
        }

        List<Character> reste = new ArrayList<Character>();

        for (Character separator : AVAILABLE_SEPARATORS) {
            int previous = 0;
            boolean isGoodCandidate = false;
            for (int i = 0; i < numberOfLinesForAutoDetectSeparator; i++) {
                int compte = compterSeperateurs(cleanedLines.get(i), separator);
                if (compte == 0) {
                    // pas de séparateur dans cette ligne
                    isGoodCandidate = false;
                    break;
                }
                if (compte != previous && previous != 0) {
                    // pas le même nombre de séparateurs que la ligne précédente
                    isGoodCandidate = false;
                    break;
                }

                previous = compte;
                isGoodCandidate = true;
            }
            if (isGoodCandidate) {
                reste.add(separator);
            }
        }

        if (reste.isEmpty()) {
            // Exception ? aucun candidat
        }

        if (1 < reste.size()) {
            // Exception ? trop de candidats
        }

        return reste.get(0);

    }

    public int compterSeperateurs(String line, char separator) {
        int number = 0;

        int pos = line.indexOf(separator);
        while (pos != -1) {
            number++;
            line = line.substring(pos + 1);
            pos = line.indexOf(separator);
        }
        return number;
    }

    private boolean isValidSeparator(char separator) {
        return AVAILABLE_SEPARATORS.contains(separator);
    }

    private void init() {
        lines = CsvFileHelper.readFile(file);

        cleanedLines = new ArrayList<String>();
        for (String line : lines) {
            // Suppression des espaces de fin de ligne
            line = line.trim();

            // On saute les lignes vides
            if (line.length() == 0) {
                continue;
            }

            // On saute les lignes de commentaire
            if (line.startsWith("#")) {
                continue;
            }

            cleanedLines.add(line);
        }

        if (autoDetectSeparatorMode) {
            this.separator = selectBestSeparator();
        }

        data = new ArrayList<String[] >(cleanedLines.size());
        String regex = new Character(separator).toString();
        boolean first = true;
        for (String line : cleanedLines) {
            ...
        }

        mapData();
    }
...
}

private static final String FILE_NAME = "src/test/resources/chien-test-04.csv";

@BeforeClass
public static void beforeClass() {
    file = CsvFileHelper.getResource(FILE_NAME);
}

@Test
public void testCompterSeperateurs() {

    // Param
    final char separator = ',';
    final String line = "1,Titi,Jaune,5";

    // Result
    final int nombre = 3;

    // Appel
    final CsvFile05 csvFile = new CsvFile05(file, separator, true);
    final int compte = csvFile.compterSeperateurs(line, separator);

    // Test
    assertEquals(nombre, compte);

}

@Test
public void testSelectBestSeparator() {
    // Param
    // ..

    // Result
    final Character separator = ';';

    // Appel
    final CsvFile05 csvFile = new CsvFile05(file, separator, true);
    final Character separatorCalcule = csvFile.selectBestSeparator();

    // Test
    assertEquals(separator, separatorCalcule);

}


@Test
public void testMappedData() {

    // Param
    final char separator = ';';

    // Result
    final int nombreLigne = 10;
    final int nombreColonnes = 4;

    // Appel
    final CsvFile csvFile = new CsvFile05(file, separator, true);
    final List<Map<String, String>> mappedData = csvFile.getMappedData();

    // Test
    assertEquals(nombreLigne, mappedData.size());

    for (Map<String, String> oneMappedData : mappedData) {
        assertEquals(nombreColonnes, oneMappedData.size());
    }
}

public class CsvFile06 implements CsvFile {
    ...

    public Character selectBestSeparator() {

        if (cleanedLines.size() < 2) {
            // Exception ?...
        }

        for (Character separator : AVAILABLE_SEPARATORS) {
            final String ligneTitre = cleanedLines.get(0);
            final String ligne1 = cleanedLines.get(1);

            final int compteLigneTitre = compterSeperateurs(ligneTitre, separator);
            final int compteLigne1 = compterSeperateurs(ligne1, separator);

            if (compteLigneTitre == 0 || compteLigne1 == 0) {
                continue;
            }

            if (compteLigneTitre == compteLigne1) {
                return separator;
            }
        }

        return null;
    }

    ...

# Titres id; Prénom; Couleur et Age.
Id;Prénom;Couleur;Age

# Titi a une couleur avec doubles guillemets
1;Titi;"Jaune ""bizarre"" et noir";5

2;Médor;Noir;10
3;Pitié;Noir;5
4;Juju;Gris;5
5;Vanille;Blanc;7
6;Chocolat;Marron;12
7;Milou;Blanc;3

# La ligne suivante (Idefix) a trois couleurs avec un point-virgule dedans
8;Idefix;"Blanc; noir et beige";14

9;Pluto;Jaune;17
10;Dingo;Roux;1

public class CsvFile08 extends AbstractAdvanceCsvFile {

    ...

    private void init() {
        lines = CsvFileHelper.readFile(file);

        cleanLines();

        data = new ArrayList<String[] >(cleanedLines.size());

        final String regex = "(^|(?<=" + separator + "))([^\"" + separator + "])*((?=" + separator
                + ")|$)|((?<=^\")|(?<=" + separator + "\"))([^\"]|\"\")*((?=\"" + separator + ")|(?=\"$))";
        Pattern p = Pattern.compile(regex);
        boolean first = true;
        for (String line : cleanedLines) {
            Matcher m = p.matcher(line);

            List<String> temp = new ArrayList<String>();
            while (m.find()) {
                String value = m.group();
                value = value.replaceAll("\"\"", "\"");
                temp.add(value);
            }

            String[] oneData = listToArray(temp);
            if (first) {
                titles = oneData;
                first = false;
            } else {
                data.add(oneData);
            }
        }

        mapData();
    }

    ...
}

# Titres id; Prénom; Couleur et Age.
Id;Prénom;Couleur;Age

# Titi a une couleur avec doubles guillemets
1;Titi;"Jaune ""bizarre""";5

2;Médor;Noir;10
3;Pitié;Noir;5
4;Juju;Gris;5
5;Vanille;Blanc;7
6;Chocolat;Marron;12

# Le prénom de Milou est sur plusieurs lignes
7;"Milou
Chien de Tintin
Ami du Capitaine Addock";Blanc;3

# La ligne suivante (Idefix) a trois couleurs avec un point-virgule dedans
8;Idefix;"Blanc; noir et beige";14

9;Pluto;Jaune;17
10;Dingo;Roux;1

public static String readFullFile(File file) {
        StringBuilder sb = new StringBuilder();

        FileReader reader = new FileReader(file);

        char[] buffer = new char[2048];
        int nb = 0;
        while ((nb = reader.read(buffer)) > 0) {
            sb.append(buffer, 0, nb);
        }

        reader.close();

        return sb.toString();
    }

public static String readFullFile(File file) {
        final List<String> lines = CsvFileHelper.readFile(file);

        StringBuilder sb = new StringBuilder();

        for(String line : lines) {
            sb.append(line);
            sb.append("\n");     // pour recréer le retour à la ligne
        }

        return sb.toString();
    }

public List<String[] > readFileAsStringThenTab(File file) {
    final String str = readFullFile(file);

    for(int i = 0; i < str.length(); i++) {
        char c = str.charAt(i);

        // ici traiter le char c...
        processChar(c);
    }
}

    ...

    reader = new FileReader(file);
    for(char c = (char) reader.read(); c != '\0'; c = (char) reader.read() ) {
        // ici traiter le char c...
        processChar2(c);
    }

    ...

public interface ChienDao {

    List<Chien> findAllChiens();

    Chien findChienById(Integer id);
}

public abstract class AbstractChienDao implements ChienDao {

    protected CsvFile csvFile;

    private Map<Integer, Chien> chiensMap;
    private List<Chien> chiens;

    protected Chien tabToChien(String[] tab) {

        if (tab == null) {
            throw new IllegalArgumentException("Le tableau ne peut pas être null");
        }

        final SimpleChien chien = new SimpleChien();

        chien.setId(Integer.parseInt(tab[0]));
        chien.setPrenom(tab[1]);
        chien.setCouleur(tab[2]);
        chien.setAge(Integer.parseInt(tab[3]));

        return chien;
    }

    protected Chien mapToChien(Map<String, String> map) {
        if (map == null) {
            throw new IllegalArgumentException("La Map ne peut pas être null");
        }

        final SimpleChien chien = new SimpleChien();

        final String id = map.get("Id");
        final String prenom = map.get("Prénom");
        final String couleur = map.get("Couleur");
        final String age = map.get("Age");

        chien.setId(Integer.parseInt(id));
        chien.setPrenom(prenom);
        chien.setCouleur(couleur);
        chien.setAge(Integer.parseInt(age));

        return chien;
    }

    protected List<Chien> findAllChiensByMap() {
        if (chiens == null) {
            init();
        }

        return chiens;
    }

    public Chien findChienById(Integer id) {
        if (chiensMap == null) {
            init();
        }

        return chiensMap.get(id);
    }

    protected void init() {
        final List<Map<String, String>> mappedData = csvFile.getMappedData();

        // On init avec la bonne taille
        chiens = new ArrayList<Chien>(mappedData.size()); 
        chiensMap = new HashMap<Integer, Chien>();

        for (Map<String, String> map : mappedData) {
            final Chien chien = mapToChien(map);
            chiens.add(chien);
            chiensMap.put(chien.getId(), chien);
        }
    }
}

public class CsvChienDao10 extends AbstractChienDao implements ChienDao {

    private CsvChienDao10() {
    }

    public CsvChienDao10(File file) {
        if (file == null) {
            throw new IllegalArgumentException("Le fichier file ne peut pas être null");
        }

        this.csvFile = new CsvFile06(file, ';', true);
    }

    @Override
    public List<Chien> findAllChiens() {
        return findAllChiensByMap();
    }
}

public class CsvChienDao10Test {
    private static final String FILE_NAME = "src/test/resources/chien-test-04.csv";
    private static File file;
    private static ChienDao chienDao;

    @BeforeClass
    public static void beforeClass() {
        file = CsvFileHelper.getResource(FILE_NAME);
        chienDao = new CsvChienDao10(file);
    }

    @Test
    public void testFindAllChiens() {

        // Param
        // ...

        // Result
        final int nombreChien = 10;

        // Appel
        List<Chien> chiens = chienDao.findAllChiens();
        for (Chien chien : chiens) {
            System.out.println(chien);
        }
        // --> Titi(1)
        // --> Médor(2)
        // --> Pitié(3)
        // --> Juju(4)
        // --> Vanille(5)
        // --> Chocolat(6)
        // --> Milou(7)
        // --> Idefix(8)
        // --> Pluto(9)
        // --> Dingo(10)

        // Test
        assertEquals(nombreChien, chiens.size());
    }

    @Test
    public void testFindById() {
        // Param
        final Integer id = 8;

        // Result
        final String prenom = "Idefix";

        // Appel
        Chien chien = chienDao.findChienById(id);
        System.out.println(chien);
        // --> Idefix(8)

        // Tests
        assertEquals(prenom, chien.getPrenom());
    }
}

public class CsvChienDao10AvecPreInit extends AbstractChienDao implements ChienDao {

    public CsvChienDao10AvecPreInit(File file) {

        ...
        this.csvFile = new CsvFile06(file, ';', true);

        init(); // Initialisation dès le constructeur
    }

    ...
}

<dependency>
    <groupId>net.sf.opencsv</groupId>
    <artifactId>opencsv</artifactId>
    <version>2.0</version>
</dependency>

mvn clean install eclipse:eclipse

public class CsvFile12 extends AbstractAdvanceCsvFile {

    private CSVReader reader;

    private CsvFile12() {
    }

    public CsvFile12(File file) {
        this(file, DEFAULT_SEPARATOR);
    }

    public CsvFile12(File file, char separator) {

        this.file = file;
        this.separator = separator;

        // Init
        init();
    }

    private void init() {
        reader = new CSVReader(new FileReader(file), separator);
        data = new ArrayList<String[] >();

        String[] nextLine;
        while ((nextLine = reader.readNext()) != null) {
            final int size = nextLine.length;
            if(size == 0) {
                continue;
            }

            String debut = nextLine[0].trim();
            if(debut.length() == 0 && size == 1 ) {
                continue;
            }
            if(debut.startsWith("#")) {
                continue;
            }
            data.add(nextLine);
        }


        titles = data.get(0);
        data.remove(0);

        mapData();
    }

    ...

}

private static final String FILE_NAME = "src/test/resources/chien-test-11.csv";

@Test
public void testMappedData() {

    // Param
    final char separator = ';';

    // Result
    final int nombreLigne = 11;
    final int nombreColonnes = 4;

    // Appel
    final CsvFile csvFile = new CsvFile12(file, separator);
    final List<Map<String, String>> mappedData = csvFile.getMappedData();
    // List<String[] > data = csvFile.getData();

    // Test
    assertEquals(nombreLigne, mappedData.size());

    for (Map<String, String> oneMappedData : mappedData) {
        assertEquals(nombreColonnes, oneMappedData.size());
    }
}

@Test
public void testTitles() {

    // Param
    final char separator = ';';

    // Result
    String[] wantedTitles = { "Id", "Prénom", "Couleur", "Age" };

    // Appel
    final CsvFile csvFile = new CsvFile12(file, separator);
    final String[] titles = csvFile.getTitles();
    for (String title : titles) {
        System.out.println(title);
    }

    // Test
    for (int i = 0; i < wantedTitles.length; i++) {
        assertEquals(wantedTitles[i], titles[i]);
    }
}

public class DatabaseChienDao implements ChienDao {

    @Override
    public List<Chien> findAllChiens() {

        final List<Chien> chiens = new ArrayList<Chien>();

        Connection con = null;
        Statement statement = null;

        try {
            Class.forName("oracle.jdbc.driver.OracleDriver");

            // (2)
            con = DriverManager.getConnection("monUrl", "monLogin", "monPassword");
            // (3)
            String sql = "SELECT * FROM chien ";

            // (4)
            statement = con.createStatement();

            // (5)
            ResultSet rs = statement.executeQuery(sql);

            while (rs.next()) {
                final Chien chien = rsetToChien(rs);
                chiens.add(chien);
            }

        } catch (Exception e) {
            // ...
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
                if (con != null) {
                    con.close();
                }
            } catch (Exception e) {
                // ...
            }
        }

        return chiens;
    }

    private Chien rsetToChien(ResultSet rs) {
        if (rs == null) {
            throw new IllegalArgumentException("Le resultset ne peut pas être null");
        }

        final SimpleChien chien = new SimpleChien();

        try {
            final Integer id = rs.getInt("id");
            final String prenom = rs.getString("prenom");
            final String couleur = rs.getString("color_poil");
            final Integer age = rs.getInt("age");

            chien.setId(id);
            chien.setPrenom(prenom);
            chien.setCouleur(couleur);
            chien.setAge(age);

        } catch (Exception e) {
            // ...
        }

        return chien;
    }

}

public class CsvFileHelper {

    public static List<String> readFile(File file) {

        if (file == null) {
            throw new IllegalArgumentException("Le fichier ne peut pas être null");
        }

        if (!file.exists()) {
            throw new IllegalArgumentException("Le fichier " + file.getName() + " n'existe pas.");
        }

        final List<String> result = new ArrayList<String>();

        FileReader fr = null;
        BufferedReader br = null;

        try {
            fr = new FileReader(file);
            br = new BufferedReader(fr);

            for (String line = br.readLine(); line != null; line = br.readLine()) {
                result.add(line);
            }

        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

        return result;
    }

    ...
}

public class CsvChienDao1WithSingleton implements ChienDao {

    private File file;

    private CsvFile csvFile;

    private static CsvChienDao1WithSingleton instance;

    private CsvChienDao1WithSingleton() {
    }

    private CsvChienDao1WithSingleton(File file) {
        this.file = file;
        this.csvFile = new CsvFile01(file);
    }

    private static void init(File file) {
        instance = new CsvChienDao1WithSingleton(file);
    }

    public static synchronized CsvChienDao1WithSingleton getInstance(File file) {

        if (instance == null) {
            init(file);
        } else {
            final String oldFileName = instance.getFile().getAbsolutePath();
            final String newFileName = file.getAbsolutePath();
            if (!oldFileName.equals(newFileName)) {
                // Si on demande un nouveau fichier
                init(file);
            }
        }

        return instance;
    }

    @Override
    public List<Chien> findAllChiens() {
        ...
    }

    private Chien tabToChien(String[] tab) {
        ...
    }

    public File getFile() {
        return file;
    }

    public void setFile(File file) {
        this.file = file;
    }

}

public class CsvChienDao1WithSingletonTest {

    ...

    @BeforeClass
    public static void beforeClass() {
        file = CsvFileHelper.getResource(FILE_NAME);
        chienDao = CsvChienDao1WithSingleton.getInstance(file);
    }

    ...
}

public class CsvChienDao1WithSingletonMultiFile implements ChienDao {

    private CsvFile csvFile;

    private static Map<String, CsvChienDao1WithSingletonMultiFile> instanceMap 
                              = new HashMap<String, CsvChienDao1WithSingletonMultiFile>();

    private CsvChienDao1WithSingletonMultiFile() {
    }

    private CsvChienDao1WithSingletonMultiFile(File file) {
        this.csvFile = new CsvFile01(file);
    }

    private static void init(File file) {
        CsvChienDao1WithSingletonMultiFile instance = new CsvChienDao1WithSingletonMultiFile(file);
        instanceMap.put(file.getgetAbsolutePath(), instance);
    }

    public static synchronized CsvChienDao1WithSingletonMultiFile getInstance(File file) {

        CsvChienDao1WithSingletonMultiFile instance = instanceMap.get(file.getName());
        if (instance == null) {
            init(file);
        }

        return instance;
    }

    ...
}

    public final static Set<Character> AVAILABLE_SEPARATORS_AS_SET = Collections.unmodifiableSet(new LinkedHashSet<Character>(
            Arrays.asList(',', ';', '\t', '|')));