Pour les E / S de fichiers modernes en Java, utilisez Nio.2 (java.nio.file) car il fournit une API plus intuitive, riche en fonctionnalités et plus s?re par rapport aux E / S traditionnelles; 2. Utilisez des E / S traditionnelles uniquement pour le code hérité ou les opérations de flux simples, car elle bloque et moins évolutive; 3. Utilisez NIO avec des canaux et des sélecteurs pour une programmation réseau à haute performance et non bloquante; 4. Utilisez le service d'observation de Nio.2 pour surveiller les modifications du répertoire et AsynchronousFileChanal pour les opérations de fichiers non bloquantes; 5. Préférez Paths.get () et TRY-WITH-RESOURCES pour la gestion des ressources et évitez de charger des fichiers volumineux entièrement en mémoire avec ReadAlllines (). Nio.2 est la norme recommandée pour la gestion des fichiers dans Java 7 et plus tard en raison de sa conception supérieure, de sa conception, de sa conception supérieure, de ses capacités de performance.

Le système d'E / S de Java (entrée / sortie) a évolué de manière significative au fil des ans, en particulier avec l'introduction de NIO (Nouvelles E / S) dans Java 1.4 et la révision majeure de NIO.2 avec Java 7. Comprendre à la fois les I / S traditionnelles et le NIO.2 est essentiel pour la construction efficace, évolutive et maintenable des applications qui gèrent efficacement les opérations de fichiers et les données.

Décomposons les aspects clés de Java E / S et NIO.2, comparez leurs forces et voyez comment elles s'intègrent dans le développement de Java moderne.

1. E / S Java traditionnel: le modèle basé sur le flux

Le système d'E / S original de Java, introduit dans les premières versions de Java, est basé sur des flux - des représentations abstraites du flux de données. Il se trouve dans le package java.io et tourne autour des flux d'octets et de personnages.

Composants clés:

• InputStream / OutputStream : pour gérer les octets bruts (par exemple, fichiers, sockets réseau).
• Lecteur / écrivain : pour les E / S basés sur les personnages, en soutenant l'encodage / décodage (par exemple, FileReader , BufferedReader ).
• Décorateurs : Les flux peuvent être enveloppés (par exemple, BufferedInputStream , DataInputStream ) pour ajouter des fonctionnalités.

Exemple: lire un fichier

 Try (BufferedReader Reader = new BufferedReader (nouveau FileReader ("data.txt"))) {
    Ligne de cha?ne;
    while ((line = reader.readline ())! = null) {
        System.out.println (ligne);
    }
}

Caractéristiques:

• Synchrones et blocage : chaque opération d'E / S bloque le fil jusqu'à la fin.
• Axé sur le flux : les données sont traitées séquentiellement; Pas d'accès aléatoire.
• Simple pour les taches de base : idéal pour les petits fichiers ou les cas d'utilisation simples.

Cependant, les E / S traditionnelles luttent avec l'évolutivité dans des environnements à haute curances (par exemple, les serveurs manipulant des milliers de connexions), où le blocage des E / S conduit à l'épuisement du filetage.

2. Java Nio: le modèle de tampon et de canal (Java 1.4)

Nio ( java.nio ) a introduit une approche non bloquante et tampon des E / S, con?ue pour des applications hautes performances et évolutives.

Concepts de base:

• Canaux : conduits bidirectionnels pour les données (contrairement aux flux unidirectionnels). Exemples: FileChannel , SocketChannel .
• Tampons : conteneurs de données de taille fixe (par exemple, ByteBuffer , CharBuffer ) qui maintiennent les données en cours de lecture / écrite.
• SéLECTEURS : Activer le multiplexage - un seul thread peut surveiller plusieurs canaux pour les événements (par exemple, prêt à lire / écrire), crucial pour les E / S de réseau non bloquantes.

Exemple: lire un fichier avec Nio

 Try (FileChannel Channel = FileChannel.Open (paths.get ("data.txt"), standardOpenOption.read)) {
    ByteBuffer Buffer = ByteBuffer.AllOcy (1024);
    while (canal.read (tampon)> 0) {
        buffer.flip ();
        while (buffer.hasreming ()) {
            System.out.print ((char) buffer.get ());
        }
        buffer.clear ();
    }
}

Avantages:

• E / S non bloquant : particulièrement utile dans la programmation réseau (par exemple, serveurs utilisant Selector ).
• Fichiers mappés de mémoire : FileChannel.map() permet de mappage d'un fichier directement en mémoire pour un accès rapide.
• De meilleures performances pour les grands transferts de données .

Mais l'API de Nio est plus complexe et moins intuitive que les E / S traditionnelles, et la gestion des fichiers (en particulier les chemins et les métadonnées) était encore maladroite.

3. Nio.2: E / S de fichiers modernes (Java 7)

Nio.2, introduit dans Java 7 via java.nio.file , a révisé le modèle d'interaction du système de fichiers. Il vit dans java.nio.file , java.nio.file.attribute et java.nio.file.spi .

Caractéristiques clés:

• Interface de chemin : un remplacement moderne pour java.io.File , représentant un chemin de système de fichiers.
• Classe de fichiers : Méthodes d'utilité riche pour les opérations communes (copier, déplacer, supprimer, lire, écrire).
• API de Système de fichiers : prend en charge plusieurs systèmes de fichiers (par exemple, les fichiers ZIP via FileSystemProvider ).
• WatchService : Surveillez les répertoires pour les modifications de fichiers (créer, modifier, supprimer).
• E / S asynchrones : AsynchronousFileChannel permet des opérations de fichiers vraiment non bloquantes.

Exemple: lire un fichier avec Nio.2

 Path path = paths.get ("data.txt");
List <string> lines = files.readalllines (path, standardCharsets.utf_8);

Ou même plus simple:

 String Content = Files.ReadString (Path);

Exemple: regarder un répertoire

 WatchService watcher = filesystems.getDefault (). NewWatchService ();
Path dir = paths.get ("watted-folder");
dir.register (Watcher, standardwatchEventKinds.entry_create);

// dans une boucle
WatchKey key = watcher.take ();
pour (watchEvent <?> événement: key.pollevents ()) {
    System.out.println ("Fichier créé:" Event.Context ());
}

Avantages par rapport aux E / S hérités:

• API plus intuitive et expressive .
• Meilleure gestion des exceptions (exceptions spécifiques comme NoSuchFileException ).
• Prise en charge des liens symboliques, des attributs de fichiers et des autorisations .
• Fournisseurs de systèmes de fichiers enfichables (par exemple, en travaillant avec des archives ZIP comme systèmes de fichiers).

4. Quand utiliser quoi?

Règle de base : pour les E / S de fichiers dans Java moderne (8), préférez Nio.2. C'est plus s?r, plus concis et riche en fonctionnalités.

5. Conseils pratiques et gotchas

• Utilisez toujours TRY-WITH-RESOURCES : les flux et les canaux sont AutoCloseable .
• Préférer Paths.get() sur new File() : il renvoie un Path , la fondation de Nio.2.
• WatchService nécessite une consommation d'événements : appelez toujours pollEvents() et reset() sur la clé.
• évitez readAllLines() pour les fichiers volumineux : il charge tout en mémoire. Utilisez Files.lines() pour le streaming:

   Try (stream <string> lines = files.lines (path)) {
      Lines.ForEach (System.out :: println);
  }

• Utilisez StandardOpenOption pour un contr?le à grain fin (par exemple, CREATE , APPEND ).

---

Réflexions finales

Alors que les E / S Java traditionnelles sont toujours fonctionnelles et largement vues dans Legacy Code, Nio.2 est le présent et l'avenir de la gestion des fichiers en Java . Il combine les avantages de la performance de NIO avec une API propre et de haut niveau. Pour les nouveaux projets, par défaut NIO.2, sauf si vous avez une raison spécifique d'utiliser des constructions de niveau inférieur.

Comprendre l'évolution de java.io → Nio → Nio.2 vous aide à faire des choix éclairés sur les performances, l'évolutivité et la clarté du code.

Fondamentalement, si vous faites des E / S de fichiers à Java aujourd'hui, vous devriez utiliser java.nio.file . Les anciennes manières ne sont pas fausses - elles sont juste dépassées.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!