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(); //续写:在打开时后面写个true
FileOutputStream 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(); //因为不同平台的换行不一样，所以可以用跨平台换行newLine
bw.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 + "}";
}
}
