Java中阶——IO流详解

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量392 收藏
点赞数
分类专栏： Java 文章标签： java eclipse 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44808710/article/details/121875882
版权

IO流

IO流总结篇

去看看

输入流和输出流并不是一定要匹配

File类

  • File类的使用操作之前已经学过了去看看
File file = new File("E:/eclipse_code/Ssc/b.txt");
		System.out.println(file.createNewFile());
		System.out.println(file.exists());
		System.out.println(file.getName());
		System.out.println(file.isFile());
		System.out.println(file.isHidden());

File file = new File("E:/eclipse_code/Ssc/test/test1");
		System.out.println(file.mkdirs()); //无法创建多级目录 mkdirs可以创建多级目录
		System.out.println(file.isDirectory());
		System.out.println(file.getParent());
		//只输出目录内的文件名
		File file2 = new File("E:/eclipse_code");
		String[] arr = file2.list();
		for (String string : arr) {
			System.out.println(string);
		}
		//返回每个目录的全程
		File[] arr2 = file2.listFiles();
		for (File file3 : arr2) {
			System.out.println(file3);
		}

File类在IO中的作用

  • 当以文件作为数据源或目标时，除了可以使用字符串作为文件以及位置的指定以外，我
    们也可以使用 File 类指定。
BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new FileReader(new File("./b.txt")));
			bufferedWriter = new BufferedWriter(new FileWriter(new File("./e.txt")));
			String temp = "";
			int i = 1;
			while((temp = bufferedReader.readLine())!=null) {
				bufferedWriter.write(i+ ", "+temp);
				bufferedWriter.newLine();
				i++;
			}
			bufferedWriter.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if(bufferedReader!=null) {
					bufferedReader.close();
				}
				if (bufferedWriter!=null) {
					bufferedWriter.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

文件字节流

文件字节流输入流（FileInputStream）

  • FileInputStream 通过字节的方式读取文件，适合读取所有类型的文件（图像、视频、文
    本文件等）。Java 也提供了 FileReader 专门读取文本文件。
		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream("E:/eclipse_code/Ssc/1.png");
			int temp = 0;
			while ((fileInputStream.read()!=-1)) {
				System.out.println(temp);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if (fileInputStream!=null) {
					fileInputStream.close();
				}
			} catch (Exception e2) {
		
			}
		}
	}

文件字节流输出流（FileOutputStream）

  • FileOutputStream 通过字节的方式写数据到文件中，适合所有类型的文件。Java 也提供
    了 FileWriter 专门写入文本文件。
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream =null;
		try {
			fileInputStream = new FileInputStream("E:/eclipse_code/Ssc/1.png");
			//创建文件字节流输出对象
			fileOutputStream = new FileOutputStream("E:/eclipse_code/Ssc/2.png");
			int temp = 0;
			while ((fileInputStream.read()!=-1)) {
				//System.out.println(temp);
				fileOutputStream.write(temp);
			}
			//将数据从内存中写入磁盘中
			fileOutputStream.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if (fileInputStream!=null) {
					fileInputStream.close();
					fileOutputStream.close();
				}
			} catch (Exception e2) {
		
			}
		}
	}

通过缓冲区提高读写效率

方式一：创建一个指定长度的字节数组作为缓冲区

  • 通过创建一个指定长度的字节数组作为缓冲区，以此来提高 IO 流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意：缓冲区的长度一定是 2 的整数幂。一般情况下
    1024 长度较为合适。
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream =null;
		try {
			fileInputStream = new FileInputStream("E:/eclipse_code/Ssc/1.png");
			//创建文件字节流输出对象
			fileOutputStream = new FileOutputStream("E:/eclipse_code/Ssc/2.png");
			//创建一个缓冲区提高读写效率
			byte[] buffer = new byte[1024];
			int temp = 0;
			while ((fileInputStream.read(buffer)!=-1)) {
				//写入的时候一个包一个包的拿
				fileOutputStream.write(buffer, 0, temp);
			}
			//将数据从内存中写入磁盘中
			fileOutputStream.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if (fileInputStream!=null) {
					fileInputStream.close();
					fileOutputStream.close();
				}
			} catch (Exception e2) {
		
			}
		}
	}

方式二：通过输入流对象的 available()返回当前文件的预估长度

  • 通过创建一个字节数组作为缓冲区，数组长度是通过输入流对象的 available()返回当前
    文件的预估长度来定义的。在读写文件时，是在一次读写操作中完成文件读写操作的。注意：
    如果文件过大，那么对内存的占用也是比较大的。所以大文件不建议使用该方法。
FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream =null;
		try {
			fileInputStream = new FileInputStream("E:/eclipse_code/Ssc/1.png");
			//创建文件字节流输出对象
			fileOutputStream = new FileOutputStream("E:/eclipse_code/Ssc/2.png");
			//创建一个缓冲区提高读写效率
			byte[] buffer = new byte[fileInputStream.available()];
			fileInputStream.read(buffer);
			fileOutputStream.write(buffer);
			
			//将数据从内存中写入磁盘
			
			fileOutputStream.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if (fileInputStream!=null) {
					fileInputStream.close();
					fileOutputStream.close();
				}
			} catch (Exception e2) {
		
			}
		}

通过字节缓冲流提高读写效率

  • 当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就
    能够更高效的读写信息    。因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷
    新时再一次性的读取到程序或写入目的地。
  • 缓冲流还是很重要的，我们在 IO 操作时记得加上缓冲流来提升性能
  • BufferedInputStream 和 BufferedOutputStream 这两个流是缓冲字节流，通过内部缓存数组来提高操作流的效率。
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream =null;
		BufferedInputStream bufferedInputStream = null;
		BufferedOutputStream bufferedOutputStream = null;
		try {
			//完成管道嵌套
			fileInputStream = new FileInputStream("E:/eclipse_code/Ssc/1.png");
			bufferedInputStream = new BufferedInputStream(fileInputStream);
			fileOutputStream = new FileOutputStream("E:/eclipse_code/Ssc/3.png");
			bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
			//缓冲流中byte数组长度默认是8192
			int temp = 0;
			while((temp = bufferedInputStream.read())!=-1) {
				bufferedOutputStream.write(temp);
			}
			bufferedOutputStream.flush();
		} catch (Exception e) {
			
		}finally {
			try {
				//后开的先关闭原则
				if (bufferedInputStream!=null) {
					bufferedInputStream.close();
				}
				if (fileInputStream!=null) {
					fileInputStream.close();
				}
				if (bufferedOutputStream!=null) {
					bufferedOutputStream.close();
				}
				if (fileOutputStream!=null) {
					fileOutputStream.close();
				}
			} catch (Exception e2) {
		
			}
		}

定义文件拷贝工具类

  • 通过定义的拷贝工具类直接拷贝
public static void main(String[] args) {
		
		copyFile("E:/eclipse_code/Ssc/1.png", "E:/eclipse_code/Ssc/4.png");
	}
	/**
	 * 文件拷贝方法
	 */
	public static void copyFile(String src,String des) {
		FileInputStream fileInputStream = null;
		FileOutputStream fileOutputStream =null;
		BufferedInputStream bufferedInputStream = null;
		BufferedOutputStream bufferedOutputStream = null;
		try {
			//完成管道嵌套
			fileInputStream = new FileInputStream(src);
			bufferedInputStream = new BufferedInputStream(fileInputStream);
			fileOutputStream = new FileOutputStream(des);
			bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
			//缓冲流中byte数组长度默认是8192
			int temp = 0;
			while((temp = bufferedInputStream.read())!=-1) {
				bufferedOutputStream.write(temp);
			}
			bufferedOutputStream.flush();
		} catch (Exception e) {
			
		}finally {
			try {
				//后开的先关闭原则
				if (bufferedInputStream!=null) {
					bufferedInputStream.close();
				}
				if (fileInputStream!=null) {
					fileInputStream.close();
				}
				if (bufferedOutputStream!=null) {
					bufferedOutputStream.close();
				}
				if (fileOutputStream!=null) {
					fileOutputStream.close();
				}
			} catch (Exception e2) {
		
			}
		}
	}

文件字符流

文件字符输入流

FileReader fileReader = null;
		try {
			fileReader = new FileReader("E:/eclipse_code/Ssc/a.txt");
			int temp = 0;
			while ((temp = fileReader.read()) != -1) {
				//强制转换为字符
				System.out.println((char)temp);
			}
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		}finally {
			try {
				if(fileReader!=null) {
					fileReader.close();
				}
			} catch (Exception e2) {
				
			}
		}

文件字符输出流

 FileWriter fileWriter = null;
		FileWriter fileWriter2 = null;
		try {
			fileWriter = new FileWriter("E:/eclipse_code/Ssc/c.txt");
			fileWriter.write("你好我的宝贝\r\n");
			fileWriter.write("我是追加的\r\n");
			fileWriter.flush();
			
			//没有给定追加指令是直接覆盖上一个对象写入的数据
			fileWriter2 = new FileWriter("E:/eclipse_code/Ssc/c.txt",true);
			fileWriter2.write("何以解忧\r\n唯有我孙少聪");
			fileWriter2.flush();

		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		}finally {
			try {
				if(fileWriter!=null) {
					fileWriter.close();
				}
			} catch (Exception e2) {
				
			}
		}

字符流实现文件拷贝处理

		FileReader fileReader = null;
		FileWriter fileWriter = null;
		
		try {
			fileReader = new FileReader("E:/eclipse_code/Ssc/a.txt");
			fileWriter = new FileWriter("E:/eclipse_code/Ssc/d.txt");
			char[] buffer = new char[1024];
			int temp = 0;
			while ((temp=fileReader.read(buffer))!=-1) {
				fileWriter.write(buffer,0,temp);
			}
			fileWriter.flush();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			if(fileWriter!=null) {
				fileWriter.close();
			}
		}

字符缓冲流

  • BufferedReader/BufferedWriter 增加了缓存机制，大大提高了读写文本文件的效率。

字符输入缓冲流

  • BufferedReader 是针对字符输入流的缓冲流对象，提供了更方便的按行读取的方法：
    readLine(); 在使用字符流读取文本文件时，我们可以使用该方法以行为单位进行读取。
FileReader fileReader = null;
		BufferedReader bufferedReader = null;
		try {
			fileReader = new FileReader("E:/eclipse_code/Ssc/c.txt");
			bufferedReader = new BufferedReader(fileReader);
			String temp = "";
			while ((temp=bufferedReader.readLine())!=null) {
				System.out.println(temp);
			}
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if(bufferedReader!=null) {
					bufferedReader.close();
				}
				if (fileReader!=null) {
					fileReader.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

字符输出缓冲流

  • BufferedWriter 是 针对 字符 输出 流的 缓 冲流 对象 ，在 字 符输 出缓 冲流 中可 以 使用
    newLine()；方法实现换行处理。
FileWriter fileWriter = null;
		BufferedWriter bufferedWriter = null;
		try {
			fileWriter = new FileWriter("./e.txt");
			bufferedWriter = new BufferedWriter(fileWriter);
			bufferedWriter.write("你好狗屁");
			bufferedWriter.write("你好狗蛋");
			bufferedWriter.newLine();
			bufferedWriter.write("你好狗屎");
			bufferedWriter.newLine();
			bufferedWriter.write("你好狗腿子");
			bufferedWriter.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if(bufferedWriter!=null) {
					bufferedWriter.close();
				}
				if (fileWriter!=null) {
					fileWriter.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

字符缓冲流实现文本的拷贝

public static void main(String[] args) {
		
		copyFile("./e.txt","./f.txt");
	}
	/**
	 * 基于字符缓冲流实现文件拷贝
	 */
	public static void copyFile(String src,String des) {
		BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new FileReader(src));
			bufferedWriter = new BufferedWriter(new FileWriter(des));
			String temp = "";
			while((temp = bufferedReader.readLine())!=null) {
				bufferedWriter.write(temp);
				bufferedWriter.newLine();
			}
			bufferedWriter.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if(bufferedReader!=null) {
					bufferedReader.close();
				}
				if (bufferedWriter!=null) {
					bufferedWriter.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}
	}

通过字符缓冲流为文件中的内容添加行号

BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new FileReader("./f.txt"));
			bufferedWriter = new BufferedWriter(new FileWriter("./g.txt"));
			String temp = "";
			int i = 1;
			while((temp=bufferedReader.readLine())!=null) {
				bufferedWriter.write(i+","+temp);
				bufferedWriter.newLine();
			}
			bufferedWriter.flush();
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			try {
				if (bufferedWriter!=null) {
					bufferedWriter.close();
				}
				if (bufferedReader!=null) {
					bufferedReader.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

转换流

  • InputStreamReader/OutputStreamWriter 用来实现将字节流转化成字符流。

  • System.in 是字节流对象，代表键盘的输入，如果我们想按行接收用户的输入时，就必
    须用到缓冲字符流 BufferedReader 特有的方法 readLine()，但是经过观察会发现在创建
    BufferedReader 的 构 造 方 法 的 参 数 必 须 是 一 个 Reader 对 象 ， 这 时 候 我 们 的 转 换 流
    InputStreamReader 就派上用场了。

  • System.out 也是字节流对象，代表输出到显示器，按行读取用户的输入后，并且要将读取的一行字符串直接显示到控制台，就需要用到字符流的 write(String str)方法，所以我们要OutputStreamWriter 将字节流转化为字符流。

通过转换流实现键盘输入屏幕输出

BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new InputStreamReader(System.in));
			bufferedWriter = new BufferedWriter(new OutputStreamWriter(System.out));

			while (true) {
				bufferedWriter.write("请输入：");
				bufferedWriter.flush();
				String input = bufferedReader.readLine();
				if ("exit".equals(input)) {
					break;	
				}
				bufferedWriter.write("您输入的是："+input);
				bufferedWriter.newLine();
				bufferedWriter.flush();
				
			}
		} catch (IOException e) {
			
			e.printStackTrace();
		}finally {
			try {
				if(bufferedWriter!=null) {
					bufferedWriter.close();
				}
				if (bufferedReader!=null) {
					bufferedReader.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

通过字节流读取的文本文件并添加行号

BufferedReader bufferedReader = null;
		BufferedWriter bufferedWriter = null;
		try {
			bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("./g.txt")));
			bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("./h.txt")));
			String temp = "";
			int i = 1;
			
			while ((temp=bufferedReader.readLine())!=null) {
				bufferedWriter.write(i+"+"+temp);
				bufferedWriter.newLine();
				i++;
			}
			bufferedWriter.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			try {
				if(bufferedWriter!=null) {
					bufferedWriter.close();
				}
				if (bufferedReader!=null) {
					bufferedReader.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

字符输出流

  • 在 Java 的 IO 流中专门提供了用于字符输出的流对象 PrintWriter。该对象具有自动行刷
    新缓冲字符输出流，特点是可以按行写出字符串，并且可通过 println();方法实现自动换行。
BufferedReader bufferedReader = null;
		PrintWriter piPrintWriter = null;
		try {
			bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("./g.txt")));
			piPrintWriter = new PrintWriter("./i.txt");
			String temp = "";
			int i = 1;
			while ((temp=bufferedReader.readLine())!=null) {
				piPrintWriter.println(i+" "+temp);
				i++;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				if (bufferedReader!=null) {
					bufferedReader.close();
				}
				if (piPrintWriter!=null) {
					piPrintWriter.close();
				}
			} catch (Exception e2) {
				// TODO: handle exception
			}
		}

字节数组流

  • ByteArrayInputStream 和 ByteArrayOutputStream 经常用在需要流和数组之间转化的情况！

字节数组输入流

  • FileInputStream 是把文件当做数据源。ByteArrayInputStream 则是把内存中的”字节数组对象”当做数据源。
		byte[] arr = "abcdefg".getBytes();
		ByteArrayInputStream byteArrayInputStream = null;
		StringBuilder stringBuilder = new StringBuilder();
		try {
			//该构造方法的参数是一个字节数组，这个字节数组就是数据源
			byteArrayInputStream = new ByteArrayInputStream(arr);
			int temp = 0;
			while ((temp=byteArrayInputStream.read())!=-1) {
				stringBuilder.append((char)temp);
			}
			System.out.println(stringBuilder);
		} finally {
			try {
				byteArrayInputStream.close();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}

字节数组输出流

  • ByteArrayOutputStream 流对象是将流中的数据写入到字节数组中。
ByteArrayOutputStream byteArrayOutputStream = null;
		StringBuilder stringBuilder = new StringBuilder();
		try {
			byteArrayOutputStream = new ByteArrayOutputStream();
			byteArrayOutputStream.write('a');
			byteArrayOutputStream.write('b');
			byteArrayOutputStream.write('c');
			byte[] arr = byteArrayOutputStream.toByteArray();
			for (int i = 0; i < arr.length; i++) {
				stringBuilder.append((char)arr[i]);
			}
			System.out.println(stringBuilder);
		} finally {
			try {
				byteArrayOutputStream.close();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}

数据流

  • 数据流将“基本数据类型与字符串类型”作为数据源，从而允许程序以与机器无关的方式从底层输入输出流中操作 Java 基本数据类型与字符串类型。
  • DataInputStream 和 DataOutputStream 提供了可以存取与机器无关的所有 Java 基础类型
    数据（如：int、double、String 等）的方法。

数据输出流

DataOutputStream dataOutputStream = null;
		try {
			//输出的格式与文件的后缀无关
			dataOutputStream =  new DataOutputStream(new BufferedOutputStream(new FileOutputStream("./b.txt")));
			dataOutputStream.writeChar('a');
			dataOutputStream.writeInt(10);
			dataOutputStream.writeDouble(Math.random());
			dataOutputStream.writeBoolean(false);
			dataOutputStream.writeUTF("你好");
			//基于字节流输出的，看到的会是乱码
			dataOutputStream.flush();
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		} finally {
			try {
				dataOutputStream.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

数据输入流

		DataInputStream dataInputStream = null;
		try {
			dataInputStream =  new DataInputStream(new BufferedInputStream(new FileInputStream("./b.txt")));
			//直接读取数据，注意：读取顺序一定要写入数据顺序一致
			System.out.println("char:"+dataInputStream.readChar());
			System.out.println("int:"+dataInputStream.readInt());
			System.out.println("double:"+dataInputStream.readDouble());
			System.out.println("boolean:"+dataInputStream.readBoolean());
			System.out.println("String:"+dataInputStream.readUTF());
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		} finally {
			try {
				if(dataInputStream!=null)
				dataInputStream.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

对象流

  • Java 对象的序列化和反序列化
  • 把 Java 对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为 Java 对象的
    过程称为对象的反序列化。

序列化

  • 对象序列化的作用有如下两种：
  1. 持久化： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中。
  2. 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传
    递。

序列化涉及的类和接口

  • ObjectOutputStream 代表对象输出流，它的 writeObject(Object obj)方法可对参数指定的 obj
    对象进行序列化    ，把得到的字节序列写到一个目标输出流中。
  • ObjectInputStream 代表对象输入流，它的 readObject()方法从一个源输入流中读取字节
    序列，再把它们反序列化为一个对象，并将其返回。
  • 只有实现了 Serializable 接口的类的对象才能被序列化。Serializable 接口是一个空接口， 只起到标记作用(标识接口)。

操作基本数据类型

写出基本数据类型

ObjectOutputStream objectOutputStream = null;
		try {
			objectOutputStream = new  ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("./c.txt")));
			objectOutputStream.writeInt(10);
			objectOutputStream.writeDouble(Math.random());
			objectOutputStream.writeChar('a');
			objectOutputStream.writeBoolean(true);
			objectOutputStream.writeUTF("我是孙少聪");
			objectOutputStream.flush();
		} catch (Exception e) {
			
		}finally {
			try {
				if(objectOutputStream!=null) {
					objectOutputStream.close();
				}
			} catch (Exception e2) {
				
			}
		}

读出基本数据类型

ObjectInputStream objectInputStream = null;
		try {
			objectInputStream = new  ObjectInputStream(new BufferedInputStream(new FileInputStream("./c.txt")));
			System.out.println(objectInputStream.readInt());
			System.out.println(objectInputStream.readDouble());
			System.out.println(objectInputStream.readChar());
			System.out.println(objectInputStream.readBoolean());
			System.out.println(objectInputStream.readUTF());
		} catch (Exception e) {
			
		}finally {
			try {
				if(objectInputStream!=null) {
					objectInputStream.close();
				}
			} catch (Exception e2) {
				
			}
		}

操作对象

将对象序列化到文件

  • ObjectOutputStream 可以将一个内存中的 Java 对象通过序列化的方式写入到磁盘的文
    件中。被序列化的对象必须要实现 Serializable 序列化接口，否则会抛出异常。

  • Users类必须实现Serializable

package IO;

import java.io.Serializable;

public class Users implements Serializable{
	private int userId;
	private String username;
	private String userage;
	
	public int getUserId() {
		return userId;
	}
	public void setUserId(int userId) {
		this.userId = userId;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getUserage() {
		return userage;
	}
	public void setUserage(String userage) {
		this.userage = userage;
	}
	public Users(int userId, String username, String userage) {
		super();
		this.userId = userId;
		this.username = username;
		this.userage = userage;
	}
	
	
}
  • 序列化Users对象
ObjectOutputStream objectOutputStream = null;
		try {
			objectOutputStream = new  ObjectOutputStream(new FileOutputStream("./d"));
			Users users = new Users(1, "孙少聪", "18");
			objectOutputStream.writeObject(users);
			objectOutputStream.flush();
		} catch (Exception e) {
			
		}finally {
			try {
				if(objectOutputStream!=null) {
					objectOutputStream.close();
				}
			} catch (Exception e2) {
				
			}
		}

将对象反序列化到内存中

ObjectInputStream objectInputStream = null;
		try {
			objectInputStream = new  ObjectInputStream(new FileInputStream("./d"));
			Users users = (Users)objectInputStream.readObject();
			System.out.println(users.getUserId()+'\t'+users.getUsername()+'\t'+users.getUserage());
		} catch (Exception e) {
			
		}finally {
			try {
				if(objectInputStream!=null) {
					objectInputStream.close();
				}
			} catch (Exception e2) {
				
			}
		}

随机访问流（RandomAccessFile ）

  • RandomAccessFile 可以实现两个作用：
    1. 实现对一个文件做读和写的操作。
    2. 可以访问文件的任意位置。不像其他流只能按照先后顺序读取。
  • 三个核心方法：
    1. RandomAccessFile(String name, String mode) name 用来确定文件； mode 取
      r(读)或 rw(可读写)，通过 mode 可以确定流对文件的访问权限。
    2. seek(long a) 用来定位流对象读写文件的位置，a 确定读写位置距离文件开头的字节个数。
    3. getFilePointer() 获得流的当前读写位置。
RandomAccessFile randomAccessFile = null;
		try {
			randomAccessFile = new RandomAccessFile("./d.txt", "rw");
			//将若干数据写入到文件
			int[] arr = new int[] {10,20,30,40,50,60,70,80};
			for (int i = 0; i < arr.length; i++) {
				randomAccessFile.writeInt(arr[i]);
			}
			System.out.println("============================================");
			//seek(4)指向第二个字节的开头
			randomAccessFile.seek(4);
			System.out.println(randomAccessFile.readInt());
			System.out.println("============================================");
			//隔一个读取数据
			for (int i = 0; i < 8; i+=2) {
				randomAccessFile.seek(i*4);
				System.out.println(randomAccessFile.readInt());
			}
			System.out.println("============================================");
			
			//在第八个字节插入新数据45替换30
			randomAccessFile.seek(8);
			randomAccessFile.writeInt(45);
			for (int i = 0; i < 8; i+=2) {
				randomAccessFile.seek(i*4);
				System.out.println(randomAccessFile.readInt());
			}
		} catch (FileNotFoundException e) {
			
			e.printStackTrace();
		}finally {
			try {
				if (randomAccessFile!=null) {
					randomAccessFile.close();
				}
			} catch (Exception e2) {
				
			}
		}

第三方IO包（Apache IO包）

  • Apache-commons 工具包中提供了 IOUtils/FileUtils，可以让我们非常
    方便的对文件和目录进行操作。

FileUtils 的使用

FileUtils 类中常用方法：

  1. cleanDirectory：清空目录，但不删除目录。
  2. contentEquals：比较两个文件的内容是否相同。
  3. copyDirectory：将一个目录内容拷贝到另一个目录。可以通过 FileFilter 过滤需要拷贝的 文件。
  4. copyFile：将一个文件拷贝到一个新的地址。
  5. copyFileToDirectory：将一个文件拷贝到某个目录下。
  6. copyInputStreamToFile：将一个输入流中的内容拷贝到某个文件。
  7. deleteDirectory：删除目录。
  8. deleteQuietly：删除文件。
  9. listFiles：列出指定目录下的所有文件。
  10. openInputSteam：打开指定文件的输入流。
  11. readFileToString：将文件内容作为字符串返回。
  12. readLines：将文件内容按行返回到一个字符串数组中。
  13. size：返回文件或目录的大小。
  14. write：将字符串内容直接写到文件中。
  15. writeByteArrayToFile:将字节数组内容写到文件中。
  16. writeLines：将容器中的元素的 toString 方法返回的内容依次写入文件中。

使用一（前提是下载好并且已经导入了jar包）：

package IO;

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

import org.apache.commons.io.*;


public class FileUtilsTest {
	public static void main(String[] args) throws Exception {
		
		String content =  FileUtils.readFileToString(new File("./a.txt"),"utf-8");
		System.out.println(content);
	}
	
}

使用二：拷贝

//第一个参数是源，第二个是目的地，第三个是
		FileUtils.copyDirectory(new File("./test"),new File("./h.txt"),new FileFilter() {
			//文件拷贝时的过滤条件
			@Override
			public boolean accept(File pathname) {
				if(pathname.isDirectory() || pathname.getName().endsWith("txt")) {
					System.out.println(true);
					return true;
				}
				System.out.println(false);
				return false;
			}
		});

使用三：IO操作

		String content = IOUtils.toString(new FileInputStream("./a.txt"),"utf-8");
		System.out.println(content);
SunACong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ECLIPSE输入输出
weixin_47470679的博客
05-08 1408
首先我们了解一下IO类的输入输出，IO（输入/输出）是比较抽象的，看不到明显的运行效果，但输入和输出是所有程序都必需的部分。 使用输入机制，允许程序读取外部数据（包括来自磁盘、光盘等存储设备的数据、来自网络的数据）、 用户输入数据；使用输出机制，允许程序记录运行状态，将程序数据输出到磁盘、光盘等存储设备中和 网络其他设备中。 Java的IO通过java.io包下的类和接口来支持，在java.io包下主要包括输入流、输出流两种IO流，每 种输入、输出流又可分为字节流和字符流两大类。其中字节流以字节为单位来..
Java进阶——IO 流
m0_67402564的博客
08-01 327
转换流也是处理流的一种。转换流提供了在字节流和字符流之间的转换。将InputStream转换为Reader，字节输入流转换成字符输入流将Writer转换为OutputStream，字符输出流转换成字节输出流字节流中的数据都是字符时，转成字符流操作更高效。很多时候我们使用转换流来处理文件乱码问题。实现编码和解码的功能。对象流是处理流的一种。对象流有两个类ObjectInputStream和OjbectOutputSteam用于存储和读取基本数据类型数据或对象的处理流。...
【C++】输入输出流（IO流）
weixin_51983604的博客
04-21 8092
文章目录一、C语言的输入输出二、什么是流三、C++的IO流1.概览2.标准IO流（1）cin、cout、cerr、clog（2）cin、cout与scanf、printf（3）输入输出重载（4）getline（5）循环输入2.文件流（1）ifstream、ofstream感谢阅读，如有错误请批评指正 一、C语言的输入输出 C语言中最常用到的输入输出方式就是scanf()与printf()。 scanf()是从标准输入设备(键盘) 读取数据，并将值存放在一个或一些变量中；printf()是将指定的文字/字符
java从小白开始（IO流入门）
weixin_47514459的博客
12-19 411
让你了解与使用IO流的使用，原来IO也并不难
Java IO流 : 新手入门最全面总结
houjingchuan的博客
09-09 512
Java高级编程之IO流，根据尚硅谷宋红康Java课程总结，适合新手学习，也可作为查阅文档
Eclipse输入输出使用（java.io数据流）
菜????一只
02-18 6345
一、输入输出控制台 输入： 1. 使用Scanner类输入 需要添加import java.util.*; Scanner in=new Scanner(System.in); String s=in.next(); //输入字符串 String l=in.nextLine(); byte b=in.nextByte(); //位 int i=in.nextInt(); ...
Java-----关于IO流的总结
weixin_45504233的博客
08-11 124
流的分类： 因为分类的方式不同，可以将流分为不同的类型： （1）按照流向：分为 **输入流** 和 **输出流**。 输入流：表示将数据读取到java程序（内存）中使用的流。 输出流：表示从java程序（内存）向外传输使用的流。 （2）按照读取的数据单元： 分为 **字节流** 和 **字符流** 字节流 ：一次性传输一个字节数据，将数据以字节的形式传输。 字符流： 一次性传...
java——IO流技术.pdf
04-03
### Java IO流技术详解 #### 一、IO流概述 在Java编程中，**IO流**(Input/Output Stream)主要用于实现数据的输入与输出操作。无论是文件读写、网络通信还是程序间的交互，几乎所有的数据交换都依赖于IO流。 #####...
JavaIO文件复制优化-JavaIO优化详解（下载可用）
05-30
JavaIO文件复制优化——JavaIO优化详解（下载可用）。个人经导师指导并认可通过的98分大作业设计项目，适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。...
JAVA IO API使用详解
09-04
2. 字节流与字符流：Java的IO系统基于两种基本流类型——字节流（Byte Stream）和字符流（Character Stream）。字节流以字节（8位）为单位处理数据，适用于处理任何类型的二进制数据，如图片、音频文件等。字符流则...
Java文件(io)编程之记事本开发详解
08-29
"Java文件(io)编程之记事本开发详解" 标题解释 本文主要介绍了Java文件(io)编程之记事本开发，着重讲解了Java文件(io)编程的基本概念和实现方法，旨在帮助读者理解和掌握Java文件(io)编程的技术。 描述解释 通过...
java中的io详解.
06-26
Java 中的 IO 详解 Java IO 是指应用程序对外部设备的数据输入和输出，在程序中，键盘被当作输入文件，显示器被当作输出文件使用。Java 语言定义了许多类专门负责各种方式的输入输出，这些类都被放在 java.io 包中...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 379
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 443
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 241
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 614
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 261
集合之Map
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 736
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 417
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
李刚亲授：疯狂Java讲义——实战+案例详解
涵盖了java.awt、java.lang、java.io、java.nio、java.sql等多个Java核心库，适合从零基础到进阶的Java开发者阅读。 这本书不仅教授Java语言本身，也强调了Java作为一种体系和开发平台的重要性，以及开源精神在其中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值