黑馬程序員_JavaIO流（四）

時間 2019-12-11

原文原文鏈接

File概述

File類java

用來將文件或者文件夾封裝成對象。
方便對文件與文件夾的屬性信息進行操做。
File對象能夠做爲參數傳遞給流的構造函數。
瞭解File類中的經常使用方法。

字段：static String separator：與系統有關的默認名稱分隔符，爲了方便，它被表示爲一個字符串。編程

import java.io.*;

class FileDemo
{
    poblic static void main(String[] args)
    {
        
    }

    //建立File對象。
    public static void consMethod()
    {
        //將a.txt封裝成對象，能夠將已有的和未出現的文件或者文件夾封裝成對象。
        File f1 = new File("a.txt");

        //
        File f2 = new File("c:\\abc","b.txt");
        //好處在於new File("c:\\abc",str);操做的目錄不變，而操做的文件是變化的，可隨意更改。

        File d = new File("c:\\abc");
        Fiel f3 = new File(d,"c.txt");

        sop("f1":f1)://封裝的是相對路徑，打印的就是相對路徑。
        sop("f2":f2)://打印的是文件的絕對路徑
        sop("f3":f3):

        File f4 = new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"a.txt");//能夠實現跨平臺。
    }
}

File對象功能-建立和刪除，判斷和獲取，文件列表

File類常見方法：windows

一，建立數組

1，boolean createNewFile()：當且僅當不存在具備此抽象路徑名指定名稱的文件時，不可分地建立一個新的空文件。app

//在指定爲建立文件，若是該文件已經存在，則不建立，返回false。和輸出流不同，輸出流對象一創建就會建立文件。並且文件已經存在，會覆蓋。ide

2，static File createTempFile(String prefix,String suffix):在默認臨時文件目錄中建立一個空文件，使用給定前綴和後綴生成其名稱。函數

重載方法：static File createTempFile(String prefix,String suffix,File directory)：在指定目錄中建立一個新的空文件，使用給定的前綴和後綴字符串生成其名稱。測試

3，boolean mkdir()：建立此抽象路徑名指定的目錄。（建立文件夾，而且只能建立一級目錄）ui

4，boolean mkdirs()：建立此抽象路徑名指定的目錄，包括全部必需但不存在的父目錄。（建立多級目錄）spa

二，刪除

1，boolean delete()：刪除此抽象路徑名錶示的文件或目錄。

2，void deleteOnExit()：在虛擬機終止時，請求刪除此抽象路徑名錶示的文件或目錄。//在退出（或在程序運行發生異常）時刪除指定垃圾文件。

三，判斷

1，boolean canExecute()：（可執行）測試應用程序是否能夠執行此抽象路徑名錶示的文件。

2，boolean canRead()：（可讀）測試應用程序是否能夠讀取此抽象路徑名錶示的文件。

3，boolean canWrite()：（可寫）測試應用程序是否能夠修改此抽象路徑名錶示的文件。

4，int compareTo(File pathname)：按字母順序比較兩個抽象路徑名。

5，boolean exists()：測試此抽象路徑名錶示的文件或目錄是否存在。

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

6，boolean isDirectory()：測試此抽象路徑名錶示的文件是不是一個目錄。

7，boolean isFile()：測試此抽象路徑名錶示的文件是不是一個標準文件。

8，boolean isHidden()：測試此抽象路徑名指定的文件是不是一個隱藏文件。

9，boolean isAbsolute()：測試此抽象路徑名是否爲絕對路徑名。

四，獲取信息

1，String getName()：返回由此抽象路徑名錶示的文件或目錄的名稱。

2，String getPath()：將此抽象路徑名轉換爲一個路徑名字符串。

3，String getParent()：返回此抽象路徑名父目錄的路徑名字符串；若是此路徑名沒有指定父目錄，則返回 null。//若是相對路徑中有上一層目錄，那麼該目錄就是返回結果。

4，String getAbsolutePath()：返回此抽象路徑名的絕對路徑名字符串。

5，long lastModifide()：返回此抽象路徑名錶示的文件最後一次被修改的時間。

6，long length()：返回由此抽象路徑名錶示的文件的長度。

7，boolean renameTo(File dest)：從新命名此抽象路徑名錶示的文件。（重命名/剪切）

8，static File[] listRoots()：列出可用的文件系統根。（不操做具體的特有數據）

9，String[] list()：返回一個字符串數組，這些字符串指定此抽象路徑名錶示的目錄中的文件和目錄。（列出當前目錄全部文件，包含隱藏文件）調用list方法的File對象必須是封裝了一個目錄。該目錄必須存在。

10，String[] list(FilenameFilter filter)：返回一個字符串數組，這些字符串指定此抽象路徑名錶示的目錄中知足指定過濾器的文件和目錄。（注意此方法使用匿名內部類）此list方法是依據接口FilenameFilter的accept方法的返回值來斷定是不是須要過濾的文件。

11，File[] listFiles()：返回一個抽象路徑名數組，這些路徑名錶示此抽象路徑名錶示的目錄中的文件。

12，File[] listFiles(FileFilter filter)：返回抽象路徑名數組，這些路徑名錶示此抽象路徑名錶示的目錄中知足指定過濾器的文件和目錄。//此方法返回的File對象，可經過對象獲取更多信息，比返回字符串更經常使用。

【booean accept(File pathname)：測試指定抽象路徑名是否應該包含在某個路徑名列表中。】

13，File[] listFiles(FilenameFilter filter)：返回抽象路徑名數組，這些路徑名錶示此抽象路徑名錶示的目錄中知足指定過濾器的文件和目錄。

【boolean accept(File dir,String name)：測試指定文件是否應該包含在某一文件列表中。】

列出目錄下全部內容-遞歸

列出指定目錄下文件或者文件夾，包含子目錄中的內容。也就是列出指定目錄下全部內容。

由於目錄中還有目錄，只要使用同一個列出目錄功能的函數完成便可。在列出過程當中出現的仍是目錄的話，還能夠再次調用本功能。也就是函數自身調用自身。這種表現形式，或者編程手法，稱爲遞歸。

遞歸要注意：

1，限定條件。

2，要注意遞歸的次數，儘可能避免內存溢出。

import java.io.*;

class FileDemo3
{
    public static void main(String[] args)
    {
        File dir = new File("d:\\java1223");
        showDir(dir);
    }

    public static void showDir(File dir)
    {
        System.out.println(dir);
        File[] files = dir.listFiles();
        for(int x = 0; x<files.length; x++)
        {
            if(files[x].isDirectory())
                showDir(files[x]);
            else
                System.out.println(files[x]);
        }
    }
}

遞歸演示：二進制

public static coid toBin(int num)
{
    if(num>0)
    {
        toBin(num/2);
        System.out.println(num%2);//結果爲110
    }
}

求和:

public static int getSum(int n)
{
    if(n==1)
        return 1;
    return n+getSum(n-1);//會致使內存溢出。此方法在運算的過程當中，重複調用本身，在棧內存中不停開闢空間，超出內存的範圍。
}

列出目錄下全部內容-帶層次

import java.io.*;

class FileDemo3
{
    pubilc static void main(String[] args)
    {

    }

    public static String getLevel(int level)
    {
        StringBuilder sb = new StringBuilder();

        sb.append("|--");

        for(int x= 0;x<level;x++)
        {
            //sb.append("|--");
            sb.insert(0,"|  ");//只在文件前有"--"，其他的都不要。    
        }
        return sb.toString();    
    }

     public static void showDir(File dir,int level)
    {
        System.out.println(getLevel(level)+dir.getName());
        level++;//，每調用一次，級別增長一層。

        File[] files = dir.listFiles();
        for(int x=0;x<files.length;x++)
       {
            if(files[x].isDirectory())
                showDir(files[x],level)
            else
                System.out.println(getLevel(level),files[x]);
        }
    }
}

刪除帶內容的目錄

刪除原理：在windows中，刪除目錄從裏面往外刪除的。既然是從裏往外刪除，就須要用到遞歸。

import java.io.*;

class ReomveDir
{
    public static void main(String[] args)
    {
        File dir = new File("d:\\testdir");
        removeDir(dir);
    }

    public static void removeDir(File dir)
    {
        File[] files = dir.listFiles();
        for(int x=0;x<files.length;x++)
        {
            if(files[x].isDirectory())
                removeDir(files[x]);
            else
               System.out.println(files[x].toString()+"::files::"+files[x].delete());
        }
        System.out.println(dir+"::dir::"+files[x].delete());
    }
}

建立Java文件列表

練習：

將一個指定目錄下的Java文件的絕對路徑，存儲到一個文本文件中，創建一個Java文件列表文件。

思路：

1，對指定的目錄進行遞歸。

2，獲取遞歸過程全部的Java文件的路徑。

3，將這些路徑存儲到集合中。

4，將集合中的數據寫入到一個文件中。

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

class JavaFileList
{
    public static void main(String[] args)
    {
        File dir = new File("d:\\java1223");
        List<File> list = new ArrayList<File>();
        fileToList(dir,list);

        File file = new File(dir,"javalist.txt");
        writeToFile(list,file.toString());
    }

    pubilic static void fileToList(File dir,List<File> list)
    {
        File[] fiels = dir.listFiles();
        for(File file:files)
        {
            if(file.isDirectory())
                fielToList(file,list)
            else
            {
                if(files.getName().endWith(".java"))
                    list.add(file);
            }    
         }
    }

    public static void writeToFile(List<File> list,String javaListFile)throws IOException;
    {
        BufferedWriter bufw = null;

        try
        {
            bufw =  new BufferedWriter(new FileWriter(javaListFile));
        
            for(File f : list)
            {
                String path = f.getAbsolutePath();
                bufw.write(path);
                bufw.newLine();
                budw.flush();
            }
        }
        catch(IOException e)
        {
            throw e;
        }
        finally
        {
            try
            {
                if(bufw!=null)
                    bufw.close();  
            }
            catch(IOException e)
            {
                throw e;
            }
        }
    }
}

Properties簡述

Properties是hashtable的子類，也就是說它具有map集合的特色，並且它裏面存儲的鍵值對都是字符串。是集合中和IO技術相結合的集合容器。

該對象的特色：能夠用於鍵值對形式的配置文件。

Properties存取

方法：

1，String getProperty(String key):用指定的鍵在此屬性列表中搜索屬性。

2，String getProperty(String key,String defaultValue):用指定的鍵在屬性列表中搜索屬性。

3，void list(PrintStream out)：將屬性列表輸出到指定的輸出流。

4，void list(PrintWrite out)：將屬性列表輸出到指定的輸出流。

5，void load(InputStream inStream)：從輸入流中讀取屬性列表（鍵和元素對）。

6，void load(Reader reader)：按簡單的面向行的格式從輸入字符流中讀取屬性列表（鍵和元素對）。

7，Object setProperty(String key,String value)：調用 Hashtable 的方法 put。

8，Set<String> stringPropertyNames()：返回此屬性列表中的鍵集，其中該鍵及其對應值是字符串，若是在主屬性列表中未找到同名的鍵，則還包括默認屬性列表中不一樣的鍵

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

class PropertiesDemo
{
    public static void main(String[] args)
    {
        setAndGet();     
    }

    //設置和獲取元素
    public static void setAndGet()
    {
        Properties prop = new Properties();

        prop.setProperty("zhangsan","30");
        prop.setProperty("lisi","39");

        //System.out.println(prop);

        String value = prop.getProperty("lisi");
       // System.out.println(value);

        //修改
        prop.setProperty("lisi",89+"");

        Set<String> names = prop.stringPropertyNames();
        for(String s : names)
        {
            System.out.println(s+":"+prop.getProperty(s));
        }
    }
}

Properties存取配置文件

//演示：如何將流中的數據存儲到集合中。想要將info.txt中鍵值數據存儲到集合中進行操做。

//在加載數據時，須要數據有固定格式：鍵=值。

思路：

1，用一個流和info.txt文件相關聯。

2，讀取一行數據，將改行數據用「=」進行切割。

3，等號左邊做爲鍵，右邊做爲值，存入到Properties中便可。

//至關於load()方法原理。

public static void method_1()throws IOException
{
    BufferedReader bufr = new BufferedRader(new FileReader("info.txt"));

    String line = null;

    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);    
}

使用Properties中的方法：

public static void loadDemo()throws IOException
{
    Properties prop = new Properties();
    FileInputStream fis = new FileInputStream("info.txt");

    //將流中的數據加載進集合。
    prop.load(fis);

    //只做修改，不做保存。
    prop.setProperties("wangwu","39");

    FileOutputStream fos = new FileOutputStream("info.txt");
    //修改後做保存。
    prop.store(fos,"haha");
    
    prop.list(System.out);

    fos.close();
    fis.close();
}

Properties練習

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

很容易想到的是：計數器。但是該計數器定義在程序中，隨着程序的運行而在內存中存在，並進行自增。但是隨着該應用程序的退出，該計數器也在內存中消失了。下一次再啓動該程序時，又從新開始從0計數，這樣不是咱們想要的。

程序即便結束，該計數器的值也存在，下次程序啓動會先加載該計數器的值並加1後再從新存儲起來。

因此要創建一個配置文件，用於記錄該軟件的使用次數。該配置文件使用鍵值對的形式，這樣便於閱讀數據，並操做數據。

鍵值對數據是map集合，數據是以文件形式存儲，使用io技術。那麼map+io -->properties。配置文件能夠實現應用程序數據的共享。

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

class RunCount
{
    public static void main(String[] args)throws IOException
    {
        Properties prop = new Properties();
        File file = new File("count.ini");
        if(!file.exists())
            file.creatNewFile();

        FileInputStream fis = new FileInputStream(fiel);

        prop.load(fis);

        int count = 0;

        String value = prop.getProperty("time");

        if(value!=null)
        {
            count = Integer.perseInt(value);
            if(count>=5)
            {
                System.out.println("您好！使用次數已到，拿錢！");
                return;
             }
        }

        count++;

        prop.setProperty("time",count+"");

        FileOutputStream fos = new FileOutputStream(file);

        prop.store(fos,"");

        fos.close();
        fis.close();
    }
}

PrintWriter

1，打印流：PrintWriter和PrintStream，能夠直接輸入流和文件。（該流提供了打印方法，能夠將各類數據類型都原樣打印。

　　字節打印流：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)
    {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in)); 

        PrintWrtier out = new PrintWriter(System.out,true);
        //PrintWrtier out = new PrintWriter("a.txt");//不刷新
        //PrintWrtier out = new PrintWriter(new FileInputStream("a.txt"),true);//用流封裝文件

        String line = null;

        while((line=bufr.readline())!=null)
        {
            if("over".equals(line))
                break;
            out.println(linetoUpperCase());
            //out.flush();
        } 

        out.close();
        bufr.close();   
    }
}

合併流

2，序列流：SequenceInputStream(Enumeration<? extends FileInputStream> en):對多個流進行合併。

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

class SequenceDemo
{
    public static void main(String[] args)throws IOException
    {
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        v.add(new FileInputStream("c:\\1.txt"));
        v.add(new FileInputStream("c:\\2.txt"));
        v.add(new FileInputStream("c:\\3.txt"));

        Enumeration<FileInputStream> en = v.elements();

        SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = newFileOutputStream("c:\\4.txt");

        byte[] buf = new bute[1024];

        int len = 0;

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

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

切割文件

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

class SplitFile
{
    public static void main(String[] args)throws IOException
    {
        //splitFile();
        merge();
    }

    public ststic void merge()throws IOException
    {
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

        for(int x=1;x<=3;x++)
        {
            al.add(new FileInputStream("c:\\splitsfiles\\"+x+".part"));
        }

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

        Enumeration<FileInputStream> en = newEnumeration<FileInputStream>()
        {
            public boolean hasMoreElements()
            {
                return it.hasNext();
            }

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

        SequenceInputStream sis = new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bnp");

        byte[] buf = new bute[1024];

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

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

    public static void splitFile()
    {
        FileInputStream fis = new FileInputStream("c:\\1.bmp");

        FileOutputStream fos = null;

        byte[] buf = new byte[1024*1024];

        int len = 0;
        int count = 1;

        while((len = fis.read(buf))!=-1)
        {
            fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
            fos.write(buf,0,len);
            fos.close();
        }
        fis.close();
    }
}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。