Java使用I/O流讀取檔案內容的方法詳解

阿新 • • 發佈：2020-01-07

本文例項講述了Java使用I/O流讀取檔案內容的方法。分享給大家供大家參考，具體如下：

要利用I/O流讀取檔案內容，首先要掌握InputStream的體系結構。

這個體系中FileInputStream和BufferedInputStream是一定要掌握的，因為使用的頻率比較高。

InputStream的方法：InputStream位於java.io包下

OutputStream的方法：

讀取檔案（程式碼）：

package com.jredu.oopch11;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/**
 * I/O流的概念：資料流向某個物件的資料序列，並且到達這個物件的過程。
 * 輸入流：資料來源資料流向計算機記憶體的過程
 * 輸出流：把資料從程式流向目標資料來源的過程
 * @author Administrator
 *
 */
public class Ch01 {
    /**
     * 讀取檔案內容
     * @param args
     */
    public static void main(String[] args) {
        //InputStream:是一個抽象類
        // \:是一個 轉移符
        //表示磁碟路徑的兩種表示方式：1、\\  2、/
        try {
            //從檔案地址中讀取內容到程式中
            //1、建立連線
            InputStream is = new FileInputStream("E:/iodemo/ch01.txt");
            //2、開始讀取資訊
            /*
            //方法1：一次只讀一個
            System.out.println(is.read());//讀取的是位元組型的：49
            System.out.println((byte)is.read());//50
      */    
            //方法2：定義陣列，迴圈讀取
            //先定義一個位元組陣列存放資料
            byte[] b = new byte[5];//把所有的資料讀取到這個位元組當中
            //宣告一個int儲存每次讀取到的資料
            int i = 0;
            //定義一個記錄索引的變數
            int index = 0;
            //迴圈讀取每個資料
            while((i=is.read())!=-1){//把讀取的資料放到i中
                b[index]=(byte) i;
                index++;
            }
            //把位元組陣列轉成字串
            System.out.println(new String(b));
            //關閉流
            is.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            //系統強制解決的問題：檔案沒有找到
            e.printStackTrace();
        } catch (IOException e) {
            //檔案讀寫異常
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
/**
 * I/O流的概念：資料流向某個物件的資料序列，並且到達這個物件的過程。
 * 輸入流：資料來源資料流向計算機記憶體的過程
 * 輸出流：把資料從程式流向目標資料來源的過程
 * @author Administrator
 *
 */
public class Ch02 {
    /**
     * 讀取檔案內容
     * @param args
     */
    public static void main(String[] args) {
        //InputStream:是一個抽象類
        // \:是一個 轉移符
        //表示磁碟路徑的兩種表示方式：1、\\  2、/
        try {
            //從檔案地址中讀取內容到程式中
            //1、建立連線
            InputStream is = new FileInputStream("E:/iodemo/ch01.txt");
            //2、開始讀取資訊    
            //先定義一個位元組陣列存放資料
            byte[] b = new byte[5];//把所有的資料讀取到這個位元組當中
            //完整的讀取一個檔案
            is.read(b);
            //read:返回的是讀取的檔案大小
            //最大不超過b.length，返回實際讀取的位元組個數
            System.out.println(Arrays.toString(b));//讀取的是位元組陣列
            //把位元組陣列轉成字串
            System.out.println(new String(b));
            //關閉流
            is.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            //系統強制解決的問題：檔案沒有找到
            e.printStackTrace();
        } catch (IOException e) {
            //檔案讀寫異常
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
/**
 * I/O流的概念：資料流向某個物件的資料序列，並且到達這個物件的過程。
 * 輸入流：資料來源資料流向計算機記憶體的過程
 * 輸出流：把資料從程式流向目標資料來源的過程
 * @author Administrator
 *
 */
public class Ch03 {
    /**
     * 讀取檔案內容
     * @param args
     */
    public static void main(String[] args) {
        //InputStream:是一個抽象類
        // \:是一個 轉移符
        //表示磁碟路徑的兩種表示方式：1、\\  2、/
        try {
            //從檔案地址中讀取內容到程式中
            //1、建立連線
            InputStream is = new FileInputStream("E:/iodemo/ch01.txt");
            //2、開始讀取資訊    
            //先定義一個位元組陣列存放資料
            byte[] b = new byte[is.available()];//把所有的資料讀取到這個位元組當中
            //is.available()：返回檔案的大小
    //        while(is.available()==0);//不等於0時才停止迴圈
            //完整的讀取一個檔案
            int off = 0;
            int le = 2;
            while(is.read(b,off,2)!=-1){
                off+=1;
            }
            is.read(b,2);
            //read:返回的是讀取的檔案大小
            //最大不超過b.length，返回實際讀取的位元組個數
            System.out.println(Arrays.toString(b));//讀取的是位元組陣列
            //把位元組陣列轉成字串
            System.out.println(new String(b));
            //關閉流
            is.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            //系統強制解決的問題：檔案沒有找到
            e.printStackTrace();
        } catch (IOException e) {
            //檔案讀寫異常
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
public class Ch04 {
    /**
     * 讀取中文字元的檔案
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            /*FileInputStream fis = new FileInputStream("E:/iodemo/ch04.txt");
            //包裝流
            BufferedInputStream bis = new BufferedInputStream(fis);*/
            //包裝流
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:/iodemo/ch04.txt"));
            //讀取檔案內容
            byte[] b = new byte[bis.available()];
            bis.read(b);
            /*char[] c = new char[b.length];
            for (int i = 0; i < c.length; i++) {
                c[i]=(char) b[i];
            }
            System.out.println(Arrays.toString(c));//亂碼
             */        
            System.out.println(Arrays.toString(b));//得到的是位元組
            //String(byte[])把位元組陣列轉成字串
            System.out.println(new String(b));//可以得到中文
            bis.close();//關閉流(關閉bis就可以了)
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Ch05 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            //讀取檔案
            FileInputStream fis = new FileInputStream("E:/iodemo/ch01.txt");
            //fis.available():檔案的長度
            byte[] b=new byte[fis.available()];
            //skip:跳過n個位元組後再開始讀取
            fis.skip(5);//跳過前5個
            fis.read(b);
            System.out.println(new String(b));
            fis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Ch06 {
    /**
     * 讀取過程暫停，給當前做一個標記，下一次從標記位置開始讀取
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //讀取過程中暫停
        //給當前做一個標記
        //下一次從標記位置開始讀取
        try {
            BufferedInputStream bis= new BufferedInputStream(new FileInputStream("E:/iodemo/ch06.txt"));
            byte[] b = new byte[bis.available()];
        //    bis.read(b,b.length/2);
            //設定斷點
            bis.mark(bis.read(b,b.length/2));//位置就是讀取的長度
            System.out.println(new String(b));
            System.out.println("暫停讀取....");
            Thread.sleep(2000);//休眠2s
            //休眠後繼續讀
            System.out.println("繼續讀取...");
            //reset：將當前復位的位置設定成上次呼叫mark標記的位置
            bis.reset();
            bis.read(b);
            System.out.println(new String(b));
            bis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.SequenceInputStream;
/**
 * 序列流（集合流）
 * 把n個流合併在一起讀取
 * @author Administrator
 *
 */
public class Ch07 {
    public static void main(String[] args) {
        try {
            //第一個檔案流
            FileInputStream fis1=new FileInputStream("E:/iodemo/ch01.txt");
            //第二個檔案流
            FileInputStream fis2=new FileInputStream("E:/iodemo/ch04.txt");
            //合併到序列流中
            SequenceInputStream sis=new SequenceInputStream(fis1,fis2);
            //方式1
//            //臨時存放資料的陣列
//            int len =fis1.available()+fis2.available();
//            byte[] b=new byte[2*len+1];
//            //把每一次讀取到的臨時資料存放如sb中
////            StringBuffer sb=new StringBuffer();
//            //一次性讀取所有的內容
//            int off=0;
//            int i=0;
//            while((i=sis.read(b,len))!=-1) { 
////                sb.append();
//                off+=i;
//            }
//            System.out.println(new String(b));
            //方式2
            byte[] b=new byte[fis1.available()];
//            StringBuffer sb=new StringBuffer();
//            int i=0;
            while(sis.read(b)!=-1) {
                System.out.println(new String(b));
//                sb.append(new String(b));
            }
//            System.out.println(sb.toString());
            sis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.jredu.oopch11;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Vector;
public class Ch08 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            //三個檔案流
            FileInputStream fis1 = new FileInputStream("E:/iodemo/a.txt");
            FileInputStream fis2 = new FileInputStream("E:/iodemo/b.txt");
            FileInputStream fis3 = new FileInputStream("E:/iodemo/c.txt");
            //把三個流新增到集合中
            Vector<FileInputStream> vector = new Vector<>();
            vector.add(fis1);
            vector.add(fis2);
            vector.add(fis3);
        //    vector.elements(); //方法返回的是Enumeration
            //合併到一個序列流中
            SequenceInputStream sis = new SequenceInputStream(vector.elements());
            byte[] b = new byte[fis1.available()+fis2.available()+fis3.available()];
            //讀取
            int off=0;
            //vector.get(i).available():一個檔案的長度
            for (int i = 0; i < vector.size(); i++) {
                //off:陣列當中存放資料的起始下標的位置
                off+=sis.read(b,vector.get(i).available());//每次讀取一個檔案的長度
            }
            System.out.println(new String(b));
            sis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

更多關於java演算法相關內容感興趣的讀者可檢視本站專題：《Java檔案與目錄操作技巧彙總》、《Java資料結構與演算法教程》、《Java操作DOM節點技巧總結》和《Java快取操作技巧彙總》

希望本文所述對大家java程式設計有所幫助。