Java进阶11（IO流、OutputStream、InputStream、复制文件练习、字节缓冲流、复制单级文件夹练习）

Part01:IO流

1、IO流：

• 根据流的流向分类：
  • Input：输入流
  • Output：输出流
• 根据流操作的数据分类：
  • 字符流：操作字符；只能操作普通文本文件（只要能用文本工具打开，并且打开后能看懂的）最常见的文本文件：.txt、.java、.cpp等其他语言的源代码；
    注意⚠️：.doc、excel、ppt这些不是文本文件
  • 字节流：操作字节；能操作一切文件（文本文件、.mp3、.avi、.doc、excel、ppt等）

2、Java中的四大流：

• 字符输入流：共同父类Reader；子类：FileReader、BufferedReader等；
  • 功能：读取一个字符，一个字符数组；
• 字符输出流：共同父类Writer；子类：FileWriter、BufferedWriter等；
  • 功能：写一个字符，写一个字符数组（也可以只写一部分），写一个字符串；
• 字节输入流：共同父类InputStream；子类：FileInputStream、BufferedInputStream等；
  • 功能：读取一个字节，读取一个字节数组
• 字节输出流：共同父类OutputStream；子类：FileOutputStream、BufferedOutputStream等；
  • 功能：写一个字节，写一个字节数组（也可以只写一部分）

规律：

• 只要是输入流，此流的方法名一定叫read；只要是输出流，此流等方法名一定叫write；
• 一般来说流的命名为：功能+父类名字

3、一切均为字节：
在数据传输的过程中，一切数据（文本、图像、声音等）最终存储的均为一个个字节，即二进制数组。所以数据传输过程中使用二进制数据完全可以完成任意数据的传递。

Part02:OutputStream

1、OutputStream：
字节输出流的根类，这是一个抽象类；
2、OutputStream的方法：

• public void close( );//关闭流
• public void flush( );//刷新流
• public void write(int b);//写一个字节或一个字节的ASCII码值
• public void write(byte[ ] bs);//写一个字节数组
• public void write(byte[ ] bs,int startIndex,int length);//写一个字节数组的一部分（从startIndex开始，写length个；

3、FileOutputStream

• 续写：

  • 使用public FileOutPutStream(String filename, boolean flag)构造方法，当flag为true时，表示可以续写；

  • public FileOutPutStream(String filename)构造方法默认不续写；

    //创建流对象，true表示可以续写
    FileOutputStream fos = new FileOutputStream("1.txt",true);
    //写数据
    fos.write("javahh".getBytes());
    //关闭流
    fos.close();
    

• 换行：

  • windows：\r\n
  • Linux：\n
  • Mac：\r

Part03:InputStream

1、InputStream：
字节输入流的根类，这是一个抽象类；
2、InputStream的方法：

• public int read( );//读取一个字节，返回这个字节的ASCII码值；
• public int read(byte[ ] bs);//读取一个字节数组，返回实际读取到的字节数

3、FileInputStream

• 一次读取一个字节：

  FileInputStream fis = new FileInputStream("1.txt”);
  //创建文件字节输入流对象
  //检测文件是否存在，如果不存在，抛出异常
  //若文件存在，让文件输入流对象指向该文件
  //读取一个字节，返回的是该字节的ASCII码值
  int b = fis.read();
  //把该字节的ASCII码值转化为字符输出
  System.out.println((char)b);
  
  int a = 0;
  //读出来的为-1表示到达文件末尾
  while ((a=fis.read()) != -1){
    System.out.println((char)a);
  }
  fis.close();
  

• 一次读取一个字节数组:

  FileInputStream fis = new FileInputStream("1.txt”);
  byte[] bs = new byte[4];
  int len = 0;
  //1.fis.read(bs):从文件中读取数据，将读取的数据存储到字节数组bs中
  //2.len = fis.read(bs):把读到的实际个数赋值给len
  //3.判断读到的数据是否为-1，如果为-1表示读到文件末尾
  while ((len = fis.read(bs)) != -1){
    //把字节数组转换成字符串输出,从第0个开始转换，转换实际读取个数len个
    System.out.println(new String(bs,0,len));
  }
  fis.close();
  

Part04:复制文件练习

import java.io.*;

//复制文件练习,把原文件读出写入目标文件
public class CopyFileDemo {
    public static void main(String[] args) throws IOException {
        //目标文件
        FileOutputStream  fos = new FileOutputStream("2.jpg");
        //原文件
        FileInputStream fis = new FileInputStream("/Users/feng/Desktop/fl/1.jpg");
        byte[] bytes = new byte[1024];
        int len = 0;
        //读原文件
        while ((len = fis.read(bytes)) != -1){
            //把读出来的数据写入目标文件
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
}

Part05:字节缓冲流

1、字节缓冲输入流：
BufferedOutputStream//写入数据到流中
构造方法：public BufferedOutputStream(OutputStream out)

     //创建BufferedOutputStream对象
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.txt"));
    //写数据
      //写一个字节
    bos.write(100);
      //写一个字节数组
    byte[] bytes = "Java".getBytes();
    bos.write(bytes);
      //写一个字节数组的一部分
    byte[] bytes1 = "ppppp".getBytes();
    bos.write(bytes1,0,3);
    //关闭流
    bos.close();

2、字节缓冲输出流：
BufferedInputStream//读取流中的数据
构造方法：public BufferedInputStream(InputStream out)

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("2.txt"));
//一次读取一个字节
int b = 0;
while ( (b = bis.read()) != -1){
    System.out.println((char)b);
}
//一次读取一个字节数组
byte[] bytes = new byte[4];
int len = 0;
while ((len = bis.read(bytes)) != -1){
    System.out.println(new String(bytes,0,len));
}
bis.close();

Part06:复制单级文件夹练习

单级：一个文件夹中只有文件，没有其他的文件夹

import java.io.*;

public class CopyDirectoryDemo {
    public static void main(String[] args) throws IOException {
        //1、
        File file = new File("/Users/feng/Desktop/原文件夹");
        File file1 = new File("/Users/feng/Desktop/目标文件夹");
        if(file1.mkdir()){
            System.out.println("目标文件创建成功");
        }else {
            System.out.println("目标文件已存在");
        }
        File[] files = file.listFiles();
        for (File f:files
             ) {
            File f2 = new File(file1,f.getName());
            CopyFile(f,f2);
            System.out.println(file1.getName()+"复制成功");
        }
    }
private static void CopyFile(File f, File f2) throws IOException {
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(f));
    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(f2));
    byte[] b = new byte[1024];
    int len = 0;
    while ((len = bis.read(b)) != -1){
         bos.write(b,0,len);
    }
    bos.close();
    bis.close();
  }
}