IO流(First edition):

IO流：用于读入写出文件中的数据
流的方向（输入指拿出来,输出指写进去)
输入流:读取
输出流:写出
操作文件类型
字节流:所有类型文件
字符流:纯文本

 

字节流:
InputStream的子类:FileInputStream:操作本地文件的字节输入流
OutputStream的子类:FileOutputStream:操作本地文件的字节输出流

 

 //1.创建字节输出流对象//细节1:参数是字符串表示的路径或者是File对象都是可以的//细节2:如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。//细节3:如果文件存在，会清空文件的内容FileOutputStream fos = new FileOutputStream("C:\\Users\\35303\\Desktop\\a.txt");//2.写入//细节:write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符//fos.write(67);//3.释放资源//fos.close();

FileOutputStream写数据的3种方式
方法名称                                              说明
void write(int b)                                     一次写一个字节数据
void write(byte[]b)                                   一次写一个字节数组数据
void write(byte[lb,int off,int len) (参数1：数组，参数2：起始索引,参数3:个数)  一次写一个字节数组的部分数据

 //void write(byte[]b)byte a[] = new byte[]{97,98,99,100,101};fos.write(a);//fos.close();//void write(byte[lb,int off,int len)byte b[] = new byte[]{65,66,67,68,69};fos.write(b,1,3);   //从1号索引写三个fos.close();

 //续写:在打开时后面写个trueFileOutputStream fos1 = new FileOutputStream("C:\\Users\\35303\\Desktop\\b.txt",true);//方便转字符String s = "djaofjawsfja";byte[] bytes = s.getBytes();fos1.write(bytes);//fos1.close();//换行: \r\n(单写\r或\n也可以)String s1 ="\r\n";String s2 = "666";byte[] bytes1 = s1.getBytes();byte[] bytes2 = s2.getBytes();fos1.write(bytes1);fos1.write(bytes2);fos1.close();

FileInputStream:

//FileInputStream//1.创建对象FileInputStream fis = new FileInputStream("C:\\Users\\35303\\Desktop\\b.txt");//2.读取数据(如果没数据了read会返回-1)//read:表示读取数据，而且是读取一个数据就移动一次指针int a1 = fis.read();System.out.println((char)a1);//3.释放资源//fis.close();//字节输入流循环读取int a2;while((a2=fis.read())!=-1){System.out.print((char)a2);}fis.close();//方法名称                                                                  说明//public int read()                                                 一次读一个字节数据//public int read(byte[] buffer)  (返回值为获取的长度)              一次读一个字节数组数据

字符流:字符流的底层其实就是字节流
  //字符流=字节流+字符集
特点：
输入流:一次读一个字节，遇到中文时，一次读多个字节
输出流:底层会把数据按照指定的编码方式进行编码，变成字节再写到文件中
Reader的子类：FileReader
Writer的子类：FileWriter

FileReader:
构造方法 (1.创建字符输入流对象)                                                 说明
public FileReader(File file)                             创建字符输入流关联本地文件
public FileReader(string pathname)                       创建字符输入流关联本地文件
细节1：如果文件不存在就直接报错
2.读取数据
成员方法                              说明
public int read()                     读取数据，读到末尾返回-1
public int read(char[] buffer)        读取多个数据，读到末尾返回-1
细节1:按字节进行读取遇到中文，一次读多个字节，读取后解码，返回一个整数
细节2:读到文件末尾了，read方法返回-1。
3.释放资源
close();

//read无参//1.创建对象并关联本地文件FileReader fr = new FileReader("C:\\Users\\35303\\Desktop\\b.txt");//2.读取数据//字符流的底层也是字节流，默认也是一个字节一个字节的读取的。//如果遇到中文就会一次读取多个，GBK一次读两个字节，UTF-8一次读三个字节(IDEA默认UTF-8)int ch;while((ch=fr.read())!=-1){          //空参是传出的ch是字符的二进制System.out.print((char)ch);}System.out.println();

read()细节:
1.read():默认也是一个字节一个字节的读取的,如果遇到中文就会一次读取多个
2.在读取之后，方法的底层还会进行解码并转成十进制。
最终把这个十进制作为返回值
这个十进制的数据也表示在字符集上的数字
英文:文件里面二进制数据 0110 0001
read方法进行读取，解码并转成十进制97
中文:文件里面的二进制数据 11100110 10110001 10001001
read方法进行读取，解码并转成十进制27721
// 我想看到中文汉字，就是把这些十进制数据，再进行强转就可以了

  //read有参//1.创建对象FileReader fr1 = new FileReader("C:\\Users\\35303\\Desktop\\b.txt");//2.读取数据char []chars = new char[2]; //表示一次读两个数据int len;while((len=fr1.read(chars))!=-1){           //有参时传出来的是长度//把数组中的数据变成字符串再去打印System.out.print(new String(chars,0,len));        //读几个就转几个}//3.释放资源fr1.close();

 

FileWriter:

构造方法                                                                   说明
public FileWriter(File file)                                              创建字符输出流关联本地文件
public FileWriter(String pathname)                                        创建字符输出流关联本地文件
public FileWriter(File file,boolean append)  (append:续写开关,为true是续写) 创建字符输出流关联本地文件，续写
public FileWriter(String pathname,boolean append)                         创建字符输出流关联本地文件，续写
成员方法                                                      说明
void write(int c)                                             写出一个字符
void write(string str)                                        写出一个字符串
void write(String str,int off,int len)                        写出一个字符串的一部分
void write(char[] cbuf)                                       写出一个字符数组
void write(char[] cbuf,int off,int len)                       写出字符数组的一部分

FileWriter书写细节
1.创建字符输出流对象
  //细节1:参数是字符串表示的路径或者File对象都是可以的
  //细节2:如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的
  //细节3:如果文件已经存在，则会清空文件，如果不想清空可以打开续写开关
2.写数据
细节: 如果write方法的参数是整数，但是实际上写到本地文件中的是整数在字符集上对应的字符
3.释放资源
细节:每次使用完流之后都要释放资源

 

 //方法write(int c)       写出一个字符FileWriter fw = new FileWriter("C:\\Users\\35303\\Desktop\\b.txt",true);fw.write(25105);//(25105：我)//根据字符集的编码方式进行编码，把编码之后的数据写到文件中去//fw.close();//方法FileWriter(String pathname)       写出一个字符串fw.write("\n你好hello位");fw.close();//write(String str,int off,int len)    写出一个字符串的一部分//fw.write("\n你好hello位",0,3);//方法void write(char[] cbuf)          写出一个字符数组//char s[]= new char[]{'a','b','c'};//fw.write(char);//fw.close();

 

前面学的都是基本流，下面的是高级流
缓冲流:BufferedInputStream(字节缓存输入流)、BufferedOutputStream(字节缓存输出流)
BufferedReader(字符缓存输入流)、BufferedWriter(字符缓冲输出流)

字节缓存流原理:底层自带了长度为8192的缓冲区提高性能
方法名称                                                      说明
public BufferedInputStream(InputStream is)        把基本流包装成高级流，提高读取数据的性能
public BufferedOutputStream(OutputStream os)       把基本流包装成高级流，提高写出数据的性能

//字节缓冲流//一次操作一个字节//1.创建缓冲流的对象BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\35303\\Desktop\\b.txt"));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\35303\\Desktop\\c.txt"));//2.循环读取并写到目的地int b;while((b=bis.read())!=-1){bos.write((char)b);}//3.释放资源bos.close();bis.close();

 

 //一次操作多个字节byte [] bytes = new byte[1024];int len;while((len=bis.read(bytes))!=-1){bos.write(bytes,0,len);}bos.close();bis.close();

字符缓存流原理:底层自带了长度为8192的缓冲区提高性能
方法名称                                      说明
public BufferedReader(Reader r)               把基本流变成高级流
public BufferedWriter(Writer r)               把基本流变成高级流
字符缓冲流特有方法
字符缓冲输入流特有方法                                       说明
public String readLine()                  读取一行数据,如果没有数据可读了,会返回null
字符缓冲输出流特有方法                                       说明
public void newLine()                                   跨平台的换行

//1.创建字符缓冲输入流的对象BufferedReader br = new BufferedReader(new FileReader("C:\\Users\\35303\\Desktop\\b.txt"));//2.读取数据String line;while ((line=(br.readLine()))!=null) {      //获取文件中一行的数据System.out.println(line);}//3.释放资源br.close();//1.创建字符缓冲输出流对象BufferedWriter bw = new BufferedWriter(new FileWriter("C:\\Users\\35303\\Desktop\\c.txt",true));//2.写出数据bw.write("你嘴角上扬的样子");bw.newLine();                        //因为不同平台的换行不一样，所以可以用跨平台换行newLinebw.write("hello world");//3.释放资源bw.close();

转换流(不需要掌握，看看懂懂意思)
转换流属于字符流
InputStreamReader(转换输入流),OutputStreamWriter(转换输出流)
转换流是字符流和字节流之间的桥梁
输入时把字节流转换成字符流，然后就拥有了字符流的特性，输出又转换为字节流
作用：字节流想使用字符流中的方法了那就可以使用转换流转一下

 //1.创建对象并指定字符编码InputStreamReader isr = new InputStreamReader(new FileInputStream("C:\\Users\\35303\\Desktop\\b.txt"),"GBK");//第二个参数不写默认UTF-8,写了就是转换为什么编码//2.读取数据int ch;while((ch=isr.read())!=-1){System.out.print((char)ch);}//3.释放资源isr.close();//1.创建转换流的对象OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("C:\\Users\\35303\\Desktop\\b.txt"),"GBK");//2.写出数据osw.write("nihao");//3.释放资源osw.close();

 

序列化流(又叫对象操作输出流):可以把java中的对象写到本地文件中
序列化流属于字节流(输出outputStream),反序列化流(输入inputStream)
ObjectInputStream(反序列化流),ObjectOutputStream(序列化流)
构造方法                                                          说明
public ObjectOutputStream(OutputStream out)               把基本流包装成高级流
成员方法                                                            说明
public final void writeObject(object obi)                 把对象序列化(写出)到文件中去
需求:利用序列化流/对象操作输出流，把一个对象写到本地文件中

序列化流的小细节
使用对象输出流将对象保存到文件时会出现NotSerializableException异常
解决方案:
需要让Javabean类实现Serializable接口

 //1.创建对象Demo10two stu = new Demo10two("张三",12,"da");//2.创建序列化流的对象ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\35303\\Desktop\\d.txt"));//3.写出数据oos.writeObject(stu);//4.释放资源oos.close();

 

反序列化流(又叫对象操作输入流)
可以把序列化到本地文件中的对象，读取到程序中来
构造方法                                                  说明
public ObjectInputStream(InputStream out)         把基本流变成高级流
成员方法                                                              说明
public object readObject()                        把序列化到本地文件中的对象，读取到程序中来

//1.创建反序列化流的对象ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\35303\\Desktop\\d.txt"));//2.读取数据Object o = ois.readObject();//3.打印对象System.out.println(o);//3.释放资源ois.close();

 javabean类:
 

package com.itheima.demo14IO流;import java.io.Serializable;public class Demo10two implements Serializable {private static final long serialVersionUID = -8462176507494611942L;//反序列化流要定义版本号，在IDEA里设置了，所以只要点黄色的那段类名然后alt+回车添加版本号就行了//序列化流的小细节//使用对象输出流将对象保存到文件时会出现NotSerializableException异常//解决方案://需要让Javabean类实现Serializable接口//Serializable接口里面是没有抽象方法，标记型接//一旦实现了这个接口，那么就表示当前的student类可以被序列化private  String name;private  int age;//transient：瞬态关键字//作用:不会把当前属性序列化到本地文件当中private transient String a;public Demo10two(String dawda, int age, String da) {}public Demo10two(long serialVersionUID, String name, int age, String a) {this.name = name;this.age = age;this.a = a;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return age*/public int getAge() {return age;}/*** 设置* @param age*/public void setAge(int age) {this.age = age;}/*** 获取* @return a*/public String getA() {return a;}/*** 设置* @param a*/public void setA(String a) {this.a = a;}public String toString() {return "Demo10two{name = " + name + ", age = " + age + ", a = " + a + "}";}}