JAVA_IO四大家族体系：

JAVA_IO流四大家族(1)

JAVA_IO流四大家族（2）

常识介绍

IO流，什么是IO?

I：Input
O：Output
通过IO可以完成硬盘文件的读写

IO流的分类：

一种方式是按照流的方向进行分类：
以内存为参照物，
往内存中去，叫做输入，或者叫做读，
从内存中出来，叫做输出，或者叫做写

另一种方式是按照读写数据方式不同进行分类：
有的流是按照字节的方式读取数据，一次读取一个字节byte，等同于一次读取8个二进制位，这种流是万能的，什么类型的文件都能读取。包括：文本文件，图片，声音文件，视频

假设文件file.txt，采用字节流是这样读的：
a中国bc张三fe

第一次读：一个字节，正好读到’a‘，
第二次读：一个字节，正好读完‘中’字符的一半
第三次读：一个字节，正好读到‘中’字符的另外一半

有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片，声音，视频等文件，只能读取纯文本文件，连word文件都没法读取。
假设文件file.txt，采用字符流是这样读的：
a中国bc张三fe
第一次读：'a’字符（'a’字符在windows系统中占有一个字节）
第二次读：'中’字符（'a’字符在windows系统中占有两个字节）

综上所述：流的分类
输入流，输出流
字节流，字符流

JAVA中主要研究：

怎么new流对象
调用流对象的哪个方法读，哪个方法写

四个家族首领

java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流

java.io.Reader 字符输入流
java.io.Writer 字符输出流

四大家族首领都是抽象类（abstract class）

所有的流都实现了：java.io.Closeable接口，都是可关闭的，都有close（）方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费很多资源。养成好习惯，用完流一定要关闭

所有的输出流都实现了：
java.io.Flushable接口，都是可刷新的，都有flush（）方法；养成好习惯，输出流在最终输出之后，一定要记得flush（）刷新一下，这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道）刷新的作用就是清空管道
注意：如果没有flush（）可能会导致丢失数据；还有只有输出流有flush（），输入流并没有

注意：在java中只要“类名”以Stream结尾的都是字节流，以“Reader/Writer”结尾的都是字符流

java.io包下需要掌握的流有16个：

文件专属：
java.io.FileInputStream
java.io.FileOutputStream
java.io.FileReader
java.io.FileWriter

转换流：（将字节流转换为字符流）
java.io.InputStreamReader
java.io.OutputStreamWriter

缓冲流专属：
java.io.BufferedReader
java.io.BufferedWriter
java.io.BufferedInputStream
java.io.BufferedOutputStream

数据流专属：
java.io.DataInputStream
java.io.DataOutputSteam

标准输出流：
java.io.PrintWriter
java.io.PrintStream

对象专属流：
java.io.ObjectInputStream
java.io.ObjectOutputStream

FileInputStream

read方法

调用一次read方法，文件指针会往后移动一位，即如下图

当执行到f下一个位置时，read返回值就为-1，那么这种read（）读取实现的话，就可以用循环来实现

read方法1代码

/*
* 1.文件字节输出流，万能的，任何类型的文件都可以采用这个流来读
* 2.字节的方式，完成输入的操作，完成读的操作（硬盘--->内存）
* */import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStreamTest01 {public static void main(String[] args) {//创建文件字节输入流对象// 文件路径:(IDEA会自动把\编程\\，因为java中\代表转义)FileInputStream fis=null;try {fis=new FileInputStream("G:\\test.txt");//开始读int readData =fis.read();//这个方法的返回值是：读取到的“字节”本身System.out.print(readData+"\n");readData =fis.read();//这个方法的返回值是：读取到的“字节”本身System.out.print(readData+"\n");readData =fis.read();//这个方法的返回值是：读取到的“字节”本身System.out.print(readData+"\n");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {//在finally语句块中确保流一定关闭if(fis!=null){//避免空指针异常//关闭流的前提是：流不是空try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

read方法1实现截图

read方法2代码

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStreamTest02 {public static void main(String[] args) {FileInputStream fis=null;try {fis=new FileInputStream("G:\\test.txt");while(true){int readData=fis.read();if(readData==-1){break;}System.out.println(readData);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

改造后for循环

  int readData=0;while((readData=fis.read())!=-1){System.out.println(readData);}

read方法2实现截图

read方法3代码

IDEA默认的当前路径是哪里？

首先得搞懂这个问题，我们在src下面创建一个tempfile

然后执行以下代码：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStreamTest03 {/*** int read(byte[] b)* 一次最多读取b.length个字节* 减少硬盘和内存的交互，提高程序的执行效率* 往byte数组当中读* */public static void main(String[] args) {FileInputStream fis=null;try {//相对路径的话呢？相对路径一定是从当前所在的位置作为起点开始找//IDEA默认的当前路径是哪里？工程project的根就是IDEA的默认当前路径fis=new FileInputStream("tempfile");} catch (FileNotFoundException e) {e.printStackTrace();}finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

毫无疑问，报错

找不到指定文件，很简单的原因，当前路径想错了

两个解决办法：

第一个 办法

先找到文件所在path

重点

IDEA默认的当前路径是哪里？工程project的根就是IDEA的默认当前路径

把tempfile文件拷贝一份，放在工程project的根，也就是当前的上层目录

拷贝完成，然后再次执行上述代码

运行成功

第二个 办法

把如下代码

fis=new FileInputStream("tempfile");

变成

fis=new FileInputStream("src//tempfile");

执行结果如下

操作过程（如何看长度）

开始读，采用byte数组，一次读取多个字节，最多读取“数组.length”个字节

   byte []bytes=new byte [4];//准备一个4个长度的数组，一次最多读取4个字节

第一次调用read(bytes)如下图：

 int readCount= fis.read(bytes);

这个方法的返回值是：读取到的字节数量(不是字节本身)，数据已经放在了bytes数组中去

第二次调用read(bytes)如下图：

这次读取到了两个字节

readCount= fis.read(bytes);
System.out.println(readCount);//第二次只能读到2个字节

第三次调用read(bytes)：

读不到任何数据返回-1

 readCount= fis.read(bytes);//第三次1个字节都没有读取到，返回-1
System.out.println(readCount);//-1

操作过程（如何看读取出的数据）

  //这个方法的返回值是：读取到的字节数量(不是字节本身)int readCount= fis.read(bytes);System.out.println(readCount);//第一次读到了4个字节System.out.println(new String(bytes));readCount= fis.read(bytes);System.out.println(new String(bytes));// System.out.println(readCount);//第二次只能读到2个字节

第二次只读取两个字节，然后它把读取到的5和6放在1和2位置处，但是原来数组中3和4还依然存在，这也就符合我们下图所表示的

操作过程注意点

问题来了，我们应该是读取了多少个，就写多少个，（不应该全部转换）而不是写数组的全部进入String中，应该用如下形式

  //开始读，采用byte数组，一次读取多个字节，最多读取“数组.length”个字节byte []bytes=new byte [4];//准备一个4个长度的数组，一次最多读取4个字节//这个方法的返回值是：读取到的字节数量(不是字节本身)int readCount= fis.read(bytes);System.out.println(readCount);//第一次读到了4个字节System.out.println(new String(bytes,0,readCount));readCount= fis.read(bytes);System.out.println(new String(bytes,0,readCount));// System.out.println(readCount);//第二次只能读到2个字节readCount= fis.read(bytes);//第三次1个字节都没有读取到，返回-1

总结实现代码

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStreamTest04 {public static void main(String[] args)  {FileInputStream fis=null;try {fis=new FileInputStream("src//tempfile");//准备一个byte数组byte[]bytes=new byte[4];int readCount=0;while(true){readCount=fis.read(bytes);if(readCount==-1){break;}System.out.print(new String(bytes,0,readCount));}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

改版后的while循环

  int readCount1=0;while((readCount1=fis.read(bytes))!=-1){System.out.print(new String(bytes,0,readCount1));}

available方法

int available()

返回流当中剩余的没有读到的字节数量

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStreamTest05 {public static void main(String[] args)  {FileInputStream fis=null;try {fis=new FileInputStream("");System.out.println("总字节数量"+fis.available());//读取1个字节int readByte=fis.read();//还剩下可以读的字节数量是5;System.out.println("剩下多少字节没有读："+fis.available()+"字节");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

作用如下：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputStreamTest05 {public static void main(String[] args)  {FileInputStream fis=null;try {fis=new FileInputStream("src//tempfile");System.out.println("总字节数量"+fis.available());//这个方法有什么用？byte []bytes=new byte[fis.available()];//这种方式不太适合太大的文件，因为byte数组不能太大//不需要循环了//直接读一次就行了int readCount=fis.read(bytes);System.out.print(new String(bytes));//一次到位} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

注意：

这种方式不太适合太大的文件，因为byte数组不能太大

skip方法

跳过几个字节不读取

long skip (long n)

实现代码

public class FileInputStreamTest05 {public static void main(String[] args)  {FileInputStream fis=null;try {fis=new FileInputStream("src//tempfile");fis.skip(3);System.out.print(fis.read());} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

字符4的ASCII码值是52

FileOutputStream

实现代码1（清空再写入）

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class FileOutputStreamTest01 {/** 文件字节输出流，负责写* 从内存到硬盘* */public static void main(String[] args) {FileOutputStream fos=null;try {fos=new FileOutputStream("myfile");//开始写byte[]bytes={97,98,99,100};fos.write(bytes);fos.write(bytes,0,2);//再写出ab//写完之后，最后一定要刷新fos.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fos!=null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

注意点

1. myfile文件不存在时会自动新建
2. 这种方式谨慎使用，这种方式会将原文件清空，然后重新写入

实现代码2（以追加的方式）

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class FileOutputStreamTest01 {/** 文件字节输出流，负责写* 从内存到硬盘* */public static void main(String[] args) {FileOutputStream fos=null;try {//myfile文件不存在时会自动新建//这种方式谨慎使用，这种方式会将原文件清空，然后重新写入fos=new FileOutputStream("myfile",true);//开始写byte[]bytes={97,98,99,100};fos.write(bytes);fos.write(bytes,0,2);//再写出ab//写完之后，最后一定要刷新fos.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fos!=null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

注意点

1. myfile文件不存在时会自动新建
2. 以追加的方式在文件末尾写入，不会清空原文件内容

实现截图

执行前：

执行后：

如何写入一个String字符串

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;public class FileOutputStreamTest01 {/** 文件字节输出流，负责写* 从内存到硬盘* */public static void main(String[] args) {FileOutputStream fos=null;try {//myfile文件不存在时会自动新建//这种方式谨慎使用，这种方式会将原文件清空，然后重新写入fos=new FileOutputStream("myfile",true);String s="我是一个中国人，我自豪";byte[] bytes3=s.getBytes();fos.write(bytes3);//写完之后，最后一定要刷新fos.flush();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {if(fos!=null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

JAVA_IO流四大家族(1)相关推荐

1. JAVA_IO流四大家族（2）

   JAVA_IO流四大家族体系: JAVA_IO流四大家族(1) JAVA_IO流四大家族(2) 文章目录 JAVA_IO流四大家族体系: JAVA_IO流四大家族(1) JAVA_IO流四大家族(2) ...

2. Java IO流的“四大家族”

   1. IO流的概述 理论部分 简单概括就是文件的输入与输出. 磁盘中文件的东西放到内存中的这个过程称为输入(Input)或称读(read),由于这个输入的过程会有数据的流动,就有了输入流(InputS ...

3. 《CSS世界》笔记二：盒模型四大家族

   上一篇:<CSS世界>笔记一:流/元素/尺寸 下一篇:<CSS世界>笔记三:内联元素与对齐 写在前面 在读<CSS世界>第四章之前,粗浅的认为盒模型无非是margi ...

4. NoSQL数据库的四大家族

   NoSQL,泛指非关系型的数据库,全称Not Only SQL,意即"不仅仅是SQL". NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战,尤其是大数据应用难 ...

5. 【图文解析】带你看清全球机器人四大家族现状，四家企业瓜分中国57%、全球50%的市场份额...

   来源:前瞻经济学研究院 摘要:工业机器人是智能制造业最具代表性的装备. 工业机器人是智能制造业最具代表性的装备.工业机器人集精密化.柔性化.智能化.软件应用开发等先进制造技术于一体,通过对过程实施检测 ...

6. 东莞厚街工业机器人展会_工业机器人四大家族齐聚！东莞将在12月举办智博会...

   "这一届广东国际机器人及智能装备博览会"(简称"智博会")比上届有所缩小,原因有两个,第一是智博会调整策略聚焦高端发展,第二是因疫情影响,海外参展商参展难度加大 ...

7. Java_IO流(精讲)包含练习题及答案

   Java_IO流(精讲)包含练习题及答案--建议收藏 包含常用的所有属性与函数的示例,并且对[字符流][字节流]分别做的[读写]操作示例. 目录 1.Java Io流的概念 按照流的流向分,可以分为输 ...

8. 安川g7接线端子图_ABB、KUKA、FANUC、安川四大家族机器人安全回路小结

   很多新人在机器人安装调试的时候不知道如何下手,在此个人分享一下机器人安装调试的流程如下: 一个机器人项目的安装调试是否能顺利的通过客户验收,机器人的安全回路非常重要. 在此分享下ABB.KUKA.FA ...

9. 盘点机器人四大家族——KUKA机器人

   此为临时链接,仅用于预览,将在短期内失效.关闭 盘点机器人四大家族--KUKA机器人 特盖德智能装备 特盖德机器人租赁 今天 德国KUKA机器人(库卡)是Johann Josef Keller和Jak ...

最新文章

1. php protected 属性,PHP实现在对象之外访问其私有属性private及保护属性protected的方法...
2. 众测 Nebula Graph | 捉虫计划已开启，这项有礼
3. 设计模式学习----装饰器模式
4. Java替代C语言的可能性
5. php的header()函数前有echo输出情况分析
6. 20200119：（leetcode）回文数（3种解法）
7. EurekaLog发送邮件问题修正
8. SEO与爱情，十字路口中的抉择
9. 树莓派 外接HDMI线显示屏分辨率设置
10. 怎么克隆计算机的mac,选中克隆为当前电脑MAC地址
11. ajax 与form 表单连用 success不执行bug解决
12. C语言程序设计期末考试试题(含答案)
13. 哈夫曼树中压缩率到底是什么意思
14. 云原生之K8S------Pod的基础概念
15. [NOI2008] 糖果雨
16. 用于PCB设计和印刷的修补匠工具
17. linux中su命令源码,Linux中的su命令的详细解释
18. numpy.reshape（）函数
19. 高性能的gpu服务器,高性能GPU云服务器
20. 特征工程：时间特征构造以及时间序列特征构造

热门文章

1. Python之tushare：tushare库的简介、安装、使用方法之详细攻略
2. 成功解决解决VM软件安装Linux的Ubuntu过程，打开时 Operating System not found
3. 聊一聊深度学习的activation function
4. 凸集 凸函数 凸优化
5. iview area 遇到的坑
6. java.lang.NullPointerException 空指针异常问题
7. ng机器学习视频笔记（二） ——梯度下降算法解释以及求解θ
8. Linux设备驱动--块设备（二）之相关结构体
9. ---Mybatis3学习笔记(2)
10. 蹭课神器NABCD分析