JavaでIOストリームを分類する方法

1. IO: アップロードとダウンロード、書き込みと書き込み

ストリーム: 先入れで流れる一連のデータの流れ先出し方式、パイプライン、プログラム中心、プログラムとネットワーク | ファイル | サーバー | 配列.. (関連コースの推奨事項: Java ビデオ チュートリアル)

分類

1) 流れの方向による:

入力ストリーム、出力ストリーム

2) 演算単位の分類:

バイト ストリーム (ユニバーサル ストリーム):あらゆるコンテンツを転送可能 バイトであり、テキスト、画像、音声を送信可能; 文字ストリーム: プレーンテキストデータのみを操作可能

3) 関数によると:

ノードストリーム:基本的な機能を実現するためのソース; 関数ストリーム : ノードストリームのパフォーマンスを強化し、効率を向上させます

4) 各分類は補完的です

バイトストリーム

(1) バイト入力ストリーム: InputStream この抽象クラスは、バイト入力ストリームを表すすべてのクラスのスーパークラスです。FileInputStream は、ファイル システム

//字节流输入 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) バイト出力ストリーム: OutputStream This抽象クラスは、出力バイト ストリームを表すすべてのクラスのスーパークラスです。 FileOutputStream ファイル出力ストリームは、データを 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

# に書き込むために使用される出力ストリームです。プレーンテキストのみ操作可能

1) ノードストリーム:

(1)文字入力ストリーム: Reader は文字ストリームを読み取るための抽象クラス、FileReader は文字ファイルを読み取るための便利なクラス

//字符输入流 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)文字出力ストリーム: Writer は文字ストリームを記述するための抽象クラス、FileWriter は文字ファイルを記述するための便利なクラスです

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

機能の流れ
# バッファリングされたストリーム: 強化された機能、向上したパフォーマンス、高速な読み取りと書き込みの効率

##1) バイト ストリーム:

BufferedInputStream バイト入力ストリーム バッファリングされたストリーム

BufferedOutputStream バイト出力ストリーム バッファリングされたストリーム

新しいメソッドはありません。ポリモーフィックな使用が発生する可能性があります

//导包
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) 文字ストリーム:

BufferedReader 文字入力ストリーム バッファリングされたストリーム

新しいメソッド: String readLine() はテキスト行を読み取ります

BufferedWriter 文字出力ストリーム バッファ ストリーム

新しいメソッド: void newLine() は行区切り文字を書き込みます

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

データストリーム(バイトノードストリーム)

データストリーム(バイトノードストリーム):

読み書き可能な基本データ型 文字列型データ、バイトストリーム関数ストリームの一種です

DataInputStream の新しいメソッド: readXxx()

DataOutputStream の新しいメソッド: writeXxx()

新しいメソッド状態がある場合、複数の発生は発生しません。最初に書き込み、次に write

発生する可能性のある例外: EOFException ファイルには次の内容があります。内容を読み取ることができません。書き込まれたソース ファイルを読み取る必要があります。

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

オブジェクト ストリーム

オブジェクトはデータを保存します。型データ

# バイト関数ストリーム: オブジェクト型データの読み取りおよび書き込みを送信する場合は、オブジェクト ストリームを使用できます

シリアル化: オブジェクト型データを保存可能な | 形式に変換するプロセス。送信可能状態

ObjectInputStream() 逆シリアル化された入力ストリーム 新しいメソッド: readObject()

ObjectOutputStream( ) シリアル化された出力ストリーム 新しいメソッド: writeObject()

注:

1) 最初にシリアライズしてからデシリアライズ

2) シリアライズとデシリアライズの読み取りと書き込みの順序は一貫しています

3) すべてのクラスをシリアル化できるわけではありません java.io.Serializable 空のインターフェイス

4) すべてのプロパティを一時的にシリアル化する必要はありません

5) 静的コンテンツはシリアル化されません

6) 親クラスが Serializable インターフェイスを実装している場合、すべてのコンテンツはシリアル化できますサブクラス

サブクラスが Serializable インターフェイスを実装しているが、親クラスがそれを実装していない場合、サブクラスはサブクラスに固有のコンテンツのみをシリアル化できます

//导包
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. ファイル クラス

ファイル クラス: ファイルとディレクトリのパス名の抽象表現

提供される関数: ファイルの外部で操作できるが、ファイル内部のコンテンツは操作できない

実際のパス | ファイルを定義します。ファイルが存在しない場合でも定義できます。そのため、抽象式は

コンストラクター : File(Fileparent, String child) 親抽象に基づいて新しい File インスタンスを作成します。パス名と子のパス名文字列

File(String pathname) 指定されたパス名文字列を抽象パス名に変換して作成されます 新しい File インスタンス

File(Stringparent, String child) 新しい File インスタンスを作成します親パス名文字列と子パス名文字列に基づく

この記事は

Java 入門チュートリアル

列から引用したものです。ぜひ学習してください。

以上がJavaでIOストリームを分類する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。