Découper champs java Résolu

Question

Bonjour,

voilà, j'ai fait plusieurs recherche sur le net mais je n'arrive pas à trouver mon bonheur...

J'aimerai trouver une fonction java qui me permettrai de fractionner les lignes d'un fichier ISO qui sera ensuite réinjecté dans une BDD MySQL...

Merci pour votre aide

Titfofol

titfofol · Answer

Non mais s'il vous plait aider moi...

Je pense qu'il faut utiliser un StringTokenizer non ?! je n'ai pas encore bien saisie sa notion... a quoi il sert réellement

Titfofol

danimo · Answer

Bonjour,

Il nous faudrait au minimum que tu nous donnes la "structure de la ligne".

L'idée de StringTokenizer est bonne, mais il faut comment on veut éclater la ligne:

exemple:

Si la ligne est de ce type : "mot1 mot2 mot3 mot4";

.......
import java.util.*;
.........

StringTokenizer ligne;

ligne = new StringTokenizer ("mot1 mot2 mot3 mot4");

while (ligne.hasMoreTokens())
System.out.println(ligne.nextToken());

Cordialement,

Dan.

titfofol · Answer

salut danimo,

voila en fait j'ai un fichier en .iso qui représente une mise a jour de ma base de données. comme dans ce fichier il y a des lignes de produit j'aimerai les mettre dans ma bdd.

la forme des ligne sont :

"000001|0000010001|3393767|ALLO..."

les points de suspension c'est parce qu'il y a beaucoup d'autres champs derrière...

chaque ligne du fichier représente une nouvelle ligne d'enregistrement

merci de m'aider...

titfofol

danimo · Answer

Salut,

Pour extraire chaque champ avec donc le "séparateur" | :

  Dans cet exemple, j'affiche les champs dans une ou plusieurs boÎtes de dialogue pouvant contenir chacune au maximum 20 champs (il n'y a pas de "scroll" dans les boÎtes de dialogue.)


  // import java.util.*; // Token

  // Pour portabilite ne pas utiliser 

      String nL1 = System.getProperty("line.separator");
      String nL2 = nL1 + nL1;


         String laLigne = "01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|FIN|";
         String info = "LE RÉSULTAT:" + nL2;
      	
         StringTokenizer unChamp;
      
         unChamp = new StringTokenizer(laLigne, "|"); // le "séparateur" est |
      
         while (unChamp.hasMoreTokens())
         {
            max++;
            if (max > 20)
            {
               max = 1;
               javax.swing.JOptionPane.showMessageDialog(null,info + nL2 + "IL Y A UNE SUITE...");
               info = "LA SUITE DU RÉSULTAT:" + nL2;	
            }
            info+= unChamp.nextToken() + nL1;
         }	
         javax.swing.JOptionPane.showMessageDialog(null,info + nL1 + "FIN DE L'EXTRACTION.");
      
Cordialement,

Dan

titfofol · Answer

*Et si par exemple je doit l'enregistrer dans un arraylist je devrait faire comme ça?! :


StringTokenizer Tok = new StringTokenizer(Mot,"| ");
ArrayList Liste = new ArrayList();
while(Tok.hasMoreTokens( )){
	Liste.add(Tok.nextToken());
}

cordialement

Titfofol

danimo · Answer

StringTokenizer Tok = new StringTokenizer(Mot,"| ");

non;

StringTokenizer Mot = new StringTokenizer(taLigne,"| "); // mot plutot que Mot pour respecter les conventions

danimo · Answer

parceque c'est "taLigne" que tu veux découper en plusieurs "Mot"

titfofol · Answer

non oups j'ai oublié une ligne:


public static void Traitement(String Mot){
	StringTokenizer Tok = new StringTokenizer(Mot,"| ");
	ArrayList Liste = new ArrayList();
	while(Tok.hasMoreTokens( ))
	{
		Liste.add(Tok.nextToken());
		//System.out.println(Tok.nextToken());
	}
}


Bha non c'est pas Mot que je veux découpé bon tu me dira peut etre que je l'ai mal nommé mais bon, c'est Mot que je veux découper en plusieurs mot non?!

donc pour etre plus claire je devrais renommer mer var ce qui donnera :


public static void Traitement(String Ligne){
	StringTokenizer Mot = new StringTokenizer(Ligne,"| ");
	ArrayList Liste = new ArrayList();
	while(Mot.hasMoreTokens( ))
	{
		Liste.add(Mot.nextToken());
		//System.out.println(Mot.nextToken());
	}
}


cordialement

Titfofol

titfofol · Answer

c'est comme ça que je devrais faire?

Titfofol

danimo · Answer

Oui,

C'est la ligne que tu découpes  >>>> new StringTokenizer(Ligne,"| ");
pour obtenir un ou plusieurs "Mot"

si ta méthode Traitement est dans ton programme :

public static void Traitement(){
	StringTokenizer Mot = new StringTokenizer(Ligne,"| ");
	ArrayList Liste = new ArrayList();
	while(Mot.hasMoreTokens( ))
	{
		Liste.add(Mot.nextToken());
		//System.out.println(Mot.nextToken());
	}
}

et tu l'appeles comme ceci:

Traitement();

Cordialement,

Dan

titfofol · Answer

a bon o_o

normalement je ne devrais pas mettre dans les parenthèse quelque chose pour renseigner ma variable Ligne?!

comme Traitement(fichier);

cordialement

Titfofol

danimo · Answer

Non Ligne est connue par la méthode il est donc inutile de passer (Ligne)

Un petit problème quand même, il faut écrire:

Liste.add(Mot); 
 et non
Liste.add(Mot.nextToken());  sinon tu auras un mot sur 2.

danimo · Answer

Une autre remarque:

Il faut bien entendu que Traitement() soit appelée après l'obtention de Ligne.

titfofol · Answer

oui, oui

en fait voila, j'ai une autre procédure qui est lecture est en fait', c'est elle qui ouvre le fichier, ou la Ligne sera stocké.

Le fichier sera lu dans la procédure lecture, puis enregistré dans un arraylist donc...

A mais non maic j'ai oublié une ETAPE!! pff 

alors attends, voilà lorsque j'appelle Traitement, je l'appelle avec une ArrayList c'est mieux peut etre...

Alors faudra que je découpe...

Au la la, ça devient tout confus dans ma tête, à force que je réfléchisse...

tu veux bien m'aider?! pour que ce ne soit plus confus?

cordialement

Titfofol

danimo · Answer

Ok, on respire bien fort...

Bien entendu que je veuxbien t'aider!

tu dis:

"en fait voila, j'ai une autre procédure qui est lecture est en fait', c'est elle qui ouvre le fichier, ou la Ligne sera stocké. "

Bien, à partir de là, tu appèles la methode Traitement comme ceci:

Traitement();
et tu exploites ce que tu as stocké dans Liste.
........
.........

Tu as donc quelque part la methode

public static void Traitement()
{ 
StringTokenizer Mot = new StringTokenizer(Ligne,"|"); 
ArrayList Liste = new ArrayList(); 
while(Mot.hasMoreTokens( )) 
{ 
Liste.add(Mot);
} 
}

titfofol · Answer

Oui,

mais voilà, je me pose plusieurs questions, notament, lorsque j'appelle Traitement c'est mieu de faire passer en paramètre un ArrayList qu'un String non?! ça veux dire qu'il faudrait que j'extrait une ligne de l'arraylist et que je la stock dans une variable de type string. et là je met le code qui est inscrit plus haut c'est ca?!

au fait' voila mon code pour Lecture


public class LectureFichier {
	public static void main(String[] args) {
		//Initialise les variables Chaine et Fichier
		ArrayList Chaine = new ArrayList();
		String Fichier = "T00.ISO";

		//lecture du fichier texte
		try{
		//Ouvre le fichier T00.ISO
		InputStream Ips = new FileInputStream(Fichier);
		//Lit le fichier en séquence
		InputStreamReader Ipsr = new InputStreamReader(Ips);
		BufferedReader Br = new BufferedReader(Ipsr);
		String Ligne;
		while ((Ligne = Br.readLine()) != null){
			System.out.println(Ligne);
			//Chaine += Ligne + "
";
			Chaine.add(Ligne);

		}
		Br.close();
		}
		catch (Exception e){
			System.out.println(e.toString());
		}
	}
}


alors si je fais avec un ArrayList j'appelle Traitement avant la ligne Br.close(); 
et si j'appelle avec un String la je suis obligé de faire tout un truc avant...

En plus il faudra que j'utilise une boucle si c'est avec un String

Cordialement Titfofol

danimo · Answer

Oui puisque tu vas obtenir toutes les lignes .
Et effectivement avant de découper chaque ligne tu la mets dans un String. mais je suppose que mettre les mots extraits dans une autre ArrayList n'est pas nécessaire (pas nécessaire mais pourquoi pas!), tu peux peut-être traiter chaque mot et boucler au tok suivant et quand la liigne est totalement éclatée boucler sur la ligne suivante (donc il te faut une double boucle).

Je vais modifier mon exemple et te le soumettre, mais il faut que je l'écrive et le teste.

titfofol · Answer

attend

j'ai fait plusieurs procédure parce qu'en fait, il faut essayer de les faire aussi si souple que possible pour pouvoir éventuellement les réutiliser dans différents programmes...

normalement après à la fin je devrais avoir trois class une LectureFichier, TraitementFichier et EnregistrementFichier.

A la fin les lignes de code devront être enregistré dans une base de données.

a vrai dire je ne m'y connais pas trop en java mais bon, j'essaye de me débrouiller... ;))

cordialement titfofol

titfofol · Answer

bon c'est bientot l'heure pour moi, je vais bientôt aller ma journée se termine pour aujourd'hui

A demain et bonne soirée

Titfofol

danimo · Answer

Bonjour,

Dans l'exemple suivant, tout est dans ce code, il n'y a pas de classes externes:

   import java.util.*; // Token
    public class EclaterLignes
   {
      // Pour portabilité ne pas utiliser 

      static String nL1 = System.getProperty("line.separator");
      static String nL2 = nL1 + nL1;
      
      // simulation de 3 lignes lues:
      static String ligne1 = "01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|";
      static String ligne2 = "26|27|28|29|30|31|32|33|34|35|36|";
      static String ligne3 = "37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|FIN|";
      static String ligne = "";
      //static ArrayList listeM = new ArrayList(); // il n'y a plus de listeM
      static ArrayList listeL = new ArrayList();
      static int capaciteL;
         
       public static void Traitement()
      {
         for (int i = 0; i < capaciteL; i++)
         {
            ligne = "" + listeL.get(i);
            System.out.println(nL1 + "Les mots de la ligne" + (i+1) + ":");
            StringTokenizer mot = new StringTokenizer(ligne,"|");
            while(mot.hasMoreTokens( ))
            {
                   // ici traitement du mot obtenu
               System.out.println("On traite le mot " + mot.nextToken());
               // peut-etre en appelant une méthode traitementMot();
            }
         }
      }
      
       public static void main (String[] args)
      {
      // simulation des 3 lignes lues:
         listeL.add(ligne1);
         listeL.add(ligne2);
         listeL.add(ligne3);
         
         capaciteL = listeL.size();
         System.out.println(nL1 + ">>>>>>>>>>>>>>>>> nombre de lignes = " + capaciteL + nL2);
         Traitement();
      }
   }

Cordialement,

Dan

titfofol · Answer

Salut,

Merci de ton aide, et excuse moi de ne pas t'avoir répondue un peu plus tôt mais voila j'avais quelque soucie... je vais me penché sérieusement sur ton programme... et j'essaye de comprendre toute les fonction que tu as employé...

Merci encore pour ton aide je te recontacte d'ici peu ;;)

cordialement

titfofol

titfofol · Answer

Salut Danimo,

Merci pour ton aide, finalement je n'ai pas eut le temps afin d'arriver jusque là. Demain mon stage se termine et donc je ne continuerai pas sur ce projet... Et oui, lundi je retourne en cours hélas...

Merci du temps que tu m'as conssacré à la prochaine j'espère

Cordialement

Titfofol

Découper champs java

22 réponses

Votre réponse

Discussions similaires

Newsletters