Java中IO流的学习

最新推荐文章于 2022-05-21 14:04:56 发布
最新推荐文章于 2022-05-21 14:04:56 发布
阅读量131 收藏
点赞数
分类专栏： JAVA 文章标签： IO流 Object对象流 Data流 输入流：Input​输出流：Output 序列化(Serializable)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhiruochujian1/article/details/103038644
版权

一、File 类

​ File 类：文件和目录路径名的抽象表示形式
​ 提供的功能：操作文件外部的能力,不能操作文件内部的内容
​ 能够定义真实存在的路径|文件,不在的也可以定义,所以抽象表现形式
​ 构造器：

​ File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例

​ File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例

​ File(String parent, String child) 根据 parent路径名字符串和child路径名字符串创建一个新File实例

二、IO流

​ IO：上传下载，写入写出
​ 流: 一连串流动的数据，以先入先出的方式进行流动，管道，以程序为中心、程序与网络|文件|服务器|数组… , 一切以java内存为中心

1.分类

1)按照流向

​ 输入流：Input
​ 输出流：Output

2)操作单元分

​ 字节流 (万能流):任何内容都可以转为字节,可以传输文本,图片,音频…

​ InputStream/OutputStream

​ 字符流 :只能操作纯文本数据

​ Reader/Writer

3)按照功能

​ 节点流 : 包裹源头,实现基本功能

​ 字节流:FileInputStream/FileOutputStream

​ 字符流:FileReader/FileWriter

​ 功能流 : 对节点流增强性能,提高效率

​ 转换流 :InputStreamReader/OutputStreamWriter

​ 缓冲流 :BufferedInputStream/BufferedOutputStream

​ BufferedReader/BufferedWriter

​ 4)各个分类之间是相辅相成的

2.字节流

InputStream/OutputStream

1)字节输入流

​ InputStream 此抽象类是表示字节输入流的所有类的超类

​ 子类：FileInputStream 从文件系统中的某个文件中获得输入字节

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 {
        InputStream is=new FileInputStream(new File("D:/test.txt"));
        //读入数据 一个字节一个字节读入
        //使用循环,循环读入  可以简化代码,重复代码只写一次,但是还是一个字节一个字节读入
        /*int num=-1;
        while((num=is.read())!=-1){
            System.out.println((char)num);
        }*/
        //int read(byte[] b)   一个字节数组一个字节数组的读入
        //返回值: 返回读入到字节数组中数据的个数,没有读到返回-1
        byte[] car=new byte[1];
        int len=-1;
        while((len=is.read(car))!=-1){
            System.out.println(new String(car,0,len));
        }
        //关闭
        is.close();
    }
}

2)字节输出流

​ OutputStream 此抽象类是表示输出字节流的所有类的超类
​ 子类：FileOutputStream 文件输出流是用于将数据写入 File 的输出流

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)  true追加,false不追加(默认)
		//FileOutputStream(File file,boolean append) 
		OutputStream os=null;
		try {
			//1.选择流
			os=new FileOutputStream("D:/hehe.txt",true); 
			//"D:/hehe.txt"文件不存在,系统会自动帮我们创建,但是文件夹不会
			//2.准备数据
			String str="今天晚上敲代码..."; 
			byte[] car=str.getBytes();
			//3.写出 	void write(byte[] b)  
			os.write(car);
			//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();
			}
		}
	}
}

3.字符流

​ Reader/Writer 只能操作纯文本

1)字符输入流

​ Reader 读取字符流的抽象类
​ FileReader 用来读取字符文件的便捷类

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class CharDemo01 {
	public static void main(String[] args) {
		//FileReader(String fileName) 
		Reader rd=null;
		try {
			//1.选择流
			rd=new FileReader("D:/hehe.txt");
			//2.读取
			//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,证明已达到末尾
			/*while(-1!=(len=rd.read())){
				System.out.println((char)len);
			}*/
			// int read(char[] cbuf)  将字符读入数组。
			char[] ch=new char[1024];
			while((len=rd.read(ch))!=-1){
				System.out.println(new String(ch,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 用来写入字符文件的便捷类

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) 写入字符数组。 
				abstract  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={'上','海','尚','学','堂'};
			rt.write(ch);
			rt.write("\r\n");
			rt.write(ch,2,3);
			rt.write("\r\n");
			//3.刷出
			rt.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally{
			//4.关闭
			if(null!=rt){
				try {
					rt.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}
}

4.功能流(节点流)

​ 缓冲流: 增强功能，提高性能，加快读写效率

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

5.date流(字节节点流)

1)字节节点流

读写基本数据类型+String类型数据

  • 是字节流功能流的一种
  • DataInputStream 新增方法: readXxx()
  • DataOutputStream 新增方法: writeXxx()
  • 存在新增方法不能发生多态,先写出再写入
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 DataDemo01 {
	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();
	}
}

6.对象流 Object

​ 保存数据类型+数据

​ 字节的功能流:当想要传输|读写对象类型数据的时候,可以使用一个对象流

1)序列化

​ 把对象类型的数据转化为可存储|可传输的状态的过程

ObjectInputStream() 反序列化输入流 新增方法: readObject()

ObjectOutputStream() 序列化输出流 新增方法: writeObject()

2)序列化(Serializable)

  1. 先序列化后反序列化

  2. 序列化反序列读写顺序一致

  3. 不是所有的类都能序列化 实现 java.io.Serializable 空接口

  4. 不是所有的属性都需要序列化 transient

  5. static内容不会被序列化

  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("冬冬",18);
		int[] arr={1,2,3,4};
		//3.输出
		os.writeObject(p);
		os.writeObject(arr);
		//4.刷出
		os.flush();
		//5.关闭
		os.close();		
		p.setAge(100);
	}
}
//自定义Person这个类
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//重写toString方法
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}
zhiruochujian1
关注
专栏目录
java-io流学习总结.doc
11-24
Java IO 流学习总结的主要内容是对 Java 语言中 IO 流的机制和应用进行了详细的介绍，包括流的基本概念、字节流和字符流的区别、IO 体系的基本结构、FileReader 和 FileWriter 的使用、IO 流的应用等等。
Java-Io流，练习
07-06
通过运行这些示例，你可以直观地理解IO流的工作原理，并学习如何在实际项目中运用。 总结来说，Java的IO流是一个庞大且重要的主题，涵盖了数据的输入、输出、缓冲、转换等多个方面。对于初学者而言，理解和掌握IO流...
Java中的IO学习总结
weixin_34308389的博客
09-11 74
　　今天刚刚看完java的io流操作，把主要的脉络看了一遍，不能保证以后使用时都能得心应手，但是最起码用到时知道有这么一个功能可以实现，下面对学习进行一下简单的总结： 　　IO流主要用于硬盘、内存、键盘等处理设备上得数据操作，根据处理数据的数据类型的不同可以分为：字节流（抽象基类为InPutStream和OutPutStream）和字符流（抽象基类为Reader和Writer）。根据流向不同，...
Java中的IO学习（一）
Soz的专栏
01-10 114
学习Java中的IO，首先要理解Java中IO的流模型。   所谓流，可以假想成河流，流的数据源，就是河流的发源地；流的单向性，就像河流的水流是单向的一样。   Java中的IO流，从两方面去分类。 输入流和输出流 节点流和处理流 输入流和输出流，就是程序和外部的数据源进行IO操作。这些数据源可以是可以是内存，文件，还可以是网络上的一个URL。   输入流和输出流的定义都是相对程序来说的，也就...
java脚本之家_JAVA IO API使用详解_java_脚本之家（转载）
weixin_30673943的博客
02-17 127
本文通过理论、用法、实例详细说明了JAVA IO的使用，大家参考其中的实例代码实现自己的JAVA IO程序一.理论准备流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行，设备可以是文件、网络、内存等。流具有方向性，至于是输入流还是输出流则是一个相对的概念，一般以程序(小马哥说的是机器)为参考，如果数据的流向是程序至设备，我们成为输出流，反之我们...
java之模块学习-JAVA的IO流
Millet
12-31 656
一、IO流的三种分类方式 1、按流的方向分为：输入流和输出流 2、按流的数据单位不同分为：字节流和字符流 2.1.字节流读取的时候，读到一个字节就返回一个字节；  字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节） 时。先去查指定的编码表，将查到的字符返回。 2.2.字节流可以处理所有类型数据，如：图片，MP3，AVI视频文件，而字符
Java的IO编程学习
我要，我要，我还要
06-22 436
一、相关概念 流： 流向，从一端到另一端，是一个动态的、抽象的概念，是一串连续动态的数据集合。 数据： 提供数据的原始媒介，如数据库、文件等。 在Java中，对于数据的输入输出以流的方式进行的。jdk中封装了各种各样的关于流的类，在java.io包中。 java中重要的关于流的类和接口 类 说明 File 文件类 InputStream 字节输入流 OutputStream...
《JAVA_IO流学习总结》
04-23
在本文中，我们将深入探讨Java IO流的各个方面，包括它的分类、工作原理、常见类以及实际应用。 一、IO流的分类 Java IO流分为两大类：字节流和字符流。字节流处理的是单个8位的字节，而字符流处理的是16位Unicode...
Java 的 IO流笔记.md
03-08
### Java IO流学习笔记 #### 一、IO流的四大抽象类 - **InputStream/OutputStream**：字节的输入输出流的抽象类。 - 数据单位：字节（8比特，范围0-255） - **Reader/Writer**：字符的输入输出流的抽象类。 - ...
java IO流学习笔记
12-12
### Java IO流学习笔记 #### 异常处理与IO流操作 在进行Java IO流的学习过程中，异常处理是非常重要的一个方面。本节将详细介绍如何在Java中处理异常，并结合具体的IO流操作进行说明。 #### 一、异常处理 在Java...
JAVA IO必备知识
日积月累，水滴石穿
05-21 660
目录 一、什么是IO 二、IO的分类 三、字节流 1、字节传一切 2、字节输入流InputStream 3、FileInputStream类 4、字节输出流OutputStream 5、FileOutputStream类 6、综合应用 四、字符流 1、字符输入流Reader 2、FileReader类 3、字符输出流Writer 4、FileWriter类 六、IO资源的处理 七、缓冲流 1、字节缓冲流 2、字符缓冲流 3、综合案例 六、转换流 1、字符编码和字符集
吃透Java IO：字节流、字符流、缓冲流
禧年
02-05 2012
文章目录1.Java IO流有什么特点？2.Java IO流分为几种类型？3.字节流和字符流的关系与区别？4.字符流是否使用了缓冲？5.缓冲流的效率一定高吗？为什么？6.缓冲流体现了Java中的哪种设计模式思想？7.为什么要实现序列化?如何实现序列化?8.序列化数据后，再次修改类文件，读取数据会出问题，如何解决呢?1. 初识Java IO1.1 IO流分类1、输入流与输出流2、字节流与字符流3、节点流和处理流完整的IO分类图如下：1.2 案例实操2、BufferedInputStream、BufferedO
Java中io流的学习（总结）
有问题请发邮箱dengyifanlittle@163.com进行讨论
08-18 1万+
Java中按照流的不同方向分为输入流和输出流，凡是含有in的，都可理解为输入流，输入流即从文件读取到程序，凡是含有out的，都可以理解为输出流，输出流即从程序输出到文件。按照单位分的话，可以分为字节流和字符流，字节流（读取-二进制文件。写入、拷贝-文本、二进制文件）中包括： InputStream--字节输入流的基类（抽象类） OutputStream--字节输出流的基类（抽象类） File...
Java中的IO操作
moutain0101的博客
03-23 5998
     IO 操作是我以前不太理解的操作。总是觉得很神奇，然后一脸懵逼。今天终于鼓起勇气，认真的学习IO方面的知识。有理解不妥当或者不正确的地方，还请各位大佬指正。一、java的io发生在哪？      这个问题，我们必须首先明确下。io发生在内存和硬盘之间。因为程序在内存中运行。我们需要将硬盘的文件数据读入到内存中，再将数据从内存输出到硬盘中，所以我们就有了IO操作。i和o是分别代表(inpu...
Java IO流学习总结
Yue_Chen的博客
05-26 1万+
Java中IO流学习总结一.IO流中的结构 字符流：顾名思义，该流只能处理字符，但处理字符速度很快 字节流：可以处理所有以bit为单位储存的文件，也就是说可以处理所有的文件，但是在处理字符上的速度不如字符流 二.IO流的具体使用 从各种输入流到各种输出流 注：其实在各个不同的类型中，输入流到输出流的套路基本都一样。 那就拿最简单的FileOutputStream来举例子吧 从FileOutpu
Java输入输出流
weixin_33716557的博客
03-14 233
1 什么是IO 　　Java中I/O操作主要是指使用Java进行输入，输出操作。Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 　　Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核...
Java I/O学习（附实例和详解）
weixin_30364147的博客
03-06 277
一、Java I/O类结构以及流的基本概念 在阅读Java I/O的实例之前我们必须清楚一些概念，我们先看看Java I/O的类结构图： Java I/O主要以流的形式进行读写数据。 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 根据...
java IO流学习总结
热门推荐
coder150806的博客
09-09 5万+
学习了几天的java IO流，下面我来谈谈对java 输入输出流IO的个人见解吧！ 转载自：https://blog.csdn.net/zhaoyanjun6/article/details/54292148/ java流类结构图 一.流的概念： 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。它的特性是进行数据传输； 例如从水源地长江把水导入自来水厂，然后又从自...
用户登录功能的简单实现
zhiruochujian1的博客
11-27 4299
2种用户登录功能的简单实现: 表单登录; Ajax(异步无刷新技术)登录.
Java IO流详解：字节流与字符流的区别
"Java IO流的学习总结文档，涵盖了流的概念、字节流与字符流的区别以及IO体系的基本功能，特别提到了Reader和Writer类及其常用方法，并举例了FileReader和FileWriter的使用。 一、流的概念 Java中的流是处理数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值