什么是IO

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

IO流的分类

1. 按照流的方向进行分类：
   输入流：
   往内存中去，叫输入（Input）（读）
   输出流：
   从内存中出来，叫输出（Output）（写）
2. 按照读取数据方式不同进行分类：
   字节流：（这种流是万能的，什么类型的文件都能读取）
   有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制
   字符流：（只能读取纯文本文件）
   有的流是按照字符的方式读取数据的，一次读取一个字符

Java中的IO流

java中的所有流都在：java.io.*下
IO流四大家族：
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
(Stream结尾的都是字节流；Reader/Writer结尾的是字符流)
(Tip:字节流用byte[];字符流用char[])

所有的流都实现了java.io.Closeable接口，都可关闭，都有close()方法（记住常写）

所有的输出流都实现了java.io.Flushable接口，都是可刷新的，都有flush()方法（记住常写）
这个flush()表示将管道当中剩余未输出的数据强行输出完（清空管道）

java中需要掌握的流：16个

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

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

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

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

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

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

字节流

java.io.FileInputStream（字节输入流）

数组用byte[]

/*
java.io.FileInputStream1.文件字节输入流，万能的，任何类型的为那就都可采用这个流来读2.字节的方式，完成输入的操作
*/
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;public class FileInputSteamTest01 {public static void main(String[] args) throws IOException {//创建文件字节输入流对象FileInputStream fis=null;try {fis=new FileInputStream("F:\\XXXX\\XXX.png");byte[] bytes=new byte[10];int readCount=0;while ((readCount=fis.read(bytes))!=-1){//读System.out.println(new String(bytes,0,readCount));//返回成字符串}} catch (FileNotFoundException e) {e.printStackTrace();}finally {//关闭流if(fis!=null) {try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}
}

java.io.FileOutputStream（字节输出流）

数组用byte[]

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;/*
java.io.FileOutputStream
写文件
*/
public class FileOutputStreamTest01 {public static void main(String[] args) {FileOutputStream fos=null;try {//“true”以追加的方式在文件后面写入，不会清空原文件fos = new FileOutputStream("文件",true);//这里默认路径为IDEA中Project的根byte[] bytes={1,3,5,48,29,78,98,97,100};//写入fos.write(bytes);} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally {if(fos!=null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

文件Copy

使用字节流copy

数组用byte[]

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;//文件copy
public class Copy01 {public static void main(String[] args) {FileInputStream fis=null;FileOutputStream fos=null;try {fis =new FileInputStream("F:\\图片\\123.png");fos =new FileOutputStream("C:\\Users\\Yang\\Desktop\\123.png");byte[] bytes=new byte[1024*1024];//一次拷贝1BMint readCount=0;while ((readCount=fis.read(bytes))!=-1){//读文件fos.write(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();}}if(fos!=null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}
}

使用字符流Copy

数组用char[]
只能Copy普通“文本文件”

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;public class Copy2 {/*
使用FileReader FileWriter进行拷贝的话，只能拷贝“普通文本”文件
*/public static void main(String[] args) {FileReader in=null;FileWriter out=null;try {in=new FileReader("C:\\Users\\Yang\\Desktop\\新建文本文档.txt");out=new FileWriter("C:\\Users\\Yang\\Desktop\\新建文本文档2.txt");char[] chars=new char[1024*512];int read=0;while ((read=in.read(chars))!=-1){out.write(chars,0,read);}out.flush();//用Reader和Writer记得刷新} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally {if(in!=null) {try {in.close();} catch (IOException e) {e.printStackTrace();}}if(out!=null) {try {out.close();} catch (IOException e) {e.printStackTrace();}}}}
}

java.io.BufferedReader（带有缓冲区的【字符】输入流）

不用自定义char/byte数组，它自带缓冲区

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;/*
BufferedReader
带有缓冲区的【字符】输入流
不需要自定义char/byte数组，它自带缓冲
*/
public class BufferedReaderTest01 {public static void main(String[] args) {try {FileReader reader=new FileReader("C:\\Users\\Yang\\Desktop\\新建文本文档2.txt");//当一个流的构造方法需要一个流的时候，这个被传进来的流叫：节点流//外部负责包装的这个流，叫做：包装流/处理流//这里FileReader就是节点流，BufferedReader就是包装流BufferedReader bf=new BufferedReader(reader);String s=null;while ((s=bf.readLine())!=null){//读一行.readLine()System.out.println(s);}//关闭流bf.close();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}
}

java.io.InputStreamReader（转换流）

将字节流转换成字符流

import java.io.*;
/*
转换流：（将字节流转换成字节流）
*/
public class BufferedReaderTest02 {public static void main(String[] args) throws IOException {//创建一个字节流FileInputStream fis=new FileInputStream("C:\\Users\\Yang\\Desktop\\新建文本文档2.txt");//将字节流转换为字符流InputStreamReader isr=new InputStreamReader(fis);//创建一个字符流BufferedReader br=new BufferedReader(isr);String s=null;while ((s=br.readLine())!=null){System.out.println(s);}}
}

File类

File类中的常用方法：（举例）

1. exists()判断是否存在某文件
2. createNewFile()创建一个新文件
3. getAbsoluteFile()获取文件绝对路径
4. getParent()获取该文件父目录路径名字符串
5. listFiles()获取当前目录下所有子文件（返回值是数组）

import java.io.File;
import java.io.IOException;public class FileTest01 {public static void main(String[] args) {File file=new File("G:\\迅雷下载\\你好");System.out.println(file.exists());//判断是否存在此文件if(file.exists()==false){try {file.createNewFile();//如果不存在则创建一个新文件} catch (IOException e) {e.printStackTrace();}}System.out.println(file.getAbsoluteFile());//获取文件绝对路径System.out.println(file.getParent());//获取该文件父目录路径名字符串file.mkdir();//创建目录File file1=new File("G:\\X社区");File[] files=file1.listFiles();//获取当前目录下所有子文件（返回的是个数组）for(File filess:files){System.out.println(filess);}}
}

java.io.PrintStream（标准输出流）或者PrintWriter

这里写一个记录日志的代码来提现标准输出流
在具体做项目的时候若记录某些方法的日志，方便代码的修改。

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
记录日志的方法  标准输出流*/
public class Logger {public static void log(String msg){try {//指向一个日志文件//这里追加true，防止日志文件被覆盖PrintStream printStream=new PrintStream(new FileOutputStream("log.txt",true));//改变输出方向System.setOut(printStream);//获取当前时间Date date=new Date();//日期格式化SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");String time=sdf.format(date);System.out.println(time+":"+msg);} catch (FileNotFoundException e) {e.printStackTrace();}}
}

public class LogTest {//主方法 记录日志public static void main(String[] args) {Logger.log("log方法执行");}
}

日志文件的记录：
2020/06/09 21:28:14 181:log方法执行
2020/06/09 21:30:09 949:log方法执行
2020/06/09 21:30:14 715:log方法执行

对象专属流

1. 序列化和反序列化：
   反序列化：DeSerialize 将硬盘上的数据重新恢复到内存当中，恢复成java对象
   序列化：Serialize java对象储存到文件中

2. 参与序列化和反序列化的对象，必须要实现Serializable接口
   这个接口起到一个标识的作用。让JVM识别到这个接口后，会位该类
   自动生成一个序列化版本号。

3. 序列化版本号的用途？
   用来区分类。

4. 自动生成序列化版本号的缺陷？
   若修改类的代码，序列化版本号也会再次自动生成，JVM会认为这是个全新的类
   （一旦代码确定之后，不能进行后续修改）

重要结论：
　　凡是一个类实现了Serializable接口，建议给该类提供一个固定的序列化版本号，不建议自动生成这样以后如果该类的代码修改了，JVM也会认为这是同一个类。

ObjectOutputStream（序列化）（写文件）

创建Student类

import java.io.Serializable;
import java.util.Objects;
/*
参与序列化和反序列号的对象，必须要实现Serializable接口
*/
public class Student implements Serializable {//手动生成序列化版本号private static final long serialVersionUID = 123l;private String name;private int no;public Student() {}public Student(String name, int no) {this.name = name;this.no = no;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getNo() {return no;}public void setNo(int no) {this.no = no;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return no == student.no &&Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, no);}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", no=" + no +'}';}
}

//序列化（写）
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;public class Test {public static void main(String[] args) throws IOException {//创建java对象Student s1=new Student("zhangsan",123);FileOutputStream fos=null;ObjectOutputStream oos=null;try {//序列化fos=new FileOutputStream("XXX\\XXX\\XXX\\students");oos=new ObjectOutputStream(fos);//序列化对象oos.writeObject(s1);//刷新oos.flush();//关闭oos.close();} catch (FileNotFoundException e) {e.printStackTrace();}}
}

写入后的这个文件不能用文档的格式打开，必须反序列化读出来

ObjectInputStream（反序列化）（读文件）

import java.io.*;
/*
反序列化（读）
*/
public class ObjectInputStreamTest01 {public static void main(String[] args) {ObjectInputStream ois=null;FileInputStream fis=null;try {fis =new FileInputStream("XXX\\XXX\\XXX\\students");ois =new ObjectInputStream(fis);//反序列化Object obj=ois.readObject();System.out.println(obj);ois.close();} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} catch (ClassNotFoundException e) {e.printStackTrace();}}
}

输出结果：
//Student{name='zhangsan', no=123}

IO+Properties的联合应用

IO+Properties的联合应用
结论：经常改变的数据，可以单独写到一个文件中，使用程序动态获取。将来只需要修改文件中的数据，就可以拿到动态信息。

类似于这样的文件被称为：配置文件
当配置文件中的格式为：key=value这种的时候，称为：属性配置文件
java中建议将属性配置文件以.properties结尾

序列化文件：

userid=123
username=lisi
userpassword=123456

测试类：

package IO_Properties;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;public class Test {public static void main(String[] args) throws IOException {/*Properties是一个Map集合，key和value都是String类型将user文件中的数据加载到Properties对象中*///新建输入流对象FileInputStream fis=new FileInputStream("18流\\src\\IO_Properties\\user");//新建Map集合Properties pro=new Properties();//调用Properties对象的load方法将文件中的数据加载到Map集合中pro.load(fis);System.out.println(pro.getProperty("userid"));System.out.println(pro.getProperty("username"));}
}

输出结果：
123
lisi

这样只用修改配置文件中的value就可以直接获取新的value值，并不用修改代码。

java学习笔记-初学IO流相关推荐

1. java学习笔记16--I/O流和文件

   本文地址:http://www.cnblogs.com/archimedes/p/java-study-note16.html,转载请注明源地址. IO(Input  Output)流 IO流用来处理 ...

2. Java学习——Day13：IO流

   6.1 File类 java.io.File类:文件和文件目录路径的抽象表示形式,与平台无关 File 能新建.删除.重命名文件和目录,但 File 不能访问文件内容本身. 如果需要访问文件内容本身, ...

3. Java学习笔记之 IO包 字符流

   字符流:Writer/Reader(字符流) 通过子类FileWriter和FileReader实现父类实例化 package iotest; import java.io.File; import ...

4. java学习笔记(十三)----IO操作

   一.文件的创建 ------------------------------------------------------- File类,表示磁盘上的文件或目录,可对文件或目录进行操作.   * 常 ...

5. Java学习笔记之 IO包 字节流

   IO包最重要的五个类和一个接口 File/OutputStream/InputStream(字节流)/Writer/Reader(字符流) 一个接口:Serializable File类: 字节流: ...

6. Java学习笔记（7）——Java基础之IO多线程网络思维导图

   Java面向对象学习笔记之:包括IO(字节流,字符流,节点流,处理流).线程(线程创建,线程控制,线程同步).网络(TCP Scoket,  UDP Scoket)(全屏观看Java学习笔记(7)-- ...

7. java学习笔记十三

   11． 凡是继承了FilterOutputStream或FilterInputStream的类都是过滤流,也就是说他们不能直接跟目标(键盘,文件,网络等,节点流可以)数据打交道,只能包装 Intput ...

8. c++文件流读取一行_「软帝学院」Java挑战者专栏：IO流详解2

   软帝学院笔记Day18 IO流(字符流FileReader) 1.字符流是什么 字符流是可以直接读写字符的IO流 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符 ...

9. Java学习笔记——流程控制

   Java学习笔记--流程控制 Day05 一.用户交互Scanner 1.Scanner对象 我们通过Java工具包java.util.Scanner中的Scanner类来获取用户的输入 基本语法:S ...

最新文章

1. Python type hints 之 Optional，Union
2. 在公网(internet)上建立website时不能用http访问
3. Django创建项目
4. win10一按右键就闪屏_升级Win10正式版后屏幕一直闪烁正确的解决办法
5. mysql 分析服务_MySQL分析服务器状态_MySQL
6. xampp启动Apache报错 1、Error: Apache shutdown unexpectedly. 2、Unclean shutdown of previous Apache run?
7. 知识选择visual studio 2012 知识笔记
8. php 向ldap请求文件,绑定 LDAP 目录 - PHP 7 中文文档
9. mysql always as_MySQL always returning BIT values as blank
10. Linux服务器安装JavaWeb环境(四) Sentinel，Xxl-Job，Seata
11. jenkins shell 权限_使用Jenkins一键打包部署SpringBoot应用，就是这么6！
12. idea粘贴代码为什么都在一行_【学园】今天程序员的每一行代码都是未来高达身上的一颗螺丝...
13. wps如何在目录里面打省略号_wps中目录的点怎么打（目录的点点怎样手动打）
14. android P-sensor (Proximity Sensor)
15. 数学的意义——席南华院士科普讲座实录
16. win7 修复计算机无法进入系统,win7系统下启动修复无法正常进入系统的解决方法...
17. 小学如何开展创客教育教学工作
18. 利用SNMP获取H3C交换机端口信息
19. 搜索引擎应用优化技能总结
20. vue移动端调用照相机及相册

热门文章

1. openpose：Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields ∗
2. 计算机控制在化工中有哪些应用,探析计算机控制在化工生产中的应用
3. LIO-SAM: Tightly-coupled Lidar Inertial Odometry via Smoothing and Mapping论文解读
4. IC卡读写器VB源代码
5. PDDON | 又偶遇一款令人惊艳的在线绘图工具
6. 听说谷歌秘密开发Xphone手机
7. 广东移动宽带dns服务器未响应,宽带连不上 dns 无响应
8. HTML5 Audio(音频)简介
9. Delphi调用外部程序函数：WinExec() 和ShellExecute详解
10. STM32 OLED显示字符汉字