Introduction et exemple d'analyse de la classe File et du flux IO en Java

IO stream :

Aperçu du flux IO :

IO : Entrée/Sortie (Entrée/Sortie)

Stream : C'est un concept abstrait et un terme général pour les données transmission. . C'est-à-dire que la transmission de données entre appareils est appelée flux. L'essence d'un flux est la transmission de données. Les flux IO sont utilisés pour traiter les problèmes de transmission de données entre appareils. Applications courantes : téléchargement de fichiers ; etc. Bref, cela implique Tout ce qui concerne la transmission implique des flux.

Schéma du système de flux IO :

Étant donné que l'IO implique des opérations sur les fichiers, elle doit être indissociable de la technologie d'exploitation des fichiers :

Classe de fichiers :

La classe de fichiers est dans le package java.io Le seul objet qui représente le fichier disque lui-même. La classe File définit certaines méthodes pour exploiter les fichiers, principalement utilisées pour obtenir ou traiter des informations liées aux fichiers du disque, telles que le nom du fichier, le chemin du fichier, les autorisations d'accès, la date de modification, etc., et peut également parcourir la hiérarchie des sous-répertoires.

La classe File représente les informations liées au traitement des fichiers et des systèmes de fichiers. La classe File n'a pas pour fonction de lire les informations des fichiers et d'écrire des informations dans les fichiers. Elle décrit uniquement les propriétés du fichier lui-même. Il est donc associé à IO pour les opérations de lecture et d’écriture.

Regardez d'abord un schéma récapitulatif des méthodes couramment utilisées de la classe File :

Utilisez createNewFile() pour créer un fichier :

public class test01 {
    public static void main(String[] args) throws IOException {
		//先建立一个File对象，并传入路径
        File file1 = new File("G://abc.txt");
        //创建空文件，如果没有存在则新建一个，并且返回True,如果存在了就返回false
        System.out.println(file1.createNewFile());   
}

Si après exécution, le répertoire ne possède pas ceci fichier, alors un sera créé. Et renvoie vrai s'il existe déjà, il retournera faux, indiquant que la création a échoué.

Utilisez mkdir() pour créer un répertoire :

File file2 = new File("G://a");
	System.out.println(file2.mkdir());   
//创建一个目录，如果没有存在则新建一个，并且返回True,如果存在了就返回false

Utilisez mkdirs() pour créer un répertoire à plusieurs niveaux :

File file3 = new File("G://a//b//c");
        System.out.println(file3.mkdirs());   
//创建多级目录，如果没有存在则新建一个，并且返回True,如果存在了就返回false

Ensuite, nous devons utiliser la fonction dans le Flux IO pour entrer le fichier et sortir :

Introduisez d'abord quatre flux couramment utilisés :

• Flux d'entrée d'octets : InputStreamInputStream

• 字节输出流：OutputStream

• 字符输入流：Reader

• 字符输出流：Writer

Flux de sortie d'octets : OutputStream <p><strong></strong></p>Flux d'entrée de caractères : <code>Lecteur

Flux de sortie de caractères : Écrivain

Pourquoi y a-t-il deux flux, octet et caractère ?

En code ASCII

, une lettre anglaise (indépendamment des majuscules et des minuscules) équivaut à un octet et un caractère chinois équivaut à deux octets.

Dans l'encodage UTF-8, un mot anglais fait un octet et un mot chinois fait trois octets.

Dans l'encodage Unicode, un mot anglais équivaut à un octet et un mot chinois équivaut à deux octets.

Nous savons donc que l'ordinateur lit les données une par une. Lorsque le fichier contient des chiffres ou de l'anglais, car ils occupent tous un octet, ils peuvent être lus normalement.

Et si c’était des caractères chinois ? Il occupe au moins deux octets. Si un caractère chinois est divisé et lu, il y aura certainement un problème d'affichage.

Résumé :

Si les données sont ouvertes via le logiciel Bloc-notes fourni avec Windows et que nous pouvons toujours lire le contenu à l'intérieur, utilisez le flux de caractères, sinon utilisez le flux d'octets. Si vous ne savez pas quel type de flux utiliser, utilisez un flux d'octets !

Ce qui suit est un tableau récapitulatif des noms de méthodes pour les fonctions correspondantes des quatre flux :

Flux de sortie d'octets :

Nous utilisons le flux de sortie d'octets pour écrire une phrase dans le fichier abc.txt :

public class test01 {
    public static void main(String[] args) {

        try{
              //创建输出流对象：
            OutputStream fos = null;
            fos = new FileOutputStream("G://abc.txt");
            String str = "今天的博客是IO流";
            //先将需要写入的字符打散成数组：
            byte[] words = str.getBytes();
            //使用写入的功能
            fos.write(words);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Après l'exécution :

Flux d'entrée d'octets (lu du fichier à la console) : Nous savons que si le fichier contient des caractères chinois et utilise le flux d'entrée d'octets, alors l'affichage sera définitivement tronqué. Si le fichier est maintenant à l'intérieur se trouvent les quatre mots "I love China". Utilisez le code suivant :

public class test02 {
    public static void main(String[] args) {
        //创建字节输入流对象：
        InputStream fis = null;
        try{
            fis = new FileInputStream("G://abc.txt");
            int data;
            //fis.read()取到每一个字节通过Ascll码表转换成0-255之间的整数，没有值返回-1
            while((data=fis.read())!=-1){
                //(char) data 将读到的字节转成对应的字符
                //中文的字符是2+个字节组成
                System.out.print((char) data);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Le résultat de sortie est :

🎜🎜 Ensuite, modifiez les informations du fichier en anglais et en chiffres. : 🎜🎜🎜🎜🎜 🎜🎜Conclusion : les fichiers contenant des caractères chinois ne peuvent pas être lus à l'aide de flux d'octets🎜🎜

字符输出流：

我们使用字符输出流给abc.txt文件里面写几句话：

public class test03 {
    public static void main(String[] args) {
        try{
            //使用字符输出流的FileWriter写入数据
            Writer fw = new FileWriter("G://abc.txt");
            fw.write("我们在学Java");
            fw.write("一起加油");
            fw.close(); //关闭资源
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

也没用问题，我们发现，使用字符流写中文汉字更方便。

字符输入流：

可以设置缓存流提高获取值的效率：

public class test04 {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象：
        Reader fr = null;
        try{
            fr = new FileReader("G:/abc.txt");
            //借助字符流对象创建了字符缓存区 把字符一个一个的取到后先放到缓存区
            //然后一起再读写到程序内存来，效率更高
            BufferedReader br = new BufferedReader(fr);
            //先去缓存区一行一行的读取
            String line = br.readLine();
            while(line != null){
                System.out.println(line);
                line = br.readLine();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

当文件内的信息为多行的时候：

字节流和字符流总结：

• IO是文件的输入和输出，我们要想去对文件或者写，或者通过程序发送消息给另外的用户都要用到流。

• IO流分 字节流和字符流，字节流是以字节为单位IO，字符流是以字符为单位IO；通常读写图片、视频音频等用字节 流，如果读写文件的内容比如中文建议用字符流。

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!