黑馬程序員——IO流(File類、Properties類、打印流、序列流)

------- android培訓、java培訓、期待與您交流！ ----------

第一講     File類

一、概述

1、File類：文件和目錄路徑名的抽象表現形式

2、特點：

        1）用來將文件或文件夾封裝成對象

        2）方便於對文件與文件夾的屬性信息進行操作

        3）File類的實例是不可變的；也就是說，一旦創建，File 對象表示的抽象路徑名將永不改變

        4）File對象可以作爲參數傳遞給流的構造函數

 

二、File對象創建

方式一：      

             File f =new File("a.txt");

        將a.txt封裝成File對象。可以將已有的和未出現的文件或者文件夾封裝成對象。

 方式二：

            File f2=newFile("c:\\abc","b.txt");

        將文件所在目錄路徑和文件一起傳入，指定文件路徑。

 方式三：

            File d=new File("c:\\abc");

             File f3=new File(d,"c.txt");

        將文件目錄路徑封裝成對象。再創建文件對象。降低了文件於父目錄的關聯性。

小知識：

        File.separator表示目錄分隔符，可以跨平臺使用。相當於路徑中的“\”（雙斜槓\\在windows中表示表示轉義後的分隔符，但是在linux系統中就不是）。

 

三、File類的常見方法

1、創建

        booleancreateNewFile();

        //在指定位置創建文件，如果該文件已經存在，則不創建，返回false。和輸出流不一樣，輸出流對象一建立就創建文件。而且文件已經存在，會覆蓋。

        boolean mkdir();//創建文件夾，只能創建一級文件夾

例：

        File dir=new File("abc");

        dir.mkdir();//創建abc這個文件夾

        boolean mkdirs();//創建多級文件夾

2、刪除

        boolean delete();

        //刪除文件或目錄。文件存在，返回true；文件不存在或者正在被執行，返回false。    

        void deleteOnExit();//在程序退出時刪除指定文件

3、判斷

        boolean canExecute();//是否是可執行文件

        boolean exists();//文件是否存在

        boolean isFile();//是否是文件

        boolean isDirectory();//是否是文件夾

        boolean isHidden();//是否是隱藏文件

        boolean isAbsolute();//文件是否是絕對路徑

記住：在判斷文件對象是否是文件或者目錄時，必須要判斷該文件對象封裝的內容是否存在。通過exists判斷。

4、獲取信息

        String getName();//獲取文件名

        String getPath();

        //獲取文件的相對路徑（即創建的對象傳入的參數是什麼就獲取到什麼）

        String getParent();

        //獲取文件父目錄。返回的是絕對路徑中的父目錄。如果獲取的是相對路徑，返回null。如果相對路徑中有上一層目錄，那麼該目錄就是返回結果。

        String getAbsolutePath();//獲取文件的絕對路徑      

        long lastModified();//返回文件最後一次被修改的時間

        long length();//返回文件長度

5、列出文件及文件過濾

        static File[] listRoots();//列出可用的文件系統根目錄，即系統盤符

        String[] list();

        //列出當前目錄下所有文件，包括隱藏。調用list方法的file對象必須是封裝了一個目錄。該目錄還必須存在。

        String[]list(FilenameFilter filter);

        //返回一個字符串數組，獲取目錄中滿足指定過濾器的文件或目錄。

        //FilenameFilter：文件名過濾器，是一個接口，其中包含一個方法，accept(Filedir,String name)，返回的是boolean型，對不符合條件的文件過濾掉。

        File[] listFiles();//返回一個抽象路徑名數組，獲取當前文件夾下的所有文件和文件夾

        File[] ListFiles(FilenameFilterfilter);//返回抽象路徑名數組，獲取目錄中滿足指定過濾器的文件或目錄。

四、遞歸

1、定義

       當函數內每一次循環還可以調用本功能來實現，也就是函數自身調用自身。這種表現形式，或者編程手法，稱爲遞歸。

2、遞歸注意事項

        a、限定條件。是來結束循環調用，否則是死循環。

        b、注意遞歸的次數，儘量避免內存溢出。因爲每次調用自身的時候都會先執行下一次調用自己的方法，所以會不斷在棧內存中開闢新空間，次數過多，會導致內存溢出。

示例一

/*
需求：列出指定目錄下文件或文件夾，包含子目錄，即列出指定目錄下所有內容（帶層次的）。

分析，因爲目錄中還有目錄，只有使用同一個列出目錄功能的函數完成即可，在列出過程中出現的還是目錄的話，還可以再調用本功能，這就是利用遞歸原理。

*/
import java.io.*;
class  RecursionDemo
{
    public static void main(String[] args)
    {
        //關聯指定路徑
        File dir=new File("e:\\Java Study\\Practice");

        //列出關聯路徑中所有的.java文件
        allFileList(dir,0);
    }

    //列出指定目錄下的所以內容
    public static void allFileList(File dir,int level)
    {
        //有層次的輸出
        System.out.println(getLevel(level)+dir);
        level++;
        File[] fileArr=dir.listFiles();//獲取本目錄下的所以文件和目錄的抽象路徑

        //遍歷
        for (File file : fileArr)
        {
            if(file.isDirectory())
            {
                //如果目錄下還是目錄，則繼續調用本函數
                allFileList(file,level);
            }
            else
                System.out.println(getLevel(level)+file);//顯示（列出）文件
        }
    }

    //帶層次的列表
    public static String getLevel(int level)
    {
        StringBuilder sb=new StringBuilder();
        sb.append("|--");
        //每多一級目錄，就多輸出指定字符
        for (int x=level;x>0 ; x--)
        {
            //sb.append("|--");
            sb.insert(0,"|  ");
        }
        return sb.toString();
    }
}

 

第二講      Properties類

一、概述

1、Properties是Hashtable的子類，它具備Map集合的特點。而且它裏面還有存儲的鍵值對，都是字符串，無泛型定義。是集合中和IO技術想結合的集合容器。

2、特點：

        1）可用於鍵值對形式的配置文件

        2）在加載時，需要數據有固定的格式，常用的是：鍵=值

 

二、特有方法

1、設置

        Object setProperty(String key,String value);

        //設置鍵和值，調用Hashtable的方法put

2、獲取

        String getProperty(String key);

        //指定key搜索value

        Set<String> stringPropertyName();

        //返回屬性列表的鍵集，存入Set集合

3、加載流和存入流

        void load(InputStream ism);

        //從輸入字節流中讀取屬性列表（鍵和元素對）。又稱將流中的數據加載進集合。

        void load(Readerreader);

        //從輸入字符流中讀取屬性列表（鍵和元素對）。又稱將流中的數據加載進集合。

        voidlist(PrintStream out);//將屬性列表輸出到指定的輸出流

        void store(OutputStreamout,String comments);

        //對應load(InputStream )將屬性列表（鍵值對）寫入輸出流。comments屬性列表的描述。

        void store(Writerwriter, String comments);

        //對應load(Reader)將屬性列表（鍵值對）寫入輸出流。comments屬性列表的描述。

練習：

/*
練習：用於記錄應用程序運行次數。如果使用次數已到，那麼給出註冊提示。

分析：
很容易想到的是：計數器。可是該計數器定義在程序中，隨着該應用程序的退出，該計數器也在內存中消失了。
所以要建立一個配置文件，用於記錄該軟件的使用次數。該配置文件使用鍵值對的形式。鍵值對數據是map集合。數據是以文件形式存儲。使用io技術。那麼map+io——>Properties。

思路：1、用讀取流關聯文本信息文件。如果存在則讀取，如果不存在，則創建
      2、每次運行，將文件數據存入集合中，讀取值，判斷次數，如果小於等於5次，則次數增加1次，如果大於則輸出提示信息。
      3、將值小於等於5次的信息數據存入文件中
*/
import java.util.*;
import java.io.*;

class  RunCount
{
    public static void main(String[] args)throws IOException
    {
        int count=runCount();
        if(count>5)//如果程序被使用了超過5次，則終止使用，並提示
        {
            System.out.println("次數到了，交錢！！！！！");
            return ;
        }
        else
            System.out.println("程序第"+count+"次Run！");
    }
    //獲取程序運行的次數
    public static int runCount()throws IOException
    {
        Properties ps=new Properties();//創建集合對象

        File file=new File("info.ini");//將文件進行封裝
        if(!file.exists())//判斷是否存在
            file.createNewFile();
        FileReader fr=new FileReader(file);//將文件於讀取流進行關聯

        ps.load(fr);//加載流中的文件數據到集合中

        int count=0;//定義計數器
        String value=ps.getProperty("time");//獲取次數值

        if(value!=null)//如過值不等於null，則將其賦值給count
        {
            count=Integer.parseInt(value);
        }
        count++;//每啓動一次自增
        ps.setProperty("time",count+"");//將次數記錄住集合

        FileWriter fw=new FileWriter(file);
        ps.store(fw,"");//將集合中的數據存入硬盤文件中

        fr.close();//關流
        fw.close();

        return count;//返回程序啓動的次數
    }
}

 

第三講    打印流

一、概述

        1、打印流包括：PrintStream和PrintWriter

        2、該流提供了打印方法，可將各種類型的數據都原樣打印。

 

二、字節打印流：PrintStream

構造方法中可接收的參數類型：

        1、File對象。File

        2、字符串路徑：String

        3、字符輸出流：OutputStream

 

三、字符串打印流：PrintWriter

構造方法中可接受的參數類型

        1、File對象：File

        2、字符串路徑：String

        3、字節輸出流：OutputStream

        4、字符輸出流：Writer

示例

import java.io.*;

class  PrintStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        //鍵盤錄入
        BufferedReader bufr =
            new BufferedReader(new InputStreamReader(System.in));

        //打印流關聯文件，自動刷新
        PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))//結束字符
                break;
            out.println(line.toUpperCase());
            //out.flush();
        }

        //關流
        out.close();
        bufr.close();

    }
}

 

第四講    序列流

一、概述

1、SequenceInputStream對多個流進行合併。也被稱爲合併流。

2、常用構造函數

        SequenceInputStream(Enumeration<?extends FileInputStream> e)

 

二、常見合併多個流文件步驟

        1、創建集合，並將流對象添加進集合

        2、創建Enumeration對象，將集合元素加入。

        3、創建SequenceInputStream對象，合併流對象

        4、創建寫入流對象，FileOutputStream關聯寫入文件

        5、利用SequenceInputStream對象和FileOutputStream對象讀數據進行反覆讀寫操作。

練習：

/*
切割文件
需求：將一個mp3文件按1M大小切割成幾部分
思路：1、使用文件字節流關聯mp3文件
      2、定義一個容器存儲1M大小的數據，當存儲滿時，寫入一個新文件中

*/
import java.util.*;
import java.io.*;

class  SplitFile
{
    public static void main(String[] args) throws IOException
    {
        //指定要切割的文件
        File file=new File("C:\\Users\\asus\\Desktop\\蘇芮 - 一樣的月光.mp3");
        //將指定文件進行切割
        splitFile(file);

        //指定要合併到的文件
        File file1=new File("E:\\Java Study\\Practice\\day20\\splitFile\\一樣的月光.mp3");
        //將部分文件進行合併指定文件中
        merge(file1);

    }
    //接收一個文件，將其按1M大小進行切割
    public static void splitFile(File file)throws IOException
    {
        //關聯要切割的文件
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));

        BufferedOutputStream bos=null;

        //定義1M大小存儲容器
        byte[] buf=new byte[1024*1024];
        int len=0,x=0;
        while ((len=bis.read(buf))!=-1)
        {
            //每滿1M就寫入一個新文件中
            bos=new BufferedOutputStream(new FileOutputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+(++x)+".part"));
            bos.write(buf,0,len);
            bos.close();//沒寫完一個文件要記得關流
        }
        //關流
        bis.close();
    }

    //將部分文件合併爲一個可執行文件
    public static void merge(File file)throws IOException
    {
        //定義一個集合存儲這些部分文件關聯路徑數據
        ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();

        for (int x=1;x<=6 ; x++)
        {
            al.add(new FileInputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+x+".part"));
        }

        //因爲Enumeration是Vector特有的迭代方法，所以這裏創建一個Enumeration類型的匿名內部類
        final  ListIterator<FileInputStream> it=al.listIterator();
        Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()
        {
            public boolean hasMoreElements()
            {
                return it.hasNext();
            }

            public FileInputStream nextElement()
            {
                return it.next();
            }
        };

        //關聯枚舉對象
        SequenceInputStream sis=new SequenceInputStream(en);

        //將合併的文件數據寫入指定文件中
        FileOutputStream fos=new FileOutputStream(file);

        //定義臨時存儲數據的數組
        byte[] buf=new byte[1024];
        int len=0;
        while((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);//寫數據
        }

        //關流
        fos.close();
        sis.close();

    }

}