Java IO流

最新推荐文章于 2024-08-15 04:01:02 发布
最新推荐文章于 2024-08-15 04:01:02 发布
阅读量337 收藏
点赞数 1
分类专栏： java 文章标签： java iostream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucien_ma/article/details/107713732
版权

IO 流

  • File 类
  • 字节流
  • 字符流
  • 处理流
  • 缓冲流
  • 序列化和反序列化

File 类

​ Java 会用对象来表示文件，Java 提供了 java.io.File 类，使用该类的构造函数可以创建文件对象以表示一个物理资源，File 的常用方法如表：

方法描述
public File(String pathname)根据路径创建对象
public String getName()获取文件名
public String getParent()获取文件所在目录
pubilc File getParentFile()获取文件所在目录对应的 File 对象
public String getPath()获取文件路径
public boolean exists()判断文件是否存在
public boolean isDirectory()判断对象是否为目录
public boolean isFile()判断对象是否为文件
public long length()获取文件的大小
public boolean createNewFile()根据当前对象创建文件
public boolean delete()删除对象
public boolean mkdir()根据当前对象创建目录
public boolean renameTo(File dest)为已存在的对象重命名

File 常用方法使用：

public class TestFile {
	public static void main(String[] args) {
		File file = new File("E:/test.txt");
		boolean flag = file.exists();
		System.out.println("文件是否存在："+flag);
		String fileName = file.getName();
		System.out.println("文件名："+fileName);
		long length = file.length();
		System.out.println("文件的大小："+length);
		String path = file.getPath();
		System.out.println("文件路径："+path);
		String parent = file.getParent();
		System.out.println("文件所在的目录："+parent);
		File parentFile = file.getParentFile();
		boolean flag2 = parentFile.isDirectory();
		System.out.println("文件的父级对象是否为目录："+flag2);
		boolean flag3 = parentFile.isFile();
		System.out.println("文件的父级对象是否为文件："+flag3);
		File file2 = new File("E:/test2.txt");
		System.out.println("新生文件是否存在："+file2.exists());
		try {
			System.out.println("新生文件是否创建成功："+file2.createNewFile());
		}catch(IOException e) {
			e.printStackTrace();
		}
		File file3 = new File("E:/test3.txt");
		System.out.println("新文件重命名是否成功："+file2.renameTo(file3));
		System.out.println("新文件删除是否成功："+file2.delete());
	}
}

运行结果：

在这里插入图片描述

字节流

​ 接下来我们学习如何读取 File 对象，就是本章重点内容——IO 流，即通过输入输出流完成对文件的读写。流是一种以先进先出的方式传输数据的序列，Java 中的流有很多种不同的分类：

  • 按照方向分，可以分为输入流和输出流
  • 按照单位分，可以分为字节流和字符流，字节流指每次处理数据是以字节为单位的，字符流是指每次处理数据是以字符为单位的
  • 按照功能分，可以分为节点流和处理流

字节流按照方向分又可以分为输入流（InputStream）和输出流（OutputStream），InputStream 是 java.io 包中的顶层父类，并且是一个抽象类，InputStream 实现了 Closeable 接口，该接口的作用是每次操作结束之后完成资源释放，InputStream 常用方法如表：

方法描述
public abstract int read() throws IOException以字节为单位读取数据
public int read(byte b[]) throws IOException将数据存入 byte 类型数组中，并返回数据长度
public int read(byte b[],int off,int len) throws IOException将数据存入 byte 类型数组的指定区间中，并返回数据长度
public int available() throws IOException返回当前数据流中未读取的数据个数
pubic void close() throws IOException关闭数据流

​ 在实际开发中不能直接实例化 InputStream 类的对象，应该实例化其实现了抽象方法的子类 FileInputStream

public class TestFileRead {
	public static void main(String[] args) {
		try {
			InputStream inputStream = new FileInputStream("E:/test.txt");
			int temp = 0;
			System.out.println("当前未读取的数据个数："+inputStream.available());
			while((temp = inputStream.read()) != -1){
				System.out.println(temp+",当前未读取的数据个数："+inputStream.available());
			} 
			inputStream.close();
			System.out.println("***********************");
			inputStream = new FileInputStream("E:/test.txt");
			byte[] bytes = new byte[6];
			int length = inputStream.read(bytes);
			System.out.println("数据流长度："+length);
			System.out.println("遍历 byte 数组");
			for(byte b : bytes) {
				System.out.println(b);
			}
			inputStream.close();
			System.out.println("***********************");
			inputStream = new FileInputStream("E:/test.txt");
			bytes = new byte[10];
			length = inputStream.read(bytes, 2, 7);
			System.out.println("数据流长度："+length);
			System.out.println("遍历 byte 数组");
			for(byte b : bytes) {
				System.out.println(b);
			}
			inputStream.close();
			System.out.println("**************************");
			
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

在这里插入图片描述

OutputStream 跟 InputStream 类似，也是一个抽象父类。OutputStream 除了实现 Closeable 接口之外，还实现了 Flushable 接口。Flushable 接口可以将缓冲区的数据同步到输出流中，保证数据的完整性，OutputStream 的常用方法如表：

方法描述
public abstract void write(int b) throws IOException以字节为单位写数据
public void write(byte b[]) throws IOException将 byte 类型数组中的数据写出
public void wirte(byte b[],int off, int len) throws IOException将 byte 类型数组中指定区间的数据写出
pulblic void flush() throws IOException可以强制将缓冲区的数据同步到输出流中
public void close() throws IOException关闭数据流

​ 我们在使用 OutputStream 进行写操作时，不能直接实例化 OutputStream 类的对象，应该实例化其实现了抽象方法的子类 FileOutputStream，我们学习对 OutputStream 各种常用方法的使用

  • write(int b)方法的使用
public class Test{
    public static void main(String[] args){
        try{
            OutputStream outputStream = new FileOutputStream("E:/test2.txt");
            outputStream.write(99);
            outputStream.flush();
            outputStream.close();
        }catch(IOException e){
            
        }
    }
}

代码会在 E 盘下创建 test2.txt 文件，并且行文件中写入 byte 类型的数据 99.而byte 类型的数据会转换成字符，99 对应的是 ‘c’ ，所以运行结果我们会在 E 盘下 test2.txt 文件中看到 c

OutputStream 的 write(byte b[]) 方法的使用

public class OutputTest {
	public static void main(String[] args) {
		try {
			OutputStream outputStream = new FileOutputStream("E:/test2.txt");
			byte[] bytes = new byte[] {105,111,99};
			outputStream.write(bytes);
			outputStream.flush();
			outputStream.close();
		}catch(IOException e) {
			
		}
	}
}

{105,111,99} 转换成字符串为 “ioc” ，所以我们可以在文件中看到 ioc

OutputStream 的 write(byte b[] int off, int len) 方法的使用

public class OutputTest {
	public static void main(String[] args) {
		try {
			OutputStream outputStream = new FileOutputStream("E:/test2.txt");
			byte[] bytes = new byte[] {105,111,99};
			outputStream.write(bytes, 1, 2);
			outputStream.flush();
			outputStream.close();
		}catch(IOException e) {
			
		}
	}
}

对数组 {105,111,99} 进行截取，从下标 1 开始取，长度为 2 ，所以出去的值是 “111,99”，转换为字符串为 “oc” ，随意我们可在文件中看到 oc

字符流

​ 字符流是有别于字节流的另一种数据流，两者的区别在于每次处理的数据单位不同一个是以字节为单位，一个是以字符为单位。字符流也分为输入流（Reader）和输出流（Writer） 。

​ Reader 是一个抽象类，实现类 Readable 和 Closeable 接口。Readable 接口的作用是可以将数据以字符的形式读入缓冲区，Reader 常用方法如表：

方法描述
public int read() throws IOException以字符为单位读数据
public int read(char cbuf[]) throws IOException将数据读入 char 类型数组，并返回数据长度
public abstract int read(char cbuf[], int off, int len) throws IOException将数据读入 char 类型数组的指定区间，并返回数据长度
public abstract void close() throws IOException关闭数据流
public long transferTo(Writer out)将数据直接读入字符输出流

我们在使用 Reader 进行读入操作时，不能直接实例化 Reader 对象，应该实例化其实现了抽象方法的子类 FileReader。FileReader 又继承了 InputStreamReader ，这个类才是 Reader 的直接子类，他的作用是将字节流转为字符流，属于处理流，我们在这儿直接使用 FileReader 进行实例操作，同时看看与字节流的区别（字符编码：utf-8，test.txt文件的内容为：你好）

public class TestReader {
	public static void main(String[] args) {
		try {
			System.out.println("用字符读数据");
			Reader reader = new FileReader("E:/test.txt");
			int temp = 0;
			while((temp = reader.read()) != -1) {
				System.out.println(temp);
			}
			reader.close();
			System.out.println("用字节读数据");
			InputStream inputStream = new FileInputStream("E:/test.txt");
			temp = 0;
			while((temp = inputStream.read()) != -1) {
				System.out.println(temp);
			}
			inputStream.close();
		}catch(IOException e) {
			
		}
	}
}

运行结果：

用字符读数据
20320
22909
用字节读数据
228
189
160
229
165
189

在 utf-8 中 1 个汉字对应三个字节，所以 “228,189,160” 三个字节组合起来表示 ”你“。

Reader 其他常用方法的使用：

public class TestReader2 {
	public static void main(String[] args) {
		try {
			Reader reader = new FileReader("E:/test.txt");
			char[] chars = new char[8];
			int length = reader.read(chars);
			System.out.println("数据流长度："+length);
			System.out.println("遍历 char 数组：");
			for(char c : chars) {
				System.out.println(c);
			}
			reader.close();
			System.out.println("--------------------------");
			reader = new FileReader("E:/test.txt");
			chars = new char[8];
			length = reader.read(chars, 2, 6);
			System.out.println("数据流长度："+length);
			System.out.println("遍历 char 数组");
			for(char c : chars) {
				System.out.println(c);
			}
			reader.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

在这里插入图片描述

字符输出流 Writer 实现了 Appendable 接口可以将 char 类型的数据读入数据缓冲区，Writer 的常用方法如表：

方法描述
public void write(int c) throws IOException以字符为单位写数据
pulbic void write(char cbuf[]) throws IOException将 char 类型数组中的数据写出
public abstract void write(char cbuf[], int off, int len) throws IOException将 char 类型数组中指定区间的数据写出
public void write(String str) throws IOException将 String 类型的数据写出
public void write(String str, int off, int len) throws IOException将 String 类型指定区间的数据写出
public abstract void flush() throws IOException可以强制将缓冲区的数据同步到输出流中
public abstract void close() throws IOException关闭数据流
我们在使用 Writer 进行写出操作时，不能直接实例化 Writer 对象，应该实例化其实现了抽象方法的子类 FileWriter ，FileWriter 有继承自 OutputStreamWriter，和 InputStreamReader 一样，OutputStreamWriter 也属于处理流，我们来学习 Writer 的常用方法如何使用：
  • write(int c) 方法
public class TestWriter {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			writer.write(20320);
			writer.write(22909);
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

你好

  • write(char cbuf[]) 方法
public class TestWriter {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			char[] chars = {'你','好','世','界'};
			writer.write(chars);
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

你好世界

  • write(char cbuf[], int off, int len)
public class TestWriter {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			char[] chars = {'你','好','世','界'};
			writer.write(chars, 2, 2);
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

世界

  • write(String str) 方法
public class TestWriter {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			String str = "Hello World,你好世界";
			writer.write(str);
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

Hello World，你好世界

  • write(String str, int off, int len)
public class TestWriter {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			String str = "Hello World,你好世界";
			writer.write(str, 10 ,6);
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

d，你好世界

处理流

​ 字节流是基础管道，字符流是在字节流的基础上转换来的，Java 提供了完成转换的类，按照输入和输出两个方向分为输入转换流（InputStreamReader） 和输出转换流（OutputStreamWriter） 。FileReader 继承自 InputStreamReader ，即输入转换流。通过这个类将字节流转为字符流，字节是基本单位，所以是基础管道。同理，FileWriter 继承自 OutputStreamWriter。

处理流将字节流转换为字符流的过程：

在这里插入图片描述

InputStreamReader 的使用（test.txt文件中的内容为：Hello World)：

class InputStreamReaderDemo {
	public static void main(String[] args) {
		try {
			InputStream inputStream = new FileInputStream("E:/test.txt");
			InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
			Reader reader = inputStreamReader;
			char[] chars = new char[1024];
			int length = reader.read(chars);
			reader.close();
			String result = new String(chars,0,length);
			System.out.println(result);
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

Hello World

OutputStreamWriter 的使用：

public class OutputStreamWriterDemo {
	public static void main(String[] args) {
		String str = "你好 世界";
		try {
			OutputStream outputStream = new FileOutputStream("E:/test2.txt");
			OutputStreamWriter outputStreamWriter = new OutputStreamWriter(outputStream);
			Writer writer = outputStreamWriter;
			writer.write(str);
			writer.flush();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

创建文件，内容为：你好 世界

缓冲流

实际上在真实的运行环境中，无论是使用哪种流读取数据都需要频繁地访问硬盘，这样对硬盘的损伤比较大，而且效率不高。为了解决这一个问题，减少访问硬盘时的资源开销，我们引入了缓冲流。缓冲流自带缓冲区，可以一次性从硬盘读取部分数据存入缓冲区，在写入程序内存中。

在这里插入图片描述

​ 缓冲流也属于处理流，即不能直接关联文件进行操作，只能对已存在的节点流进行包装，如何区分节点流和处理流呢？如果该流可以直接关联了文件，即提供了一个参数为 File 对象或文件路径的构造函数 ，该流就是节点流。如果该流不能直接关联文件，即没有提供参数为 File 对象或文件路径的构造函数，而必须依赖其他流来实例化的就是处理流。缓冲流又可以分为字节缓冲流和字符缓冲流，再细分又可分为字节输入缓冲流和字节输出缓冲流，以及字符输入缓冲流和字符输出缓冲流。

  • 缓冲流
    • 字节缓冲流
      • 字节输入缓冲流（BufferedInputStream）
      • 字节输出缓冲流（BufferedOutputStream）
    • 字符缓冲流
      • 字符输入缓冲流（BufferedReader）
      • 字符输出缓冲流（BufferedWriter）

输入缓冲流

字节输入缓冲流

字节输入出缓冲流 BufferedInputStream 的常用方法与 InputStream 类似，并且我们说过缓冲流是处理流，必须依赖于已存在的流才能创建实例化对象，接下来使用 BufferedInputStream 来读取 test.txt.

test.txt 的内容为：

Java 是一门面向对象编程语言，不仅吸收了 C++ 语言的各种优点，
还摒弃了 c++ 里面难以理解的多继承，指正等概念，因此 Java 语言具有功能强大和简单易用两个特性
Java 语言作为静态面向对象编程语言的代表，极好的实现了面向对象理论，
允许程序员以优雅的思维方式进行复杂的编程。
Java 具有简单性、面向对象、分布式、健壮性、安全性，平台独立与可移植性。
多线程、动态性等特点
Java 可以编写桌面应用程序、Web应用程序
分布式系统和镶入式系统应用程序等

  • BufferedInputStream 的 read() 方法的使用：
public class Test{
    public static void main(String[] args){
        try{
        	 InputStream inputStream = new FileInputStream("E:/test.txt");
            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            int temp = 0;
            while((temp = bufferedInputStream.read()) != -1){
                System.out.println(temp);
            }
            bufferedInputStream.close();
            inputStream.close();
        }catch(IOException e){
            
        }
    }
}

运行结果：

一堆数字。。。。

  • BufferedInputStream 的 read(byte b[]) 方法
public class Test{
    public static void main(String[] args){
        try{
            InputStream inputStream = new FileInputStream("E:/test.txt");
            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            byte bytes = new byte[1024];
            int length = bufferedInputStream.read(bytes);
            for(byte b : bytes){
                System.out.println(b);
            }
            bufferedInputStream.close();
            inputStream.close();
        } catch(IOException e){
            
        }
    }
}

运行结果：

一堆数字

  • BufferedInputStream 的 read(byte b[], int off, int len) 方法
public class Test{
    public static void main(String[] args){
        try{
            InputStream inputStream = new FileInputStream("E:/test.txt");
            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            byte bytes = new byte[1024];
            int length = bufferedInputStream.read(bytes,10,10);
            for(byte b : bytes){
                System.out.println(b);
            }
            bufferedInputStream.close();
            inputStream.close();
        } catch(IOException e){
            
        }
    }
}

运行结果：

中间有是个非零的数字，其余都为 0

字符输入缓冲流

同样是读取 test.txt ，接下来我们看看字符输入缓冲流 BufferedReader。

BufferedReader 的 readLine() 方法可以直接读取一整行数据

public class Test{
    
    public static void main(String[] args){
        try{
            Reader reader = new FileReader("E:/test.txt");
            BufferedReader bufferedReader = new BufferedReader(reader);
            String str = "";
            while((str = bufferedReder.readLine()) != null){
                System.out.println(str);
            }
            bufferedReader.close();
            reader.close();
        }catch(IOException e){
            
        }
    }
}

运行结果：

Java 是一门面向对象编程语言，不仅吸收了 C++ 语言的各种优点，
还摒弃了 c++ 里面难以理解的多继承，指正等概念，因此 Java 语言具有功能强大和简单易用两个特性
Java 语言作为静态面向对象编程语言的代表，极好的实现了面向对象理论，
允许程序员以优雅的思维方式进行复杂的编程。
Java 具有简单性、面向对象、分布式、健壮性、安全性，平台独立与可移植性。
多线程、动态性等特点
Java 可以编写桌面应用程序、Web应用程序
分布式系统和镶入式系统应用程序等

  • BufferedReader 的 read() 方法
public class Test{
    public static void main(String[] args){
        try{
            Reader reader = new FileReader("E:/test.txt");
            BufferedReader bufferedReader = new BufferedReader(reader);
            int temp = 0;
            while((temp = bufferedReader.read()) != -1){
                System.out.println(temp);
            }
            bufferedReader.close();
            reader.close();
        }catch(IOException e){
            
        }
    }
}

运行结果：

一堆数字

  • BufferedReader 的 read(char cbuf[]) 方法
public class Test{
    public static void main(String[] args){
        try{
            Reader reader = new FileReader("E:/test.txt");
            BufferedReader bufferedReader = new BufferedReader(reader);
            char chars = new char[1024];
            int length = bufferedReader.read(chars);
            System.out.println(length);
            for(char c : chars){
                System.out.println(c);
            }
            bufferedReader.close();
            reader.close()
        }cathc(IOException e){
            
        }
    }
}

运行结果：

230

J

a

v

a

是

一

…

  • BufferedReader 的 read(char cbuf[], int off, int len) 方法
public class Test{
    public static void main(String[] args){
        try{
            Reader reader = new FileReader("E:/test.txt");
            BufferedReader bufferedReader = new BufferedReader(reader);
            char chars = new char[1024];
            int length = bufferedReader.read(chars,2,2);
            System.out.println(length);
            for(char c : chars){
                System.out.println(c);
            }
            bufferedReader.close();
            reader.close()
        }cathc(IOException e){
            
        }
    }
}

运行结果：

2

J

a

输出缓冲流

字节输出缓冲流

字节输出缓冲流（BufferedOutputStream），这次我们通过 Java 程序向文件 test2.txt中写入数据。需要注意的是，输出缓冲流在关闭之前需要先调用 flush() 方法，目的是将缓冲区的数据全部写入到目标文件中，再关闭流。

  • BufferedOutputStream 的 write(int b) 方法
public class BufferedOutput {
	public static void main(String[] args) {
		try {
			OutputStream outputStream = new FileOutputStream("E:/test2.txt");
			BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
			String str = "JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，\r\n是一个"
					+ "编写 Java 的 Applet 小程序和应用程序的程序开发环境";
			byte[] bytes = str.getBytes();
			for(byte b : bytes) {
				bufferedOutputStream.write(b);
			}
			bufferedOutputStream.flush();
			bufferedOutputStream.close();
			outputStream.close();
		} catch(IOException e) {
			
		}
	}
}

运行结果：

JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，
是一个编写 Java 的 Applet 小程序和应用程序的程序开发环境

  • BufferedOutputStream 的 write(byte b[]) 方法
public class BufferedOutput {
	public static void main(String[] args) {
		try {
			OutputStream outputStream = new FileOutputStream("E:/test2.txt");
			BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
			String str = "JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，\r\n是一个"
					+ "编写 Java 的 Applet 小程序和应用程序的程序开发环境";
			byte[] bytes = str.getBytes();
			bufferedOutputStream.write(bytes);
			bufferedOutputStream.flush();
			bufferedOutputStream.close();
			outputStream.close();
		} catch(IOException e) {
			
		}
	}
}

运行结果：

JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，
是一个编写 Java 的 Applet 小程序和应用程序的程序开发环境

  • BufferedOutputStream 的 write(byte b[],int off, int len) 方法
public class BufferedOutput {
	public static void main(String[] args) {
		try {
			OutputStream outputStream = new FileOutputStream("E:/test2.txt");
			BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
			String str = "JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，\r\n是一个"
					+ "编写 Java 的 Applet 小程序和应用程序的程序开发环境";
			byte[] bytes = str.getBytes();
			bufferedOutputStream.write(bytes,10,10);
			bufferedOutputStream.flush();
			bufferedOutputStream.close();
			outputStream.close();
		} catch(IOException e) {
			
		}
	}
}

运行结果：

Developmen

字符输出缓冲流

字符缓冲流 BufferedWriter 提供了一个可以直接将字符串输出的方法 write(String str) 方法

public class BufferedWriterDemo {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			BufferedWriter bufferedWriter = new BufferedWriter(writer);
			String str = "JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，\r\n是一个"
					+ "编写 Java 的 Applet 小程序和应用程序的程序开发环境";
			bufferedWriter.write(str);
			bufferedWriter.flush();
			bufferedWriter.close();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，
是一个编写 Java 的 Applet 小程序和应用程序的程序开发环境

BufferedWriter 的 write(String s,int off, int len) 方法

public class BufferedWriterDemo {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test2.txt");
			BufferedWriter bufferedWriter = new BufferedWriter(writer);
			String str = "JDK (Java Development Kit) 称为 Java 开发包或 Java 开发工具，\r\n是一个"
					+ "编写 Java 的 Applet 小程序和应用程序的程序开发环境";
			bufferedWriter.write(str, 3, 10);
			bufferedWriter.flush();
			bufferedWriter.close();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

(Java Deve

BufferedWriter 的 writer(char cbuf[]) 方法

public class BufferedWriterDemo2 {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test3.txt");
			BufferedWriter bufferedWriter = new BufferedWriter(writer);
			char[] chars = {'I',' ','L','o','v','e',' ','J','a','v','a'};
			bufferedWriter.write(chars);
			bufferedWriter.flush();
			bufferedWriter.close();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

I Love Java

BufferedWriter 的 write(char cbuf[],int off,int len) 方法

public class BufferedWriterDemo2 {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test3.txt");
			BufferedWriter bufferedWriter = new BufferedWriter(writer);
			char[] chars = {'I',' ','L','o','v','e',' ','J','a','v','a'};
			bufferedWriter.write(chars, 3, 6);
			bufferedWriter.flush();
			bufferedWriter.close();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

ove Ja

BufferedWriter 的 writer(int c) 方法

public class BufferedWriterDemo2 {
	public static void main(String[] args) {
		try {
			Writer writer = new FileWriter("E:/test3.txt");
			BufferedWriter bufferedWriter = new BufferedWriter(writer);
			bufferedWriter.write(22909);
			bufferedWriter.flush();
			bufferedWriter.close();
			writer.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：

好

序列化和反序列化

前面我们介绍的所有流都是将文件读取到内存中，比 byte、数组、char、String 类型展示，同理我们也可以将内存中的数字或者字符串数据输出到文件中。那么如果我们需要将内存中的对象输出到文件中，或者从文件中读取数据并还原成内存中的对象，应该如何处理？

序列化和反序列化：序列化和反序列化。序列化就是指将内存中的对象输出到硬盘文件中进行保存，反序列化就是相反的操作，从文件中读取数据并还原成内存中的对象

序列化

序列化，首先给需要序列化的对象的类实现 java.io.Serializable 接口

class User implements Serializable{
	private int id;
	private String name;
	private int age;
	private char gender;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	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;
	}
	public char getGender() {
		return gender;
	}
	public void setGender(char gender) {
		this.gender = gender;
	}
	public User(int id,String name,int age,char gender) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
}

接下来就可以将 User 的实例化对象进行序列化处理，通过数据流写入到文件中，这里需要用到 ObjectOutputStream，该类是专门将对象进行输出处理的

public class TestSerializable {
	public static void main(String[] args) {
		User user = new User(1,"张三",22,'男');
		try {
			OutputStream outputStream = new FileOutputStream("E:/test3.txt");
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
			objectOutputStream.writeObject(user);
			objectOutputStream.flush();
			objectOutputStream.close();
			outputStream.close();
		} catch (IOException e) {
			// TODO: handle exception
		}
	}
}

运行结果：（有可能再文件中看到很多数字，也有可能乱码，这是编码问题，不影响）

 sr com.al.objectIO.User6cY商紋l I ageC genderI idL namet Ljava/lang/String;xp u7 t 寮犱笁

反序列化

接下来就是反序列化操作，即从文件中读取数据并还原成内存中的对象，这里需要用到 ObjectInutStream 类

public class TestSerializable2 {
	public static void main(String[] args) {
		try {
			InputStream inputStream = new FileInputStream("E:/test3.txt");
			ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
			User user = (User) objectInputStream.readObject();
			objectInputStream.close();
			inputStream.close();
			System.out.println(user.getId());
			System.out.println(user.getName());
			System.out.println(user.getGender());
			System.out.println(user.getAge());
		} catch (IOException e) {
			// TODO: handle exception
		} catch (ClassNotFoundException e) {
			
		}
	}
}

运行结果：

1

张三

男

22

lucien_ma
关注
专栏目录
java-详解File类,InputStream和OutStream的用法
Lzm的博客
04-17 2104
file 类以及 InputStream 和 OutStream 详解（另附代码，以及运行截图）
java中getinputstream_java getinputstream
weixin_39611275的博客
02-24 1676
2 二、 I/O类层次结构 Java提供超过60个不同的流类型,这些流 类包含在上面提到的java.io包中,四个基本的抽象类: InputStream、OutputStream、Reader和 Writer......其他还有值得一提的就是,在 jdk1.4 中,新增了 NIO 包,优化了一些 IO 处理的速度,所以 在 FileInputStream 和 FileOutputStream 中新...
原生java获取MultipartFile getInputStream
最新发布
weixin_41035488的博客
08-15 136
使用原生 Java 获取 MultipartFile 的输入流 在Java Web开发中，处理文件上传是一个常见的任务。当我们需要获取一个MultipartFile的输入流时，通常会用到Spring框架。本文将指导你一步步实现这个目标，尤其是如何使用原生Java代码来获取getInputStream()。 实现流程 以下是...
Java中File类及关于InputStream和OutputStream的基本用法
m0_61630116的博客
07-05 4557
Java中的File类的基本使用以及关于InputStream和OutputStream。
【JavaEE】文件操作IO之File 、InputStream、OutputStream 用法详解
m0_63372226的博客
02-02 3485
狭义上：针对硬盘这种持久化存储的I/O设备，当进行数据保存时，往往不是保存成一个整体，而是独立成一个个的单位进行保存，这个独立的单位就被抽象成文件的概念。每个文件都有属于它自己的，不是内容的一些信息。例如文件名、文件类型、文件大小，不作为文件数据。这些信息就称作文件的元信息。InputStream 只是一个抽象类。读：输入流。例如利用水龙头节水。方法修饰符及返回值类型方法签名说明intread()读取一个字节的数据，返回 -1 代表已经完全读完了int。
java上传文件
BLUESKYHOST的博客
08-21 232
服务器端 package cn.net.update; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public...
File 类以及 InputStream, OutputStream 的用法
hahaharden的博客
02-25 1850
File 类以及 InputStream, OutputStream 的用法
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
java IO流将一个文件拆分为多个子文件代码示例
08-28
Java IO流将一个文件拆分为多个子文件代码示例 Java IO流是一个文件流处理的基础组件，它提供了基本的文件读取和写入操作。将一个文件拆分为多个子文件是文件处理中一个常见的需求，例如上传大文件时，可以先分割成...
文件上传到本地
weixin_48860638的博客
11-17 834
InputStream inputStream = file.getInputStream(); String fileName = file.getOriginalFilename(); byte[] bs = new byte[1024]; int len; Long startTs = System.currentTimeMillis(); String timeStemp = String.valueOf(startTs); // 获得时间戳 File f = new File(path + "
file.getinputstream(); 要关闭吗_告别复杂的流关闭
热门推荐
weixin_42113794的博客
12-26 1万+
一、引言也许大家在使用流时因为未关闭、或者未正常关闭引发了很多问题。其实java7引入了自动关闭流机制，只是我们未使用而已。二、自动关闭流例子public class AutoCloseTest { public static void main(String[] args) throws IOException { //将打开流代码放到try中 try (...
POI的导入功能(EXCEL)
admin_mvip的博客
12-10 282
InputStream inputStream = file.getInputStream(); //此处file指的是springmvc的MultipartFile HashMap<String, String> map = new HashMap<String, String>(); //用于数据 XSSFWorkbook workbook = n
MultipartFile.getInputStream打开的流是否需要关？
jimmyleeee的专栏
04-19 8285
MultipartFile.getInputStream打开流之后，是否需要关闭呢？ 因为也继承了AutoCloseable接口。 从AutoCloseable的说明里可知它是为了更好的管理资源，也就是及时释放资源，当一个资源类集成了它并且实现了close方法，在使用try-catch-resources语法创建的资源抛出异常后，JVM会自动调用close 方法进行资源释放，当没有抛出异常正常退出try-block时候也会调用close方法。 有些文章说只要对象销毁时，就会调用close方法释放流资源。
java校验导入的模板
weixin_30514745的博客
08-26 1043
/** * 验证导入模板的正确性 InputStream inputStream = file.getInputStream(); */ @SuppressWarnings("deprecation") public Boolean falg(InputStream inputStream,String fileName) throws IOExceptio...
File 类,InputStream, OutputStream 的用法
qq_62718027的博客
06-23 790
运行原理和字节流读取一样,唯一不同的是在屏幕上显示的是字符而不是ask表对应的数字。我们先在D盘创建一个名字叫做hello.txt的文件,然后输入hello。基本方法： read（） ：读取一个字节的数据，返回-1代表读取完毕。那么File类的操作实际上就全部是对文件进行操作。这种方式一定要注意在最后使用flush方式。否则会什么都没有但是程序依然不报错。基本方法： write（）把存储在内存中的字节流拿出来。File翻译过来"文件"(读写的基本单位是字节)就是从文件里面读取数据。就是向文件里面写数据。
Java中FileInputStream使用
weixin_51351637的博客
03-17 5757
import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /*FileInputStreamTest 文件字节输入流 任何文件都可以采用这个流读取*/ /*字节输入流,是从硬盘向内存中读入*/ public class FileInputStreamTest { public static void main(String[] args) { .
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值