Java当中的IO

喜欢ヅ旅行 2021-07-24 15:15 441阅读 0赞

![format_png][]

## 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`

//第一种：输入流输出流//第二种：字节流字符流//第三种：节点流处理流//FileInputStreamclass 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[100];  int temp = fis.read(buffer,0,buffer.length);
      fos.write(buffer,0,temp);
      }   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和BufferedReaderclass 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();

检查文件是否存在