SOS programmation java

[vinc'03]

Bonjour,
alors voila, la j'ai un probleme que je ne sais pas resoudre, mais alors pas du tout (bon en meme temps jsuis débutant..)
Je fais un programme pour décomposer un fichier, et utiliser ses données.
Donc en fait j'ai un fichier de terrains, avec formes, dimensions, lieu ou ils se trouvent avec des references de proprietaires;
Ensuite j'ai un fichier avec les tarifs du metre carré selon le lieu.
Le but est d'afficher les biens de chaque proprietaire sachant que un mm proprietaire peut avoir plusieurs terrains dan sdifferents lieux.
Bref tout va bien, le proramme s'execute sans probleme,mais quand je demande de l'afficher, il m'affiche deux fois le meme proprietaire et m'en oublie un...(avec la premiere fois la bonne surface et la seconde, la surface de celui qui manque )
donc je ne sais pas comment faire.
J'ai essayé de localiser le probleme, on dirait qu'il ne lit pas le proprietaire manquant...
donc concernant les proprio ca donne:
reference forme, dimension1 dimension 2 Lieu
P231 C 12.75 0 Colmar
S304 R 15 20 1Obernai
P231 C 20 0 Barr
S104 R 57.5 52.35 Strasbourg
S442 T 23 32.60 Mulhouse
P231 C 21 0 Nancy
S442 R 73.25 37.10 Paris
P211 T 69.50 55.40 Laval
P231 C 61 0 Poitiers

et le programme:

import fr.insa.goepp.Lire; 
import java.io.* ; 
import java.util.* ;    // pour StringTokenizer 

public class Decompose_Chaine 
{ public static void main (String args[]) throws IOException 
  { String forme, lieu, lieu2,reference ; 
    int i,j,initialisation=0,c=0,posmini=0;float Dim1, Dim2, Prix; 
    double S=0,patri=0,P=0; 
    boolean ajouter, permute; 
    Proprietaire[]p=new Proprietaire[100]; 
    BufferedReader entree1 = new BufferedReader (new FileReader ("terrains.txt")) ; 
    while (true) 
     { String ligneLue = entree1.readLine() ; 
       if (ligneLue == null) break ; 
       StringTokenizer k = new StringTokenizer (ligneLue, " ") ; 
       reference=k.nextToken(); 
       ajouter=true; 
       if(initialisation==0){ 
           p[0]=new Proprietaire(reference,0); 
           initialisation=1; 
           c=++c; 
          } 
        
       else{ 
           for(i=0;i<c;++i){ 
               if(reference.equals(p[i].reference)){ 
                   ajouter=false; 
               } 
           } 
           if(ajouter=true){ 
               p[c]=new Proprietaire(reference,0); 
               ++c; 
           } 
       } 
    } 
    entree1.close();        //APPAREMENT CA BUGGE ENTRE LE DEBUT ET ICI. 
    initialisation=0; 
      BufferedReader entree2 = new BufferedReader (new FileReader ("terrains.txt")) ; 
    while (true) 
     { String ligneLue = entree2.readLine() ; 
       if (ligneLue == null) break ; 
       StringTokenizer l = new StringTokenizer (ligneLue, " ") ; 
       reference= l.nextToken(); 
       forme= l.nextToken(); 
       Dim1 = Float.parseFloat (l.nextToken()) ; 
       Dim2 = Float.parseFloat (l.nextToken()) ; 
       if (forme.equals("C")){ 
               S=3.14*(Dim1*Dim1); 
           } 
           if (forme.equals("R")){ 
               S=(Dim1*Dim2); 
           } 
           if (forme.equals("T")){ 
               S=((Dim1*Dim2)/2); 
           } 
      lieu= l.nextToken(); 
     BufferedReader entree3 = new BufferedReader (new FileReader ("Tarifs.txt")) ; 
     while (true) 
     { String ligneLue2 = entree3.readLine() ; 
       if (ligneLue2 == null) break ; 
       StringTokenizer m = new StringTokenizer (ligneLue2, " ") ; 
       lieu2= m.nextToken(); 
       Prix = Float.parseFloat (m.nextToken()) ; 
       if(lieu.equals(lieu2)){ 
           P=Prix*(S/100);    
       } 
     } 
     if(initialisation==0){ 
           p[0]=new Proprietaire(reference,P); 
           initialisation=1; 
       } 
       else{ 
           for (i=0; i<5; i++){ 
               if(reference.equals(p[i].reference)){ 
                   p[i].patri=p[i].patri+(P);  
               } 
           }   
       } 
     entree3.close () ; 
     } 
    entree2.close () ; 
    permute=true; 
    while(permute){ 
        permute=false; 
        for(i=0; i<4; i++){ 
             if(p[i].patri<p[i+1].patri){ 
                Proprietaire temp=p[i]; 
                p[i]=p[i+1]; 
                p[i+1]=temp; 
                permute=true; 
            } 
        } 
    } 
     System.out.println("proprietaires classés dans l'ordre décroissant de patrimoine"); 
 for(i=0; i<5; i++){ 
       System.out.println(p[i].reference+"\t");      
} 
   System.out.println("patrimoines correspondants"); 
 for(i=0; i<5; i++){ 
      System.out.println(p[i].patri);      
}  
 }// Fin main() 
} //Fin classe

Merci d'avance pour vos reponses parce que la c'est limite la crise!lool

 

[Eul Mulot]

Salut, juste pour savoir si tu pouvais éditer ton message en utilisant la balise CODE, pour indenter ton code parce que là j'ai pas très envie de lire pour chercher une erreur.

Si j'ai le temps ce week-end j'y jetterai un oeil.

 

[nicolas2b54]

Salut,

Desolé de te dire ca comme ca : mais ton code est crade !
(Faut pas le prendre mechamment)
Il y a plusieurs erreurs qui font que ton code a des problemes :

• le code n'est PAS commenté => dure pour le corriger
• tu parcours plusieurs fois le même fichiers,
• tu utilise mal la pre-incrementation et la post-incrementation (les ++c et c++)
• tu t'emmêle dans la création de tes objets "propriétaire"
• tu accède directement au attributs sans utiliser des getters et des setters

J'ai donc totalement réecris ton code
Différence :

• j'uitlise une liste pour les proprietaire
• j'utilise les exceptions lors du parcours du fichier
• je ne parcours qu'une fois le fichier de lieu
• l'initialisation d'un nouveau propriétaire puis sa réutilisation sont simplifié
• utilisation des getters et setters
• utilisation de l'interface Comparator pour trier une arraylist

Voici donc le nouveau code.
Ce que tu dois rajouter ailleurs:

• des getters et des setters dans la classe propriétaire (il s'agit des méthodes pr accéder aux attributs)
• redéfinir la méthode equals pour qu'elle dise que deux propriétaire sont égaux, s'ils ont la même référence

si t'a des questions, des problemes n'hesite pas, et je repete ne prend pas mal ce que je dit sur ton code au depart, mais en fait il etati ecrit d'une facon tres "langage C", et pas java/objet.

import fr.insa.goepp.Lire; 
import java.io.* ; 
import java.util.* ;    // pour StringTokenizer 

public class Terrain//tu peux changer le nom de la classe en fonction du fichier
{
    public static void main( String[] args) 
    {
        ArrayList<Proprietaire> liste_prop = new ArrayListe<Proprietaire>();//une liste de proprietaire mieux que le tableau car on peut trier
        BufferedReader br = new BufferedReader(new FileReader("Terrains.txt") );
        try {//utilison java et ses exceptions ;)
            String ligne = new String();
            while ( ligne=br.readLine())
            {
                StringTokenizer st = new StringTokenizer(ligne);
                String reference = st.nextToken();
                
                //ici tu cree tes objet proprietaire...
                Proprietaire p = null, p_ligne = null;
                p_ligne = new Proprietaire(reference,0);    //ici on cree un proprietaire, puis on va comparee 
                                                //si il existe deja, la variable est abondonne, sinon, on va l'utiliser
                for ( Proprietaire p_temp : liste_prop )
                {
                    if ( p_temp.equals(p.ligne) )
                        p = p_temp;     //on vient d'en trouve un qui exsite donc on le recupere
                                    // ATTENTION, s'il y en a plusieur, cela ne prend que le dernier
                }
                if ( p == null )
                    p = p_ligne; //si on a pas trouve de proprietaire existant, alors on prend le "nouveau" cree avant
                
                   forme= st.nextToken(); 
                   Float dim1 = Float.parseFloat (st.nextToken()) ; 
                   Float dim2 = Float.parseFloat (st.nextToken()) ; 
                   Double surface;
                   if (forme.equals("C"))
                   { 
                    surface =3.14*(dim1*dim1); 
                } 
                
                if (forme.equals("R"))
                { 
                    surface=(dim1*dim2); 
                } 
                
                if (forme.equals("T"))
                { 
                    surface=((dim1*dim2)/2); 
                } 
                
                lieu= l.nextToken();
                
                //on va lire le fichier des tarif pour le proprietaire qui nous interresse
                // NE PAS OUBLIER que l'on est TOUJOURS dans la boucle sur UN proprietaire, et que celui, c'est la variable "p" (cf. plus haut)
                BufferedReader br_tarif = new BufferedReader (new FileReader ("Tarifs.txt")) ; 
                try {
                    Double prix_surf;
                    String ligne_tarif = new String();
                    boolean trouve = false;
                    while ( ligne_tarif = br_tarif.readLine() && !trouve ) 
                    {
                        StringTokenizer st_tarif = new StringTokenizer (ligne_tarif) ; 
                        String lieu2= st_tarif.nextToken(); 
                        Float prix = Float.parseFloat (st_tarif.nextToken()) ; 
                        if(lieu.equals(lieu2))
                        { 
                            trouve = true;
                            prix_surf=prix*(surface/100);    
                        } 
                    } 
                    
                    //ici on met a jour la patrimoine du proprietaire:
                    //on recupere l'ancien avec p.getPatrimoine()
                    //puis on ajoute la nouvelle valeur,
                    //enfin avec setPatrimoine(), on met tout a jour
                    p.setPatrimoine(p.getPatrimoine()+prix));
                    
                }
                catch(IOException ioe) {
                    // rien de particulier : on a atteint la fin du fichier de tarif
                    br_ligne.close (); 
                }
                
            }
        }
        catch( IOException ioe) {
            br.close();
            //on ne fait rien, simplement on est arrive à la fin du fichier ;)
        }
        
        //ici, on trie
        //C'est pas dur tu cree un classe qui implemente l'interface comparator, et tu réecris la methode sort
        //cette methode doit renvoyer -1, 0, ou 1 suivant que l'objet qui appelle est plus petit, egal ou pus grand que le parametre
        // il suffit que tu regarde avec proprio1.getNom().compareTo(proprio2.getNom())
        Comparator.sort(liste_prop);
        
        //ici on affiche
        for ( Proprietaire p : liste_prop )
        {
            System.out.println( p.getReference() + " - valeur de ses terrains : " + p.getPatrimoine() );
        }
    }
}

 

[tatouille]

mais ton code est crade ! (Faut pas le prendre mechamment)

 

[molgow]

Et en même temps, c'est normal quand on est débutant
On est tous passé par là...