simuler un FileFilter

Version imprimable

Bonjour voila je développe une classe fichier
je commence en java et je voudrais simuler un filtre avec cette fonction
mais je bloques sur comment retourner la collection de File

dites moi si c intelligent :
Code:

1 2 3 4 5 6 7 8 9 public File[] lister(String monFiltre){ File[] tabFichier; for(File f : monFichier.listFiles()){ if(f.getName().endsWith(monFiltre)){ tabFichier=f; } } return tabFichier; }
d'avance merci

Je ne comprend pas cette ligne :

Citation:

tabFichier=f;

tabFichier est un tableau de File alors que f est un File, tu ne peux pas faire =, ils sont de type différents. Préfère l'utilisation de ArrayList, comme ça :
Code:

1 2 3 4 5 6 7 ArrayList<File> files = new ArrayList<File>(); for(File f : monFichier.listFiles()){ if(f.getName().endsWith(monFiltre)){ files.add(f); } } return files.toArray(new File[files.size()]);
J'ai pas testé le code, il est possible que tu devras faire quelques changement. Sinon, la logique de la méthode est bonne, bien que je ne comprends pas d'où viens la variable monFichier :? . Bonne chance ;) .

moFichier vient de ma classe

Code:

1
2
3
4
5
6
7
8
9
10
package fichier;
 
import java.io.*;
import javax.swing.JOptionPane;
 
 
public class Fichier {
    private File monFichier;
 
public File[] lister(String monFiltre){

D'accord mais je te conseil alors d'ajouter un second paramètre à ta méthode 'lister' de type File afin quel soit plus facilement réutilisable. Cela donnerait :
Code:

1 2 3 4 5 6 7 8 9 public File[] lister(String monFiltre, File monFile){ ArrayList<File> files = new ArrayList<File>(); for(File f : monFile.listFiles()){ if(f.getName().endsWith(monFiltre)){ files.add(f); } } return files.toArray(new File[files.size()]); }
Mais si tu n'envisages pas d'utiliser cette méthode hors de ta classe, alors oublie ce que je viens de dire. Le code fonctionne ?

si justement alors j'ai décidé de changer et de faire hériter ma classe fichier de file et d'enlever la déclaration de monFichier

ce qui donne :
Fichier.java

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
package fichier;

import java.io.*;
import javax.swing.JOptionPane;
import java.util.ArrayList;

public class Fichier extends File{

    /*Fonction copier un fichier*/
    public boolean copier (File destination){
        //Mes variables
        boolean resultat=false;
        FileInputStream sourceFile=null;
        FileOutputStream destFile=null;
        
        //Mon buffer : Lecture par segment de 0.5Mo 
        byte buffer[]=new byte[512*1024];
        
        int nbLecture;
        
        try{
        
            destination.createNewFile();
            
            sourceFile= new FileInputStream(this);
            destFile = new FileOutputStream(destination);
            
            while((nbLecture=sourceFile.read(buffer))!=-1){
                destFile.write(buffer,0,nbLecture);
            }
            //Copie Réussie
            resultat=true;
                     
        }catch(FileNotFoundException e){
            JOptionPane.showMessageDialog(new JOptionPane(),"Pas de fichier trouvé.","Erreur",JOptionPane.ERROR_MESSAGE);
        }catch(IOException e){
            JOptionPane.showMessageDialog(new JOptionPane(),"Erreur d'IO","Erreur",JOptionPane.ERROR_MESSAGE);
        }finally{
            //Fermer les flux
            try{
                sourceFile.close();
            }catch(Exception e){
               JOptionPane.showMessageDialog(new JOptionPane(),"Erreur durant la fermeture de fichier","Erreur",JOptionPane.ERROR_MESSAGE); 
            }
            try{
                destFile.close();
            }catch(Exception e){
               JOptionPane.showMessageDialog(new JOptionPane(),"Erreur durant la fermeture de fichier","Erreur",JOptionPane.ERROR_MESSAGE); 
            }
        }
        return (resultat);
    }
    public File[] lister(){
        return this.listFiles();
    }
    public File[] lister(FilenameFilter filtre){
        return this.listFiles(filtre);
    }
    public ArrayList lister(String monFiltre){
        ArrayList<File> tabFichier= new ArrayList<File>();
        for(File f : this.listFiles()){
        if(f.getName().endsWith(monFiltre)){
            tabFichier.add(f);
        }
        }
        return tabFichier;
    }

mon probleme est que je veux faire un copier sur un File
Ihm.java

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    public class ActionSauver implements ActionListener {
        public void actionPerformed (ActionEvent ev){
         Fichier sourceFile = new Fichier(System.getProperty("user.home")+"/Bureau/Projet Productivité");
         File destFile;
         ArrayList<File> mesFichiers;
          
          mesFichiers=sourceFile.lister(".mdb");
          
          for(File f : mesFichiers){
              if(f.getName().endsWith(".mdb")){
                  System.out.println("Je copie : "+f.getName());
                   destFile= new File("C:/Documents and Settings/Stephane/Bureau/"+ f.getName());
                    if (f.copier(destFile)){
            JOptionPane.showMessageDialog(new JOptionPane(), "Sauvegarde réussie","KarKam Dvpt.",JOptionPane.INFORMATION_MESSAGE);
           }else{
            JOptionPane.showMessageDialog(new JOptionPane(),"L'opération de sauvegarde a échoué.","KarKam Dvpt.",JOptionPane.WARNING_MESSAGE);
           }
                   
              }
          }  
        }

01/05/2007, 01h42
komando

J'ai peut être une meilleure idée que l'héritage. Ta classe MonFichier a tout l'air d'une classe utilitaire dont tu serveras dans bcp de classes.

Donc à mon avis, tu la déclare static, tu utilse une fabrique pour l'utiliser dans tes classes --> gain de perfs et d'organisation

Au lieu de faire appel à l'héritage, il serait possible d'utiliser le pattern décorateur bcp plus élégant et fait le job.

Java permet aussi d'invoquer toute la puissance des regex que tu pourra utiliser au lieu de str.endsWith(monFiltre). Ton filtre devient une regex et la méthode gagne en puissance et en temps.

Aussi, il est possible de remplacer le package io par nio qui est bcp plus rapide.

Je vais essayer de te préparer cette classe dans mon prochain post :)
01/05/2007, 11h48
LeXo

je vais penser a tout ce que tu viens de me dire, faire des recherches pour essayer de pondre quelquechose

Voici la solution que j'ai trouvé, j'èspère que qq pourra me donner son avis et surtout ses critiques

D'abord une classe qui implemente l'interface FileNameFilter permettant de filtrer les noms en utilisant les regex

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
 
import java.io.File;
import java.io.FilenameFilter;
import java.util.regex.Pattern;
 
public class RegexFileNameFilter implements FilenameFilter{
 
    private static final String ANY_VALUE = ".*" ;
    private String regex;
 
    public RegexFileNameFilter() {
        this(ANY_VALUE);
    }
 
    public RegexFileNameFilter(String regex){
        this.regex = regex;
    }
 
    public boolean accept(File dir, String name) {
        return Pattern.compile(regex , Pattern.CASE_INSENSITIVE).matcher(name).matches();
    }
 
    public void setRegex(String regex) {
        this.regex = regex;
    }
}

Ensuite, notre classe utilitaire qui utilise le RegexFileNameFilter et propose 3 méthodes de recherches

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
 
import java.io.File;
import java.io.FilenameFilter;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.Arrays;
import java.util.regex.Pattern;
/**
 *
 * @author Administrateur
 */
public class FileHelper implements Serializable{
 
    private static final String WILD_CARD = ".*" ;
    private static final FileHelper INSTANCE = new FileHelper();
    private static final RegexFileNameFilter regexFilter= new RegexFileNameFilter();
 
    private FileHelper() {
    }
 
    public static String listFilesBeginWith(String filter , File dir){
        regexFilter.setRegex(filter+WILD_CARD);
        return Arrays.toString(dir.list((regexFilter)));
    }
 
    public static String listFilesContain(String filter, File dir){
        regexFilter.setRegex(WILD_CARD+filter+WILD_CARD);
        return Arrays.toString(dir.list((regexFilter)));
    }
 
    public static String listFilesEndWith(String filter, File dir){
        regexFilter.setRegex(WILD_CARD+filter);
        return Arrays.toString(dir.list((regexFilter)));
    }

et enfin un exemple illustrant l'utilsation

Code:

1
2
3
4
5
6
7
8
 
    public static void main(String[] args) {
        String path = "d:\\docs";
        File dir = new File(path);        
        System.out.println(FileHelper.listFilesBeginWith("hack" , dir));
        System.out.println(FileHelper.listFilesContain("in" , dir));
        System.out.println(FileHelper.listFilesEndWith("pdf" , dir));
    }

l'implements

Reuuu j'ai décidé de faire une interface

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package fichier;
 
import java.io.File;
 
public interface Fichier {
 
    /*Obtenir l'extension du fichier
     *@return booléen */
    boolean isExtension();
 
    /*Obtenir la taille du fichier
     *@return Taille*/
    int getTaille();
...

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
package fichier;
 
import java.io.*;
import javax.swing.JOptionPane;
import java.util.ArrayList;
 
public class FichierInterface implements Fichier{
 
    private File monFichier;
 
  /*Contruis un fichier vide
   *@param Chemin du fichier*/
  public FichierInterface(String nom){
  monFichier = new File(nom);
  }
 
  public boolean isExtension(String extension){
        return this.getName().endsWith(extension);  
  }
    public String getNom(){
        return this.getName();
    }
    /*Fonction Taille du fichier*/
    public long taille(){
        return this.length();
    }

mais mon objet courant this n'hérites pas des méthodes de File

mon but est de faire une classe fourre-tout surtout pour utiliser la méthode copier

07/05/2007, 13h55
remika

Pourquoi tu ne fais pas hériter ta classe de File directement ?

Sinon apparemment pour faire une copie de fichier avec les FileChannel ça serait plus rapide :

http://java.developpez.com/faq/java/...FICHIER_copier

ah oui je connais ;) ct mon 2nd post
mais je voudrais faire une classe fourre tout et de promener cette classe dans mes projets
ce que je voulais faire
Code:

1 2 3 4 5 6 7 8 File[] tabFichier =new File[]; //recup les fichiers avec une certaine extensions tabFichier = monFichier.listFiles(monFiltre); //Pour les copier dans un autre emplacement for (File fichier : tabFichier){ fichier.copier(destination); }
mais je voulais que la méthode copier porte sur l'objet courant (this) et pas dans un des param
source.copier(destination) et non pas copier(source,destination)

ça dans une classe réutilisable 8-)

Rien ne t'empêche de faire la copie avec les channels comme tu le décris :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
...
public void copie(String fileName)throws IOException{
   FileInputStream fis=new FileInputStream(this.fileName);
   FileOutputStream fos=new FileOutputStream(fileName);
   FileChannel chIn=fis.getChannel();
   FileChannel chOut=fos.getChannel();
   long size=chIn.size();
   chIn.transferTo(0,size,chOut);
   chIn.close();
   chOut.close();
   fis.close();
   fos.close();
}