码迷，mamicode.com
首页 > 编程语言 > 详细

Java基础---IO(二)--File类、Properties类、打印流、序列流（合并流）

时间：2015-01-15 21:44:53      阅读：230      评论：0      收藏：0      [点我收藏+]

标签：

第一讲     File类

一、概述

1、File类：文件和目录路径名的抽象表现形式

2、特点：

        1）用来将文件或文件夹封装成对象

        2）方便于对文件与文件夹的属性信息进行操作

        3）File类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变

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

 

二、File对象创建

方式一：      

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

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

 方式二：

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

        将文件所在目录路径和文件一起传入，指定文件路径。

 方式三：

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

             File f3=new File(d,"c.txt");

        将文件目录路径封装成对象。再创建文件对象。降低了文件于父目录的关联性。

小知识：

        File.separator表示目录分隔符，可以跨平台使用。相当于路径中的“\”（双斜杠\\在windows中表示表示转义后的分隔符，但是在linux系统中就不是）。

 

三、File类的常见方法

1、创建

        booleancreateNewFile();

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

        boolean mkdir();//创建文件夹，只能创建一级文件夹

例：

        File dir=new File("abc");

        dir.mkdir();//创建abc这个文件夹

        boolean mkdirs();//创建多级文件夹

2、删除

        boolean delete();

        //删除文件或目录。文件存在，返回true；文件不存在或者正在被执行，返回false。    

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

3、判断

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

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

        boolean isFile();//是否是文件

        boolean isDirectory();//是否是文件夹

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

        boolean isAbsolute();//文件是否是绝对路径

记住：在判断文件对象是否是文件或者目录时，必须要判断该文件对象封装的内容是否存在。通过exists判断。

4、获取信息

        String getName();//获取文件名

        String getPath();

        //获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

        String getParent();

        //获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。

        String getAbsolutePath();//获取文件的绝对路径      

        long lastModified();//返回文件最后一次被修改的时间

        long length();//返回文件长度

5、列出文件及文件过滤

        static File[] listRoots();//列出可用的文件系统根目录，即系统盘符

        String[] list();

        //列出当前目录下所有文件，包括隐藏。调用list方法的file对象必须是封装了一个目录。该目录还必须存在。

        String[]list(FilenameFilter filter);

        //返回一个字符串数组，获取目录中满足指定过滤器的文件或目录。

        //FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(Filedir,String name)，返回的是boolean型，对不符合条件的文件过滤掉。

        File[] listFiles();//返回一个抽象路径名数组，获取当前文件夹下的所有文件和文件夹

        File[] ListFiles(FilenameFilterfilter);//返回抽象路径名数组，获取目录中满足指定过滤器的文件或目录。

[java] view plaincopy
 
  1. <span style="font-size:14px;">/* 
  2. 练习：用String[] list(FilenameFilter filter)方法获取一个目录下所有的.java文件，其他文件不要。 
  3. 思路：1、FilenameFilter是一个过滤器接口，用匿名内部类传入filter对象 
  4.       2、复写FilenameFilter接口的accept(File file,String name)方法，并判断name是否是java文件 
  5.       3、遍历String类型数组 
  6. */  
  7.   
  8. import java.io.*;  
  9. class  GetJavaFile  
  10. {  
  11.     public static void main(String[] args)   
  12.     {  
  13.         File file=new File("E:\\Java Study\\Practice\\day07");  
  14.         getJavaFile(file);  
  15.     }  
  16.     //获取一个目录下所有的.java文件方法  
  17.     public static void getJavaFile(File dir)  
  18.     {  
  19.         //传入FilenameFilter匿名内部类子类对象，并复写accept方法  
  20.         String[] javaFile=dir.list(new FilenameFilter()  
  21.         {  
  22.             public boolean accept(File dir,String name)  
  23.             {  
  24.                 return name.endsWith(".java");//判断文件名是否是以.java结尾  
  25.             }  
  26.         });  
  27.   
  28.         System.out.println("len:"+javaFile.length);  
  29.         //遍历数组  
  30.         for (String s : javaFile )  
  31.         {  
  32.             System.out.println(s);  
  33.         }  
  34.     }  
  35. }  
  36. </span>  


四、递归

1、定义

       当函数内每一次循环还可以调用本功能来实现，也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。

2、递归注意事项

        a、限定条件。是来结束循环调用，否则是死循环。

        b、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的方法，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。

示例一

[java] view plaincopy
 
  1. /* 
  2. 需求：列出指定目录下文件或文件夹，包含子目录，即列出指定目录下所有内容（带层次的）。 
  3.  
  4. 分析，因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再调用本功能，这就是利用递归原理。 
  5.  
  6. */  
  7. import java.io.*;  
  8. class  RecursionDemo  
  9. {  
  10.     public static void main(String[] args)   
  11.     {  
  12.         //关联指定路径  
  13.         File dir=new File("e:\\Java Study\\Practice");  
  14.           
  15.         //列出关联路径中所有的.java文件  
  16.         allFileList(dir,0);  
  17.     }  
  18.   
  19.     //列出指定目录下的所以内容  
  20.     public static void allFileList(File dir,int level)  
  21.     {  
  22.         //有层次的输出  
  23.         System.out.println(getLevel(level)+dir);  
  24.         level++;  
  25.         File[] fileArr=dir.listFiles();//获取本目录下的所以文件和目录的抽象路径  
  26.           
  27.         //遍历  
  28.         for (File file : fileArr)  
  29.         {  
  30.             if(file.isDirectory())  
  31.             {  
  32.                 //如果目录下还是目录，则继续调用本函数  
  33.                 allFileList(file,level);  
  34.             }  
  35.             else  
  36.                 System.out.println(getLevel(level)+file);//显示（列出）文件  
  37.         }     
  38.     }  
  39.   
  40.     //带层次的列表  
  41.     public static String getLevel(int level)  
  42.     {  
  43.         StringBuilder sb=new StringBuilder();  
  44.         sb.append("|--");  
  45.         //每多一级目录，就多输出指定字符  
  46.         for (int x=level;x>0 ; x--)  
  47.         {  
  48.             //sb.append("|--");  
  49.             sb.insert(0,"|  ");  
  50.         }  
  51.         return sb.toString();  
  52.     }  
  53. }  

示例二

[java] view plaincopy
 
  1. /* 
  2. 删除一个带内容的目录。 
  3. 删除原理： 
  4. 在windows中，删除目录从里面往外面删除的。 
  5. 既然是从里往外删除。就需要用到递归。 
  6.  
  7. */  
  8. import java.io.*;  
  9. class RemoveDir   
  10. {  
  11.     public static void main(String[] args)   
  12.     {  
  13.         //指定目录  
  14.         File dir=new File("e:\\1");  
  15.         //删除目录  
  16.         removeDir(dir);  
  17.   
  18.     }  
  19.   
  20.     //删除传入目录  
  21.     public static void removeDir(File dir)  
  22.     {  
  23.         File[] files=dir.listFiles();//列出目录下的所以文件和文件夹  
  24.         //遍历  
  25.         for (File file : files )  
  26.         {  
  27.             //如果还是目录且非隐藏  
  28.             if(!file.isHidden()&&file.isDirectory())  
  29.                 removeDir(file);//继续删除目录里的内容  
  30.             else  
  31.                 System.out.println(file.toString()+":-file-:"+file.delete());//删除文件  
  32.         }  
  33.         System.out.println(dir+":::dir:::"+dir.delete());//删除目录  
  34.     }  
  35. }  

示例三

[java] view plaincopy
 
  1. /* 
  2. 练习： 
  3. 将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。建立一个java文件列表的文件。 
  4. 思路： 
  5.      1、对指定的目录进行递归。 
  6.      2、获取递归过程所有的java文件的路径。 
  7.      3、将这些路径存储到集合中。 
  8.      4、将集合中的数据写入到一个文件中。 
  9. */  
  10. import java.util.*;  
  11. import java.io.*;  
  12.   
  13. class  JavaFileList  
  14. {  
  15.     public static void main(String[] args)   
  16.     {  
  17.         //指定目录  
  18.         File dir=new File("e:/Java Study/Practice");  
  19.           
  20.         //定义一个List集合，用于存储.java文件的File对象  
  21.         List<File> list =new ArrayList<File>();  
  22.           
  23.         //调用获取文件路径方法  
  24.         fileToList(dir,list);  
  25.           
  26.         //指定写入文件  
  27.         File file=new File(dir,"javafilelist.txt");  
  28.         //调用写入文件方法  
  29.         writeToFile(list,file);  
  30.       
  31.     }  
  32.     //获取指定文件夹内的所有java文件的绝对路径，并存入集合中  
  33.     public static void fileToList(File dir,List<File> list)  
  34.     {  
  35.         File[] files=dir.listFiles();//列出dir路径下的所以文件和目录，  
  36.         //遍历  
  37.         for (File file : files)  
  38.         {  
  39.             //如果是目录，则继续获取  
  40.             if(file.isDirectory())  
  41.             {  
  42.                 list.add(file.getAbsoluteFile());//把父目录路径也存入  
  43.                 fileToList(file,list);  
  44.             }  
  45.             //将是.java文件的绝对路径存入  
  46.             else if(file.getName().endsWith(".java"))  
  47.                 list.add(file);  
  48.         }  
  49.     }  
  50.   
  51.     //将集合中元素写入到一个文本文件中  
  52.     public static void writeToFile(List<File> list,File file)  
  53.     {  
  54.           
  55.         BufferedWriter bw=null;  
  56.               
  57.         try  
  58.         {   //使用字符流缓冲区对象关联写入的文件  
  59.             bw=new BufferedWriter(new FileWriter(file));  
  60.             for (File file0 : list )  
  61.             {  
  62.                 bw.write(file0.getAbsolutePath());//写入  
  63.                 bw.newLine();//换行  
  64.                 bw.flush();//刷新  
  65.             }  
  66.         }  
  67.         catch (IOException e)  
  68.         {  
  69.             throw new RuntimeException("写入文件失败");  
  70.         }  
  71.         finally  
  72.         {  
  73.             try  
  74.             {  
  75.                 if(bw!=null)  
  76.                     bw.close();//关流  
  77.             }  
  78.             catch (IOException e)  
  79.             {  
  80.                 throw new RuntimeException("流资源关闭失败");  
  81.             }  
  82.         }  
  83.     }  
  84. }  

 

第二讲      Properties类

一、概述

1、Properties是Hashtable的子类，它具备Map集合的特点。而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术想结合的集合容器。

2、特点：

        1）可用于键值对形式的配置文件

        2）在加载时，需要数据有固定的格式，常用的是：键=值

 

二、特有方法

1、设置

        Object setProperty(String key,String value);

        //设置键和值，调用Hashtable的方法put

2、获取

        String getProperty(String key);

        //指定key搜索value

        Set<String> stringPropertyName();

        //返回属性列表的键集，存入Set集合

3、加载流和存入流

        void load(InputStream ism);

        //从输入字节流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        void load(Readerreader);

        //从输入字符流中读取属性列表（键和元素对）。又称将流中的数据加载进集合。

        voidlist(PrintStream out);//将属性列表输出到指定的输出流

        void store(OutputStreamout,String comments);

        //对应load(InputStream )将属性列表（键值对）写入输出流。comments属性列表的描述。

        void store(Writerwriter, String comments);

        //对应load(Reader)将属性列表（键值对）写入输出流。comments属性列表的描述。

示例

[java] view plaincopy
 
  1. //演示，如何将流中的数据存储到集合中。  
  2.     //想要将info.txt中键值数据存到集合中进行操作。  
  3.     /* 
  4.         1,用一个流和info.txt文件关联。 
  5.         2，读取一行数据，将该行数据用"="进行切割。 
  6.         3，等号左边作为键，右边作为值。存入到Properties集合中即可。 
  7.  
  8.     */  
  9.         //将文件数据存储进Properties集合方法  
  10.     public static void method()throws IOException  
  11.     {  
  12.         //使用字符读取缓冲流关联文件  
  13.         BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));  
  14.   
  15.         String line = null;  
  16.         //定义Properties集合  
  17.         Properties prop = new Properties();  
  18.   
  19.             while((line=bufr.readLine())!=null)  
  20.         {  
  21.             String[] arr = line.split("=");//将一行数据以“=”号进行分割  
  22.             //将=左边作为键存入，将=右边作为值存入  
  23.             prop.setProperty(arr[0],arr[1]);  
  24.         }  
  25.   
  26.         bufr.close();//关流  
  27.   
  28.         System.out.println(prop);  
  29.     }  

练习：

[java] view plaincopy
 
  1. /* 
  2. 练习：用于记录应用程序运行次数。如果使用次数已到，那么给出注册提示。 
  3.      
  4. 分析： 
  5. 很容易想到的是：计数器。可是该计数器定义在程序中，随着该应用程序的退出，该计数器也在内存中消失了。 
  6. 所以要建立一个配置文件，用于记录该软件的使用次数。该配置文件使用键值对的形式。键值对数据是map集合。数据是以文件形式存储。使用io技术。那么map+io——>Properties。 
  7.  
  8. 思路：1、用读取流关联文本信息文件。如果存在则读取，如果不存在，则创建 
  9.       2、每次运行，将文件数据存入集合中，读取值，判断次数，如果小于等于5次，则次数增加1次，如果大于则输出提示信息。 
  10.       3、将值小于等于5次的信息数据存入文件中伤感的句子
  11. */  
  12. import java.util.*;  
  13. import java.io.*;  
  14.   
  15. class  RunCount  
  16. {  
  17.     public static void main(String[] args)throws IOException   
  18.     {  
  19.         int count=runCount();  
  20.         if(count>5)//如果程序被使用了超过5次，则终止使用，并提示  
  21.         {  
  22.             System.out.println("次数到了，交钱！！！！！");  
  23.             return ;  
  24.         }  
  25.         else  
  26.             System.out.println("程序第"+count+"次Run！");  
  27.     }  
  28.     //获取程序运行的次数  
  29.     public static int runCount()throws IOException  
  30.     {  
  31.         Properties ps=new Properties();//创建集合对象  
  32.   
  33.         File file=new File("info.ini");//将文件进行封装  
  34.         if(!file.exists())//判断是否存在  
  35.             file.createNewFile();  
  36.         FileReader fr=new FileReader(file);//将文件于读取流进行关联  
  37.           
  38.         ps.load(fr);//加载流中的文件数据到集合中  
  39.   
  40.         int count=0;//定义计数器  
  41.         String value=ps.getProperty("time");//获取次数值  
  42.           
  43.         if(value!=null)//如过值不等于null，则将其赋值给count  
  44.         {  
  45.             count=Integer.parseInt(value);  
  46.         }  
  47.         count++;//每启动一次自增  
  48.         ps.setProperty("time",count+"");//将次数记录住集合  
  49.   
  50.         FileWriter fw=new FileWriter(file);  
  51.         ps.store(fw,"");//将集合中的数据存入硬盘文件中  
  52.           
  53.         fr.close();//关流  
  54.         fw.close();  
  55.   
  56.         return count;//返回程序启动的次数  
  57.     }  
  58. }  

 

第三讲    打印流

一、概述

        1、打印流包括：PrintStream和PrintWriter

        2、该流提供了打印方法，可将各种类型的数据都原样打印。

 

二、字节打印流：PrintStream

构造方法中可接收的参数类型：

        1、File对象。File

        2、字符串路径：String

        3、字符输出流：OutputStream

 

三、字符串打印流：PrintWriter

构造方法中可接受的参数类型

        1、File对象：File

        2、字符串路径：String

        3、字节输出流：OutputStream

        4、字符输出流：Writer

示例

[java] view plaincopy
 
  1. import java.io.*;  
  2.   
  3. class  PrintStreamDemo  
  4. {  
  5.     public static void main(String[] args) throws IOException  
  6.     {  
  7.         //键盘录入  
  8.         BufferedReader bufr =   
  9.             new BufferedReader(new InputStreamReader(System.in));  
  10.   
  11.         //打印流关联文件，自动刷新  
  12.         PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);  
  13.   
  14.         String line = null;  
  15.   
  16.         while((line=bufr.readLine())!=null)  
  17.         {  
  18.             if("over".equals(line))//结束字符  
  19.                 break;  
  20.             out.println(line.toUpperCase());  
  21.             //out.flush();  
  22.         }  
  23.           
  24.         //关流  
  25.         out.close();  
  26.         bufr.close();  
  27.   
  28.     }     
  29. }  

 

第四讲    序列流

一、概述

1、SequenceInputStream对多个流进行合并。也被称为合并流。

2、常用构造函数

        SequenceInputStream(Enumeration<?extends FileInputStream> e)

 

二、常见合并多个流文件步骤

        1、创建集合，并将流对象添加进集合

        2、创建Enumeration对象，将集合元素加入。

        3、创建SequenceInputStream对象，合并流对象淘宝开店

        4、创建写入流对象，FileOutputStream关联写入文件

        5、利用SequenceInputStream对象和FileOutputStream对象读数据进行反复读写操作。

示例：

[java] view plaincopy
 
  1. /* 
  2. SequenceInputStream 
  3. 合并流 
  4. 需求：将三个文本文件中的数据合并到一个文本文件中 
  5. 思路：1、创建一个Vector集合，将三个文本文件字节流添加到集合中 
  6.       2、创建Enumeration对象，创建SequnceInputStream对象关联Enumeration 
  7.       3、输出流关联新文本文件 
  8.       4、反复读写操作 
  9. */  
  10. import java.util.*;  
  11. import java.io.*;  
  12.   
  13. class  SequenceInputStreamDemo  
  14. {  
  15.     public static void main(String[] args)throws IOException  
  16.     {  
  17.         Vector<InputStream> ve=new Vector<InputStream>();//创建vector集合，并添加相关流对象  
  18.         ve.add(new FileInputStream("1.txt"));  
  19.         ve.add(new FileInputStream("2.txt"));  
  20.         ve.add(new FileInputStream("3.txt"));  
  21.   
  22.         Enumeration<InputStream> en=ve.elements();//创建枚举对象  
  23.         SequenceInputStream sis=new SequenceInputStream(en);//合并流  
  24.   
  25.         FileOutputStream fos=new FileOutputStream("4.txt");//关联写入文件  
  26.           
  27.         //反复读写操作  
  28.         byte[] buf=new byte[1024];  
  29.         int len=0;  
  30.         while((len=sis.read(buf))!=-1)  
  31.         {  
  32.             fos.write(buf,0,len);  
  33.         }  
  34.           
  35.         //关流  
  36.         fos.close();  
  37.         sis.close();  
  38.     }  
  39. }  

练习：

[java] view plaincopy
 
    1. /* 
    2. 切割文件 
    3. 需求：将一个mp3文件按1M大小切割成几部分 
    4. 思路：1、使用文件字节流关联mp3文件 
    5.       2、定义一个容器存储1M大小的数据，当存储满时，写入一个新文件中 
    6.  
    7. */  
    8. import java.util.*;  
    9. import java.io.*;  
    10.   
    11. class  SplitFile  
    12. {  
    13.     public static void main(String[] args) throws IOException  
    14.     {  
    15.         //指定要切割的文件  
    16.         File file=new File("C:\\Users\\asus\\Desktop\\苏芮 - 一样的月光.mp3");  
    17.         //将指定文件进行切割  
    18.         splitFile(file);  
    19.   
    20.         //指定要合并到的文件  
    21.         File file1=new File("E:\\Java Study\\Practice\\day20\\splitFile\\一样的月光.mp3");  
    22.         //将部分文件进行合并指定文件中  
    23.         merge(file1);  
    24.   
    25.     }  
    26.     //接收一个文件，将其按1M大小进行切割  
    27.     public static void splitFile(File file)throws IOException  
    28.     {  
    29.         //关联要切割的文件  
    30.         BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));  
    31.           
    32.         BufferedOutputStream bos=null;  
    33.   
    34.         //定义1M大小存储容器  
    35.         byte[] buf=new byte[1024*1024];  
    36.         int len=0,x=0;  
    37.         while ((len=bis.read(buf))!=-1)  
    38.         {  
    39.             //每满1M就写入一个新文件中  
    40.             bos=new BufferedOutputStream(new FileOutputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+(++x)+".part"));  
    41.             bos.write(buf,0,len);  
    42.             bos.close();//没写完一个文件要记得关流  
    43.         }  
    44.         //关流  
    45.         bis.close();  
    46.     }  
    47.   
    48.     //将部分文件合并为一个可执行文件  
    49.     public static void merge(File file)throws IOException  
    50.     {  
    51.         //定义一个集合存储这些部分文件关联路径数据  
    52.         ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();  
    53.   
    54.         for (int x=1;x<=6 ; x++)  
    55.         {  
    56.             al.add(new FileInputStream("E:\\Java Study\\Practice\\day20\\splitFile\\"+x+".part"));  
    57.         }  
    58.           
    59.         //因为Enumeration是Vector特有的迭代方法，所以这里创建一个Enumeration类型的匿名内部类  
    60.         final  ListIterator<FileInputStream> it=al.listIterator();  
    61.         Enumeration<FileInputStream> en=new Enumeration<FileInputStream>()  
    62.         {  
    63.             public boolean hasMoreElements()  
    64.             {  
    65.                 return it.hasNext();  
    66.             }  
    67.   
    68.             public FileInputStream nextElement()  
    69.             {  
    70.                 return it.next();  
    71.             }  
    72.         };  
    73.   
    74.         //关联枚举对象  
    75.         SequenceInputStream sis=new SequenceInputStream(en);  
    76.   
    77.         //将合并的文件数据写入指定文件中  
    78.         FileOutputStream fos=new FileOutputStream(file);  
    79.           
    80.         //定义临时存储数据的数组  
    81.         byte[] buf=new byte[1024];  
    82.         int len=0;  
    83.         while((len=sis.read(buf))!=-1)  
    84.         {  
    85.             fos.write(buf,0,len);//写数据  
    86.         }  
    87.   
    88.         //关流  
    89.         fos.close();  
    90.         sis.close();  
    91.   
    92.     }  
    93.   
    94. }  

Java基础---IO(二)--File类、Properties类、打印流、序列流（合并流）

标签：

原文地址：http://www.cnblogs.com/tiankong101/p/4227268.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！