python的io流详解_分享知识-快乐自己：IO流基本操作(示例代码)

小咪咪 2022-10-28 00:52 79阅读 0赞

IO图解：

![lazy.gif][]

相关理论：

流的概念和作用：

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类：

根据处理数据类型的不同分为：字符流和字节流

根据数据流向不同分为：输入流和输出流

字符流和字节流：

字符流的由来： 因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。

字节流和字符流的区别：

读写单位不同：

字节流以字节(8bit)为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

处理对象不同：

字节流能处理所有类型的数据(如图片、avi等)，而字符流只能处理字符类型的数据。

字节流：

一次读入或读出是8位二进制。

字符流：

一次读入或读出是16位二进制。

设备上的数据无论是图片或者视频，文字，它们都以二进制存储的。二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。

意味着，字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

输入流和输出流：

输入流只能进行读操作，输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。

输入字节流 InputStream：

InputStream：是所有的输入字节流的父类，它是一个抽象类。

ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。

PipedInputStream：是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。

ObjectInputStream：和所有 FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

输出字节流 OutputStream：

OutputStream：是所有的输出字节流的父类，它是一个抽象类。

ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。

PipedOutputStream：是向与其它线程共用的管道中写入数据。

ObjectOutputStream：和所有 FilterOutputStream 的子类都是装饰流。

总结：

输入流：InputStream或者Reader：从文件中读到程序中；

输出流：OutputStream或者Writer：从程序中输出到文件中；

节点流：

节点流：直接与数据源相连，读入或读出。

直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

这里写图片描述：

![lazy.gif][]

常用的节点流：

父　类 ：InputStream 、OutputStream、 Reader、 Writer

文　件 ：FileInputStream 、 FileOutputStrean 、FileReader 、FileWriter 文件进行处理的节点流

数　组 ：ByteArrayInputStream、 ByteArrayOutputStream、 CharArrayReader 、CharArrayWriter 对数组进行处理的节点流(对应的不再是文件，而是内存中的一个数组)

字符串 ：StringReader、 StringWriter 对字符串进行处理的节点流

管　道 ：PipedInputStream 、PipedOutputStream 、PipedReader 、PipedWriter 对管道进行处理的节点流

处理流：

处理流和节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。

一个流对象经过其他流的多次包装，称为流的链接。

这里写图片描述：

![lazy.gif][]

常用的处理流：

缓冲流：BufferedInputStrean 、BufferedOutputStream、 BufferedReader、 BufferedWriter 增加缓冲功能，避免频繁读写硬盘。

转换流：InputStreamReader 、OutputStreamReader实现字节流和字符流之间的转换。

数据流： DataInputStream 、DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来。

转换流：

InputStreamReader 、OutputStreamWriter 要InputStream或OutputStream作为参数，实现从字节流到字符流的转换。

构造函数：

InputStreamReader(InputStream)：//通过构造函数初始化，使用的是本系统默认的编码表GBK。

InputStreamWriter(InputStream,String charSet)：//通过该构造函数初始化，可以指定编码表。

OutputStreamWriter(OutputStream)：通过该构造函数初始化，使用的是本系统默认的编码表GBK。

OutputStreamwriter(OutputStream,String charSet)：通过该构造函数初始化，可以指定编码表。

1)：File文件操作

创建文件：

/\*\*\* 创建文件\*/

private static voidcreateNewFile() \{

System.out.println("请你输入文件的名称：默认(D:/)");

String fileName=input.next();//创建File对象

File file = new File("src\\FileText\\" +fileName);//判断文件是否存在

if(file.exists()) \{

System.out.println("该文件已存在！！！");

\}else\{try\{boolean flag =file.createNewFile();if(flag) \{

System.out.println("成功创建");

\}else\{

System.out.println("创建失败！！！！");

\}catch(IOException e) \{

e.printStackTrace();

删除文件：

/\*\*\* 删除文件\*/

private static voiddelFIle() \{

System.out.println("请你输入要删除文件的名称：默认(项目：FileText)");

String fileName=input.next();//创建File对象

File file = new File("src\\FileText\\" +fileName);if(file.exists()) \{boolean flag =file.delete();if(flag) \{

System.out.println("删除成功");

\}else\{

System.out.println("删除失败！！！！");

\}else\{

System.out.println("该文件不存在！！！");

修改文件：

/\*\*\* 更新文件名\*/

private static voidupdFile() \{

System.out.println("请你输入要修改的文件的名称：默认(项目：FileText)");

String oldfileName=input.next();

System.out.println("请你输入要新文件名称：默认(项目：FileText)");

String newfileName=input.next();//创建File对象

File oldfile = new File("src\\FileText\\" +oldfileName);

File onewfile= new File("src\\FileText\\" +newfileName);if(oldfile.renameTo(onewfile)) \{

System.out.println("更新成功");

\}else\{

System.out.println("更新失败！！！");

创建文件夹：

/\*\*\* 创建文件夹\*/

private static voidmkdirss() \{

System.out.println("请你输入要创建的文件夹名称：默认(项目：FileText)");

String fileName=input.next();//创建File对象

File file = new File("src\\FileText\\" +fileName);//同时创建多级文件file.mkdirs()//单个创建文件file.mkdir()

if(file.mkdirs()) \{

System.out.println("创建文件夹成功");

\}else\{

System.out.println("创建文件夹失败！！！");

查询文件夹下的文件列表：

/\*\*\* 查询文件夹下所有的文件\*/

private static voidsleFile() \{

System.out.println("请你输入要查询的文件夹名称：默认(项目：FileText)");//String fileName = input.next();//创建File对象

File file = new File("src\\FileText\\");//获取数组集合

File\[\] files =file.listFiles();/\*\*\*

\* 遍历集合

\* countDic：文件夹个数

\* countFile：文件个数\*/

int countDic = 0;int countFile = 0;for(File file1 : files) \{//判断文件夹

if(file1.isDirectory()) \{

countDic++;

\}//判断文件

if(file1.isFile()) \{

countFile++;

System.out.println("文件夹共有：" +countDic);

System.out.println("文件共有：" +countFile);

2)：操作 字节流

public static voidmain(String\[\] args) \{//创建输入和输出流对象

InputStream inputStream=null;

OutputStream outputStream=null;try\{

inputStream=new FileInputStream("src\\FileText\\fileText.txt");

outputStream=new FileOutputStream("src\\FileText\\fileText.txt");//向文件写入

outputStream.write("abc".getBytes());//迭代数据

int num=0;

StringBuffer sb=newStringBuffer();while ((num=inputStream.read())!=-1)

\{//子节转字符

sb.append((char)num);

System.out.println(sb.toString());

\}catch(Exception e)

e.printStackTrace();

\}finally\{try\{

outputStream.close();

inputStream.close();

\}catch(IOException e)

e.printStackTrace();

3)：操作 字符流

/\*\*\* 字符流

\* Reader Writer 基类

\* FileReader FileWrider 子类\*/

public static voidmain(String\[\] args) \{//创建输入输出流

Reader reader = null;

Writer writer= null;try\{

reader= new FileReader("src\\FileText\\fileText.txt");//append:true,标识文件末尾追加

writer = new FileWriter("src\\FileText\\fileText.txt", true);//写入数据

writer.write("今天天气不错！！！");//刷新缓冲区

writer.flush();//读取文件//创建一次性读取数组

char\[\] data = new char\[1024\];int num = 0;//拼接字符串

StringBuffer sb = newStringBuffer();while ((num = reader.read(data)) != -1) \{

sb.append(data,0, data.length);

System.out.println(sb.toString());

\}catch(Exception e) \{

e.printStackTrace();

\}finally\{try\{

reader.close();

\}catch(IOException e) \{

e.printStackTrace();

4)：操作 缓冲流

/\*\*\* 缓冲流

\* BufferReader BufferWriter 不单独使用

\* 一般结合Reader 和 Wrider\*/

public static voidmain(String\[\] args) \{//创建输入输出流

Reader reader = null;

Writer writer= null;

BufferedReader br= null;

BufferedWriter bw= null;try\{

reader= new FileReader("src\\FileText\\fileText.txt");//append:true,标识文件末尾追加

writer = new FileWriter("src\\FileText\\fileText.txt");

br= newBufferedReader(reader);

bw= newBufferedWriter(writer);//写入数据

bw.write("今天很好！！！");

bw.newLine();

bw.write("今天很好吗！！！");//刷新缓冲区

bw.flush();

bw.close();//迭代数据

StringBuffer sb = newStringBuffer();

String temp= null;while ((temp = br.readLine()) != null) \{

sb.append(temp);

System.out.println(sb.toString());

\}catch(Exception e) \{

e.printStackTrace();

\}finally\{try\{

br.close();

writer.close();

reader.close();

\}catch(IOException e) \{

e.printStackTrace();

5)：操作 二进制流

/\*\*\* 二进制流

\* DataInputStream DataOutputStream

\* 不单独使用 一般结合 InputStream OutPutStream 使用\*/

public static voidmain(String\[\] args) \{//创建输入和输出流对象

InputStream inputStream = null;

OutputStream outputStream= null;

DataInputStream dis= null;

DataOutputStream dos= null;try\{

inputStream= new FileInputStream("src\\FileText\\text.txt");

outputStream= new FileOutputStream("src\\FileText\\abc.txt");

dos= newDataOutputStream(outputStream);

dis= newDataInputStream(inputStream);//获取写入

int count = 0;while ((count = dis.read()) != -1) \{

dos.write(count);

\}catch(Exception e) \{

e.printStackTrace();

\}finally\{try\{

dos.close();

outputStream.close();

dis.close();

inputStream.close();

\}catch(IOException e) \{

e.printStackTrace();

6)：操作 序列化

/\*\*\* 序列化：把java中的对象持久化到文件中 的过程

\* 反序列化：把文件中保存的信息还原成java对象的过程

\* 想实现序列化，必须实现Serializable接口\*/

public static voidmain(String\[\] args) \{

InputStream inputStream= null;

OutputStream outputStream= null;

ObjectInputStream objectInputStream= null;

ObjectOutputStream objectOutputStream= null;try\{

inputStream= new FileInputStream("src\\FileText\\fileText.txt");

outputStream= new FileOutputStream("src\\FileText\\fileText.txt");

objectOutputStream= newObjectOutputStream(outputStream);

objectInputStream= newObjectInputStream(inputStream);//序列化信息

TextUser info = newTextUser();

info.setName("admin");

objectOutputStream.writeObject(info);

objectOutputStream.flush();

objectOutputStream.close();//读取序列化

TextUser user =(TextUser) objectInputStream.readObject();

System.out.println(user.getName()+ "=========");

\}catch(Exception e) \{

e.printStackTrace();

\}finally\{

Face your past without regret. Handle your present with confidence.Prepare for future without fear. keep the faith and drop the fear.

面对过去无怨无悔，把握现在充满信心，备战未来无所畏惧。保持信念，克服恐惧！一点一滴的积累，一点一滴的沉淀，学技术需要不断的积淀！

[lazy.gif]: https://www.136.la/skin/m03sred/image/lazy.gif

python的io流详解_分享知识-快乐自己：IO流基本操作(示例代码)

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java中IO流的读写操作：示例详解

相关详解Java中的IO流操作

相关详解Java中的IO流：读写操作示例

相关 IO流基础知识详解--文件及IO流原理

相关 IO流详解.

相关 IO流操作

相关 IO流的详解，彻底了解IO流

相关 IO流知识详解

相关 python的io流详解_分享知识-快乐自己：IO流基本操作(示例代码)

相关 JAVA IO流示例