Comment classer les flux IO en Java

1. IO : télécharger et télécharger, écrire et écrire

Flux : une série de données fluides, circulant dans un premier entré , premier sorti, pipeline, centré sur le programme, programme et réseau | serveur | tableau.. (Recommandations de cours associées : Tutoriel vidéo Java

Classification

1) Selon le sens du flux :

flux d'entrée ; flux de sortie

2) Unité d'opération :

Flux d'octets (flux universel) : n'importe quel contenu peut être transféré. Il s'agit d'octets et peut transmettre du texte, des images et de l'audio ; flux de caractères : ne peut utiliser que des données en texte brut

3) Selon la fonction :

Flux de nœuds : encapsule le source pour réaliser les fonctions de base ; flux de fonctions : Améliorer les performances des flux de nœuds et améliorer l'efficacité

4) Chaque catégorie est complémentaire les unes des autres

Flux d'octets

(1) Flux d'entrée d'octets : InputStream Cette classe abstraite est la superclasse de toutes les classes qui représentent des flux d'entrée d'octets ; FileInputStream obtient des octets d'entrée à partir d'un fichier dans le système de fichiers

//字节流输入 InputStream 
//导包	导包快捷键: ctrl+shift+o
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
public class Demo01 {
	public static void main(String[] args) throws IOException {
		//FileInputStream(String name) 
		通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定
		//FileInputStream(File file) 
		通过打开一个到实际文件的连接来创建一个 FileInputStream，
		该文件通过文件系统中的 File 对象 file 指定
		InputStream is=new FileInputStream(new File("D:/test.txt"));//创建D盘符的根目录下的文件
		System.out.println(is);
		//方式1： int read() 读入数据 一个字节一个字节读入
		/*int num=is.read();
		System.out.println((char)num);
		num=is.read();
		System.out.println((char)num);
		System.out.println((char)(is.read()));*/
		//方式2：使用循环,循环读入，可以简化代码,重复代码只写一次,但还是一个字节一个字节的读入
		/*int num=-1;
		while((num=is.read())!=-1){
			System.out.println((char)num);
		}*/
		//方式3：int read(byte[] b) 一个字节数组一个字节数组的读入
		//返回值: 返回读入到字节数组中数据的个数,没有读到返回-1
		byte[] car=new byte[1];
		//int len=is.read(car); 
		int len=-1;
		while((len=is.read(car))!=-1){
			System.out.println(new String(car,0,len));
		}
		//关闭
		is.close();
	}
}

(2) Flux de sortie d'octets : OutputStream Cette classe abstraite est la superclasse de toutes les classes qui représentent les flux d'octets de sortie ; FileOutputStream Le flux de sortie du fichier est le flux de sortie utilisé pour écrire des données dans File

//字节输出流 OutputStream
//导包	导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo02 {
	public static void main(String[] args) {
		//FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流
		//FileOutputStream(String name,boolean append)  
		创建一个向具有指定 name 的文件中写入数据的输出文件流
		//FileOutputStream(File file,boolean append) 
		创建一个向指定 File 对象表示的文件中写入数据的文件输出流
		//boolean append	返回值：true追加,false不追加(默认false)
		OutputStream os=null;
		//try...catch(){}	捕捉异常，处理异常
		try {
			//1.选择流
			os=new FileOutputStream("D:/hhh.txt",hhtrue); 
			//文件不存在,系统会自动帮我们创建,但文件夹不会
			//2.准备数据
			String str="要好好学习，天天向上..."; 
			byte[] c和=str.getBytes();
			//3.写出 void write(byte[] b)  
			os.write(ch);
			//4.刷出
			os.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//5.关闭
			try {//预防空指针异常
				if(os!=null){
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Character stream

Ne peut fonctionner que sur du texte brut

1) Flux de nœuds :

(1) Flux d'entrée de caractères : Reader est une classe abstraite pour la lecture de flux de caractères FileReader est une classe pratique pour la lecture ; fichiers de caractères

//字符输入流 Reader
//导包	导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class Demo03 {
	public static void main(String[] args) {
		//FileReader(String fileName) 
		Reader rd=null;
		try {
			//1.选择流
			rd=new FileReader("D:/hehe.txt");//创建D盘符的根目录下的文件
			//2.读入
			//方法1：int read() 读取单个字符。 
			/*System.out.println((char)rd.read());
			System.out.println((char)rd.read());
			System.out.println((char)rd.read());
			System.out.println((char)rd.read());*/
			int len=-1;  //存储读到的数据  如果为-1,证明已达到末尾
			//方法2:
			/*while(-1!=(len=rd.read())){
				System.out.println((char)len);
			}*/
			//方法3：int read(char[] cbuf)  将字符读入数组。
			char[] car=new char[1024];
			while((len=rd.read(car))!=-1){
				System.out.println(new String(car,0,len));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			if(rd!=null){
				try {
					//关闭功能
					rd.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}
}

(2) Flux de sortie de caractères : Writer est une classe abstraite pour écrire des flux de caractères ; FileWriter est une classe pratique pour écrire des fichiers de caractères

//字符输出流：Writer
//导包	导包快捷键: ctrl+shift+o
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class CharDemo02 {
	public static void main(String[] args) {
		//FileWriter(File file) 		//默认不追加
		//FileWriter(File file, boolean append)  	
		//FileWriter(String file)  
		//FileWriter(String file, boolean append)  
		Writer rt=null;
		try {
			//1.选择流
			rt=new FileWriter("D:/houhou.txt",true);
			//2.写出
			/*	void write(char[] cbuf)  写入字符数组 
				void write(char[] cbuf, int off, int len) 写入字符数组的某一部分
				void write(int c) 写入单个字符
				void write(String str)  写入字符串 
				void write(String str, int off, int len) 写入字符串的某一部分 
			*/
			rt.write(97);
			rt.write("\r\n");  		//换行
			rt.write("你真好看!!!!");
			rt.write("\r\n");
			rt.write("你真好看!!!!",2,2);
			rt.write("\r\n");
			char[] ch={'a','b','c','d','e'};
			rt.write(ch);
			rt.write("\r\n");
			rt.write(ch,2,3);
			//3.刷出
			rt.flush();		
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//4.关闭
			if(null!=rt){
				try {
					rt.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

Flux de fonctions

Flux tamponné : fonctions améliorées, performances améliorées, efficacité de lecture et d'écriture plus rapide

1) Flux d'octets :

Flux d'entrée d'octets BufferedInputStream flux tamponné

Flux de sortie d'octets BufferedOutputStream flux tamponné

Aucune nouvelle méthode, une utilisation polymorphe peut se produire

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class BufferedInputStream01 {
	public static void main(String[] args) throws IOException {
		//1.选择流
		//BufferedInputStream(InputStream in) 
		InputStream is=new BufferedInputStream(new FileInputStream("D:/hehe.txt"));
		OutputStream os=new BufferedOutputStream(new FileOutputStream("E:/hengheng.txt") );
		//2.读写
		byte[] car=new byte[1024];
		int len=-1;
		while((len=is.read(car))!=-1){
			os.write(car,0,len);
		}
		//3.刷出
		os.flush();
		//4.关闭
		os.close();
		is.close();
	}
}

2) Flux de caractères :

Flux d'entrée de caractères BufferedReader flux tamponné

Nouvelle méthode : String readLine() Lire une ligne de texte

BufferedWriter Flux de sortie de caractères flux tamponné

Nouvelle méthode : void newLine() Écrire un séparateur de ligne

//导包
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedReader02 {
	public static void main(String[] args) throws IOException {
		//1.选择流  导包快捷键: ctrl+shift+o
		BufferedReader br=new BufferedReader(new FileReader("D:/hehe.txt"));
		BufferedWriter bw=new BufferedWriter(new FileWriter("D:/ccc.txt"));
		//2.读写
		String msg=null;
		while((msg=br.readLine())!=null){
			bw.write(msg);
			bw.newLine();
		}
		//3.刷出
		bw.flush();
		//4.关闭
		bw.close();
		br.close();
	}
}

Flux de données (flux de nœuds d'octets)

Flux de données (flux de nœuds d'octets) :

Lire et écrire des types de données de base + Données de type chaîne, est un type de fonction de flux d'octets stream

DataInputStream nouvelle méthode : readXxx()

DataOutputStream nouvelle méthode : writeXxx()

Ne peut pas se produire si une nouvelle méthode existe Polymorphisme, écrivez d'abord puis écrivez

Exceptions possibles rencontrées : EOFException Il y a un fichier, mais le contenu ne peut pas être lu. Ce qui doit être lu, c'est le fichier source écrit

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Data01 {
	public static void main(String[] args) throws IOException {
		//调用方法
		write("D:/data.txt");
		read("D:/data1.txt");
	}
	//读入
	public static void read(String path) throws IOException{
		//1.输入流 数据类型+数据
		DataInputStream in=new DataInputStream(new  BufferedInputStream(new FileInputStream(path)));
		//2.读入
		int i=in.readInt();
		boolean b=in.readBoolean();
		String s=in.readUTF();
		System.out.println(i+"-->"+b+"-->"+s);
		//3.关闭
		in.close();
	}
	//写出
	public static void write(String path) throws IOException{
		//1.输出流
		DataOutputStream out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
		//2.准备数据
		int i=101;
		boolean f=false;
		String s="哈哈";
		//3.写出  写出和读入的顺序要保持一致
		out.writeInt(i);
		out.writeBoolean(f);
		out.writeUTF(s);
		//4.刷出
		out.flush();
		//5.关闭
		out.close();
	}
}

Object stream

Object. enregistre le type de données + les données

Flux de fonction d'octet : lorsque vous souhaitez transmettre | lire et écrire des données de type d'objet, vous pouvez utiliser un flux d'objet

Sérialisation : le processus de conversion des données de type d'objet en un état stockable|transmissible

ObjectInputStream() Désérialiser le flux d'entrée Nouvelle méthode : readObject()

ObjectOutputStream() Flux de sortie sérialisé Nouvelle méthode : writeObject()

Remarque :

1) Sérialiser d'abord puis désérialiser

2) Sérialiser et désérialiser la lecture L'ordre d'écriture est cohérent

3) Toutes les classes ne peuvent pas être sérialisées java.io.Interface vide sérialisable

4) Tous les attributs n'ont pas besoin d'être sérialisés de manière transitoire

5) le contenu statique ne sera pas sérialisé

6) Si la classe parent implémente l'interface Serialisable, tout le contenu peut être sérialisé dans la sous-classe

Si la sous-classe implémente l'interface Serialisable, mais que la classe parent ne l'implémente pas, les sous-classes ne peuvent sérialiser que le contenu unique à la sous-classe

//导包
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Arrays;
public class ObjectDemo02 {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		write("D:/object.txt");
		read("D:/object.txt");
	}
	//反序列化输入
	public static void read(String path) throws IOException, ClassNotFoundException{
		//1.输入流
		ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
		//2.读入
		Object p= is.readObject();
		int[] arr= (int[]) is.readObject();
		if(p instanceof Person){
			Person person=(Person)p;
			System.out.println(person.getName());
		}
		System.out.println(p);
		System.out.println(Arrays.toString(arr));
		//3,关闭
		is.close();
	}
	//序列化输出
	public static void write(String path) throws IOException{
		//1.输出对象信息
		ObjectOutputStream os=new ObjectOutputStream(new BufferedOutputStream(new 
		FileOutputStream(path)));
		//2.准备数据
		Person p=new Person("aaa",18);
		int[] arr={1,2,3,4};
		//3.输出
		os.writeObject(p);
		os.writeObject(arr);
		//4.刷出
		os.flush();
		//5.关闭
		os.close();
	}
}
//接口
class Person implements Serializable{
	private  String name;
	private static int age;
	public Person() {
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

2. class

Classe de fichiers : représentation abstraite des noms de chemin de fichier et de répertoire

Fonctions fournies : La possibilité d'opérer en dehors du fichier, mais pas le contenu à l'intérieur du fichier

Possibilité de définir de vrais chemins|fichiers, et ceux qui n'y sont pas peuvent également être définis, donc l'expression abstraite est

Constructeur : Fichier (Fichier parent, String enfant) Créer une nouvelle instance de Fichier basée sur le parent chemin abstrait et chaîne de chemin enfant

Fichier (String pathname) En convertissant la chaîne de chemin donnée en un chemin abstrait Pour créer une nouvelle instance de fichier

File (String parent, String child) Créer un nouveau Instance de fichier basée sur la chaîne de nom de chemin parent et la chaîne de nom de chemin enfant

Cet article provient de la colonne

Tutoriel de démarrage Java , bienvenue pour apprendre !

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!