Java笔记输入和输出处理（二）

水沉草木

已于 2022-07-09 14:18:03 修改

阅读量184

点赞数

文章标签： java 开发语言 jvm

于 2022-07-07 13:50:44 首次发布

本文链接：https://blog.csdn.net/qq_69761234/article/details/125651939

版权

字符流

InputStreamReader类

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class InputStreamReaderDemo01 {

	public static void main(String[] args) {
		//创建File对象
		File file=new File("D:\\Workspaces\\demo.txt");
		
		//创建InputStream类对象，InputStream是一个抽象类，可以创建一个子类FileInputStream对象
		InputStream is=null;
		InputStreamReader isd=null;
		try {
			is=new FileInputStream(file);
			isd=new InputStreamReader(is);
			
			//读取数据
			int num=isd.read();
			System.out.println(num);
			//循环遍历读取数据
			int num1;
			while((num1=isd.read())!=-1){
				System.out.print((char)num1);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			//关闭多个流的原则：先开的后关，后开的先关
			if(isd!=null){
				try {
					isd.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(is!=null){
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}
}

FileReader类BufferedReader类

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo01 {

	public static void main(String[] args) {
//		FileReader fr=null;		
		try {
			FileReader fr=new FileReader("D:\\Workspaces\\demo.txt");
			int num=fr.read();
			System.out.println((char)num);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

BufferedReader类

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferedReaderDemo01 {

	public static void main(String[] args) {
        //创建对象
		BufferedReader br=null;
		try {
			br=new BufferedReader(new InputStreamReader(new 
            FileInputStream("D:\\Workspaces\\demo.txt")));
			String str;
			while((str=br.readLine())!=null){
				System.out.println(str);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

OutputStreamWriter类

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo01 {

	public static void main(String[] args) {
		// 创建OutputStreamWriter类对象
		OutputStreamWriter osw=null;
		try {
			osw=new OutputStreamWriter(new                 
          FileOutputStream("D:\\Workspaces\\demo.txt",true));
			osw.write("hello java");
			System.out.println("输入完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(osw!=null){
				try {
					osw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

FileWriter类

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo01 {

	public static void main(String[] args) {
		//创建FileWriter类对象
		FileWriter fw=null;
		try {
			fw=new FileWriter("D:\\Workspaces\\demo.txt",true);
			fw.write("hi,js");
			System.out.println("数据写入完毕");
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(fw!=null){
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}	
		}
	}
}

BufferedWriter类

import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class BufferedWriterDemo01 {

	public static void main(String[] args) {
		//创建BufferedWrite类对象
		BufferedWriter bw=null;
		try {
			bw=new BufferedWriter(new OutputStreamWriter
					(new FileOutputStream("D:\\Workspaces\\demo.txt")));
			//newLine() 写入一个行分隔符
			bw.newLine();
			bw.write("fqefqefqjyk");
			bw.newLine();
			bw.write("jwroooppppkp");
			//flush() 刷新该流的缓冲，在读入数据和关闭流之前需要先刷新
			bw.flush();
			System.out.println("数据写入完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(bw!=null){
				try {
					bw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}			
		}
	}
}

读写二进制文件

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 DataInputStreamAndDataOutputStreamDemo01 {

	public static void main(String[] args) {
		//创建FileInputStream类对象
		FileInputStream fis=null;
		//创建DataInputStream类对象
		DataInputStream dis=null;
		//创建FileOutputStream类对象
		FileOutputStream fos=null;
		//创建DataOutputStream类对象
		DataOutputStream dos=null;
				
		try {
			fis = new FileInputStream("D:/Workspaces/haha.jpg");
			dis=new DataInputStream(fis);
			fos=new FileOutputStream("D:/Workspaces/hahaha.jpg");
			dos=new DataOutputStream(fos);
			int num;
			while((num=dis.read())!=-1){
				dos.write(num);
			}
			System.out.println("图片复制完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			if(dos!=null){
				try {
					dos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fos!=null){
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(dis!=null){
				try {
					dis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis!=null){
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}		
	}
}

序列化和反序列化

序列化是将对象的状态写入到特定的流中的过程

反序列化则是从特定的流中获取数据重新构建对象的过程

import java.io.Serializable;

public class Student implements Serializable{
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(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 "Student [name=" + name + ", age=" + age + "]";
	}
}

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class ObjectOutputStreamDemo01 {

	public static void main(String[] args) {
		// 创建OutputStream类对象
		OutputStream os = null;
		// 创建ObjectOutputStream类对象
		ObjectOutputStream oos = null;
		try {
			os = new FileOutputStream("D:\\Workspaces\\Student.txt");
			oos = new ObjectOutputStream(os);
			//准备要输出的学生对象
			Student stu1 = new Student("张三", 15);			
			oos.writeObject(stu1);
			System.out.println("对象写入完毕");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				oos.close();
				os.close();
			} catch (IOException e) {
				e.printStackTrace();
			}			
		}
	}
}



import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ObjectInputStreamDemo01 {

	public static void main(String[] args) {
		// 创建ObjectInputStream类对象
		ObjectInputStream ois =null;
		try {
			ois = new ObjectInputStream(new     
            FileInputStream("D:\\Workspaces\\Student.txt"));
			Object object=ois.readObject();
			Student stu = (Student)object;
			System.out.println(stu.getName()+"-"+stu.getAge());
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}finally{
			try {
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

流总结：

   （1）File类：操作文件或者目录的属性
           File("文件路径")
   （2）流：传输数据的通道
           按照传输方向分类：
               输入流：InputStream、Reader
               输出流：OutputStream、Writer
           按照数据处理单元分类
               字节流：InputStream、OutputStream
               字符流：Reader、Writer
   （3）InputStream类（抽象类）
   （4）FileInputStream类（InputStream类的子类）
           构造方法：
               FileInputStream(File file)
               FileInputStream(String path)
   （5）OutputStream类（抽象类）
   （6）FileOutputStream类（OutputStream类的子类）
           FileOutputStream(File file)
           FileOutputStream(String path)
           FileOutputStream(File file,boolean bool)
           FileOutputStream(String path,boolean bool)
   （7）Reader类（抽象类）
   （8）InputStreamReader类（Reader类的子类）
               InputStreamReader(InputStream is)
               InputStreamReader(InputStream is,String charset)
   （9）FileReader类（InputStreamReader类的子类）
           FileReader(File file)
           FileReader(String path)
   （10）BufferedReader类（Reader类的子类）
           BufferedReader(Reader re)
   （11）Writer类（抽象类）
   （12）OutputStreamWriter类（Writer类的子类）
           OutputStreamWriter(OutputStream os)
           OutputStreamWriter(OutputStream os,String charset)
   （13）FileWriter类（OutputStreamWriter类的子类）
           FileWriter(File file)
           FileWriter(String path)
           FileWriter(File file,boolean bool)
           FileWriter(String path,boolean bool)
   （14）BufferedWriter类（Writer类的子类）
           BufferedWriter(Writer wr)
   （15）DataInputStream类
           DataInputStream(InputStream in)
   （16）DataOutputStream类
           DataOutputStream(OutputStream os)
   （17）序列化：将对象写入到特定的流中，将对象存储到文件中
       反序列化：从特定的流中构造对象对象的过程，从文件中读取对象信息
   （18）ObjectOutputStream类（OutputStream类的子类）
           ObjectOutputStream()
           ObjectOutputStream(OutputStream os)
   （19）ObjectInputStream类（InputStream类的子类）
           ObjectInputStream()
           ObjectInputStream(InputStream is)