Lire 1 fichier CSV

Version imprimable

Lire 1 fichier CSV

Bonsoir,

Pour actualiser le stock d'un site web j'ai un code qui utilise 2 variables : reference et quantity situé dans un fichier CSV (sur mon bureau)

J'ai fouillé sur internet et j'ai trouver le code ci-dessous (que j'ai essayé d'adapter) mais il ne fonctionne pas.

Pouvez vous m'indiquer ou je fais erreur ? ou si vous avez un autre code je suis preneur.

Mon objectif est de d'affecter à référence et stock les valeurs de la première ligne du fichier CSV puis de faire tourner une boucle pour passer toute les lignes en revu.

merci pour votre aide
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 import org.apache.poi.hssf.usermodel.HSSFWorkbook; import com.opencsv.CSVReader; import kong.unirest.HttpResponse; import kong.unirest.Unirest; public class Stock { public static void main(String[] args) { // TODO Auto-generated method stub String reference; int stock; final char SEPARATOR = ','; final String RESOURCES_PATH = "C:\Users\DELL\Desktop\disponibilité produit configurable\"; final String stockBoutique = "Import Stock vers boutique wizishop.csv"; File file = new File(RESOURCES_PATH + stockBoutique); FileReader fr; try { fr = new FileReader(file); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } // CSVReader csvReader = new CSVReader(fr, SEPARATOR); System.out.println(fr);

seconde version du code

Bonjour,

J'ai trouvé un second code mais qui ne fonctionne pas. Avez vous une idée ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package projet2;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Paths;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import com.opencsv.CSVReader;
import com.opencsv.CSVReaderBuilder;
import com.opencsv.exceptions.CsvValidationException;
import kong.unirest.HttpResponse;
import kong.unirest.Unirest;
 
public class Stock {
 
	static final String chemin = "C:\\Users\\DELL\\Desktop\\disponibilité produit configurable\\Import Stock vers boutique wizishop.csv";
 
	public static void main(String[] args)  throws IOException {
		// TODO Auto-generated method stub
 
		 try (
		            Reader reader = Files.newBufferedReader(Paths.get(chemin));
		            CSVReader csvReader = new CSVReaderBuilder(reader).withSkipLines(1).build();
		        ) {
		            // Reading Records One by One in a String array
		            String[] nextRecord;
		            try {
						while ((nextRecord = csvReader.readNext()) != null) {
						    System.out.println(nextRecord[0]);
						    System.out.println(nextRecord[1]);
						    System.out.println(nextRecord[2]);
						    System.out.println( nextRecord[3]);
 
						}
					} catch (CsvValidationException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
 
		 }
}
}

Je pense que le plus simple est de regarder:
La javadoc ( http://opencsv.sourceforge.net/apido...CSVReader.html )
Ou ce tutoriel ( https://www.baeldung.com/opencsv )

Pour ma part, je n'ai jamais utilisé opencsv, et Apache POI, c'est pour word/Excel.

Ou mieux, on peut utiliser un code Java pure à base de reader.
Comme je suis feignant, je joins un code d'un TP pour le CNAM qui lisait du CSV.

En CSV, on avait:

Code:

1
2
3
4
5
 
id,nom,prenom,date_naissance
1,De la Fontaine,Jean,08/07/1621
2,Goscinny,René,14/08/1926
3,Uderzo,Albert,25/04/1927

Code:

1
2
3
4
5
 
isbn,titre,auteurs
978-2-253-01004-3,Fables,1
978-2-01-21055-5,Obelix et compagnie,2/3
978-2-01-210147-0,La zizanie,2/3

Et le modèle:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
package question2.bean;
 
import java.util.Date;
import java.util.List;
 
public class Auteur {
 
     private String nom;
     private String prenom;
     private Date dateDeNaissance;
     private List<Livre> livres;
 
     public String getNom() {
          return nom;
          }
 
     public void setNom(String nom) {
          this.nom = nom;
          }
 
     public String getPrenom() {
          return prenom;
          }
 
     public void setPrenom(String prenom) {
          this.prenom = prenom;
          }
 
     public Date getDateDeNaissance() {
          return dateDeNaissance;
          }
 
     public void setDateDeNaissance(Date dateDeNaissance) {
          this.dateDeNaissance = dateDeNaissance;
          }
 
     public List<Livre> getLivres() {
          return livres;
          }
 
     public void setLivres(List<Livre> livres) {
          this.livres = livres;
          }
     }

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
package question2.bean;
 
import java.util.List;
 
public class Livre {
 
     private String titre;
 
     private String isbn;
 
     private List<Auteur> auteurs;
 
     public String getTitre() {
          return titre;
          }
 
     public void setTitre(String titre) {
          this.titre = titre;
          }
 
     public String getIsbn() {
          return isbn;
          }
 
     public void setIsbn(String isbn) {
          this.isbn = isbn;
          }
 
     public List<Auteur> getAuteurs() {
          return auteurs;
          }
 
     public void setAuteurs(List<Auteur> auteurs) {
          this.auteurs = auteurs;
          }
     }

Je lisais à l'aide de:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
package question2.csv;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import question2.bean.Auteur;
import question2.bean.Livre;
import question2.interfaces.AbstractBibliotheque;
 
public class BibliothequeCSV extends AbstractBibliotheque{
 
     private String pathAuteursCSV;
 
     private String pathLivresCSV;
 
     private SimpleDateFormat sdf;
 
     //Auteurs
     private final String ID = "id";
     private final String NOM = "nom";
     private final String PRENOM = "prenom";
     private final String DATE_NAISSANCE = "date_naissance";
     private final String[] AUTEURS_TAB = {ID,NOM,PRENOM,DATE_NAISSANCE};
 
     //Livres
     private final String ISBN = "isbn";
     private final String TITRE = "titre";
     private final String AUTEURS = "auteurs";
     private final String[] LIVRES_TAB = {ISBN,TITRE,AUTEURS};
 
     public BibliothequeCSV(){
          super();
          }
 
     @Override
     public void initialise() throws Exception {
          livres = new ArrayList<Livre>();
          auteurs = new ArrayList<Auteur>();
          Map<Integer,Auteur> mapAuteurs = initialiseAuteurs();
          initialiseLivres(mapAuteurs);
          }
 
 
     private Map<Integer,Auteur> initialiseAuteurs() throws IOException,ParseException{
          Map<Integer,Auteur> mReturn = new HashMap<Integer,Auteur>();
 
          URL url = this.getClass().getResource(pathAuteursCSV);
 
          try(FileReader fr = new FileReader(new File(url.getFile()))){
 
               try(BufferedReader br = new BufferedReader(fr)){
                    int i = 0;
                    String ligne;
                    Map<Integer, String> mapIndex = null;
                    Map<String,String> map;
                    Auteur auteur;
                    while( (ligne = br.readLine()) != null){
                         if(i == 0){
                              mapIndex = readLigneOne(ligne, Arrays.asList(AUTEURS_TAB));
                              }else{
                              map = readLignes(ligne, mapIndex);
                              auteur = new Auteur();
                              auteur.setLivres(new ArrayList<Livre>());
                              auteur.setNom(map.get(NOM));
                              auteur.setPrenom(map.get(PRENOM));
                              auteur.setDateDeNaissance(sdf.parse(map.get(DATE_NAISSANCE)));
                              mReturn.put(Integer.parseInt(map.get(ID)), auteur);
                              auteurs.add(auteur);
                              }
                         i++;
                         }
 
                    }catch(IOException | ParseException e){
                    throw e;
                    }
 
               }catch(IOException | ParseException e){
               throw e;
               }
 
          return mReturn;
          }
 
     private void initialiseLivres(Map<Integer,Auteur> mapAuteurs)throws IOException{
 
          URL url = this.getClass().getResource(pathLivresCSV);
 
          try(FileReader fr = new FileReader(new File(url.getFile()))){
 
               try(BufferedReader br = new BufferedReader(fr)){
                    int i = 0;
                    String ligne;
                    Map<Integer, String> mapIndex = null;
                    Map<String,String> map;
                    Livre livre;
 
                    Auteur auteur;
                    String[] auteurs;
                    Integer id;
 
                    while( (ligne = br.readLine()) != null){
                         if(i == 0){
                              mapIndex = readLigneOne(ligne, Arrays.asList(LIVRES_TAB));
                              }else{
                              map = readLignes(ligne, mapIndex);
                              livre= new Livre();
                              livre.setIsbn(map.get(ISBN));
                              livre.setTitre(map.get(TITRE));
                              livre.setAuteurs(new ArrayList<Auteur>());
 
                              auteurs = map.get(AUTEURS).split("/");
                              for(String a:auteurs){
                                   id = Integer.parseInt(a);
                                   auteur = mapAuteurs.get(id);
                                   auteur.getLivres().add(livre);
                                   livre.getAuteurs().add(auteur);
                                   }
 
                              livres.add(livre);
                              }
                         i++;
                         }
                    }catch(IOException e){
                    throw e;
                    }
 
               }catch(IOException e){
               throw e;
               }
          }
 
     private Map<Integer, String> readLigneOne(String ligne,List<String> list){
          Map<Integer, String> mapReturn = new HashMap<Integer, String>();
          String[] tab = ligne.split(",");
          String a;
          for(Integer index = 0; index < tab.length;index++){
               a = tab[index];
               if(list.contains(a))
                    mapReturn.put(index,a);
               }
 
          return mapReturn;
          }
 
     private Map<String, String> readLignes(String ligne, Map<Integer, String> mapIndex){
          Map<String, String> mapReturn = new HashMap<String, String>();
          String[] tab = ligne.split(",");
          for(Integer i:mapIndex.keySet()){
               mapReturn.put(mapIndex.get(i), tab[i]);
               }
          return mapReturn;
          }
 
 
 
     public void setPathAuteursCSV(String pathAuteursCSV) {
          this.pathAuteursCSV = pathAuteursCSV;
          }
 
     public void setPathLivresCSV(String pathLivresCSV) {
          this.pathLivresCSV = pathLivresCSV;
          }
 
     public void setSdf(SimpleDateFormat sdf) {
          this.sdf = sdf;
          }
 
     }

Qui étendait:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
package question2.interfaces;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
 
import question2.bean.Auteur;
import question2.bean.Livre;
 
public abstract class AbstractBibliotheque implements Bibliotheque{
 
     protected List<Livre> livres;
 
     protected List<Auteur> auteurs;
 
     public AbstractBibliotheque(){
          livres = new ArrayList<Livre>();
          auteurs = new ArrayList<Auteur>();
          }
 
     @Override
     public Livre getLivreByIsbn(String isbn) {
          Livre lReturn = null;
          Iterator<Livre> it = livres.iterator();
          Livre l;
          while(lReturn == null && it.hasNext()){
               l = it.next();
               if(l.getIsbn().equals(isbn))
                    lReturn = l;
               }
          return lReturn;
          }
 
 
     @Override
     public List<Livre> getLivresByAuteur(Auteur auteur) {
          List<Livre> lReturn = new ArrayList<Livre>();
          for(Livre livre:livres){
               for(Auteur a:livre.getAuteurs()) {
                    if(isSameAuteur(auteur, a))
                         lReturn.add(livre);
                    }
               }
          return lReturn;
          }
 
     @Override
     public List<Livre> getLivresByTitre(String titre) {
          List<Livre> lReturn = new ArrayList<Livre>();
          for(Livre livre:livres){
               if(livre.getTitre().equals(titre))
                    lReturn.add(livre);
               }
          return lReturn;
          }
 
     @Override
     public List<Auteur> getAuteurs() {
          return auteurs;
          }
 
     @Override
     public Auteur getAuteur(String nom, String prenom, Date date) {
          Auteur auteurTest = new Auteur();
          auteurTest.setDateDeNaissance(date);
          auteurTest.setNom(nom);
          auteurTest.setPrenom(prenom);
          Iterator<Auteur> it = auteurs.iterator();
          Auteur auteurReturn = null;
          Auteur a;
          while(auteurReturn == null && it.hasNext()){
               a = it.next();
               if(isSameAuteur(a, auteurTest))
                    auteurReturn = a;
               }
 
          return auteurReturn;
          }
 
     private boolean isSameAuteur(Auteur a1,Auteur a2){
          return a1.getNom().equals(a2.getNom()) && a1.getPrenom().equals(a2.getPrenom()) && a1.getDateDeNaissance().equals(a2.getDateDeNaissance());
          }
     }

Tu devrais avoir tout ce qu'il faut.

Je me permets également 2 remarques.

Si tu travailles avec des librairies extérieures, passe par un projet Maven (et je trouve Maven plus simple que Gradle, mais il parait que je fais partie de la minorité).

Grâce à Maven, tu téléchargera sans difficulté les librairies utilisées.
D'ailleurs, dans les liens que je t'ai fourni, baeldung passe par Maven pour télécharger opencsv.

Enfin, un flux (Reader...) doit toujours être fermé. Par pitié, passe par un try-with ressources.
Dans mon code:

Code:

1
2
3
4
 
try(FileReader fr = new FileReader(new File(url.getFile()))){
 
               try(BufferedReader br = new BufferedReader(fr)){

Ou mieux:

Code:

1
2
 
try(FileReader fr = new FileReader(new File(url.getFile()));BufferedReader br = new BufferedReader(fr)){

Le code qui permet de lire des CSV

Bonjour,

J'ai enfin réussi ! Voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
package projet2;
 
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Paths;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import com.opencsv.CSVReader;
import com.opencsv.CSVReaderBuilder;
import com.opencsv.exceptions.CsvValidationException;
import kong.unirest.HttpResponse;
import kong.unirest.Unirest;
 
public class Stock {
 
	final static String chemin= new String("le chemin d'accès de votre fichier csv");
	public static void main(String[] args) throws IOException  {
		// TODO Auto-generated method stub
 
	    CSVReader reader = new CSVReader(new FileReader(chemin));
 
	     String [] nextLine;
	     while ((nextLine = reader.readNext()) != null) {
	        // nextLine[] is an array of values from the line
	       System.out.println(nextLine[0]);
 
 
	     }
 
	        }
	    }

10/08/2020, 16h42
PhilippeGibault
C'est très bien. Néanmoins, selon la javadoc ( http://opencsv.sourceforge.net/apido...CSVReader.html ), CSVReader est un flux (car il est autoclosable entre autre).
Il doit donc impérativement être fermé.

Soit:
Code:

1 2 try( CSVReader reader = new CSVReader(new FileReader(chemin)){
Ne pas fermer les flux, c'est rédhibitoire.

Cordialement.

fermé le flux

Merci pour cette précision mais je vais être honnête. Je n'ai rien compris.
Concernant la documentation Java : Je n'y comprend rien du tout

Donc en fouillant j'ai pondu ce code qui a fonctionné.
J'espère que ça répond à la contrainte de fermer les flux.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 try { CSVReader reader = new CSVReader(new FileReader(chemin)); String [] nextLine; while ((nextLine = reader.readNext()) != null) { // nextLine[] is an array of values from the line // System.out.println(nextLine[0]); String reference = nextLine[0]; String stock = nextLine[1]; System.out.println(reference+","+stock); } }finally {} } }
Bonne nuit

13/08/2020, 14h42
PhilippeGibault
Ce code fonctionne sans doute, mais il est rédhibitoire en milieu professionnel car le flux n'est pas fermé.

Dans des applications réelles, ne pas fermer un flux peut vraiment provoquer des bugs sérieux.

J'ai déjà vu ça d'ailleurs.

Avant Java 7, on faisait comme ça:
Code:

1 2 3 4 5 6 7 8 9 CSVReader reader = null; try{ CSVReader reader = new CSVReader(new FileReader(chemin)); }finally{ if(reader != null){ reader.close(); } }
En général, un try va avec un catch. Le but était de fermer le flux quoi qu'il arrive.

Ce pattern étant fastidieux, Java 7 a introduit les try-with-ressources. Ça a changé ma vie.

On écrit:
Code:

1 2 try( CSVReader reader = new CSVReader(new FileReader(chemin)){
Une fois le code du try exécuté, le programme se charge d'appeler la méthode close().