So klassifizieren Sie IO-Streams in Java

1. IO: Hochladen und herunterladen, schreiben und ausschreiben

Stream: Eine Reihe fließender Daten, die in einem First-In fließen , First-Out-Methode, Pipeline, programmzentriert, Programm- und Netzwerk-Array |. (Verwandte Kursempfehlungen: Java-Video-Tutorial)

Klassifizierung

1) Entsprechend der Flussrichtung:

Eingabestrom; Ausgabestrom

2) Operationseinheit:

Bytestrom (universeller Strom): Jeder Inhalt kann übertragen werden. Es handelt sich um Bytes, die Text, Bilder und Audio übertragen können. Zeichenstrom: Kann nur Klartextdaten verarbeiten Quelle zur Realisierung grundlegender Funktionen; Funktionsstrom: Verbessern Sie die Leistung von Knotenströmen und verbessern Sie die Effizienz

4) Jede Kategorie ergänzt einander

Byte-Strom

(1) Byte-Eingabestream: InputStream Diese abstrakte Klasse ist die Oberklasse aller Klassen, die Byte-Eingabestreams darstellen; FileInputStream erhält Eingabebytes aus einer Datei im Dateisystem

//字节流输入 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) Byte-Ausgabestream : OutputStream Diese abstrakte Klasse ist die Oberklasse aller Klassen, die Ausgabebyteströme darstellen; FileOutputStream Der Dateiausgabestrom ist der Ausgabestrom, der zum Schreiben von Daten in 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

verwendet wird

Kann nur mit einfachem Text arbeiten1) Knotenstrom:

(1) Zeicheneingabestrom: Reader ist eine abstrakte Klasse zum Lesen von Zeichenströmen; FileReader ist eine Komfortklasse zum Lesen Zeichendateien

//字符输入流 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) Zeichenausgabestrom: Writer ist eine abstrakte Klasse zum Schreiben von Zeichenströmen; FileWriter ist eine praktische Klasse zum Schreiben von Zeichendateien

//字符输出流：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();
				}
			}
		}
	}
}

Funktionsablauf

Gepufferter Stream: Erweiterte Funktionen, verbesserte Leistung, schnellere Lese- und Schreibeffizienz
1) Byte-Stream:

BufferedInputStream Byte-Eingabestream gepufferter Stream

BufferedOutputStream Byte-Ausgabestrom gepufferter Stream

Keine neue Methode, polymorphe Verwendung kann auftreten

//导包
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) Zeichenstrom:

BufferedReader Zeicheneingabestrom gepufferter Stream

Neue Methode: String readLine() Eine Textzeile lesen

BufferedWriter Zeichenausgabestrom gepufferter Stream

Neue Methode: void newLine() Einen Zeilentrenner schreiben

//导包
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();
	}
}

Datenstrom (Byte-Knotenstrom)

Datenstrom (Byte-Knotenstrom): Grundlegende Datentypen lesen und schreiben + Daten vom Typ String, ist eine Art Byte-Stream-Funktion stream

DataInputStream neue Methode: readXxx()

DataOutputStream neue Methode: writeXxx()

kann nicht auftreten, wenn es eine neue Methode gibt Polymorphismus, zuerst schreiben und dann

Mögliche Ausnahmen aufgetreten: EOFException Es gibt eine Datei, aber der Inhalt kann nicht gelesen werden. Was gelesen werden muss, ist die geschriebene Quelldatei

//导包
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();
	}
}

Objektstrom

Objekt speichert Datentyp + Daten

Byte-Funktionsstrom: Wenn Sie Objekttypdaten lesen und schreiben möchten, können Sie einen Objektstrom verwenden

Serialisierung: Der Prozess der Konvertierung des Objekttyps Daten in einen speicherbaren|übertragbaren Zustand

ObjectInputStream() Deserialisieren Sie den Eingabestream. Neue Methode: readObject()

ObjectOutputStream() Serialisierter Ausgabestream. Neue Methode: writeObject()

Hinweis :

1) Zuerst serialisieren und dann deserialisieren

2) Lesen serialisieren und deserialisieren Die Schreibreihenfolge ist konsistent

3) Nicht alle Klassen können java.io.Serializable serialisiert werden leere Schnittstelle

4) Nicht alle Attribute müssen transient serialisiert werden

5 )Statischer Inhalt wird nicht serialisiert

6) Wenn die übergeordnete Klasse die Serializable-Schnittstelle implementiert, alle Inhalte können in der Unterklasse serialisiert werden

Wenn die Unterklasse die Serializable-Schnittstelle implementiert, die übergeordnete Klasse sie jedoch nicht implementiert, können Unterklassen nur für die Unterklasse eindeutige Inhalte serialisieren

//导包
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 . Dateiklasse

Dateiklasse: abstrakte Darstellung von Datei- und Verzeichnispfadnamen

Bereitgestellte Funktionen: Die Möglichkeit, außerhalb der Datei zu arbeiten, aber nicht den Inhalt innerhalb der Datei

Möglichkeit, echte Pfade|Dateien zu definieren, und solche, die nicht vorhanden sind, können ebenfalls definiert werden, daher lautet der abstrakte Ausdruck:

Konstruktor: Datei (übergeordnete Datei, untergeordnete Zeichenfolge) Erstellen Sie eine neue Dateiinstanz basierend auf der übergeordnete abstrakte Pfadname und die untergeordnete Pfadnamenzeichenfolge

File(String pathname) Durch Konvertieren der angegebenen Pfadnamenzeichenfolge in einen abstrakten Pfadnamen So erstellen Sie eine neue Dateiinstanz

File(String parent, String child) Erstellen eine neue Dateiinstanz basierend auf der übergeordneten Pfadnamenzeichenfolge und der untergeordneten Pfadnamenzeichenfolge

Dieser Artikel stammt aus der Spalte

Java Getting Started Tutorial

, willkommen zum Lernen!

Das obige ist der detaillierte Inhalt vonSo klassifizieren Sie IO-Streams in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!