转--黑马程序员-Java学习笔记（File）

File类：

import java.io.*;

class FileDemo

{

    public static void main(String [] args)

    {

        consMethod();

    }

    public static void consMethod()

    {

        //将a.txt封装成File对象，可以将已有的和未出现的文件或者文件夹封装成对象

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

 

        //目录和文件分开

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

 

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

        File f3 = new File(d,"c.txt");// File(String parent, String child)

 

        System.out.println("f1:"+f1);

        System.out.println("f2:"+f2);

        System.out.println("f3:"+f3);

 

        //File.separator是与系统有关的默认名称分隔符，可以跨系统运行

        File f4 = new File("c:"+File.separator+"abc"+File.separator+"d.txt");

        System.out.println("f4:"+f4);

    }

}

打印结果如下：

File类的常见方法：

/*

File常见方法：

1.创建

    boolean    createNewFile();

    在指定位置创建文件，创建成功，返回True，如果该文件已存在，则不能创建，返回false

    和输出流不一样，输出流不管文件是否已经存在，都会创建文件

    public static void create_method() throws IOException

    {

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

        boolean bl = f1.createNewFile();

        System.out.println("create： " + bl);

    }

    

    创建文件夹：

boolean mkdir();//创建一层目录

boolean mkdirs();//创建多层目录

    public static void create_directory()

    {

        File f4 = new File("d.txt");    

 

        File dir = new File("abc");

        System.out.println("mkdir: " + dir.mkdir());//只能创建一级目录,成功，返回true

 

        File dir2 = new File("abc\\def\\dsa");

        System.out.println("mkdir: " + dir2.mkdir());//多层目录不能创建返回false

        System.out.println("mkdir: " + dir2.mkdirs());//可以创建多重目录，返回true

    }

打印结果：

 

 

2.删除

    boolean delete();删除失败返回false

    void deleteOnExit();在程序退出时删除指定文件

    public static void delete_method() throws IOException

    {

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

        File f2 = new File("b.txt");

        f1.deleteOnExit();//在程序退出的时候将文件删除

 

        boolean bl1 = f1.delete();

        boolean bl2 = f2.delete();

 

        System.out.println("delete： " + bl1);//文件存在，删除成功，返回true

        System.out.println("delete： " + bl2);//文件不存在，删除失败，返回false

    }

输出结果：

 

 

3.判断

    boolean canExecute();    //判断文件是否可执行

    boolean canRead();    //判断文件是否可读

    boolean canWrite();    //判断文件是否可写

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

    boolean isFile();    //要先用exists()判断文件的封装对象是否存在

    Boolean isDirectory();     //要先用exists()判断文件的封装对象是否存在

    boolean isHidden();    //判断文件是否隐藏

    boolean isAbsolute();    //判断路径名是否是绝对路径

 

    public static void file_or_directory()throws IOException

    {

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

        

        f.creatNewFile();

        //注意！在判断文件对象是文件或者目录时，必须要先判断文件对象封装的内容是否存在

        //通过exists判断

        if(f.exists())

        {

            System.out.println("dir: " + f.isDirectory());

            System.out.println("File: " + f.isFile());

        }

 

    }

 

 

4.获取信息

String    getName();

    String    getPath();

    String    getParent();

    String    getAbsolutePath();

    long    lastModified();

    long    length();

 

    public static void getInfoDemo() throws IOException

    {

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

        //不管文件存不存在，都可以打印路径

 

        System.out.println("path = " + f.getPath());//返回相对路径

        System.out.println("abspath = " + f.getAbsolutePath());//返回绝对路径

        System.out.println("parent = " + f.getParent());//该方法返回的是绝对路径的父目录

 

        File f1 = new File("zzz\\xx.txt");

        System.out.println("parent = " + f1.getParent());//如果相对路径中有上一层目录，那么该目录就是返回结果                

 

 

    }

打印结果：

 

boolean renameTo(File dest) 
          重新命名此抽象路径名表示的文件

    public static void renameToDemo() throws IOException

    {

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

        File fTo = new File("haha.txt");        

        System.out.println("renamTo = " + f.renameTo(fTo));//将f的文件名改为fTo的文件名

    }

*/

重点内容：

File的List 方法：

1.static File[] listRoots() 
          列出可用的文件系统根

    File[] files = File.listRoots();//返回系统的盘符

    for(File f:files)

    {

        System.out.println(f);

    }

输出结果：

 

2.String[] list() //只返回文件或者文件夹的名称

          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

        //list()方法，列出文件夹下的所有文件

        File f = new File("c:\\");

        String[] names = f.list();//调用list方法的file对象必须是封装了一个目录，该目录还必须存在

        for(String name : names)

        {

            System.out.println(name);

        }

 

3.String[] list(FilenameFilter filter)

          返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

    public static void listFilterDemo()

    {

        

        File dir = new File("D:\\Loujj\\File");

        String[] all_name = dir.list();

        System.out.println("All file :");

        for(String str:all_name)

        {

            System.out.println(str);

        }

 

 

    String[] java_files = dir.list(new FilenameFilter()//以创建匿名内部类来实现

    {    

    public boolean accept(File dir,String name)        

    {

        //打印，look look 这里的dir和name具体是什么

//从下面打印结果可以看出,dir为当前的目录，name为目录下的所有文件

        System.out.println("dir = "+dir+"...."+"name = "+name);

        return name.endsWith(".java");        

    }        

    });    

    System.out.println("Java file :");

    for(String str : java_files)

    {    

        System.out.println(str);    

    }    

    

    }

打印结果：

 

4.File[] listFiles() //返回的是文件文件夹的对象
          返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

 

    public static void listFilesDemo()

    {

        File dir = new File("d:\\");

        File[] files = dir.listFiles();

        for(File f : files)

        {

            System.out.println(f.getName()+"::"+f.length());

        }

 

    }

打印结果：可以看出，文件夹的长度为0

 

递归调用列出文件夹下所有内容，包括子文件夹和子文件夹下的文件：

    /*

    列出指定目录下文件或者文件夹，包含子目录中的内容

    也就是列出指定目录下的所有内容

 

    因为目录中还有目录，只要使用同一个列出目录功能的函数即可

    函数自身调用自身，称为递归

 

    递归要注意：

    1.限定条件

    2.要注意递归次数，避免内存溢出

    */

    public static void listAllFiles(File dir)

    {

        System.out.println(dir);

        File[] files = dir.listFiles();

        for(int i=0;i<files.length;i++)

        {

            if(files[i].isDirectory())//判断是否是文件夹

                listAllFiles(files[i]);//如果是，重新调用该函数

            else

                System.out.println(files[i]);//如果不是，则打印之

        }

        

    }

 

 

    /*

    删除一个文件夹：

    在windows中，删除目录从里面往外删除

    既然是从里往外删除，就需要用到递归

    */

    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()+"--file--"+files[x].delete());//如果是文件，就删除掉

        }

        System.out.println(dir+"--dir--"+dir.delete());//文件删除完后，开始删除文件夹

    }

删除"D:\Loujj\File\MpaTest":

 

/*

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中

建立一个java文件列表文件

 

思路：

1.对指定的目录进行递归

2.获取递归过程所有的java文件的路径

3.将这些路径存储到集合中

*/

import java.io.*;

import java.util.*;

class FileDemo2

{

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

    {

        File dir = new File("D:\\Loujj\\File\\");

        List<File> list = new ArrayList<File>();

        fileStorage(dir,list);

 

        File file = new File(dir,"javaFiles3.txt");//创建存储的目标文件

        writeToFile(list,file);        

 

    }

    public static void writeToFile(List<File> list,File javaListFile) throws IOException //将list中的java文件的绝对路径写入到目标的文件当中

    {

        BufferedWriter bufw = null;

        try

        {

            bufw = new BufferedWriter(new FileWriter(javaListFile));

            for(File f : list)

            {

                String path = f.getAbsolutePath();//得到每一项的绝对路径

                bufw.write(path);//将绝对路径写入到文件当中

                bufw.newLine();

                bufw.flush();

            }

        }

        catch (IOException e)

        {

            throw e;

        }

        finally

        {

            try

            {

                if(bufw != null)

                    bufw.close();

            }

            catch (IOException e2)

            {

                throw e2;

            }            

        }

    }

    public static void fileStorage(File dir,List<File> list)//遍历目标目录，将符合要求的文件加入到list

    {

        File[] files = dir.listFiles();

        for(File f:files)

        {

            if(f.isDirectory())

                fileStorage(f,list);

            else

            {

                if(f.getName().endsWith(".java"))//如果是java文件，就将其加入到List

                    list.add(f);

            }

        }        

    }

在本地创建的目标文本文件内的内容：

 

/*

Properties是Hashtable的子类

具备map集合的特点，里面存储的键值都是字符串

是集合中和IO技术相结合的集合容器。

该对象的特点，可以用于键值对形式的配置文件

*/

Properties的读取和设置：

Object setProperty(String key, String value) 
          调用 Hashtable 的方法 put。

String getProperty(String key) 
          用指定的键在此属性列表中搜索属性。

    //设置和获取元素

    public static void setAndGet()

    {

        Properties prop = new Properties();    //新建一个Properties

        prop.setProperty("zhangsan","30");    //存入元素

        prop.setProperty("lisi","33");

 

        System.out.println(prop);

 

        String value = prop.getProperty("zhangsan"); //读取"zhangsan"键的值

        System.out.println(value);

    

        Set<String> names = prop.stringPropertyNames(); //循环打印输出prop的值

        for(String s : names)

        {

            System.out.println(s+"::"+prop.getProperty(s));

        }

 

    }

打印结果：

 

    //将本地文件info.txt中的键值数据存到集合中的进行操作

    /*

    1.用一个流和info.txt文件关联

    2.读取以后数据，将该行数据用"="进行切割

    3.等号左边作为键，右边作为值，存入到Properties集合中

    */

    public static void fileToProperty() throws IOException

    {

        BufferedReader bufr = new BufferedReader(new FileReader("info.txt")); //新建一个流跟本地文件关联

        String line = null;

 

        Properties prop = new Properties();    //新建一个Properties保存数据

        while((line = bufr.readLine())!= null)

        {

            String arr[] = line.split(",");//将info.txt的每一行数据以"，"分割

            prop.setProperty(arr[0],arr[1]);//将左右两边的值分别存入键和值

        }

 

        System.out.println(prop);

        

    }

 

 

 

void load(InputStream inStream) 
          从输入流中读取属性列表（键和元素对）

注意：文件中的内容，键和值必须以=连接

    public static void loadDemo() throws IOException

    {

        Properties prop = new Properties();        

        FileInputStream fis = new FileInputStream("info.txt");

        prop.load(fis);

        System.out.println(prop);

    }

以逗号分割的文件，读取的结果如下：

以=分割的文件，读取结果如下：

 

void store(OutputStream out, String comments) 
          以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此Properties 表中的属性列表（键和元素对）写入输出流。

    public static void loadDemo() throws IOException

    {

        Properties prop = new Properties();        

        FileInputStream fis = new FileInputStream("info.txt");

        prop.load(fis);

        //假如现在要修改某个键值，并将其存入文件"hoho.txt"

        prop.setProperty("wangwu","19");

        FileOutputStream fos = new FileOutputStream("hoho.txt");

        prop.store(fos,"Modify Wangwu value！");//利用Properties的store方法，将prop内容存入hoho.txt

        

        System.out.println(prop);

        fis.close();

        fos.close();

    }

源文件info.txt:

 

"hoho.txt"保存的内容

控制台上输出的结果：

 

    /*

    练习：用于记录应用程序运行次数

    如果使用次数已到，那么给出注册提示

 

    比较容易想到的是：计数器

    可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增

    可随着程序的退出，计数器也随着消失

    下一次启动程序时，又重新开始从0计数

 

    我们的需求：

    程序即使结束，计数器也要存在

    下次程序启动时，会先读取上次的值再加一后再重新存储

 

    所以要建立一个配置文件，用于记录该软件的使用次数

 

    该配置文件使用键值对的形式

    这样便于阅读数据，并操作数据

 

    键值对数据是map集合，数据是以文件形式存储，使用io技术

    那么map+io->Properties

 

    配置文件可以实现应用程序数据的共享

    */

    public static void memoryCount()throws IOException

    {

        Properties prop = new Properties();

        File file = new File("count.ini");

 

        if(!file.exists())

            file.createNewFile();

        FileInputStream fis = new FileInputStream(file);

        prop.load(fis);        //启动时装载保存文件

        

        int count = 0;

        String value = prop.getProperty("time");//运行时，从文件中读取time的值

        if(value != null)

        {

            count = Integer.parseInt(value);//如果从文件中读取count值，则需要将其从String转换成int

            if(count > 3)

            {

                System.out.println("使用次数已到，请及时缴费！");

                return;

            }

        }

        count++;//使用完一次，次数+1

        prop.setProperty("time",count+"");//重新设置time对应的值

        FileOutputStream fos = new FileOutputStream(file);    //输出流，用于保存文件

        prop.store(fos,"");//将修改完的配置保存到文件中

 

    }

 

运行多次以后：

 

对应的count.ini文件内容：

PrintWriter：

PrintWriter(OutputStream out, boolean autoFlush) 
          通过现有的 OutputStream 创建新的 PrintWriter。

/*

打印流：

该流提供了打印方法，可以将各种数据都原样打印

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1.file对象：File

2.字符串路径 String

3.字节输出流 OutputStream

PrintWriter

构造函数可以接收的参数类型：

1.file对象：File

2.字符串路径 String

3.字节输出流 OutputStream

4.字符输出流 Writer

*/

import java.io.*;

class PrintWriterDemo

{

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

    {

        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

        //PrintWriter out = new PrintWriter(System.out);//不带自动刷新

        //PrintWriter out = new PrintWriter(System.out,true);//带自动刷新

        //PrintWriter out = new PrintWriter("a.txt");//直接传文件，不能带自动刷新

        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("a.txt")),true);//可以带自动刷新

        String line = null;

        while ((line = bufr.readLine())!=null)

        {

            if("over".equals(line))

                break;

            out.println(line);

            //out.flush();

        }

        out.close();

        bufr.close();

    }

    

}

输出结果：

并未打印over结束，可以瞬时刷新

/*

SequenceInputStream(Enumeration<? extends InputStream> e)

通过记住参数来初始化新创建的 SequenceInputStream，该参数必须是生成运行时类型为 InputStream 对象的 Enumeration 型参数。

SequenceInputStream可以将几个file文件串联在一起，连续输出内容

*/

import java.io.*;

import java.util.*;

class SequenceInputStreamDemo

{

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

    {

        sequenceInputStreamDemo();

    }

    public static void sequenceInputStreamDemo() throws IOException

    {

        Vector<FileInputStream> v = new Vector<FileInputStream>();

 

        v.add(new FileInputStream("D:\\Loujj\\File\\1.txt"));

        v.add(new FileInputStream("D:\\Loujj\\File\\2.txt"));

        v.add(new FileInputStream("D:\\Loujj\\File\\3.txt"));

 

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

        SequenceInputStream sis = new SequenceInputStream(en);    //利用SequenceInputStream将几个file流对象串联起来

 

        BufferedOutputStream bufo = new BufferedOutputStream(new FileOutputStream("D:\\Loujj\\File\\5.txt"));

        byte[] buf = new byte[1024];

        int len = 0;

        while((len = sis.read(buf))!= -1)//sis是InputStream的子类，因此可以使用read方法

        {

            bufo.write(buf,0,len);

        }

        bufo.close();

        sis.close();

    }

}

1.txt,2.txt,3.txt内容如下：

输出的结果如下：

切割文件：

/*

将一个比较大的文件切割成几部分；

假设按照1M大小切割，每读取1M内容，就新建一个文件将其存储，如此反复，直到读完整个文件

*/

 

import java.io.*;

import java.util.*;

class SplitFileDemo

{

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

    {

        splitFileDemo();

    }

 

    public static void splitFileDemo() throws IOException

    {

        FileInputStream fis = new FileInputStream("1.jpg");//读取源文件

        FileOutputStream fos = null;

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

        int len = 0;

        int count = 1;

        while((len = fis.read(buf))!=-1)

        {

            fos = new FileOutputStream("D:\\Loujj\\File\\Split\\"+(count++)+".part");//读完1M大小内容，新建一个文件存储

            fos.write(buf,0,len);

        }

        fos.close();

        fis.close();

        

    }

}

读取的源文件：

切割后的文件：

 

注意：如果读取一个比较大的文件，比如说500M，按照100M切割文件

不能直接读取100M的缓冲！会导致内存崩溃！

需要每次读1M，计数，如果达到100次，就新建一个.part文件，如此反复