Java基礎——IO（2）

File類

1.列出文件及文件過濾

/**
 * 練習：用String[] list(FilenameFilter filter)方法獲取一個目錄下所有的.java文件，
 * 其他文件不要。 
思路：1、FilenameFilter是一個過濾器接口，用匿名內部類傳入filter對象 
          2、複寫FilenameFilter接口的accept(File file,String name)方法，
          並判斷name是否是java文件 
          3、遍歷String類型數組 

 */
import java.io.File;
import java.io.FilenameFilter;

public class Test1 {

    public static void main(String[] args) {
        File file = new File("F:\\java");
        getJavaList(file);

    }

    private static void getJavaList(File file) {
        //傳入FilenameFilter匿名內部類子類對象，並複寫accept方法  
        String s[] = file.list(new FilenameFilter() {

            @Override
            public boolean accept(File dir, String name) {
                //判斷文件名是否是以.java結尾  
                return name.endsWith(".java");
            }
        });
        System.out.println("文件長度："+file.length());
        for(String ss : s ){
            System.out.println(ss);
        }
    }
}

2.獲取信息

3.創建

遞歸

練習一：

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

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

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

        //列出關聯路徑中所有的.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)
        {
            //isDirectory() ：測試此抽象路徑名錶示的文件是否是一個目錄。
            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();
    }
}

練習二：

/*
刪除一個帶內容的目錄。
刪除原理：
在windows中，刪除目錄從裏面往外面刪除的。
既然是從裏往外刪除。就需要用到遞歸。

*/
import java.io.*;
public class RemoveDir 
{
    public static void main(String[] args) 
    {
        //指定目錄
        File dir=new File("f:\\1");
        //刪除目錄
        removeDir(dir);

    }

    //刪除傳入目錄
    public static void removeDir(File dir)
    {
        File[] files=dir.listFiles();//列出目錄下的所以文件和文件夾
        //遍歷
        for (File file : files )
        {
            //如果還是目錄且非隱藏
            if(!file.isHidden()&&file.isDirectory())
                removeDir(file);//繼續刪除目錄裏的內容
            else
                System.out.println(file.toString()+":-file-:"+file.delete());//刪除文件
        }
        System.out.println(dir+":::dir:::"+dir.delete());//刪除目錄
    }
}

練習三：

/*
練習：
將一個指定目錄下的java文件的絕對路徑，存儲到一個文本文件中。建立一個java文件列表的文件。
思路：
     1、對指定的目錄進行遞歸。
     2、獲取遞歸過程所有的java文件的路徑。
     3、將這些路徑存儲到集合中。
     4、將集合中的數據寫入到一個文件中。
*/
import java.util.*;
import java.io.*;

public class  JavaFileList
{
    public static void main(String[] args) 
    {
        //指定目錄
        File dir=new File("F:\\java");

        //定義一個List集合，用於存儲.java文件的File對象
        List<File> list =new ArrayList<File>();

        //調用獲取文件路徑方法
        fileToList(dir,list);

        //指定寫入文件
        File file=new File(dir,"javafilelist.txt");
        //調用寫入文件方法
        writeToFile(list,file);

    }
    //獲取指定文件夾內的所有java文件的絕對路徑，並存入集合中
    public static void fileToList(File dir,List<File> list)
    {
        File[] files=dir.listFiles();//列出dir路徑下的所以文件和目錄，
        //遍歷
        for (File file : files)
        {
            //如果是目錄，則繼續獲取
            if(file.isDirectory())
            {
                list.add(file.getAbsoluteFile());//把父目錄路徑也存入
                fileToList(file,list);
            }
            //將是.java文件的絕對路徑存入
            else if(file.getName().endsWith(".java"))
                list.add(file);
        }
    }

    //將集合中元素寫入到一個文本文件中
    public static void writeToFile(List<File> list,File file)
    {

        BufferedWriter bw=null;

        try
        {   //使用字符流緩衝區對象關聯寫入的文件
            bw=new BufferedWriter(new FileWriter(file));
            for (File file0 : list )
            {
                bw.write(file0.getAbsolutePath());//寫入
                bw.newLine();//換行
                bw.flush();//刷新
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("寫入文件失敗");
        }
        finally
        {
            try
            {
                if(bw!=null)
                    bw.close();//關流
            }
            catch (IOException e)
            {
                throw new RuntimeException("流資源關閉失敗");
            }
        }
    }
}

Properties類

概述：

他是一個鍵值對形式，常用作配置文件。

最有特點的方法：

可以直接將鍵值對放到輸入輸出流之中

還可以放置到XML文件中

練習1:

//演示，如何將流中的數據存儲到集合中。
    //想要將info.txt中鍵值數據存到集合中進行操作。
    /*
        1,用一個流和info.txt文件關聯。
        2，讀取一行數據，將該行數據用"="進行切割。
        3，等號左邊作爲鍵，右邊作爲值。存入到Properties集合中即可。

    */
        //將文件數據存儲進Properties集合方法
public class Test2{
    public static void main(String[] args) throws IOException {
        method();
    }
    public static void method()throws IOException
    {
        //使用字符讀取緩衝流關聯文件
        BufferedReader bufr = new BufferedReader(new FileReader("d:\\info.txt"));

        String line = null;
        //定義Properties集合
        Properties prop = new Properties();

            while((line=bufr.readLine())!=null)
        {
            String[] arr = line.split("=");//將一行數據以“=”號進行分割
            //將=左邊作爲鍵存入，將=右邊作爲值存入
            prop.setProperty(arr[0],arr[1]);
        }

        bufr.close();//關流

        System.out.println(prop);
    }
}

打印流

一、概述

    1、打印流包括：PrintStream和PrintWriter

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

二、字節打印流：PrintStream

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

    1、File對象。File

    2、字符串路徑：String

    3、字符輸出流：OutputStream

三、字符串打印流：PrintWriter

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

    1、File對象：File

    2、字符串路徑：String

    3、字節輸出流：OutputStream

    4、字符輸出流：Writer

序列流

一、概述

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

SequenceInputStream 表示其他輸入流的邏輯串聯。它從輸入流的有序集合開始，並從第一個輸入流開始讀取，直到到達文件末尾，接着從第二個輸入流讀取，依次類推，直到到達包含的最後一個輸入流的文件末尾爲止。 

2、常用構造函數

    SequenceInputStream(Enumeration<?extends FileInputStream> e)

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

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

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

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

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

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

P.S

import java.io.*;

import java.util.*;

public class SequenceInputStreamDemo {
    public static void main(String[] args) throws Exception {

        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for (int x = 1; x <= 3; x++) {
            al.add(new FileInputStream("d:\\IO\\"+x + ".txt"));
        }

        final Iterator<FileInputStream> it = al.iterator();

        Enumeration<FileInputStream> en = Collections.enumeration(al);
        /*
         * //Collections工具類的enumeration方法核心代碼：
         *  Enumeration<FileInputStream> en =
         * new Enumeration<FileInputStream>(){ public boolean hasMoreElements(){
         * return it.hasMoreElements(); 
         * }
         * 
         * public FileInputStream nextElement(){ return it.next(); } 
         * };
         */

        SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("d:\\IO\\4.txt");

        byte[] buf = new byte[1024];

        int len = 0;

        while ((len = sis.read(buf)) != -1) {
            fos.write(buf, 0, len);
        }

        fos.close();
        sis.close();
    }
}

Serializable序列化接口

主要用於類的流操作

例：
將一個常規的類對象序列化的obj.object文件對象中去

public class ObjectStreamDemo {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        writeObj();
        readObj();
    }

    public static void readObj() throws IOException, ClassNotFoundException {

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\obj.object"));
        //對象的反序列化。 
        Person p = (Person)ois.readObject();

        System.out.println(p.getName()+":"+p.getAge());

        ois.close();

    }

    public static void writeObj() throws IOException, IOException {

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:\\obj.object"));
        //對象序列化。  被序列化的對象必須實現Serializable接口。 
        oos.writeObject(new Person("小強",30));

        oos.close();

    }

}