第39节：Java当中的IO

矫情吗；* 2021-09-16 07:56 316阅读 0赞

![image][]

## Java当中的`IO` ##

`IO`的分类

第一种分：输入流和输出流  
第二种分：字节流和字符流  
第三种分：节点流和处理流

> 节点流处理数据，处理流是节点流基础上加工的。

`IO`中的重点：

InputStream
    OutputStream
    FileInputStream
    FileOutputStream

#### InputStream ####

int read(byte[] b,int off,int len)

#### OutputStream ####

void write(byte[] b,int off,int len)

// 第一步，导入类
    import java.io.*;
    class Demo {
     public static void main(String[] args){
      // 声明输入流的引用
      FileInputStream fis = null;
     // 声明输出流的引用
     FileOutputStream fos = null;
      try{
       // 生成输入流的对象
       fis = new FileInputStream("e:/from.txt");
      // 生成代表输出流的对象
      fos = new FileOutputSteam("e:/to.txt");
      // 生成一个字节数组
       byte[] buffer = new byte[100];
     // 调用输入流对象的read方法
      int temp = fis.read(buffer,0,buffer.length);
    
      fos.write(buffer,0,temp);
       for(int i=0; i<buffer.length; i++){
        System.out.println(buffer[i]);
       }
      }catch(Exception e){
       System.out.println(e);
      }
     }
    }

> `IO`是为了对数据进行读写操作，数据的流向是以`Java`程序为参照物的，注意`read`方法和`write`方法。

流：在`Java`中输入和输出是通过流的类来实现的，`Java`提供了一套丰富的流类，可导入`java.io`，这样就可以完成输入和输出了，也同样可以实现网络操作等。

听到流，是不是很形象了呢？流好比一个走向，当程序中需要读取数据时，就会开启一个通向数据源的流，这个数据源可以是文件，内存，网络连接等，需要写入数据时，也会开启一个通向目的地的流。流好比连接起点到终点的路。

**输入流：**源到程序，即读，从数据源的地方输入到程序中，读即 一个文件里的内容读到程序中。

**输出流：**程序中输出到目的地，输出流，即写，一个文件写到另一个文件，从这边输出到另一边。

在`Java`中流：字节流，字符流都要掌握

InputStream
    OutputStream
    Reader
    Writer

重点早期的`Java`内容：`InputStream`和`OutputStream`，这两个都是基于字节流。

字符流：`Reader`和`Writer`

> `Java`语言中的流分：文本流（字符序列）和二进制流

## 输入流和输出流 ##

`InputStream`类为基本的输入流类，是抽象的类，在`InputStream`类中定义了`read`方法，用于读取数据的，读的。

`OutputStream`类为基本的输出类，是抽象的类，在`OutputStream`类中定义了`write`方法，用于输出数据，写的。

> `OutputStream`类  
> 清除缓冲区：`public void flush()`  
> 关闭输出流：`public void close()`

#### 其他重点： ####

在`Java`中提供了`DataInputStream`类与`DataOutputStream`类，数据输入流和数据输出流。在`JDK1.1`版本提供了`InputStreamReader`类与`OutputStreamWriter`类，它们是`Reader`、`Writer`类的子类，提供了字节流到字符流的转换。

#### 字符流 ####

`BufferedReader`类与`BufferedWriter`类分别是`Reader`类和`Writer`类的子类，输入和输出的缓冲区得以提供。

## 文件类 ##

`FileInputStream`类为输入操作，是文件输入流类

import java.io.*;
    public class Demo{
     public static void main(String[] args){
      byte buffer[] = new byte[1024];
      try{
      // 创建FileInputStream类对象
       FileInputStream fis = new FileInputStream("from.txt");
     int temp = fis.read(buffer,0,buffer.length);
     String str=new String(buffer,0,temp);
     // 输出字符串内容
     System.out.println(str);
      }catch(Exception e){
       System.out.println(e);
      }
     }
    }

`FileOutputStream`类为输出类，与`FileInputStream`同理即可。

> `FileInputStream`类，`FileOutputStream`类  
> `DataInputStream`类，`DataOutputStream`类  
> `InputStream`类，`OutputStream`类  
> `BufferedReader`类，`BufferedWriter`类

说说`IO`

//第一种：输入流输出流
    //第二种：字节流字符流
    //第三种：节点流处理流
    //FileInputStream
    class Test{
     public static void main(String args[]){
      FileInputStream fis = null;
      try{
      fis = new FileInputStream("e:/read.txt");
      byte[] buffer = new byte[100];
      fis.read(buffer,0,buffer.length);
      for(int i = 0;i<buffer.length;i++){
       System.out.println(buffer[i]);
      }
    }
     catch(Exception e){
     System.out.println(e);
      }
     }
    }

class Test{
     public static void main(String args[]){
      FileInputStream fis = null;
      FileOutputStream fos = null;
      try{
       fis = new FileInputStream("e:/read.txt");
       fos = new FileOutputStream("e:/write.txt");
      byte[] buffer = new byte[1024];
      while(true){
       int temp = fis.read(buffer,o,buffer.length);
       if(temp = -1){
        break;
       }
       fos.write(buffer,0,temp);
      }
      }catch(Exception e){
       System.out.println(e);
     }finally{
      try{
      fis.close();
      fos.close();
     }catch(Excepiton e){
     System.out.println(e);
      }
     }
    }
    }

//字符流
    public class TextChar
     public static void main(String args[]){
      FileReader fr = null;
      FileWriter fw = null;
      try{
      fr = new FileReader("e:/read.txt");
      fw = new FileWriter("e:/write.txt");
    
       char[] buffer = new char[100];
       int temp = fr.read(buffer,0,buffer.length);
       fw.write(buffer,0,temp); 
       }
       catch(Exception e){
        System.out.println(e);
       }finally{
         try{
           fr.close();
           fw.close();
           }
       catch(Excepiton e){
        System.out.println(e); 
       }
      }
    }

//FileReader和BufferedReader
    class Test{
     public static void main(String args[]){
      FileReader fileReader = null;
      BufferedReader bufferedReader = null;
    try{
      fileReader = new FileReader("e:/read.txt");
      bufferedReader = new BufferedReader(fileReader);
      String line = null;
       while(true){
       line = bufferedReader.readLine();
       if(line == null){ 
         break;
       }
       System.out.println(line);
      }
      }catch(Exception e){
      System.out.println(e); 
     }
      finally{
       try{
         bufferedReader.close(); 
         fileReader.close();
        }
        catch(Exception e){
         System.out.println(e);
        }
       }
      }
    }

public class Test{
     public static void main(String[] args) throws Exception{
      //字节流
     FileInputStream in = new FileInputStream("c:/read.txt");
     FileOutStream out = new FileOutputStream("c:/write.txt");
     byte[] buffer = new byte[1024];
      int len;
      while( (len = in.read(buffer)) != -1){
      out.write(buffer,0,len);
      }
      in.close();
      out.close();
      //字符流
      BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
      BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
     String str;
     while( (str=bf.readLine()) != null ){
      bw.write(str);
      bw.newLine();
     }
     bf.close();
     bw.close();
      }
    }

字节流: `InputStream`字节输入流,`OutputStream`字节输出流  
字符流 : `Reader`字符输入流 ,`Writer`字符输出流  
数据流: `DataInputStream` 数据输入流 ,`DataOutputStream` 数据输出流

#### 文件读写 ####

目的  
1 掌握文件读写的几种方法  
2 `FileOutputStream`和`FileInputStream`类的使用。  
3 基本数据类型之间的转换

实现文件读取后转换为大写后写入到目标文件中，其中`src`是指源文件，`des`是目标文件目录。

public class FileDemo {
    
        //创建一个文件夹
        public static void createFolder(String path){
            File folder=new File(path);
            if(folder.exists()){
                System.out.println("文件夹已存在！");
            }else{
                //不存在时去创建
                folder.mkdir();
            }
        }
        //创建一个文件
        public static void createFile(String path,String filename){
            File file=new File(path,filename);
            //文件判断是否已存在
            if(file.exists()){
                System.out.println("文件已存在！");
                System.out.println(file.length());
            }else{
                try{
                    file.createNewFile();
                }catch(IOException e){
                    System.out.println("文件创建失败！");
                }
            }
        }
        //写文件
        public static void write(String path,String filename){
            try{
                String str="0123456789/nac";
                String Upstr = str.toUpperCase();//
                byte b[]=Upstr.getBytes();//
                FileOutputStream fos=new FileOutputStream(new File(path,filename));
                fos.write(b);
                fos.close();
            }catch(FileNotFoundException e){
                System.out.println("文件不存在");
            }catch(IOException e){
                System.out.println("写文件失败");
            }
        }
        //读文件
        public static void read(String path,String filename){
            try{
                int length=0;
                String str="";
    
                byte buffer[]=new byte[10];
                FileInputStream fis=new FileInputStream(new File(path,filename));
    
                while((length=fis.read(buffer, 0, buffer.length)) !=-1){
                    str+=new String (buffer, 0, length);
                }
                System.out.println(str);//
                fis.close();
            }catch(FileNotFoundException e){
                System.out.println("文件不存在");
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    //
        public static void FileReaderCopy(String src,String des){
            try{
            FileReader fr=new FileReader(src);
            FileWriter fw=new FileWriter(des);
            char c[]=new char[1024];
            int len=0;
    
            while((len=fr.read(c, 0, c.length)) != -1){
                fw.write(c, 0, c.length);
            }
            fw.close();
            fr.close();
        } catch(FileNotFoundException e){
            System.out.println("文件不存在");
        }catch(IOException e){
            System.out.println("读写失败");
        }
        }
        //
        public static void BufferedReaderCopy(String src,String des){
            try{
                BufferedReader br=new BufferedReader(new FileReader(src));
                BufferedWriter bw=new BufferedWriter(new FileWriter(des));
                String str="";
                while((str=br.readLine()) != null){
                    String Upstr = str.toUpperCase();//加入大写的变换
                    bw.write(Upstr);//
                    bw.newLine();
                }
                bw.close();
                br.close();
            } catch(FileNotFoundException e){
                System.out.println("文件存在");
            }catch(IOException e){
                System.out.println("读写失败");
            }
            }
        //复制
        public static void copy(String src,String des){
            try{
                FileInputStream fis=new FileInputStream(src);
                FileOutputStream fos=new FileOutputStream(des);
                int c;
                while((c=fis.read()) != -1){
                    fos.write(c);
                }
                fos.close();
                fis.close();
            }catch(FileNotFoundException e){
                System.out.println("文件不存在");
            }catch(IOException e){
                System.out.println("读写失败");
            }
        }
        //复制文件
        public static void copy1(String src,String des){
            try{
                FileInputStream fis=new FileInputStream(src);
                FileOutputStream fos=new FileOutputStream(des);
                int c;
                byte buff[]=new byte[1024];
                while((c=fis.read(buff,0,buff.length)) != -1){
                    fos.write(buff,0,c);
                }
                fos.close();
                fis.close();
            }catch(FileNotFoundException e){
                System.out.println("文件不存在");
            }catch(IOException e){
                System.out.println("读写失败");
            }
        }
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            FileDemo.createFolder("c:/test");
            FileDemo.createFile("c:/test", "1.txt");
            FileDemo.write("c:/test", "1.txt");
            FileDemo.read("c:/test", "1.txt");
            FileDemo.read("c:/test", "FileDemo.java");
            FileDemo.BufferedReaderCopy("c:/test/FileDemo.java", "c:/test/FileDemo2.java");
            FileDemo.copy1("c:/test/1.mp3", "c:/test/2.mp3");
        }
    
    }

#### 读文件 ####

//读文件
    public static void read(String path,String filename){
     try{
      int length = 0;
      String str = "";
      byte buffer[]=new byte[10];
      FileInputStream fis=new FileInputStream(new File(path,filename));
    
      while((length=fis.read(buffer,0,buffer.length))!=-1){
         str+=new String(buffer,0,length);
      }
      System.out.println(str);
      fis.close();
     }catch(FileNotFoundException e){
       System.out.println("文件不存在");
     }catch(IOException e){
      e.printStackTrace();
     }
    }

#### 文件的创建 ####

public class FileDemo{
     public static void createFolder(String path){
      File folder = new File(path);
      if(folder.exists()){
       System.out.println("文件已存在!");
      }else{
        folder.mkdir();
     }
    }
    
     public static void createFile(String path,String filename){
      File file = new File(path,filename);
      if(file.exists()){
       System.out.println("文件已存在!");
       System.out.println(file.length());
      }else{
       try{
        file.createNewFile();
      }catch(IOException e){
       System.out.println("文件创建失败");
      }
      }
    }
    
    public static void main(String[] args){
      FileDemo.createFolder("c:/test");
      FileDemo.createFile("c:/test","1.txt");
    }
    }

#### 写文件 ####

public static void write(String path,String filename){
     try{
      String str = "234455";
       byte b[] = str.getBytes();
       FileOutputStream fos =  new FileOutputStream(new File(path,filename));
      fos.write(b);
     }catch(FileNotFoundException e){
       System.out.println("文件不存在");
      }catch(IOException e){
       System.out.println("写文件失败");
      }
    }

#### 文件的读写 ####

重点：

文件类主要功能：创建，读属性，写属性，删除等

#### 文件读写操作 ####

`File`类  
`File`类的对象

用来获取文件本身的信息，如文件所在目录、文件长度、文件读写权限等，不涉及文件的读写操作。

#### 构造函数 ####

File(String filename)
    File(String directoryPath,String filename)
    File(File f,String filename)

#### 获取文件的属性 ####

String getName()
    boolean canRead()
    boolean canWrite()
    long length()
    boolean isFile()等

#### 目录操作 ####

boolean mkdir()：创建目录。
    String[] list()：以字符串的形式返回目录下所有文件。
    File[] listFiles()：以File对象形式返回目录下所有文件。

#### 文件操作 ####

boolean createNewFile()：创建一个新的文件。
    boolean delete()：删除一个文件

#### 流的概念 ####

`Java`输入输出功能是借助输入输出流类来实现的。

`java.io`包中包含大量用来完成输入输出流的类。

#### Java中流的分类： ####

流的运动方向，可分为`输入流`和`输出流`两种。

流的数据类型，可以分为`字节流`和`字符流`。

输入流类都是抽象类`InputStream`（字节输入流）或抽象类`Reader`类（字符输入流）的子类。

输出流类都是抽象类`OutputStream`（字节输出流）或抽象类`Writer`类（字符输出流）的子类。

#### 输入流 ####

输入流用于读取数据，用户可以从输入流中读取数据，但不能写入数据。

#### 输入流读取数据过程如下： ####

（1）打开一个流。  
如：`FileInputStream` `inputFile`=`new` `FileInputStream`(“数据源”);  
（2）从信息源读取信息。  
如：`inputFile.read()`;  
（3）关闭流。  
如：`inputFile.close()`;

#### 输出流 ####

输出流用于写入数据。只能写，不能读。

#### 写数据到输出流过程如下： ####

（1）打开一个流。  
如：`FileOutputStream` `outFile`=`new` `FileOutputStream`(“数据源”);  
（2）写入信息到目的地。  
如：`outFile.write(inputFile.read())`:  
（3）关闭流。如：  
如：`outFile.close()`;

## `IO` ##

1.  `I/O`操作的目标
2.  `IO`的分类方法
3.  读取文件和写入文件的方法

## I/O操作的目标 ##

目标是从数据源中读取数据，将数据写入到数据目的地中。

从一个地方输入到`java`程序中输出到另外一个地方。

## 文件与数据流 ##

写入和读出数据文件，在`Java`的`输入/输出`操作采用数据流的形式，数据流的两种形式为`16位字符`或`8位字节`

数据流的操作对象：

数据文件的读写
    线程间的数据传输
    网络间的数据传播

读/写步骤：  
导入输入/输出包，导入`java.io.*`包  
创建文件对象

`FileReader/FileWriter`类用于文本文件的读写操作  
`DataInputStream`（用于文件读出）和`DataOutputStream`（用于文件写入）类文件的读写  
`FileInputStream`（用于文件读出）和`FileOutputStream`对象（用于文件写入）

## 关闭文件 ##

`close`函数关闭文件

## File对象的特性 ##

创建文件

boolean createNewFile();

创建子目录

boolean mkdir();
    boolean mkdirs();

重命名/移动文件

boolean renameTo(File dest);

删除文件

boolean delete();

检查文件是否存在

boolean exists();

检查是否为文件

boolean isFile();

检查是否为文件夹

boolean isDirectory();

查询文件长度

long length();

> 往后余生，唯独有你  
> 简书作者：达叔小生  
> 90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通  
> 简书博客： [https://www.jianshu.com/u/c785ece603d1][https_www.jianshu.com_u_c785ece603d1]

## 结语 ##

*  下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[image]: /images/20210724/95900828e35e456dbc5d7d9ef9b37d20.png
[https_www.jianshu.com_u_c785ece603d1]: https://www.jianshu.com/u/c785ece603d1