黑马程序员_Java基础_IO流（File类和properties类相关操作）

来源：互联网发布：人的极限寿命知乎编辑：程序博客网时间：2024/05/28 18:44

一、IO流(File概述)

File类：

用来将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数。

[java] view plaincopy
/* 
File概述: 
*/  
import java.io.*;  
class FileDemo  
{  
    public static void main(String[] args)   
    {  
        consMethod();  
    }  
    public static void consMethod()//创建File对象  
    {  
        //将a.txt封装成对象。可以将已有和未出现的文件或文件夹封装成对象  
        File f1=new File("a.txt");//1  
  
        File f2=new File("e:\\abc","b.txt");//2  
          
        File d=new File("e:\\abc");//3  
        File f3=new File(d,"c.txt");  
  
        File f4=new File("c:"+File.separator+"abc"+File.separator+"e.txt");  
  
        sop("f1:"+f1);  
        sop("f2:"+f2);  
        sop("f3:"+f3);  
        sop("f4:"+f4);  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  

二、IO流(File对象功能)

File类常见方法：

1.创建。

boolean createNewFile()：在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一创建文件，而且文件已经存在，会覆盖。
boolean mkdir()：创建一级文件夹
boolean mkdirs():创建多级文件夹

2.删除。

boolean delete():删除失败返回false。
boolaan deleteOnExit():在程序退出时删除指定文件。

3.判断。

boolean canExecute():测试应用程序是否可以执行此抽象路径名表示的文件。
boolean exists():文件是否存在。
boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。
boolean isDirectory():测试此抽象路径名表示的文件是否是一个目录。
boolean isHidden():测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute():测试此抽象路径名是否为绝对路径名。

4.获取信息。

String getName():返回由此抽象路径名表示的文件或目录的名称。
String getPath():将此抽象路径名转换为一个路径名字符串。
String getParent():返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
File getAbsoluteFile():返回此抽象路径名的绝对路径名形式。等同于 new File(this.getAbsolutePath())。
String getAbsolutePath():返回此抽象路径名的绝对路径名字符串。
long lastModified():返回此抽象路径名表示的文件最后一次被修改的时间。
long length():返回由此抽象路径名表示的文件的长度。如果此路径名表示一个目录，则返回值是不确定的。
boolean renameTo(File dest):重新命名此抽象路径名表示的文件。

[java] view plaincopy
/* 
File类常见方法： 
 
*/  
import java.io.*;  
class FileDemo  
{  
    public static void main(String[] args) throws IOException  
    {  
        consMethod();  
        method_1();  
        method_2();  
        method_3();  
        method_4();  
        method_5();  
    }  
      
    public static void method_1()throws IOException  
    {  
        sop("method_1:");  
  
        File f=new File("file.txt");  
        f.deleteOnExit();//告诉结束程序时删除file.txt  
        sop("create:"+f.createNewFile());  
        sop("delete:"+f.delete());  
  
        //创建文件夹（注意：目录已存在，则创建失败！）  
        File dir1=new File("abc");  
        sop("mkdir:"+dir1.mkdir());//创建一级文件夹  
        File dir2=new File("abc\\bcd\\asd");  
        sop("mkdirs:"+dir2.mkdirs());//创建多级文件夹  
  
  
    }  
  
    public static void method_2()throws IOException  
    {  
        sop("method_2:");  
  
        File f=new File("file.txt");  
        sop("exists:"+f.exists());  
        //sop("execute:"+f.canExecute());  
    }  
  
    public static void method_3()throws IOException  
    {  
        sop("method_3:");  
  
        File f=new File("file.txt");  
  
        /*注意：在判断文件对象是否是文件或者目录时，必须先判断文件对象封装的内容是否存在。 
        通过exists判断。 
        */  
        f.createNewFile();  
        //f.mkdir();  
        sop("isDirectory:"+f.isDirectory());  
        sop("isFile:"+f.isFile());  
  
        sop("isAbsolute:"+f.isAbsolute());//测试此抽象路径名是否为绝对路径名。  
    }  
    public static void method_4()throws IOException  
    {  
        sop("method_4:");  
  
        File f=new File("a.txt");  
        f.createNewFile();  
        sop("path:"+f.getPath());  
        sop("abspath:"+f.getAbsolutePath());/*返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 
                                              如果相对路径中有上一层目录，那么就返回该目录。 
                                            */  
    }  
    public static void method_5()throws IOException  
    {  
        sop("method_5:");  
        File f1=new File("e:\\a.txt");  
        f1.createNewFile();  
        File f2=new File("e:\\b.txt");  
  
        sop("rename:"+f1.renameTo(f2));  
    }  
  
  
    public static void consMethod()//创建File对象  
    {  
        sop("consMethod:");  
        //将a.txt封装成对象。可以将已有和未出现的文件或文件夹封装成对象  
        File f1=new File("a.txt");//1  
  
        File f2=new File("e:\\abc","b.txt");//2  
          
        File d=new File("e:\\abc");//3  
        File f3=new File(d,"c.txt");  
  
        File f4=new File("c:"+File.separator+"abc"+File.separator+"e.txt");  
  
        sop("f1:"+f1);  
        sop("f2:"+f2);  
        sop("f3:"+f3);  
        sop("f4:"+f4);  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  

三、IO流(File对象功能-文件列表)

[java] view plaincopy
/* 
static File[] listRoots():列出可用的文件系统根。 
String[] list():返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。 
 
String[] list(FilenameFilter filter)返回一个字符串数组，这些字符串指定此抽象路径名表示的 
目录中满足指定过滤器的文件和目录。除了返回数组中的字符串必须满足过滤器外，此方法的行为与  
list() 方法相同。如果给定 filter 为 null，则接受所有名称。否则，当且仅当在此抽象路径名及 
其表示的目录中的文件名或目录名上调用过滤器的  
FilenameFilter.accept(java.io.File, java.lang.String) 方法返回 true 时，该名称才满足过滤器。 
 
*/  
import java.io.*;  
class FileDemo2   
{  
    public static void main(String[] args)   
    {  
        listDemo_1();//获取根目录文件和文件夹名称  
        listDemo_2();//获取根目录文件和文件夹名称（只提取*.doc文件）  
        listDemo_3();//获取根目录文件和文件夹名称以及文件的长度       
    }  
    public static void listDemo_3()  
    {  
        File dir=new File("e:\\");  
        File[] files=dir.listFiles();  
        for(File f:files)  
        {  
            System.out.println("文件名:"+f.getName()+"长度："+f.length());  
        }  
        System.out.println();  
    }  
    public static void listDemo_2()  
    {  
        File dir=new File("e:\\");  
        String[] arr=dir.list(new FilenameFilter(){  
          
        public boolean accept(File fir,String name)  
        {  
            /* 
            if(name.endsWith(".doc")) 
                return true; 
            else 
                return false; 
            */  
  
            return name.endsWith(".doc");  
        }  
          
        });  
        for(String name:arr)  
        {  
            System.out.println(name);  
        }  
        System.out.println();  
    }  
    public static void listDemo_1()  
    {  
        File f=new File("c:\\");  
        String[] names=f.list();//调用list的File对象必须是一个目录，该目录必须存在。  
        for(String name:names)  
        {  
            System.out.println(name);  
        }  
        System.out.println();  
    }  
    public static void listRootsDemo()  
    {  
        File[] files =File.listRoots();  
        for(File f:files)  
        {  
            System.out.println(f);  
        }  
        System.out.println();  
    }  
}  

四、IO流(列出目录下所有内容-递归)

[java] view plaincopy
/* 
列出指定目录下文件或文件夹，包含子目录中的内容。 
也就是列出指定目录下的所有内容。 
 
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。在列出过程中出现的还是目录的话， 
还可以再次调用本功能。也就是函数自身调用自身，这种编程手法称为递归。 
 
注意： 
1.限定条件 
2.注意递归的次数，避免内存溢出。 
*/  
import java.io.*;  
class FileDemo3   
{  
    public static void main(String[] args)   
    {  
        File dir=new File("d:\\");  
        showDir(dir);  
  
        //toBin(3);//十进制转换为二进制  
        //System.out.println();  
        //System.out.println(getNum(100));//等差数列前N项和  
    }  
      
    public static void showDir(File dir)  
    {  
        System.out.println(dir);  
        File[] files=dir.listFiles();  
        for(int i=0;i<files.length;i++)  
        {  
            if(files[i].isDirectory())  
                showDir(files[i]);  
            else  
                System.out.println(files[i]);  
        }  
    }  
      
      
    public static void toBin(int num)//十进制转换为二进制  
    {  
        if(num>0)  
        {  
            toBin(num/2);  
            System.out.print(num%2);  
        }  
    }  
    public static int getNum(int n)//等差数列前N项和  
    {  
        if(n==1)  
            return 1;  
        return n+getNum(n-1);  
    }  
}  

五、IO流(列出目录下所有内容-带层次)

[java] view plaincopy
/* 
列出目录下所有内容-带层次: 
*/  
import java.io.*;  
class FileDemo3   
{  
    public static void main(String[] args)   
    {  
        File dir=new File("C:\\Users");  
        showDir(dir,0);  
    }  
    public static String getLevel(int level)  
    {  
        StringBuilder sb=new StringBuilder();  
        sb.append("|---");  
        for(int i=0;i<level;i++)  
        {  
            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 i=0;i<files.length;i++)  
        {  
            if(files[i].isDirectory())  
                showDir(files[i],level);  
            else  
                System.out.println(getLevel(level)+files[i]);  
        }  
    }  
}  

六、IO流(删除带内容的目录)

[java] view plaincopy
/* 
删除一个带内容的目录： 
删除原理： 
在Windows中，删除目录从里面往外删除。 
既然是从里往外删除，就需要用到递归。 
*/  
import java.io.*;  
class RemoveDir   
{  
    public static void main(String[] args)   
    {  
        File dir=new File("e:\\removeText");  
        removeDir(dir);  
    }  
    public static void removeDir(File dir)  
    {  
        File[] files=dir.listFiles();  
        for(int i=0;i<files.length;i++)  
        {  
            if(files[i].isDirectory())  
                removeDir(files[i]);  
            else  
                System.out.println(files[i].toString()+"\t文件删除状态："+files[i].delete());  
  
        }  
        System.out.println(dir+"\t目录删除状态："+dir.delete());  
          
    }  
}  

七、IO流(创建java文件列表)

[java] view plaincopy
/* 
练习： 
 
将一个指定目录下的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:\\java");  
        List<File> list=new ArrayList<File>();  
        fileToList(dir,list);  
  
        File file=new File(dir,"javalist.txt");  
        writeToFile(list,file.toString());  
    }  
    public static void fileToList(File dir,List<File> list)  
    {  
        File[] files=dir.listFiles();  
        for(File file:files)  
        {  
            if(file.isDirectory())  
                fileToList(file,list);  
            else  
            {  
                if(file.getName().endsWith(".java"))  
                    list.add(file);  
            }  
        }  
    }  
    public static void writeToFile(List<File> list,String javaListFile)   
    {  
        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 new RuntimeException("操作文件失败");  
        }  
        finally  
        {  
            try  
            {  
                if(bufw!=null)  
                    bufw.close();  
            }  
            catch (IOException e)  
            {  
                throw new RuntimeException("关闭写入流失败");  
            }  
        }  
    }  
}  

八、IO流(Properties简述)

Properties是Hashtable的子类，也就是说它具备了Map集合的特点。它里面存储的键值对都是字符串。

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

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

那么在加载数据式，需要数据有固定格式：键=值

九、IO流(Properties存取)

[java] view plaincopy
/* 
Properties存取: 
*/  
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","20");  
        prop.setProperty("lisi","39");  
  
        System.out.println(prop);  
        System.out.println(prop.getProperty("lisi"));  
          
        prop.setProperty("lisi","43");  
        Set<String> names=prop.stringPropertyNames();  
        for(String s:names)  
        {  
            System.out.println(s+":"+prop.getProperty(s));  
        }  
    }  
}  

十、IO流(Properties存取配置文件)

[java] view plaincopy
/* 
Properties存取: 
 
想要将info.txt中键值数据存入到集合中进行操作。 
1.用一个流和info.txt文件关联。 
2.读取一行数据，将该行数据用"="号进行切割。 
3.等号左边作为键，右边作为值。存入到Properties集合中。 
*/  
import java.io.*;  
import java.util.*;  
import java.io.*;  
class PropertiesDemo   
{  
    public static void main(String[] args)throws IOException  
    {  
        //setAndGet();  
        //method_1();  
        loadDemo();  
    }  
    public static void loadDemo()throws IOException  
    {  
        Properties prop=new Properties();  
        FileInputStream fis=new FileInputStream("info.txt");  
  
        //将流中的数据加载进集合。  
        prop.load(fis);  
        prop.setProperty("wangwu","21");  
  
        FileOutputStream fos=new FileOutputStream("info.txt");  
        prop.store(fos,"abc");//第二个参数：注释信息  
        //System.out.println(prop);  
        prop.list(System.out);  
        fos.close();  
    }  
    public static void method_1()throws IOException  
    {  
        BufferedReader bufr=new BufferedReader(new FileReader("info.txt"));  
        String line=null;  
        Properties prop=new Properties();  
        while((line=bufr.readLine())!=null)  
        {  
            String[] arr=line.split("=");  
            //System.out.println("键："+arr[0]+"\t值："+arr[0]);  
            prop.setProperty(arr[0],arr[1]);  
        }  
        bufr.close();  
  
        System.out.println(prop);  
    }  
    public static void setAndGet()  
    {  
        Properties prop=new Properties();  
        prop.setProperty("zhangsan","20");  
        prop.setProperty("lisi","39");  
  
        System.out.println(prop);  
        System.out.println(prop.getProperty("lisi"));  
          
        prop.setProperty("lisi","43");  
        Set<String> names=prop.stringPropertyNames();  
        for(String s:names)  
        {  
            System.out.println(s+":"+prop.getProperty(s));  
        }  
    }  
}  

十一、IO流(Properties练习)

[java] view plaincopy
/* 
用于记录应用程序运行次数。 
如果使用次数已到，那么给出注册提示。 
 
很容易想到：计数器。 
课时该计数器定义在程序中随着程序的运行而在内存中存在，并进行自增。 
可是随着该应用程序的退出，计数器也在内存中消失了，下次再启动该程序， 
该计数器也在内存中消失了。 
下一次再启动该程序，又重新开始从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.createNewFile();  
        FileInputStream fis=new FileInputStream(file);  
          
        prop.load(fis);  
  
        int count=0;  
        String value=prop.getProperty("time");  
        if(value!=null)  
        {     
            count=Integer.parseInt(value);  
            if(count>=3)  
            {  
                System.out.println("您好，试用次数已到。");  
                return;  
            }  
              
        }  
  
        count++;  
        prop.setProperty("time",count+"");  
        FileOutputStream fos=new FileOutputStream(file);  
        prop.store(fos,"");  
    }  
}  

十二、IO流(PrintWriter)

打印流：

PrintWriter与PrintStream：

可以直接操作输入流和文件。

[java] view plaincopy
/* 
打印流： 
该流提供了打印方法，可以将各种数据类型的数据都原样打印。 
 
字节打印流： 
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);//true:刷新缓冲区  
  
        String line=null;  
        while((line=bufr.readLine())!=null)  
        {  
            if("over".equals(line))  
                break;  
            out.println(line.toUpperCase());  
            //out.flush();  
        }  
        out.close();  
        bufr.close();  
    }  
}  

十三、IO流(合并流)

序列流：

SequenceInputStream：对多个流进行合并。

[java] view plaincopy
/* 
SequenceInputStream：对多个流进行合并。 
*/  
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("e:\\1.txt"));  
        v.add(new FileInputStream("e:\\2.txt"));  
        v.add(new FileInputStream("e:\\3.txt"));  
  
        Enumeration<FileInputStream> en=v.elements();  
  
        SequenceInputStream sis=new SequenceInputStream(en);  
        FileOutputStream fos=new FileOutputStream("e:\\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();  
  
    }  
}  

十四、IO流(切割文件)

[java] view plaincopy
/* 
切割，合并mp3文件： 
 
*/  
import java.io.*;  
import java.util.*;  
class SplitFile   
{  
    public static void main(String[] args)throws IOException   
    {  
        splitFile();  
        merge();  
    }  
    public static void splitFile()throws IOException//切割  
    {  
        FileInputStream fis=new FileInputStream("e:\\1.mp3");  
        FileOutputStream fos=null;  
  
        byte[] buf=new byte[1024*1024];  
        int len=0;  
        int count=1;  
        while((len=fis.read(buf))!=-1)  
        {  
            fos=new FileOutputStream("e:\\splitfiles\\"+(count++)+".part");  
            fos.write(buf,0,len);  
            fos.close();  
        }  
        fis.close();  
    }  
    public static void merge()throws IOException //合并  
    {  
        ArrayList<FileInputStream> a1=new ArrayList<FileInputStream>();  
        for(int i=1;i<=4;i++)  
        {  
            a1.add(new FileInputStream("e:\\splitfiles\\"+i+".part"));  
        }  
  
        final Iterator<FileInputStream> it=a1.iterator();  
        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("e:\\splitfiles\\0.mp3");  
        byte[] buf=new byte[1024];  
        int len=0;  
        while((len=sis.read(buf))!=-1)  
        {  
            fos.write(buf,0,len);  
        }  
        fos.close();  
        sis.close();  
    }  
}  

0 0