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

IO图解：

相关理论：

流的概念和作用：

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

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：从程序中输出到文件中；

节点流：

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

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

这里写图片描述：

常用的节点流：

父　类 ：InputStream 、OutputStream、 Reader、 Writer

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

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

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

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

处理流：

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

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

这里写图片描述：

常用的处理流：

缓冲流：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.

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