IO流: In,Out
分类:
根据数据的流向进行分类:
输入流(其它设备==>内存)
输出流(内存==>其它设备)
根据数据流向单位进行分类:
字节流(在输入输出过程中以字节为单位)
字符流(在输入输出过程中以字符 为单位)
针对上述分类重新进行组合(IO的四大基类,四个基类都是抽象类)
字节输入流(InputStream)
字节输出流(OutputStream)
字符输入流(Reader)
字符输出流(Writer)
根据涉及读写内容进行分类:
文件流
文件字节输入流
文件字节输出流
文件字符输入流
文件字符输出流
缓冲流
缓冲字节输入流
缓冲字节输出流
缓冲字符输入流
缓冲字符输出流
转换流:
转换输入流
转换输出流
对象流
对象输入流
对象输出流
标准流
标准输入流
标准输出流
文件字节输出流FileOutputStream类
类的特点
针对文件以字节为单位进行输出操作的工具类
类的位置
java.io
类的构造器
public FileOutputStream(File file)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
public FileOutputStream(File file,boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
public FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的输出文件流
public FileOutputStream(String name,boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。
类的方法
public void close()
关闭此文件输出流并释放与此流有关的所有系统资源
public void write(int b)
将指定字节写入此文件输出流。
public void write(byte[] b)
将 b.length 个字节从指定 byte 数组写入此文件输出流中。
public void write(byte[] b,int off,int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
输出流的注意事项:
输出流在没有打开续写开关都会创建一个新的文件覆盖以前的文件
//创建文件字节输出流对象
FileOutputStream fos = new FileOutputStream("FileOutputStream.txt");
//以单字节为单位进行输出
fos.write(97);
fos.write(98);
fos.write(99);
//以单字节数组为单位进行输出
fos.write("尚硅谷".getBytes());
//以指定范围的字节数组为单位进行输出
byte[] bytes = {97,98,99,100,101,102,103};
fos.write(bytes,3,3);
//关闭资源
fos.close();
输出中的回车换行
命名:\r\n
//创建文件字节输出流对象
FileOutputStream fos = new FileOutputStream("FileOutputStream.txt");
//往指定文件中进行输出操作
fos.write("尚".getBytes());
fos.write("\n".getBytes());
fos.write("硅".getBytes());
fos.write("\r".getBytes());
fos.write("谷".getBytes());
//关闭资源
fos.close();
文件的续写
需要在文件字节输出流的构造器中开发续写开发:
如果是true,表示续写开关开启
如果是false或者只有一个参数的构造器,表示续写开关关闭
文件字节输入流FileInputStream类
类的特点
针对文件以字节为单位进行输入(读取)操作的工具类
类的位置
java.io
类的构造器
public FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
public FileInputStream(String name)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
类的方法
public void close()
关闭此文件输入流并释放与此流有关的所有系统资源。
public int read()
从此输入流中读取一个数据字节。
public int read(byte[] b)
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
public static void main(String[] args) throws IOException {
//创建文件字节输入流对象
FileInputStream fis = new FileInputStream("FileInputStream.txt");
//读取文件以单个字节的方式
/*int len;
while ((len = fis.read()) != -1) {
System.out.println(len);
}*/
//读取文件以字节数组的方式
byte[] bytes = new byte[2];
int len;
while ((len = fis.read(bytes)) != -1) {
System.out.println(new String(bytes,0,len));
}
//关闭资源
fis.close();
}
文件的复制
public static void main(String[] args) throws IOException {
//以单个字节为单位进行文件的复制
//method01();
//以字节数组为单位进行文件的复制
method02();
}
private static void method02() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("girl.jpg");
FileOutputStream fos = new FileOutputStream("girl_copy.txt");
//进行读写操作
byte[] bytes = new byte[8192];//数组大小参考标准:(1)根据实际文件进行制定 (2)程序员约定俗成标准:8192(空间和时间复杂度的折中)
int len;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
//关闭资源
fos.close();
fis.close();
}
private static void method01() throws IOException {
//思路:一边读一边写
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("girl.jpg");
FileOutputStream fos = new FileOutputStream("girl_copy.jpg");
//进行读写操作
int len;
while ((len = fis.read()) != -1) {
fos.write(len);
}
//关闭资源(先开后关,后开先关)
fos.close();
fis.close();
}
在操作系统中一切皆为字节
使用字节流读写含有中文的文本文件时,先将中文字符拆分成字节,进行读写操作,最后再将拆分后的字节进行重新组合
字符流的学习目的
进行读写操作的时候,应用层不会在进行字节的拆分,直接以字符为单位
文件字节流:
主要用于读写音频,视频,图片等
文件字符流:
主要用于读写文本文件
//创建文件字节输入流
FileInputStream fis = new FileInputStream("FileInputStream.txt");
//进行读取操作
int len;
byte[] bytes = new byte[8192];
fis.read();
while ((len = fis.read(bytes)) != -1) {
System.out.println(new String(bytes,0,len));
}
//关闭资源
fis.close();
文件字符输入流FileReader
类的特点
针对文件以字符为单位进行输入操作的工具类
类的位置
java.io
类的构造器
public FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。
public FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader
类的方法
public void close()
关闭该流并释放与之关联的所有资源
public int read()
读取单个字符。
public int read(char[] cbuf)
将字符读入数组。
//创建文件字符输入流对象
FileReader fr = new FileReader("FileReader.txt");
//进行读取操作以单个字符的方式
/*int len;
while ((len = fr.read()) != -1) {
System.out.println(len);
}*/
//进行读取操作以字符数组的方式
char[] chars = new char[8192];
int len;
while ((len = fr.read(chars)) != -1) {
System.out.println(new String(chars,0,len));
}
//关闭资源
fr.close();
文件字符输出流FileWriter
类的特点
针对文件以字符为单位进行输出操作的工具类
类的位置
java.io
类的构造器
public FileWriter(File file)
根据给定的 File 对象构造一个 FileWriter 对象。
public FileWriter(File file,boolean append)
根据给定的 File 对象构造一个 FileWriter 对象。
public FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。
public FileWriter(String fileName,boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
类的方法
public void close()
关闭此流，但要先刷新它。
public void flush()
刷新该流的缓冲
public void write(int c)
写入单个字符。
public void write(char[] cbuf)
写入字符数组。
public abstract void write(char[] cbuf,int off,int len)
写入字符数组的某一部分。
public void write(String str)
写入字符串。
public void write(String str,int off,int len)
写入字符串的某一部分。
public static void main(String[] args) throws IOException {
//创建文件字符输出流对象
FileWriter fw = new FileWriter("FileWriter.txt");
//进行输出操作以单个字符方式
fw.write(97);
fw.write(98);
fw.write(99);
fw.write(27801);
fw.write("\r\n");
//进行输出操作以字符数组方式
fw.write("abcdefg".toCharArray());
fw.write("\r\n");
//进行输出操作以指定范围字符数组方式
fw.write("abcdefg".toCharArray(),3,3);
fw.write("\r\n");
//进行输出操作以字符串方式
fw.write("abcdefg");
fw.write("\r\n");
//进行输出操作以指定范围字符串方式
fw.write("尚硅谷",1,2);
//关闭资源
//fw.close();//(1)刷新 (2)关闭
//进行流的刷新
//fw.flush();
fw.close();
}
缓冲字节流
缓冲字节输入流
缓冲字节输出流
缓冲字节输入流BufferedInputStream
类的特点
针对另外一个字节输入流添加高效输入操作的工具类
类的位置
java.io
类的构造器
public BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
类的方法
public void close()
关闭此输入流并释放与该流关联的所有系统资源。
public int read()
参见 InputStream 的 read 方法的常规协定。
public int read(byte[] b)
从此输入流中将 byte.length 个字节的数据读入一个 byte 数组中
缓冲字节输出流BufferedOutputStream
类的特点
针对另外一个字节输出流添加高效输出操作的工具类
类的位置
java.io
类的构造器
public BufferedOutputStream(OutputStream out)
创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
类的方法
public void close()
关闭此输出流并释放与此流有关的所有系统资源。
public void write(int b)
将指定的字节写入此缓冲的输出流。
public void write(byte[] b,int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流。
注意事项:
1.缓冲流之所有高效,是因为底层封装了一个长度为8192的字节数组
2.在实际开发中往往不会选择缓冲字节流,往往会选择以8192字节数组的文件字节流的方式进行操作
private static void method08() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//创建缓冲字节输入输出流对象
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//进行读写操作
byte[] bytes = new byte[1024*1024];
int len;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes,0,len);
}
//关闭资源
bos.close();
bis.close();
fos.close();
fis.close();
}
private static void method07() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//进行读写操作
byte[] bytes = new byte[1024*1024];
int len;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
//关闭资源
fos.close();
fis.close();
}
private static void method06() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//创建缓冲字节输入输出流对象
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//进行读写操作
byte[] bytes = new byte[8192];
int len;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes,0,len);
}
//关闭资源
bos.close();
bis.close();
fos.close();
fis.close();
}
private static void method05() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//进行读写操作
byte[] bytes = new byte[8192];
int len;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
//关闭资源
fos.close();
fis.close();
}
private static void method04() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//创建缓冲字节输入输出流对象
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//进行读写操作
byte[] bytes = new byte[1024];
int len;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes,0,len);
}
//关闭资源
bos.close();
bis.close();
fos.close();
fis.close();
}
private static void method03() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//进行读写操作
byte[] bytes = new byte[1024];
int len;
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes,0,len);
}
//关闭资源
fos.close();
fis.close();
}
private static void method02() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//创建缓冲字节输入输出流对象
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//进行读写操作
int len;
while ((len = bis.read()) != -1) {
bos.write(len);
}
//关闭资源
bos.close();
bis.close();
fos.close();
fis.close();
}
private static void method01() throws IOException {
//创建文件字节输入输出流对象
FileInputStream fis = new FileInputStream("G:\\jdk-8u202-windows-x64.exe");
FileOutputStream fos = new FileOutputStream("G:\\jdk.exe");
//进行读写操作
int len;
while ((len = fis.read()) != -1) {
fos.write(len);
}
//关闭资源
fos.close();
fis.close();
}
缓冲字符流
缓冲字符输入流
缓冲字符输出流
缓冲字符输入流BufferedReader
类的特点
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
类的位置
java.io
类的构造器
public BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。
类的方法
public String readLine()
读取一个文本行。
缓冲字符输出流:BufferedWriter
类的特点
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
类的位置
java.io
类的构造器
public BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流。
类的方法
public void newLine()
写入一个行分隔符。
public static void main(String[] args) throws IOException {
//reader();
writer();
}
private static void writer() throws IOException {
//创建缓冲字符输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("BufferedWriter.txt"));
//进行输出操作
bw.write("尚");
bw.newLine();
//bw.write("\r\n");
bw.write("硅");
bw.newLine();
//bw.write("\r\n");
bw.write("谷");
System.out.println("HelloWorld");
//关闭资源
bw.close();
}
private static void reader() throws IOException {
//创建缓冲字符流
BufferedReader br = new BufferedReader(new FileReader("BufferedReader.txt"));
//进行读取行操作
String len;
while ((len = br.readLine()) != null) {
System.out.println(len);
}
//关闭资源
br.close();
}
转换流
转换输入流InputStreamReader
转换输出流OutputStreamWriter
转换输入流InputStreamReader
类的特点
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符
类的位置
java.io
类的构造器
public InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader。
public InputStreamReader(InputStream in, String charsetName)
创建使用指定字符集的 InputStreamReader。
类的方法
转换输出流OutputStreamWriter
类的特点
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节
类的位置
java.io
类的构造器
public InputStreamReader(InputStream in)
创建一个使用默认字符集的 InputStreamReader。
public InputStreamReader(InputStream in,String charsetName)
创建使用指定字符集的 InputStreamReader。
类的方法
转换流的应用:
用户上传utf8编码文件,下载utf8文件
用户上传GBK编码文件,下载utf8文件
用户上传utf8编码文件,下载GBK文件
用户上传GBK编码文件,下载GBK文件
//编码和解码过程:文件编码(gbk,用户系统),读取文件(gbk,程序员自定义),输出文件(gbk,程序员自定义),打开文件(gbk,用户系统)
private static void method04() throws IOException {
//创建转换输入输出流
InputStreamReader isr = new InputStreamReader(new FileInputStream("G:\\20220328\\day17\\resources\\gbk.txt"),"gbk");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("G:\\20220328\\day17\\resources\\gbk_gbk.txt"),"gbk");
//进行读写操作
char[] chars = new char[8192];
int len;
while ((len = isr.read(chars)) != -1) {
osw.write(chars,0,len);
}
//关闭资源
osw.close();
isr.close();
}
//编码和解码过程:文件编码(utf8,用户系统),读取文件(utf8,程序员自定义),输出文件(gbk,程序员自定义),打开文件(gbk,用户系统)
private static void method03() throws IOException {
//创建转换输入输出流
InputStreamReader isr = new InputStreamReader(new FileInputStream("G:\\20220328\\day17\\resources\\utf8.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("G:\\20220328\\day17\\resources\\utf8_gbk.txt"),"gbk");
//进行读写操作
char[] chars = new char[8192];
int len;
while ((len = isr.read(chars)) != -1) {
osw.write(chars,0,len);
}
//关闭资源
osw.close();
isr.close();
}
//编码和解码过程:文件编码(gbk,用户系统),读取文件(gbk,程序员自定义),输出文件(utf8,程序员自定义),打开文件(utf8,用户系统)
private static void method02() throws IOException {
//创建转换输入输出流
InputStreamReader isr = new InputStreamReader(new FileInputStream("G:\\20220328\\day17\\resources\\gbk.txt"),"gbk");
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("G:\\20220328\\day17\\resources\\gbk_utf8.txt"));
//进行读写操作
char[] chars = new char[8192];
int len;
while ((len = isr.read(chars)) != -1) {
osw.write(chars,0,len);
}
//关闭资源
osw.close();
isr.close();
}
private static void method01() throws IOException {
//创建转换输入输出流
InputStreamReader isr = new InputStreamReader(new FileInputStream("G:\\20220328\\day17\\resources\\utf8.txt"));
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("G:\\20220328\\day17\\resources\\utf8_utf8.txt"));
//进行读写操作
char[] chars = new char[8192];
int len;
while ((len = isr.read(chars)) != -1) {
osw.write(chars,0,len);
}
//关闭资源
osw.close();
isr.close();
}
对象流
对象输入流ObjectInputStream
对象输出流ObjectOutputStream
对象输出流ObjectOutputStream(对象==>字节)
类的特点
针对跨项目使用对象实现序列化操作的工具类
类的位置
java.io
类的构造器
public ObjectOutputStream(OutputStream out)
创建写入指定 OutputStream 的 ObjectOutputStream。
类的方法
public final void writeObject(Object obj)
将指定的对象写入 ObjectOutputStream。
public static void main(String[] args) throws IOException {
//创建对象输出流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
//创建对象
Student s = new Student("张三", 18);
//写出对象
oos.writeObject(s);
//关闭资源
oos.close();
}
对象输入流ObjectInputStream
类的特点
针对跨项目使用对象实现反序列化(字节==>对象)操作的工具类
类的位置
java.io
类的构造器
public ObjectInputStream(InputStream in)
创建从指定 InputStream 读取的 ObjectInputStream。
类的方法
public final Object readObject()
从 ObjectInputStream 读取对象。
public static void main(String[] args) throws IOException, ClassNotFoundException {
//创建对象输入流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
//读取对象
Object o = ois.readObject();
System.out.println(o);
//关闭资源
ois.close();
}
对象流的注意事项:
1.进行对象流读写操作对象的类必须实现序列化接口Serializable,否则发生没有实现序列化异常NotSerializableException
2.进行序列化操作的时候虽然可以实现多个对象序列化操作,可以将多个对象存储到对应的集合(容器)对象,针对集合对象进行序列化和反序列化操作
3.进行序列化和反序列化的过程中,操作对象所对应的类不能发生任何修改
该类的序列版本号与从流中读取的类描述符的版本号不匹配
该类包含未知数据类型
该类没有可访问的无参数构造方法
4.进行序列化和反序列化的过程中,针对序列化文件不能进行任何修改
5.如果在进行序列化的过程中哪个属性信息不想被实现序列化,可以在对应的类中进行transient关键字修饰
transient关键字:
含义:
瞬时的,瞬态的
作用:
被transient关键字修饰的属性不会被实现序列化操作
标准流:
标准输入流System.in
BufferedInputStream
标准输出流System.out
PrintStream
PrintStream类(打印流)
类的特点
针对文本文件进行快速打印
类的位置
java.io
类的构造器
public PrintStream(String fileName)
创建具有指定文件名称且不带自动行刷新的新打印流。
类的方法
private static void method02() throws FileNotFoundException {
//创建打印流对象
PrintStream ps = new PrintStream("print.txt");
//重置标准输出流
System.setOut(ps);
System.out.println("Hello");
System.out.println("World");
System.out.println("atguigu");
//关闭资源
ps.close();
}
private static void method01() throws IOException {
//第二种键盘录入
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
//实现键盘录入
String s = br.readLine();
System.out.println(s);
//关闭资源
br.close();
}
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
