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[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和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

結語

• 下面我將繼續對 其他知識 深入講解 ，有興趣可以繼續關註
• 小禮物走一走 or 點贊

第39節：Java當中的IO