File[] listeRacine = File.listRoots();

/** Class : java.io.File */
public File [] listFiles ();

/** Class : java.io.File */
public boolean isDirectory ();
public boolean isFile ();

public static void listeRepertoire ( File repertoire ) {
        System.out.println ( repertoire.getAbsolutePath());
        
        if ( repertoire.isDirectory ( ) ) {
                File[] list = repertoire.listFiles();
                for ( int i = 0; i < list.length; i++) {
                        // Appel récursif sur les sous-répertoires
                        listeRepertoire( list[i]);
                        
                } 
        } 
}

/** copie le fichier source dans le fichier resultat
 * retourne vrai si cela réussit
 */
public static boolean copier( File source, File destination )
{
        boolean resultat = false;
        
        // Declaration des flux
        java.io.FileInputStream sourceFile=null;
        java.io.FileOutputStream destinationFile=null;
        
        try {
                // Création du fichier :
                destination.createNewFile();
                
                // Ouverture des flux
                sourceFile = new java.io.FileInputStream(source);
                destinationFile = new java.io.FileOutputStream(destination);
                
                // Lecture par segment de 0.5Mo 
                byte buffer[]=new byte[512*1024];
                int nbLecture;
                
                while( (nbLecture = sourceFile.read(buffer)) != -1 ) {
                        destinationFile.write(buffer, 0, nbLecture);
                } 
                
                // Copie réussie
                resultat = true;
        } catch( java.io.FileNotFoundException f ) {
                
        } catch( java.io.IOException e ) {
                
        } finally {
                // Quoi qu'il arrive, on ferme les flux
                try {
                        sourceFile.close();
                } catch(Exception e) { }
                try {
                        destinationFile.close();
                } catch(Exception e) { }
        } 
        return( resultat );
}

public static boolean deplacer(File source,File destination) {
        if( !destination.existe() ) {
                // On essaye avec renameTo
                boolean result = source.renameTo(destination);
                if( !result ) {
                        // On essaye de copier
                        result = true;
                        result &= copier(source,destination);
                        result &= source.delete();
                        
                } return(result);
        } else {
                // Si le fichier destination existe, on annule ...
                return(false);
        } 
}

static public boolean deleteDirectory(File path) { 
        boolean resultat = true; 
        
        if( path.exists() ) { 
                File[] files = path.listFiles(); 
                for(int i=0; i<files.length; i++) { 
                        if(files[i].isDirectory()) { 
                                resultat &= deleteDirectory(files[i]); 
                        } 
                        else { 
                        resultat &= files[i].delete(); 
                        } 
                } 
        } 
        resultat &= path.delete(); 
        return( resultat ); 
}

File source = new File("mon fichier");
File destination = new File("mon fichier renommé");
source.renameTo(destination);

File temp = File.createTempFile("nom",".tmp");
temp.deleteOnExit();

public static String getMIMEType(File file){
   if(file.isDirectory()){return "repertoire";}
   if(!file.exists()){return "fichier inexistant";}
   try{
      URL url = file.toURL();
      URLConnection connection = url.openConnection();
      return connection.getContentType();
   }catch(MalformedURLException mue){
      return mue.getMessage();
   }catch(IOException ioe){
      return ioe.getMessage();
      }
}

Date dateModification = new Date(monFichier.lastModified());

/** Class : java.io.File */
public static final char separatorChar;

/** Class : java.io.File */
public static final char pathSeparatorChar;

/** Convertion du flux en BufferedReader */
BufferedReader entree = new BufferedReader(new InputStreamReader(System.in));

try {
        /** Lecture d'une ligne : */entree.readline();
} catch( IOException e ) {
        e.printStackTrace();
}

Scanner scanner = new Scanner(System.in);
// traitement
scanner.close();

package com.developpez; 

public class Test 
{ 

  public Test() 
  { 
    InputStream is1 = getClass().getResourceAsStream("fichier.txt"); 

    InputStream is2 = getClass().getResourceAsStream("/fichier.txt"); 
  } 
}

   public static void toISO(String source, String destination){
      BufferedReader br = null;
      PrintWriter pw = null;
      try{
         //flux de lecture en UTF-8
         br = new BufferedReader(
               new InputStreamReader(
                     new FileInputStream(source),"UTF-8"));
         //flux d'écriture en ISO (valeur par défaut)
         pw = new PrintWriter(new FileOutputStream(destination));
         String ligne;
         while((ligne = br.readLine())!=null){
            pw.println(ligne);
         }
      }catch(Exception e){e.printStackTrace();}   
      finally{
         try { pw.close(); } catch( Throwable e ) {}
         try { br.close(); } catch( Throwable e ) {} 
      }
   }

SortedMap<String,Charset> charsets = Charset.availableCharsets();
for(String nom : charsets.keySet()){
   System.out.println("Charset "+nom);
   Charset charset = charsets.get(nom);
   for(String alias : charset.aliases()){
      System.out.print(" "+alias+",");
   }
   System.out.println();
}

PrintStream ps = new PrintStream(System.out,true,"IBM850");
// on commence par changer l'encodage en IBM850 (connu aussi sous l'alias Cp850)
System.setOut(ps);
// ensuite l'utilisation de la sortie standard reste la même
System.out.println("àâäÂÄéèêëîïÎÏÊËôöÔÖûüùÛÜÿç");