IO流的概述和分类
一切数据（文本、图片、视频等）在储存时，，都是以二进制的形式进行保存的，都是一个个字节。那么传输时同样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么流对象，底层都为二进制数据。
字节流
字节输出流的基本使用
/*
java.io.OutputStream:字节输出流
此抽象类是表示输出字节流的所有类的超类。
OutputStream里边定义了所有字节输出流中共性的成员方法,所有的子类都可以使用
共性的成员方法:
- public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
- public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
- public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
- public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
- public abstract void write(int b) ：将指定的字节输出流。
java.io.FileOutputStream:文件字节输出流 extends OutputStream
作用:把内存中的字节写入到文件中保存
构造方法:
FileOutputStream(File file)
FileOutputStream(String name)
参数:输出的目的地
File file:输出的目的地是一个文件
String name:输出的目的地是一个文件的路径
构造方法的作用:
1.会创建FileOutputStream对象
2.会根据构造方法中传递文件|文件的路径,创建一个空白的文件
3.会把FileOutputStream对象指向创建好的文件
使用字节输出流往文件中写数据的底层过程
java程序==>JVM==>操作系统(OS)==>调用系统中写数据的方法==>把数据写到文件中
字节输出流的使用步骤(重点)
1.创建FileOutputStream对象,构造方法中绑定输出的目的地
2.使用FileOutputStream对象中的方法write,把数据写入到文件中
3.释放资源
*/
public class Demo01OutputStream {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream对象,构造方法中绑定输出的目的地
FileOutputStream fos = new FileOutputStream("day14\\a.txt");
//2.使用FileOutputStream对象中的方法write,把数据写入到文件中
//public abstract void write(int b) 一次写一个字节
fos.write(97);
//3.释放资源
fos.close();
}
}
字节输出流写多个字节的方法
/*
字节输出流中写多个字节的方法
public void write(byte[] b) 一次写字节数组中的多个字节到文件中
public void write(byte[] b, int off, int len) 写字节数组的一部分到文件中
off:数组的开始索引
len:写的字节个数
*/
public class Demo02OutputStream {
public static void main(String[] args) throws IOException {
//1.创建字节输出流FileOutputStream对象,构造方法中绑定要写的目的地
FileOutputStream fos = new FileOutputStream(new File("day14\\b.txt"));
//2.使用FileOutputStream对象中的方法write,把数据写入到文件中
/*
public void write(byte[] b) 一次写字节数组中的多个字节到文件中
一次写多个字节:了解
第一个字节是负数,那么会和第二个字节组成一个中文
第一个字节是正数,那么写出单个的字节
*/
byte[] bytes = {65,66,67,68,69};//ABCDE
//byte[] bytes = {-65,-66,-67,68,69};//烤紻E
fos.write(bytes);
/*
思考
在文件中显示100,怎么写?
*/
byte[] bytes2 = {49,48,48};
fos.write(bytes2);
/*
public void write(byte[] b, int off, int len) 写字节数组的一部分到文件中
off:数组的开始索引
len:写的字节个数
*/
fos.write(bytes,1,3);//BCD]
//把字符串转换为字节数组,写入到文件中
byte[] bytes3 = "中国".getBytes();
System.out.println(Arrays.toString(bytes3));//IDEA默认是UTF-8编码 [-28, -72, -83, -27, -101, -67]6个字节
fos.write(bytes3);
//3.释放资源
fos.close();
}
}
字节输出流的续写和换行
换行:使用换行符号
windows: \r\n
linux: /n
mac: /r 从Mac OS X版本开始与linux统一
/*
字节输出流的续写和换行
1.续写(追加写):使用两个参数的构造方法
FileOutputStream(File file, boolean append)
FileOutputStream(String name, boolean append)
参数:
File file,String name:写入数据的目的地
boolean append:续写开关
true:可以续写,使用构造方法创建对象,文件名相同,不会创建新的文件覆盖之前的文件,会继续往文件的末尾写数据
false:不可以续写,使用构造方法创建对象,文件名相同,会创建一个新的空白文件覆盖之前的文件,在新的文件写数据
2.换行:使用换行符号
windows: \r\n
linux: /n
mac: /r 从Mac OS X版本开始与linux统一
*/
public class Demo03OutputStream {
public static void main(String[] args) throws IOException {
//创建FileOutputStream对象,构造方法中传递输出的目的地和续写开关
FileOutputStream fos = new FileOutputStream("day14\\c.txt",true);
//使用FileOutputStream对象中的方法write,把数据写入到文件中
for (int i = 1; i <= 10; i++) {
fos.write(("你好"+i+"\r\n").getBytes());
}
//释放资源
fos.close();
}
}
上边介绍了字节输出流，接下来介绍字节输入流
字节输入流的介绍
/*
java.io.InputStream:字节输入流
此抽象类是表示字节输入流的所有类的超类。
InputStream里边定义了所有字节输入流中共性的成员方法,所有字节输入流都可以使用这些方法
共性的成员方法:
- public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
- public abstract int read()： 从输入流读取数据的下一个字节。
- public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
java.io.FileInputStream:文件字节输入流 extends InputStream
作用:
把文件中的数据,以字节的方式读取到内存中
构造方法:
FileInputStream(File file)
FileInputStream(String name)
参数:传递要读取的数据源
File file:读取的数据源是一个文件
String name:读取的数据源是一个文件的路径
构造方法的作用:
1.会创建FileInputStream对象
2.会把创建好的FileInputStream对象指向要读取的文件中的第一个字节
注意:
要读取的文件不存在,那么会抛出文件找不到异常
使用字节输入流读取文件到内存中的底层原理:
java程序=>JVM==>操作系统==>调用系统中读取数据的方法==>读取文件
*/
字节输入流的基本使用：一次读取一个字节
/*
java.io.InputStream:字节输入流
此抽象类是表示字节输入流的所有类的超类。
InputStream里边定义了所有字节输入流中共性的成员方法,所有字节输入流都可以使用这些方法
共性的成员方法:
- public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
- public abstract int read()： 从输入流读取数据的下一个字节。
- public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
java.io.FileInputStream:文件字节输入流 extends InputStream
作用:
把文件中的数据,以字节的方式读取到内存中
构造方法:
FileInputStream(File file)
FileInputStream(String name)
参数:传递要读取的数据源
File file:读取的数据源是一个文件
String name:读取的数据源是一个文件的路径
构造方法的作用:
1.会创建FileInputStream对象
2.会把创建好的FileInputStream对象指向要读取的文件中的第一个字节
注意:
要读取的文件不存在,那么会抛出文件找不到异常
使用字节输入流读取文件到内存中的底层原理:
java程序=>JVM==>操作系统==>调用系统中读取数据的方法==>读取文件
*/
/*
字节输入流的使用步骤(重点)
1.创建FileInputStream对象,构造方法中绑定要读取的数据源
2.FileInputStream对象中的方法read,以字节的方式读取文件
3.释放资源
*/
public class Demo01InputStream {
public static void main(String[] args) throws IOException {
//1.创建FileInputStream对象,构造方法中绑定要读取的数据源
//FileInputStream fis = new FileInputStream("D:\\Work_idea\\llz\\day15\\a.txt");
FileInputStream fis = new FileInputStream("day15\\a.txt");
//2.FileInputStream对象中的方法read,以字节的方式读取文件
//- public abstract int read()一次读取一个字节并返回
/*
我们发现读取文件是一个重复的过程,所以可以使用循环优化
不知道文件中有多少数据,使用while循环
循环结束的条件,read方法读取到-1的时候结束
布尔表达式:(len = fis.read())!=-1
1.fis.read():读取一个字节
2.len = fis.read():把读取到的字节赋值给len变量
3.(len = fis.read())!=-1:判断变量len的值是否为-1
*/
int len = 0;
while ((len = fis.read())!=-1){
System.out.print((char)len);
}
/*int len = fis.read();
System.out.println(len);//97
len = fis.read();
System.out.println(len);//98
len = fis.read();
System.out.println(len);//99
len = fis.read();
System.out.println(len);//-1*/
//3.释放资源
fis.close();
}
}
使用字节输入流一次读取多个字节
/*
使用字节输入流一次读取多个字节
- public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
明确两个内容:
1.read方法的参数byte[]字节数组的作用?
起到缓冲作用,把读取到的字节依次存储到数组中
把数组一次性的由操作系统返回给JVM,由JVM返回给java程序,效率高
数组的长度一般都使用:1024或者1024的整数倍
2.read方法的返回值int是什么?
每次读取到的有效字节个数
String类中的构造方法
String(byte[] bytes) 把字节数组转换为字符串
String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串
int offset:数组的开始索引
int length:转换的个数,读取到的有效字节个数
*/
public class Demo02InputStream {
public static void main(String[] args) throws IOException {
//1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("day15\\b.txt");//ABCDE
//2.使用FileInputStream对象中的方法read,以字节的方式读取文件
//- public int read(byte[] b) 使用字节数组缓冲一次读取多个字节
/*
我们发现读取数据,是一个重复的过程,所以可以使用循环优化
不知道文件中有多少数据,使用while循环
循环结束的条件,read方法读取到-1结束
*/
byte[] bytes = new byte[1024];
int len = 0;
while ((len = fis.read(bytes))!=-1){
//把字节数组的一部分转换为字符串
System.out.println(new String(bytes,0,len));
}
/*byte[] bytes = new byte[2];
int len = fis.read(bytes);
//System.out.println(Arrays.toString(bytes));//[65, 66]
System.out.println(new String(bytes));//AB
System.out.println(len);//2
len = fis.read(bytes);
System.out.println(new String(bytes));//CD
System.out.println(len);//2
len = fis.read(bytes);
System.out.println(new String(bytes));//ED
System.out.println(len);//1
len = fis.read(bytes);
System.out.println(new String(bytes));//ED
System.out.println(len);//-1*/
//3.释放资源
fis.close();
}
}
文件复制（重点）
/*
文件复制:
原理:一读一写
数据源: c:\\1.jpg
写的目的地: d:\\1.jpg
实现步骤:
1.创建FileInputStream对象,构造方法中绑定要读取的数据源
2.创建FileOutputStream对象,构造方法中绑定要写的目的地
3.使用FileInputStream对象中的方法read,以字节的方式读取文件
4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中
5.释放资源
*/
public class Demo01CopyFile {
public static void main(String[] args) throws IOException {
long s = System.currentTimeMillis();
//1.创建FileInputStream对象,构造方法中绑定要读取的数据源
FileInputStream fis = new FileInputStream("c:\\1.exe");
//2.创建FileOutputStream对象,构造方法中绑定要写的目的地
FileOutputStream fos = new FileOutputStream("d:\\1.exe");
//3.使用FileInputStream对象中的方法read,以字节的方式读取文件
//一次读取一个字节,写一个字节的方式复制:效率低下
/*int len = 0;
while ((len = fis.read())!=-1){
//4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中
fos.write(len);
}*/
//一次读取多个字节,写多个字节的方式复制:效率高
byte[] bytes = new byte[1024*500];
int len = 0;
while ((len = fis.read(bytes))!=-1){
fos.write(bytes,0,len);//写读取到的有效的字节个数(最后一次不一定读取1024个)
}
//5.释放资源
fos.close();
fis.close();
long e = System.currentTimeMillis();
System.out.println("复制文件共耗时:"+(e-s)+"毫秒!");
}
}