CSVFile monFichier = new CSVFile("C:\\youplaboum.csv"); 
String valeur = monFichier.getData(3, 5); 
monFichier.setData(6,1, "Nouvelle valeur"); 
monFichier.write("C:\\toto.csv"); 
monFichier = null;

import java.io.*;

public class LineCount
{
     static public void main(String args[]) throws Exception
     {

//Change the directory where the count files are existing
File di   = new File("c:/count");
File fl[] = di.listFiles();
int j;
int count=0;
String str="";
String totalinfo="";

for (j=0; j < fl.length; j++)
{
System.out.println(""+fl[j]);
FileInputStream fis = new FileInputStream(fl[j].getCanonicalFile());
LineNumberReader l = new LineNumberReader(new BufferedReader(new InputStreamReader(fis)));
while ((str=l.readLine())!=null)
{
count = l.getLineNumber();
}
System.out.println(count);

String filename = fl[j].getName().toString();
totalinfo = filename+"-------------"+count;

FileOutputStream file = new FileOutputStream("c:/one.txt",true); //append
PrintStream printtofile = new PrintStream(file);
printtofile.println(totalinfo);
printtofile.close();
file.close();
}
}
}

public static void main(String args[]){
         try{
         File dir = new File("d:\\temp");
        
         String[] children = dir.list();
             if (children == null) {
             System.out.println("Directory does not exist or is not a Directory");
             } else {
                 for (int i=0; i                 // Get filename of file or directory
                 String filename = children[i];
                 System.out.println(filename);
             }
         }
        
         // It is also possible to filter the list of returned files.
         // This example does not return any files that start with `.'.
             FilenameFilter filter = new FilenameFilter() {
                 public boolean accept(File dir, String name) {
                 return !name.startsWith(".");
             }
         };
         children = dir.list(filter);
        
        
         // The list of files can also be retrieved as File objects
         File[] files = dir.listFiles();
        
         // This filter only returns directories
             FileFilter fileFilter = new FileFilter() {
                 public boolean accept(File file) {
                 return file.isDirectory();
             }
         };
         files = dir.listFiles(fileFilter);
     }
         catch (Exception ioe){
         ioe.printStackTrace();
     }
}

/*
 * FileUtility
 * @author P. Thomas
 *
  -----------------------------------------------------------------------------
  Description

  Les quatres principales methodes de cette classe utilitaire permet :
     - de calculer un chemin relatif à partir d'un répertoire de référence
        et du répertoire à relativiser
     - de supprimer récursivement des répertoires
     - de copier un fichier
     - de créer un fichier à un emplacement précis avec un nom défini à l'aide
        d'un pattern du type "Out-{0,number,#000}.tmp" [Cf. MessageFormat]   
     
  -----------------------------------------------------------------------------
  */

package AltaOcas.Util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.ArrayList;

import javax.swing.JFileChooser;

public class FileUtility {

   protected static String getPrimaryPath(File ref, File access) {
      String path = "";
      ArrayList refp = new ArrayList();
      for (File cur = ref; cur != null; cur = cur.getParentFile()) {
         String name = cur.getName();
         if (name.length() == 0)
            name = cur.getAbsolutePath();
         refp.add(name);
         //System.out.println("Ref : '" + name + "'");
      }
      ArrayList accp = new ArrayList();
      for (File cur = access; cur != null; cur = cur.getParentFile()) {
         String name = cur.getName();
         if (name.length() == 0)
            name = cur.getAbsolutePath();
         accp.add(name);
         //System.out.println("Acc : '" + name + "'");
      }
      if (refp.size() == 0 || accp.size() == 0)
         return path;
         
      if (refp.get(refp.size()-1).equals(accp.get(accp.size()-1))) {
         boolean equal = true;
         while (equal && refp.size() > 1 && accp.size() > 1) {
            refp.remove(refp.size()-1);
            accp.remove(accp.size()-1);
            equal = (refp.get(refp.size()-1).equals(accp.get(accp.size()-1)));
         }

         if (refp.size() == 1) {
            if (!equal) {
               refp.remove(refp.size()-1);
               path += ".." ;
            }
            else {
               refp.remove(refp.size()-1);
               accp.remove(accp.size()-1);
               path += ".";
            }
         }
         else {
            if (equal && accp.size() == 1) {
               refp.remove(refp.size()-1);
               accp.remove(accp.size()-1);
            }
            while (refp.size() > 0) {
               refp.remove(refp.size()-1);
               path += ".." ;
               if (refp.size() > 0) path += File.separator;
            }
         }
         while (accp.size() > 0) {
            String name = (String)accp.remove(accp.size()-1);
            path += File.separator;
            path += name;
         }
      }
      else {
         try {
            path = access.getCanonicalPath();
         } catch (IOException e) {
            path = access.getAbsolutePath();
            e.printStackTrace();
         }
      }
      return path;
   }

   public static String getDiffPath(File ref, File acc) {
      try {
         File cref = ref.getCanonicalFile();
         File cacc = acc.getCanonicalFile();
         return getPrimaryPath(cref, cacc);
      }
      catch (IOException e) {
         e.printStackTrace();
         return getPrimaryPath(ref, acc);
      }
   }

   public static String getDiffPath(String ref, String acc) {
      File fref = new File(ref);
      File facc = new File(acc);
      return getDiffPath(fref, facc);
   }

   public static void main(String[] args) {
      JFileChooser dlg = new JFileChooser();
      dlg.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
      
      while (true) {
         if( dlg.showOpenDialog(null)
               == JFileChooser.CANCEL_OPTION) return;
         File first = dlg.getSelectedFile();
         if (first == null) return;
         if( dlg.showOpenDialog(null)
               == JFileChooser.CANCEL_OPTION) return;
         File last = dlg.getSelectedFile();
         if (last == null) return;
         
         System.out.println("First Path : " + first.getPath());
         System.out.println("Last  Path : " + last.getPath());
         System.out.println("First Name : " + first.getName());
         System.out.println("Last  Name : " + last.getName());
         System.out.println("First AbsolutePath : " + first.getAbsolutePath());
         System.out.println("Last  AbsolutePath : " + last.getAbsolutePath());
         
         System.out.println("Diff  PrimaryPath : " + getPrimaryPath(first, last));
         System.out.println("--------------------------------------------------\n");
      }
   }

   public static void recursifDelete(File path) throws IOException {
      if (!path.exists()) throw new IOException(
         "File not found '" + path.getAbsolutePath() + "'");
      if (path.isDirectory()) {
         File[] children = path.listFiles();
         for (int i=0; children != null && i<children.length; i++)
            recursifDelete(children[i]);
         if (!path.delete()) throw new IOException(
            "No delete path '" + path.getAbsolutePath() + "'");
      }
      else if (!path.delete()) throw new IOException(
         "No delete file '" + path.getAbsolutePath() + "'");
   }

   public static void copyFile(File src, File dest) throws IOException {
      if (!src.exists()) throw new IOException(
         "File not found '" + src.getAbsolutePath() + "'");
      BufferedOutputStream out = new BufferedOutputStream(
         new FileOutputStream(dest));
      BufferedInputStream in = new BufferedInputStream(
         new FileInputStream(src));
         
      byte[] read = new byte[128];
      int len = 128;
      while ((len = in.read(read)) > 0)
         out.write(read, 0, len);
      
      out.flush();
      out.close();
      in.close();
   }

   public static File createSpecifiedFile(String path, String pattern, int base) {
      File file = new File(path);
      if (!file.isDirectory()) return null;

      for (int cur = base; ; cur++) {
         Object[] args = {new Integer(cur)};
         String result = MessageFormat.format(pattern, args);
         file = new File(path, result);
         if (!file.exists())
            return file;
      }
   }
}

public static void copyFile(File src, File dest) throws IOException
{   FileInputStream fis = new FileInputStream(src);
     FileOutputStream fos = new FileOutputStream(dest);

     java.nio.channels.FileChannel channelSrc   = fis.getChannel();
     java.nio.channels.FileChannel channelDest = fos.getChannel();

     channelSrc.transferTo(0, channelSrc.size() , channelDest);

     fis.close();
     fos.close();
}

// Updates: 2004.09.27


import java.io.*;
import java.util.*;


public class ShowFiles {

 
  public ShowFiles() {
    ArrayList allFiles = new ArrayList();
    getFilesRec(allFiles, ".");
    for (int i = 0; i < allFiles.size(); i++) {
      System.out.println(allFiles.get(i));
    }
  }
  

  public static void main(String[] args) {
    new ShowFiles();
  }  


  private void getFilesRec(ArrayList allFiles, String root) {
    File f = new File(root);
    File[] listFiles = f.listFiles();
    for (int i = 0; i < listFiles.length; i++) {
      if (listFiles[i].isDirectory()) getFilesRec(allFiles, listFiles[i].toString());
      else allFiles.add(listFiles[i].toString());
    }
  }  
}

// Lire un fichier de propriétés se trouvant dans le fichier jar de l'application
  Properties props = new Properties();
  props.load(ClassLoader.getSystemResourceAsStream("Records.properties"));


// Lire un fichier texte se trouvant dans le fichier jar de l'application
  private String readFile(String filename) {
    try {
      DataInputStream dis = new DataInputStream(ClassLoader.getSystemResourceAsStream(filename));
      byte[] data = new byte[dis.available()];
      dis.readFully(data);
      dis.close();
      return (new String(data));
    }
    catch (IOException ioe) {
      System.out.println(ioe);
    }
    return "";
  }    


// Changer l'icône d'une JFrame lorsque l'image à afficher se trouve dans le 
// fichier jar de l'application
  JFrame f = new JFrame();
  f.setIconImage(new ImageIcon(getClass().getResource("icon.png")).getImage());