字节流

一切皆为字节

一切文件数据(本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节,那么传输时一样如此。所以,字节流可以传输任意文件数据。在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输的始终为二进制数据。

字节流主要是操作byte类型数据，以byte数组为准，
主要操作类时字节输入流InputStream、字节输出流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:文件字节输出流
作用:把内存中的数据写入到硬盘的文件中

构造方法:

Fileoutputstream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流。
Fileoutputstream(File file)创建一个向指定File对象表示的文件中写入数据的文件输出流。

参数:写入数据的目的

string name:目的地是一个文件的路径File file:目的地是一个文件

构造方法的作用:

1.创建一个Fifeoutputstream对象
2,会根据构造 法中传递的文件/文件路径,创建一个空的文件
3.会把Fileoutputstream对象指向创建好的文件

写出字节数据

写出字节: write(int b)方法,每次可以写出一个字节数据,

  1. public static void main(String[] args) throws IOException {
  2. //使用文件名称创建流对象
  3. Fileoutputstream fos - new Fileoutputstream("fos.txt");
  4. //写出数据
  5. fos.write(97);//写出第1个字节
  6. fos.write(98);//写出第2个字节
  7. fos.write(99);//写出第3个字节
  8. //关闭资源
  9. fos.close();
  10. }

字节输出流的使用步骤(重点):

1,创建一个Fileoutputstream对象,构造方法中传递写入数据的目的地
2,调用FileoutputStream对象中的方法write,把数据写入到文件中
3,释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)

  1. public static void main(String[] args) throws IOException {
  2. //1.创建一个Fileoutputstream对象,构造方法中传递写入数据的目的地
  3. FileoutputStream fos -new Fileoutputstrean( name: "09 IOAndProperties\\a.txt");
  4. //2.调用FileOutputstream对象中的方法write,把数据写入到文件中//public abstract void write(int b) ：将指定的字节输出流。
  5. fos.write(b: 97);
  6. //3.释放资源(流使用会占用一定的内存,使用完毕要把内存清空,提供程序的效率)
  7. fos.close();

一次写多个字节的方法:

-public void write(bytel] b);将b. Length字节从指定的字节数组写入此输出流。
public void write(bytet] b, int off, int Len) :从指定的字节数组写入Len字节,从偏移量off开始输出到此输出流。

  1. public static void main(String[] args) throws IOException {
  2. //创建Fileoutputstream对象,构造方法中绑定要写入数据的目的地
  3. FileoutputStream fos = new Fileoutputstream(new File( pathname: "09_IOAndProperties\\b.txt"));
  4. //调用Fileoutputstream对象中的方法write,把数据写入到文件中//在文件中显示100,写个字节
  5. fos.write((49);
  6. fos.write((48);
  7. fos.write((48)
  8.           /*
  9.                     public void write(bytel] b):将b.Length字节从指定的字节数组写入此输出流。
  10.           一次写多个字节:
  11.           如果写的第一个字节是正数(e-127),那么显示的时候会查询ASCII表
  12.           加果写的第一个字节是负数,那第一个字节会和第二个字节,两个字节组成一个中文显示,查询系统默认码表(GBK)
  13.           */
  14. byte[] bytes -{65,66,67, 68, 69);//ABCDE
  15. //byte[] bytes -{-65,-66, -67,68, 69);//考触E
  16. fos.write(bytes);         
  17.                /*
  18.                public void write(bytel], b, int off, int (en):把字节数组的一部分写入到文件中
  19.                int off:数组的开始索引
  20.                              int Len:写几个字节
  21.                */
  22. fos.write(bytes, off: 1, len: 2);//BC
  23.                /*
  24.                写入字符的方法:可以使用string类中的方法把字符串,转换为字节数组
  25.                byte[1 getBytes() 把字符串转换为字节数组
  26.                */
  27. byte[] bytes2-"你好".getBytes();
  28. system.out.println(Arrays.tostring(bytes2));//-28, -67,-96, -27, -91, -67
  29. fos.write(bytes2);               
  30. //释放资源
  31. fos.close();

数据追加续写

追加写/续写:使用两个参数的构造方法

Fileoutputstream(String name, boolean append)创建一个向具有指定name的文件中写入数据的输出文件流。
Fileoutputstream(File file, boolean append)创建一个向指定File对象表示的文件中写入数据的文件输出流。

参数:

string name, File file:写入数据的目的地
boolean append :追加写开关
true:创建对象不会覆盖源文件,继续在文件的末尾追加写数据false:创建一个新文件,覆盖源文件

  1. publle statle vo1d maln(sthg ags) throws IOException{
  2. FileoutputStream fos - new Fileoutputstream( name: "09_IOAndProperties\\c.txt", append: true);
  3. for (int i - 1; i <-1e; i++) {
  4. fos.urife("你好".getBytes();
  5. fos.close();
  6. }

字节输入流

java. io. InputStream:字节输入流
此抽象类是表示字节输入流的所有类的超类。
定义了所有子类共性的方法:
int read()从输入流中读取数据的下一个字节。
int read(bytel]b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中。
void close()关闭此输入流并释放与该流关联的所有系统资源。
java. io. FileInputstream extends Inputstream
FileInputStream:文件字节输入流
作用:把硬盘文件中的数据,读取到内存中使用

构造方法:

FileInputstream(String name)
FileInputStream(File file)

参数:读取文件的数据源

String name:文件的路径
File file:文件

构造方法的作用:

1,会创建一个FileInputStream对象
2.会把FileInputstream对象指定构造方法中要读取的文件

字节输入流的使用步骤(重点):

1,创建FileInputstream对象,构造方法中绑定要读取的数据源
2.使用FileInputstream对象中的方法read,读取文件
3.释放资源

  1. public static void main(String[] args) throws IOException {
  2. //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
  3. FileInputstream fis - new FileInputstream(  "09_IOAndProperties \altxt");
  4. //2,使用FileInputStream对象中的方法read,读取文件
  5. //int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
  6. int ien= fis.read();
  7. System. out.println(len);//97 a
  8. len = fis.read();
  9. System.out.println(len);// 98 b
  10. len = fis.read();
  11. System.out.printin(len);//99 c
  12. len =fis.read();
  13. System.out.println(len);//-1
  14. len = fis.read();
  15. System.out.println(len);//-1
  16. /*
  17.   发现以上读取文件是一个重复的过程,所以可以使用循环优化不知道文件中有多少字节,使用whiLe循环
  18.   while循环结束条件,读取到-1的时候结束
  19.   布尔表达式(Len -fis.read())!=-1
  20.     1.fis. read():读取一个字节
  21.   2. Len -fis. read():把读取到的字节赋值给变量Len
  22.   3. (Len-fis.read())!--1:判断变量Len是否不等于-1
  23. */
  24. int len=0; //记录读取到的字节
  25. while((len =fis.read())!= -1){
  26. System.out.printin((char)len);
  27. }
  28. //3.释放资源
  29. fis.close();
  30. }

字节输入流一次取多个字节的方法:

int read(bytel] b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中。

明确两件事情:

明确两件事情:
1.方法的参数byte[]的作用?
起到缓冲作用,存储每次读取到的多个字节
数组的长度一把定义为1024(1kb)或者1024的整数倍
2.方法的返回值int是什么?
每次读取的有效字节个数

string类的构造方法

string (byte[] bytes) :把字节数组转换为字符串
string (byte[j bytes, int offset, int length)把字节数组的一部分转换为字符串offset:数组的开始索引Length:转换的字节个数

  1. public static void main(String args) throws IOException{
  2. //创建FileInputstream对象,构造方法中绑定要读取的数据源
  3. FileInputStream fis - new FileInputStream( name: "09_1OAndProperties\\b.txt");
  4. //使用FileInputstream对象中的方法read读取文件
  5. //int read(byte[] b)从输入流中读取一定数量的字节,并将其存储在缓冲区数组b中。
  6. byte[] bytes -new byte[2];
  7. byte[] bytes - new byte[2];
  8. int len - fis.read(bytes);
  9. System.out .printin(len);//2
  10. syptem.out.println(Arrays.tostring(bytes));//[65, 66] 
  11. system.out.println(new string(bytes));//AB
  12. len= fis.read(bytes);
  13. System.out.printin(len);//2
  14. System.out.printin(new String(bytes));
  15. /*
  16.   发现以上读取时一个重复的过程,可以使用循环优化
  17.   不知道文件中有多少字节,所以使用while循环
  18.   while循环结束的条件,读取到-1结束
  19. */
  20. byte[] bytes -new byte[10241;//存储读取到的多个字节int ien -e; //记录每次读取的有效字节个数
  21. while((len -fis.read(bytes))-1){
  22. System.out.printin(new String(bytes));
  23. //String(byte[] bytes, int offset, int Length)把字节数组的一部分转换为字符串offset:数组的开始索引Length:转换的字节个数
  24. System.out.println(new string(bytes, offset: e,len)); 
  25. }
  27. //释放资源
  28. fis.close();
  29. }

图片复制

原理

039IO_字节流 - 图1

文件复制的步骤:

1,创建一个字节输入流对象,构造方法中绑定要读取的数据源
2,创建一个字节输出流对象,构造方法中绑定要写入的目的地
3,使用字节输入流对象中的方法read读取文件
4,使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
5,释放资源

代码

  1. public static void main(String[] args) throws IOException {
  2. //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
  3. FileInputstream fis -new FileInputStream( name: "c:\\1. jpg");
  4. //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
  5. FileOutputStream fos - new Fileoutputstream( name: "d:\\1.jpg");
  6. //一次读取一个字节写入一个字节的方式
  7. //3.使用字节输入流对象中的方法read读取文件
  8. /*int Len -0;
  9. while((Len -fis.read())!=-1){
  10. //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
  11. }/
  12. fos.write(Len);
  13. */
  14. //使用数组缓冲读取多个字节,写入多个字节
  15. byte[] bytes -new byte[1024];
  16. //3.使用字节输入流对象中的方法read读取文件
  17. int len =0;//每次读取的有效字节个数
  18. while((len = fis.read (bytes))!--1){
  19. //4,使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
  20. fos.write(bytes, off: e,len);
  21. //5.释放资源(先关写的,后关闭读的;如果写完了,肯定读取完毕了)
  22. fos.close();
  23. fis.close();I
  24. }