FAQ Fichiers, flux et réseauxConsultez toutes les FAQ

1
2
String fichier1 = "/home/jean/.bashrc"; 
String fichier2 = "c:\\users\\alexandra\\Documents\\lettre.docx";

1
2
File fichier1 = new File("/home/jean/.bashrc");  
File fichier2 = new File("c:\\users\\alexandra\\Documents\\lettre.docx");

1
2
Path fichier1 = Paths.get("/home/jean/.bashrc");  
Path fichier2 = Paths.get("c:\\users\\alexandra\\Documents\\lettre.docx");

1
2
3
4
5
File fichier = [...] 
URI uri = fichier.toURI(); 
URL url = fichier.toURI().toURL(); 
// Déprécié dans les JDK récents. 
// URL url = fichier.toURL();

1
2
3
Path fichier = [...] 
URI uri = fichier.toUri(); 
URL url = fichier.toUri().toURL();

1
2
File fichier = [...] 
long taille = fichier.length();

1
2
Path fichier = [...] 
long taille = Files.size(fichier);

1
2
Path fichier = [...] 
FileTime dateCreation = (FileTime)Files.getAttribute(fichier, "basic:creationTime", LinkOption.NOFOLLOW_LINKS);

1
2
File fichier = [...] 
long dateModification = fichier.lastModified();

1
2
Path fichier = [...] 
FileTime dateModification = Files.getLastModifiedTime(fichier, LinkOption.NOFOLLOW_LINKS);

1
2
Path fichier = [...]  
FileTime dateModification = (FileTime)Files.getAttribute(fichier, "basic:lastModifiedTime", LinkOption.NOFOLLOW_LINKS);

1
2
3
4
File fichier = [...] 
System.out.println("Espace total : " + fichier.getTotalSpace()); 
System.out.println("Espace libre : " + fichier.getFreeSpace()); 
System.out.println("Espace utilisable : " + fichier.getUsableSpace());

1
2
3
4
5
Path fichier = [...] 
FileStore stockage = Files.getFileStore(fichier); 
System.out.println("Espace total : " + stockage.getTotalSpace()); 
System.out.println("Espace libre : " + stockage.getUnallocatedSpace()); 
System.out.println("Espace utilisable : " + stockage.getUsableSpace());

1
2
3
Iterable<FileStore> stockages = FileSystems.getDefault().getFileStores(); 
// Ou : 
// Iterable<FileStore> stockages = fichier.getFileSystem().getFileStores();

File[] listeRacine = File.listRoots();

Iterable<Path> listeRacine = FileSystems.getDefault().getRootDirectories();

1
2
boolean estUnRepertoire = monFichier.isDirectory(); 
boolean estUnFichier = monFichier.isFile();

boolean estUnLien = !monFichier.getAbsolutePath().equals(monFichier.getCanonicalPath();

1
2
3
boolean estUnRepertoire = Files.isDirectory(monFichier); 
boolean estUnFichier =  Files.isRegularFile(monFichier.); 
boolean estUnLien =  Files.isSymbolicLink(monFichier.);

File[] fichiers = repertoire.listFiles();

String[] nomFichiers = repertoire.list();

1
2
3
4
5
6
7
8
List<Path> fichiers = new ArrayList<>(); 
try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(repertoire)) { 
    for (Path path : directoryStream) { 
        fichiers.add(path); 
    } 
} catch (IOException e) { 
    e.printStackTrace() 
}

1
2
3
4
5
6
7
8
List<String> nomFichiers = new ArrayList<>(); 
try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(repertoire)) { 
    for (Path path : directoryStream) { 
        nomFichiers.add(path.getFileName().toString()); 
    } 
} catch (IOException e) { 
    e.printStackTrace() 
}

Stream<Path> fichiers = Files.list(repertoire);

1
2
Stream<String> nomFichiers = Files.list(repertoire) 
    .map(path -> path.getFileName().toString());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void listeRepertoire ( File repertoire ) { 
    System.out.println ( repertoire.getAbsolutePath()); 
    if (repertoire.exists() && repertoire.isDirectory()) { 
        File[] fichiers = repertoire.listFiles(); 
        if (list != null) { 
            for (File fichier : fichier) { 
	        // Appel récursif sur les sous-répertoires 
	        listeRepertoire(child); 
	    }  
        } else { 
            System.err.println(repertoire + " : Erreur de lecture."); 
        } 
    }  
}

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
public static void listeRepertoire(final Path repertoire) { 
    if (Files.exists(repertoire) && Files.isDirectory(repertoire)) { 
        try { 
            Files.walkFileTree(repertoire, new SimpleFileVisitor<Path>() { 
  
                // Peut être utilisé pour effectuer des actions sur le répertoire et les sous-répertoires en début de visite. 
                @Override 
                public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { 
                    System.out.println(dir.toString()); 
                    return FileVisitResult.CONTINUE; 
                } 
  
                // Peut être utilisé pour effectuer des actions sur les fichiers dans chaque répertoire au cours de la visite. 
//              @Override 
//              public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { 
//                  return FileVisitResult.CONTINUE; 
//              } 
  
                // Peut être utilisé pour effectuer des actions sur le répertoire et les sous-répertoires en fin de visite. 
//              @Override 
//              public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { 
//                  return FileVisitResult.CONTINUE; 
//              } 
            }); 
        } catch (IOException e) { 
            System.err.println(repertoire + " : Erreur de lecture."); 
        } 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
public static void listeRepertoire(final Path repertoire) { 
    System.out.println(repertoire.toString()); 
    if (Files.exists(repertoire) && Files.isDirectory(repertoire)) { 
        try { 
            Files.list(repertoire) 
                    .filter(fichier -> Files.isDirectory(fichier)) 
                    .forEach(MaClasse::listeRepertoire); 
        } catch (IOException e) { 
            System.err.println(repertoire + " : Erreur de lecture.");  
        } 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static boolean effacerRepertoire(File repertoire) { 
    if (repertoire.exists() && repertoire.isDirectory()) { 
        boolean resultat = true; 
        File[] fichiers = repertoire.listFiles(); 
        for (File fichier : fichiers) { 
            if (fichier.isDirectory()) { 
                resultat &= effacerRepertoire(fichier); 
            } else { 
                resultat &= fichier.delete(); 
            } 
        } 
        resultat &= repertoire.delete(); 
        return resultat; 
    } 
    return false; 
}

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
public static boolean effacerRepertoire(Path repertoire) { 
    if (Files.exists(repertoire) && Files.isDirectory(repertoire)) { 
        try { 
            Files.walkFileTree(repertoire, new SimpleFileVisitor<Path>() { 
                // On efface les fichiers dans chaque répertoire au cours de la visite. 
                @Override 
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { 
                    Files.delete(file); 
                    return FileVisitResult.CONTINUE; 
                } 
  
                // On efface le répertoire et les sous-répertoires en fin de visite. 
                @Override 
                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { 
                    Files.delete(dir); 
                    return FileVisitResult.CONTINUE; 
                } 
            }); 
            return true; 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
    return false; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static boolean effacerRepertoire(Path repertoire) { 
    try { 
        if (Files.exists(repertoire) && Files.isDirectory(repertoire)) { 
            boolean resultat = Files.list(repertoire) 
                    .map(MaClasse::effacerRepertoire) 
                    .reduce(true, (a, b) -> a & b); 
            Files.delete(repertoire); 
            return resultat; 
        } 
    } catch (IOException e) { 
        e.printStackTrace(); 
    } 
    return false; 
}

1
2
3
File source = new File("mon fichier"); 
File destination = new File("mon fichier renommé"); 
boolean resultat = source.renameTo(destination);

1
2
3
Path source = Paths.get("mon fichier"); 
Path destination = Paths.get("mon fichier renommé"); 
Files.move(source, destination, StandardCopyOptions.REPLACE_EXISTING); // Écrase le fichier destination s'il existe déjà.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static boolean copier(File source, File dest) { 
    try (InputStream sourceFile = new java.io.FileInputStream(source);  
            OutputStream destinationFile = new FileOutputStream(dest)) { 
        // 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); 
        } 
    } catch (IOException e){ 
        e.printStackTrace(); 
        return false; // Erreur 
    } 
    return true; // Résultat OK   
}

1
2
3
4
5
6
7
8
9
10
11
public static boolean copier(File source, final destination) { 
    try (FileChannel in = new FileInputStream("toto.txt").getChannel(); // canal d'entrée  
            FileChannel out = new FileOutputStream("tutu.txt").getChannel()) { // canal de sortie  
        // Copie depuis le in vers le out  
        in.transferTo(0, in.size(), out); 
    } catch (IOException e) { 
        e.printStackTrace(); 
        return false; 
    }  
    return true; 
}

1
2
3
4
5
6
7
8
9
10
11
12
public static boolean copier(Path source, Path destination) { 
    try { 
        Files.copy(source, destination); 
        // Il est également possible de spécifier des options de copie. 
        // Ici : écrase le fichier destination s'il existe et copie les attributs de la source sur la destination.  
       //Files.copy(source, destination, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.COPY_ATTRIBUTES); 
    } catch (IOException e) { 
        e.printStackTrace(); 
        return false; 
    } 
    return true; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static boolean deplacer(File source, File destination) { 
    if (!destination.exists()) { 
        // On essaye avec renameTo() 
        boolean result = source.renameTo(destination); 
        if (!result) { 
            // On essaye de copier. 
            result = true; 
            result &= copier(source, destination); 
            // Puis d'effacer. 
            if (result) { 
                result &= source.delete(); 
            } 
        } 
        return result; 
    } 
    // Si le fichier destination existe, on annule... 
    return false; 
}

1
2
3
4
5
6
7
8
9
10
11
File fichier = [...] 
String typeMime = null; 
if (fichier.exists() && !fichier.isDirectory()) { 
    try { 
        URL url = fichier.toURI().toURL(); 
        URLConnection connection = url.openConnection(); 
        typeMime = connection.getContentType(); 
   } catch (IOException e) { 
      e.printStackTrace(); 
   } 
}

1
2
3
4
5
File fichier = [...] 
String typeMime = null; 
if (fichier.exists() && !fichier.isDirectory()) { 
    typeMime = URLConnection.guessContentTypeFromName(file.getName()); 
}

1
2
3
4
5
6
7
8
9
File fichier = [...] 
String typeMime = null; 
if (fichier.exists() && !fichier.isDirectory()) { 
    try (InputStream input = new FileInputStream(fichier)) { 
        typeMime = URLConnection.guessContentTypeFromStream(input); 
    } catch (IOException e) { 
      e.printStackTrace(); 
   } 
}

1
2
3
4
5
6
7
8
9
Path fichier = [...] 
String typeMime = null; 
if (Files.exists(fichier) && !Files.isDirectory(fichier)) { 
    try { 
        Files.probeContentType(fichier); 
     } catch (IOException e) { 
      e.printStackTrace(); 
    } 
}

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

Path temp = Files.createTempFile("nom", ".tmp");

1
2
3
4
File fichier = [...] 
System.out.println("Lisible - " + fichier.canRead()); 
System.out.println("Modifiable - " + fichier.canWrite()); 
System.out.println("Exécutable - " + fichier.canExecute());

1
2
3
4
Path fichier = [...] 
System.out.println("Lisible - " + Files.isReadable(fichier)); 
System.out.println("Modifiable - " + Files.isWritable(fichier)); 
System.out.println("Exécutable - " + Files.isExecutable(fichier));

1
2
3
4
5
6
7
8
Path fichier = [...] 
FileSysteme systemeFichier = fichier.getFileSystem();  
boolean supporteBasique = systemeFichier.supportedFileAttributeViews().contains("basic"); // Attributs et permissions basiques. 
boolean supporteDos = systemeFichier.supportedFileAttributeViews().contains("dos"); // Attributs et permissions DOS. 
boolean supportePosix = systemeFichier.supportedFileAttributeViews().contains("posix");  // Attributs et permissions POSIX. 
boolean supporteAcl = systemeFichier.supportedFileAttributeViews().contains("acl");  // Attributs et permissions ACL. 
boolean supporteProprietaire = systemeFichier.supportedFileAttributeViews().contains("owner");  // Attributs et permissions propriétaire. 
boolean supporteUtilisateur = systemeFichier.supportedFileAttributeViews().contains("user");  // Attributs et permissions définis par l’utilisateur.

1
2
3
4
Path ficher = [...] 
Map<String, Object> attributs = Files.readAttributes(ficher, "basic:*", LinkOption.NOFOLLOW_LINKS); 
// Ou: 
BasicFileAttributes attributs = Files.readAttributes(ficher, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);

long size = (Long) Files.getAttribute(ficher, "basic:size", LinkOption.NOFOLLOW_LINKS);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Path fichier = [...] 
FileSysteme systemeFichier = fichier.getFileSystem(); 
if (systemeFichier.supportedFileAttributeViews().contains("posix")) { 
    PosixFileAttributeView permissions = Files.getFileAttributeView(fichier, PosixFileAttributeView.class, LinkOption.NOFOLLOW_LINKS); 
    // Changement des dates du fichier 
    FileTime maintenant = FileTime.fromMillis(System.currentTimeMillis()); 
    permissions.setTimes(maintenant, maintenant, maintenant); 
    // Changement de groupe. 
    GroupPrincipal groupe = systemeFichier.getUserPrincipalLookupService().lookupPrincipalByGroupName("projet1"); 
    permissions.setGroup(groupe); 
    // Changement de propriétaire. 
    UserPrincipal utilisateur = systemeFichier.getUserPrincipalLookupService().lookupPrincipalByName("henrid"); 
    permissions.setOwner(utilisateur); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Path fichier = [...] 
FileSysteme systemeFichier = fichier.getFileSystem();  
if (systemeFichier.supportedFileAttributeViews().contains("acl")) { 
    AclFileAttributeView permissions = Files.getFileAttributeView(fichier, AclFileAttributeView.class, LinkOption.NOFOLLOW_LINKS); 
    UserPrincipal utilisateur = systemeFichier.getUserPrincipalLookupService().lookupPrincipalByName("karineb"); 
    AclEntry entry = AclEntry.newBuilder() 
            .setType(AclEntryType.ALLOW) 
            .setPrincipal(utilisateur) 
            .setPermissions(AclEntryPermission.READ_DATA, AclEntryPermission.READ_ATTRIBUTES) 
            .build(); 
    // On récupère la liste de contrôle actuelle. 
    List<AclEntry> acl = permissions.getAcl(); 
    // On ajoute la nouvelle permission dans la liste de contrôle. 
    acl.add(0, entry); 
    // On écrit la liste de contrôle. 
    permissions.setAcl(acl); 
}