输入和输出处理

已于 2023-07-15 16:33:18 修改
阅读量183 收藏
点赞数
分类专栏： Java高级 文章标签： java 开发语言 eclipse 输入输出处理
于 2023-07-02 13:56:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44114187/article/details/131491482
版权

目录

1.File类

2.流

2.1.InputStream

2.2.OutputStream

2.3.Reader

2.3.1.FileReader

2.3.2.BufferedReader

2.4.Writer

2.4.1.OutputStreamWriter

2.4.2.FileWriter

2.4.3.BufferedWriter

2.5.读写二进制文件

2.5.1.DataInputStream

2.5.2.DataOutputStream

2.6.序列化和反序列化

1.File类

文件：相关记录或存放在一起的数据的集合

Java程序如何访问文件属性？

        Java API：java.io.File类

File类访问文件属性：

File类的常用方法：

方法名称说明

boolean exists( )

判断文件或目录是否存在

boolean isFile( )

判断是否是文件

boolean isDirectory( )

判断是否是目录

String getPath( )

返回此对象表示的文件的相对路径名

String getAbsolutePath( )

返回此对象表示的文件的绝对路径名

String getName( )

返回此对象表示的文件或目录的名称

boolean delete( )

删除此对象指定的文件或目录

boolean createNewFile( )

创建名称的空文件，不创建文件夹

long  length()

返回文件的长度，单位为字节, 如果文件不存在，则返回 0L

import java.io.File;
import java.io.IOException;

public class TestFile {

	public static void main(String[] args) {
		File file = new File("E:\\eclipse_workspaces\\testDemo/test01.txt");
		System.out.println("是否存在："+file.exists());
		System.out.println("是否文件："+file.isFile());
		System.out.println("是否目录："+file.isDirectory());
		System.out.println("相对路径："+file.getPath());
		System.out.println("绝对路径："+file.getAbsolutePath());
		System.out.println("获得名称："+file.getName());
//		System.out.println("删除："+file.delete());
//		try {
//			System.out.println("创建空文件："+file.createNewFile());
//		} catch (IOException e) {
//			// TODO Auto-generated catch block
//			e.printStackTrace();
//		}
		System.out.println("文件长度："+file.length());
		

	}

}

 测试：

import java.io.File;
import java.io.IOException;

//文件操作：文件创建，获取文件相关信息，删除文件
public class FileDemo {
	// 创建文件
	public void create(File file) {
		if (!file.exists()) {
			// 如果文件不存在，则创建
			try {
				file.createNewFile();
				System.out.println("文件已创建！");
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	// 获取文件信息
	public void showFileInfo(File file) {
		if (file.exists()) {
			if (file.isFile()) {
				// 是文件
				System.out.println("文件名称：" + file.getName());
				System.out.println("文件相对路径：" + file.getPath());
				System.out.println("文件绝对路径：" + file.getAbsolutePath());
				System.out.println("文件大小为：" + file.length() + "个字节");
			}
			if (file.isDirectory()) {
				// 是目录
				System.out.println("此文件是目录！");
			}
		} else {
			System.out.println("此文件不存在！");
		}

	}

	// 删除文件
	public void delete(File file) {
		if (file.exists()) {
			file.delete();
			System.out.println("文件已删除！");
		}
	}

	// 测试方法
	public static void main(String[] args) {
		FileDemo fileDemo = new FileDemo();
		File file = new File("E:\\eclipse_workspaces\\testDemo\\test.txt");//绝对路径
		//File file = new File("test.txt");//相对路径
//		fileDemo.create(file);
//		fileDemo.showFileInfo(file);
		fileDemo.delete(file);//删除文件
	}
}

2.流

如何读写文件？

  • 通过流来读写文件
    • 流是一组有序的数据序列
    • 以先进先出的方式发送信息的通道

Java流的分类：

输入输出流是相对于计算机内存来说的

字节流是 8 位通用字节流，字符流是 16 位 Unicode 字符流

2.1.InputStream

InputStream与FileInputStream

  • InputStream类常用方法（抽象类-基类）
    • int read( )
      • 从输入流一个字节一个字节的读，返回的是该字节的整数表示形式，如果读到了输入流的末尾。返回 -1。
    • int read(byte[ ] b)
      • 从输入流读取若干字节，把这些字节保存到数组b中。返回的是读取到的字节数，，如果读到了输入流的末尾，返回-1。
    • int read(byte[ ] b , int off , int len)
      • 从输入流读取若干字节，把这些字节保存到数组b中。off指的是字节数组中开始保存数据的起始下标。len指的是读取的字节数目。返回的是实际读取到的字节数，如果读到了输入流的末尾，返回-1。
    • void close( )
      • 关闭输入流
    • int available( )
      • 可以从输入流中读取的字节数目
  • 子类FileInputStream常用的构造方法
    • FileInputStream（File file）
    • FileInputStream（String name）

使用FileInputStream读文本文件操作步骤：

  1. 引入相关的类

    import java.io.IOException;

    import java.io.FileInputStream;

  2. 构造文件输入流-FileInputStream对象

    FileInputStream fis= new FileInputStream("c:\\test.txt");

  3. 读取文本文件的数据

    fis.available();

    fis.read();    

  4. 关闭文件流对象

     fis.close();

代码演示：

//1.引入资源

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

//通过字节输入流完成对文件的读操作
public class FileInputStreamDemo {

	public static void main(String[] args) {
		FileInputStream fis = null;
		try {

			// 2.创建FileInputStream对象
			fis = new FileInputStream("E:\\eclipse_workspaces\\testDemo\\test.txt");
			System.out.println("可以读取到的字节数：" + fis.available());

			// 3.借助FileInputStream对象的read()方法读取文件
//			int data;	//读取到的每个字节的整数表示形式    比如 和--104
//			while ((data = fis.read()) != -1) {
//				System.out.print((char) data);
//			}
			// 借助借助FileInputStream对象的read(byte[])方法读取文件
			byte[] b = new byte[1024];
			int data;// 读取到的字节数
			while ((data = fis.read(b)) != -1) {
				//字节读取到了字节数组b中，需要循环输出b的内容
				for (int i = 0; i < data; i++) {
					System.out.print((char)b[i]);
				}
			
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 4.关闭输入流

			try {
				fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

}

2.2.OutputStream

OutputStream与FileOutputStream

  • OutputStream类常用方法（抽象类-基类）
    • white(int)：
      • 往输入流中写入一个个的字节。
    • write(byte[] buf)
      • 往输入流中写入一个字节数组。
    • write(byte[] b,int off,int len)
      • 往输入流中写入一个字节数组，off代表开始从字节数组的off位置开始往外写，len代表往外写len长度的字节。
    • void close( )
      • 关闭输出流。
    • void flush()
      • 强制把缓冲区的数据写到输出流中
  • 子类FileOutputStream常用的构造方法
    • FileOutputStream（File file）
    • FileOutputStream（String name）
    • FileOutputStream（String name，boolean append）
  1. 前两种构造方法在向文件写数据时将覆盖文件中原有的内容。
  2. 创建FileOutputStream实例时，如果相应的文件并不存在，则会自动创建一个空的文件

使用FileOutputStream读文本文件操作步骤：

  1. 引入相关的类

    import java.io.IOException;

    import java.io.FileOutputStream;

  2. 构造文件输入流-FileInputStream对象

    FileOutputStream fos = new FileOutputStream("text.txt");

  3. 读取文本文件的数据

    String str ="好好学习,天天向上！";

    byte[] words  = str.getBytes();

    fos.write(words, 0, words.length);

  4. 关闭文件流对象

     fos.close();

代码演示：

//1.引入资源

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

//通过字节输出流完成对文件的读操作
public class FileOutputStreamDemo {

	public static void main(String[] args) {
		FileOutputStream fos = null;
		try {
			// 2.创建字节输出流对象（FileOutputStream）
			//fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\test.txt");
			//不覆盖原有的内容。进行追加
			fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\test.txt",true);
			
			// 3.调用字节输出流对象（FileOutputStream）的write（）方法写入文件
			String infoString = "好好学习，天天向上!";
			// 将写入的字符串打散为一个字节数组
			byte[] infos = infoString.getBytes();
			fos.write(infos, 0, infos.length);
			System.out.println("test文件已被更新！");

		} catch (FileNotFoundException e) {

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

			e.printStackTrace();
		}finally {
			// 4.关闭输出流
			try {
				fos.close();
			} catch (IOException e) {
			
				e.printStackTrace();
			}
		}

	}

}

2.3.Reader

  • 字符输入流Reader类常用方法（基类-抽象类）
    • int read()
    • int read(char[ ] c)
    • int read(char[ ] ,int off ,int len)
    • void close()
  • File类是Reader类的孙子类
    • FileReader (File file)
    • FileReader (String name)

2.3.1.FileReader

使用FileReader读文本文件的操作步骤：

  • 引入资源
  • 创建FileReader对象
  • 调用相应read（）读取文件（文件操作）
  • 关闭字符流

解决中文乱码问题：

  1. 手动调整
  2. 通过流读取时设置编码格式
    1. InputStreamReader(InputStream in) 
    2. InputStreamReader(InputStream in,String charsetName) 
2.3.2.BufferedReader

       如何提高字符流读取文本文件的效率：使用FileReader类与BufferedReader类

         BufferedReader类是Reader类的子类，BufferedReader带有缓冲区，内有按行读取内容的readLine()方法。

BufferedReader：

  •  带有缓冲区的字符输入流
  •  提高了文件的读取效率

-------------------------------------------------------------------------------------------------------------

  • BufferedReader类常用的构造方法
    • BufferedReader（Reader in）
  • 子类BufferedReader特有的方法
    • readLine（）

使用BufferedReader读文本文件的操作步骤：

  1. 引入相关的类

    import java.io.FileReader;

    import java.io.BufferedReader;

    import java.io.IOException;

  2. 构造 BufferedReader 对象和 FileReader 对象

    Reader fr = new  FileReader("C:\\myTest.txt ");

    BufferedReader br=new BufferedReader(fr);

  3. 调用 readLine（）方法读取数据

    ​​​​​​br.readLine();

  4. 关闭文件流对象

    br.close();

    fr.close();

2.4.Writer

  • Writer类常用方法
    • write(String str)
    • write(String str，int off, int len)
    • void close()
    • void flush()
2.4.1.OutputStreamWriter

子类OutputStreamWriter常用的构造方法

  • OutputStreamWriter(OutputStream out)
  • OutputStreamWriter(OutputStream out,String charsetName)  //指定字符输出格式
2.4.2.FileWriter

孙子类FileWriter

  • FileWriter (File file)
  • FileWriter (String name)
  • 该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型

使用FileWriter写文件的操作步骤：

  1. 引入相关的类

    import java.io.Reader;

    import java.io.FileWriter;

    Import java.io.IOException;

  2. 创建FileWriter对象

    Writer fw= new FileWriter("D:\\myDoc\\简介.txt");

  3. 写文本文件

    fw.write();

  4. 关闭相关的流对象

    fw.close();

2.4.3.BufferedWriter
  • BufferedWriter类带有缓冲区的字符输出类
  • BufferedWriter（Write out）构建对象并使用

使用BufferedWriter写文件的操作步骤：

  1. 引入相关的类

    import java.io.FileWriter ;

    import java.io.BufferedWriter ;

    import java.io.IOException;

  2. 创建 BufferedWriter 和 FileWriter 对象

    FileWriter fw=new FileWriter("C:\\myTest.txt");

    BufferedWriter bw=new BufferedWriter(fw);

  3. 调用write（）方法写数据

    bw.write("hello");

  4. 流对象的清空和关闭 flush()和close()

    bw.flush(); 

    fw.close();

2.5.读写二进制文件

  • DataInputStream类
    • FileInputStream的子类
    • 与FileInputStream类结合使用读取二进制文件
  • DataOutputStream类
    • FileOutputStream的子类
    • 与FileOutputStream类结合使用写二进制文件
2.5.1.DataInputStream

使用 DataInputStream 读二进制文件步骤：

  1. 引入相关的类

    import java.io.FileInputStream;

    import java.io.DataInputStream;

  2. 构建数据输入流对象

    FileInputStream fis=new FileInputStream("C:\\HelloWorld.class");

    DataInputStream dis=new DataInputStream(fis);

  3. 调用read（）方法读取二进制数据

               dis.read ();

  4. 关闭数据输入流

    dis.close();

2.5.2.DataOutputStream

使用 DataOutputStream写二进制文件步骤：

  1. 引入相关的类

    import java.io.FileOutputStream;

    import java.io.DataOutputStream;

  2. 构建数据输出流对象

    FileOutputStream outFile = new FileOutputStream("C:\\temp.class");

    DataOutputStream out = new DataOutputStream(outFile);

  3. 调用write（）方法读取二进制数据

    out.write();

  4. 关闭数据输入流

    out.close();

------------------------------------------------------------------

练习：复制文件

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

//CopyPicture
//借助DataInputStream和DataOutputStream实现二进制文件读写
public class CopyPicture {
	public static void main(String[] args) {
		//读取图片文件 E:/eclipse_workspaces/img.jpg
		DataInputStream dis = null;
		FileInputStream fis = null;
		
		//将图片文件写	E:\eclipse_workspaces\testDemo\img.jpg
		DataOutputStream dos = null;
		FileOutputStream fos = null;
		try {
			//输入流
			fis = new FileInputStream("E:/eclipse_workspaces/img.jpg");
			dis = new DataInputStream(fis);
			//输出流
			fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\img.jpg");
			dos = new DataOutputStream(fos);
			//输入流读取二进制文件的同时，输出流写入二进制文件
			int temp;
			while ((temp = dis.read()) != -1) {
				dos.write(temp);
			}
	
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				dos.close();
				fos.close();
				dis.close();
				fis.close();
			} catch (IOException e) {

				e.printStackTrace();
			}
		
		}

	}
}

2.6.序列化和反序列化

调用Serializable接口

序列化过程：

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

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

--------------------------------------------------------------------------------

序列化的步骤：

  1. 实现Serializable接口
  2. 创建对象输出流
  3. 调用writeObject（）方法将对象写入文件
  4. 关闭对象输出流

反序列化的步骤：

  1. 实现Serializable接口
  2. 创建对象输入流
  3. 调用readObject（）方法读取对象
  4. 关闭对象输入流

transient ：被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

eg:

注：学生类未展示

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

//序列化和反序列化学员对象
public class SeriaStu {
	public static void main(String[] args) {
		Student student = new Student(18, "张三", "男", "123456");
		// 对象输出流
		ObjectOutputStream oos = null;
		FileOutputStream fos = null;
		//对象输入流
		ObjectInputStream ois = null;
		FileInputStream fis = null;

		try {
			
			//构建对象输出流，为序列化做准备
			fos = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			oos = new ObjectOutputStream(fos);
			
			//构建对象输入流，为反序列化做准备
			fis = new FileInputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			ois = new ObjectInputStream(fis);
			//实现对象序列化
			oos.writeObject(student);
			//实现对象范序列化
			Student student1 = (Student)ois.readObject();
			System.out.println("反序列化出来的学生信息："+student1.getAge()+"-"+student1.getName()+"-"+student1.getSex()+"-"+student1.getPassword());
		} catch (FileNotFoundException e) {

			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		finally {
			try {
				ois.close();
				fis.close();
				oos.close();
				fos.close();
			} catch (IOException e) {
		
				e.printStackTrace();
			}
		
		}

	}

}

eg：

集合实现序列化 

package dh06.demo04;

import java.util.List;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.ArrayList;

//E:\\eclipse_workspaces\\testDemo\\student.txt
//序列化和反序列化学员对象-----集合
public class SeriaStu2 {
	public static void main(String[] args) {

		try {
			List<Student> list = new ArrayList<Student>();
			list.add(new Student(18, "张三", "男", "123456"));
			list.add(new Student(22, "李四", "女", "666666"));
			list.add(new Student(33, "王五", "男", "888888"));
			// 序列化
			OutputStream os = new FileOutputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			ObjectOutputStream oos = new ObjectOutputStream(os);
			oos.writeObject(list);// 将对象存入
			System.out.println("存入成功！！！");

			// 反序列化
			InputStream is = new FileInputStream("E:\\eclipse_workspaces\\testDemo\\student.txt");
			ObjectInputStream ois = new ObjectInputStream(is);
			List<Student> list2 = (List<Student>) ois.readObject();
			for (Student student : list2) {
				
				student.show();
			}

			oos.close();
			os.close();
			ois.close();
			is.close();

		} catch (Exception e) {

			e.printStackTrace();
		} finally {

		}

	}

}

愚人钊呀
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

愚人钊呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值