黑马程序员_JavaIO流（四）

File概述

File类

• 用来将文件或者文件夹封装成对象。
• 方便对文件与文件夹的属性信息进行操作。
• 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类常见方法：

一，创建

1，boolean createNewFile()：当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。

//在指定为创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立就会创建文件。而且文件已经存在，会覆盖。

2，static File createTempFile(String prefix,String suffix):在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。

重载方法：static File createTempFile(String prefix,String suffix,File directory)：在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。

3，boolean mkdir()：创建此抽象路径名指定的目录。（创建文件夹，并且只能创建一级目录）

4，boolean mkdirs()：创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。（创建多级目录）

二，删除

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