黑马程序员——Java基础——IO流（二）——File类、Properties类、打印流、序列流

浏览数：14 / 时间：2015年06月08日

第一件　　File类

一、File类

a、用于将文件或者文件夹封装成对象

b、方便对文件与文件夹的属性信息进行操作

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

d、了解File类中的常用方法

二、File对象的创建

a、File f=new File（"a：\\a.txt"）；

b、File f2=new File("C：\\abc","a.txt");//分开的好处是后一个参数能够使用其他对象如string

c、File d=new File("C:\\abc")

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

知识点File.seperator是跨平台的分隔符如：File f=new File（"a："+File.seperator+"a.txt"）；

二、File类的常见方法

1、创建

boolean createNewFile();

Boolean mkdir（）：创建文件夹，只能一级文件夹

Boolean mkdirs（）：增加了个就能创建多级文件夹了

2、删除

boolean delete();//删除文件或目录；文件存在返回true，不存在或被执行时，返回false

void deleteOnExit();//程序退出时删除

3、判断

boolean exists();//是否存在。经常用

boolean ifFile();//是否问价

boolean isDirectory；是否文件夹

boolean isHidden（）；是否隐藏文件

boolean isAbsolute（）；是否问价绝对路径

4、获取信息

String getName()//获取文件名

String getPath();//获取问价的相对路径（就是说文件创建时传什么就写什么）

String getParent（）；//获取文件父目录。返回的是绝对路径的父目录。如果获取的是相对路径，返回null，如果相对路径有上一层目录，则返回这个

String getAbsolutePath（）：获取文件的绝对路径

long lastModified（）：返回文件最后一次被修改的时间

long length（）；返回文件长度

boolean rename();有点类似剪切

5、列出文件及文件的过滤器

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

String[] list()//列出单曲所有文件，放回string【】

File[] listFiles()//列出所有文件。返回的是路径

String【】 list（FilenameFilter filter（过滤器））//获取满足过滤器的文件，放回文件数组名

File[] ListFiles(FilenameFilter filter(过滤器))//满足过滤器的文件，返回的是文件路径

一下是使用过滤器寻找一个文件夹内的某类文件的例子：

 1 /*练习：获得一个某一文件下的.jpg文件
 2  * 思路：1、创建某一个File类，通过一个自定义的函数getJpg找到他的jpg文件；
 3  *        2、使用listFiles（new FilenameFilter（）{//复写accept（）}）即可    
 4  */
 5 import java.io.*;
 6 public class GetFile {
 7     public static void main(String[] args){
 8         File file=new File("F:\\tupain");
 9         getJpg(file);
10     }
11 //获得一个目录下所有jpg的方法
12     private static void getJpg(File file) {
13 //        传入FilenameFilter匿名内部类，并复写accept方法
14         File[] jfile=file.listFiles(new FilenameFilter() {
15             public boolean accept(File dir, String name) {//复写accpt
16                 return name.endsWith(".jpg");
17             }
18         });//注意这个位置
19         for(File f:jfile){
20             System.out.println(f);
21         }
22     }
23 }

四、递归

1、定义：函数类每次循环都调用自身

 1 /*
 2  * 列出指定目录下文件或文件夹的目录，包括子目录
 3  * 阶乘和二进制的递归方法
 4  * 思路：
 5  * 1、将需要搜索的文件夹使用listFiles后得到file数组
 6  * 2、用for循环遍历
 7  * 3、当出现不为空（使用ofDirectory（）判断）时，再次调用自身函数
 8  * 注：上述调用自身函数的方法称为递归
 9  */
10 import java.io.*;
11 public class DiGuiDemo {
12     public static void main(String[] args) {
13             File dir=new File("F:");
14             showDir(dir);
15     }
16 //遍历文件和其子文件
17     private static void showDir(File dir) {
18         System.out.println(dir+""+f);
25         }
26     }
27 //    二进制
28     public static void toBin(int n){
29         if(n>0){
30             toBin(n/2);
31             System.out.println(n%2);
32         }
33     }
34 //    阶乘
35     public static int getX(int n){
36         if(n==1){
37             return 1;
38         }
39         return n*getX(n-1);
40     }
41 }

练习3：

 1 /*
 2  * 练习题：
 3  * 做一个指定目录下的.avi文件的绝对路径，存储到一个文本文件中。
 4  * 思路：
 5  * 1、对指定目录遍历；
 6  * 2、获得递归过程所以的java文件路劲
 7  * 3、将这些路径存储到集合
 8  * 4、将集合中的数据写入一个文本中；
 9  */
10 import java.io.*;
11 import java.util.*;
12 public class JavaFileList {
13     public static void main(String[] args){
14 //        指定目录
15         File dir=new File("F:");
16 //        定义一个list集合，用于存储.java文件的file对象
17         List<File> list=new ArrayList<File>();
18 //        调用获取文件路径方法,最后的list就获得了指定类型的文件路径
19         fileTolist(dir,list);
20 //        指定写入文件
21         File f=new File(dir,"avi大全.txt");
22 //        调用写入文件方法
23         writeTO(f,list);
24     }
25 //将集合中元素写入一个文本文件中
26     private static void writeTO(File f, List<File> list) {
27         BufferedWriter bw=null;
28         try {
29 //            使用字符流缓冲区对象关联写入的文件
30             bw=new BufferedWriter(new FileWriter(f));
31             for( File f0:list ){
32                 bw.write(f0.getAbsolutePath());
33                 bw.newLine();
34                 bw.flush();
35             }
36             
37         } catch (IOException e) {
38             throw new RuntimeException("写入文件失败");
39         }
40         finally{
41             try {
42                 if(bw!=null)
43                     bw.close();
44             } catch (IOException e2) {
45             
46             }        
47         }
48     }
49 //获取指定文件内所有的据对路径
50     private static void fileTolist(File dir, List<File> list) {
51         File[] files=dir.listFiles();//列出dir的目录
52 //        开始遍历
53         for(File f:files){
54 //            如果是非隐藏的且在目录内的继续
55             if(!(f.isHidden())&&f.isDirectory()){
56                 fileTolist(f,list);
57             }else if(f.getName().endsWith(".avi")||f.getName().endsWith(".mov")){
58                 list.add(f);
59             }
60         }
61     }
62 }

第二讲　　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);//从输入字节流中读取属性列表（键和元素对）。

 1 /*
 2  * 练习：要做一个软件有一定运行次数限制的注册软件
 3  * 
 4  * 分析：由于需要每一次软件开关与关闭时该注册列表都保存有，所以需要使用io技术+键值对形式存储
 5  *         map+io====properties
 6  * 思路：1、需要封装一个file文件用于判断原来的配置文件
 7  *        2、使用集合properties为存储容易存储配置信息；分别用FileInputStream和FileOutputStream流
 8  *         来传输信息
 9  *        3、每运行一次，使用计数器count增加一次，最后通过判断
10  * 关键语句：porperties：load（）用于读取缓冲流信息        getProperty（key）：由键得值
11  *                     store（写入缓冲流对象，备注）
12  *           Integer.parseInt()获得字符型变int型
13  *           FileInputStream和FileOutputStream这里信息少不需要增强
14  */
15 import java.io.*;
16 import java.util.*;
17 public class RunCout {
18     public static void main(String[] args) throws IOException{
19         Properties prop=new Properties();//创建一个存放键值对的集合
20         
21         File file=new File("D\\count.ini");//建立一个封装用的文件。后缀为ini
22         
23         if(!file.exists()){//判断是否存在
24             file.createNewFile();
25         }
26 //        非存文本，硬盘里所以用FileInputStream读取
27         FileInputStream fis=new FileInputStream(file);
28         prop.load(fis);//集合读取的是缓冲流信息
29         int count=0;
30         String value=prop.getProperty("time");//由键读值，这个time应该是默认就有的
31         if(value!=null){
32             count=Integer.parseInt(value);//count获得value的信息
33             if(count>=5){
34                 System.out.println("此路是我开，拿钱");
35                 return;
36             }
37         }
38         count++;
39         prop.setProperty("time", "count");//设置一下time=count
40 //        至此prop集合已经设置好，只需要传进列表中需要FileOutputStream,传入源的file中
41         FileOutputStream fos=new FileOutputStream(file);
42         prop.store(fos, "");//
43 //        关流
44         fis.close();
45         fos.close();
46     }
47 }

第三讲　　打印流

1|打印流：该流提供打印数据，将各个类型的数据原样打印

2、字节打印流：PrintStream

　　1、File对象。File

　　2、字符串路径：String

　　3、字节输出流：OutputStream

2、字节打印流：PrintWriter

　　1、File对象。File

　　2、字符串路径：String

　　3、字节输出流：OutputStream

　　4、多一个：字符输出流：writer

举个字符流的例子：

import java.io.*;
public class PrintStreamDemo {
    public static void main(String[] args)throws IOException{
//        键盘录入
        BufferedReader br=
                new BufferedReader(new InputStreamReader(System.in));
//        使用打印流并关联文件
        File file=new File("D:\\a.txt");
        PrintWriter pw=new PrintWriter(new FileWriter(file),true);//true的刷新只针对流而已的
//        所以true前面的参数需要new一个FileWriter对象

        String line=null;
        while((line=br.readLine())!=null){
            if(line.equals("over")){
                System.out.println("程序结束");
                break;
            }
            pw.println(line.toUpperCase());//大写输出
//            pw.flush；由于前面prinyWriter（，true）所以不需要刷新
        }
        br.close();
        pw.close();
    }
}

总结：打印流很屌，可以多运用下~

第四讲　　序列流

概述：

1、打印流SequenceInputStream，也称合并流，就是把多个流合并

2、常用构造函数：

　　SequenceInputStream(Enumeration<?extends FileInputStream> e);

常见合并多个流的步骤

1、创建Vector集合，将对象文件添加

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

3、创建SequenceInputStream对象，合并枚举对象

4、输出写入流相关联文件

5、数组缓冲读取法读取

 1 /*合并流：SequenceINputStream
 2  * 需求：将三个文本合并为一个
 3  * 思路：
 4  * 1、创建一个Vector集合（由于只能用枚举（Enumeration）），用于三个流添加到集合
 5  * 2、创建Enumeration，创建SequenceInputStream对象关联Enumeration
 6  * 3、输出流关联新文本
 7  * 4、反复读写操作
 8  * 关键字：Enumeration需要Vector集合
 9  *         
10  */
11 import java.util.*;
12 import java.io.*;
13 public class SequenInputDemo {
14     public static void main(String[] args) throws IOException{
15         Vector<FileInputStream> ve=new Vector<FileInputStream>();//创建几个智能方法InputStream流
16         ve.add(new FileInputStream("D:\\11.txt"));
17         ve.add(new FileInputStream("D:\\22.txt"));
18         ve.add(new FileInputStream("D:\\合并.txt"));
19         
20         Enumeration<FileInputStream> en=ve.elements();//创建en枚举ve
21 //        合并流合并en
22         SequenceInputStream sis=new SequenceInputStream(en);
23 //        关联被写入的文件
24         FileOutputStream fos=new FileOutputStream("D:\\合并2.txt");
25 //        开始写了
26         byte[] buf=new byte[1024];
27         int len=0;        
28         while((len=sis.read(buf))!=-1){
29             fos.write(buf,0,len);//写进fos的FileOutputStream中
30         }
31         fos.close();
32         sis.close();        
33     }
34 }

最后一个分几节输送文件的栗子：

 1 public class qiegeDemo {
 2 
 3     public static void main(String[] args) throws IOException{
 4 //        关联要切割文件，
 5         File file=new File("D:\\dog.JPG");
 6         int num=mysplit(file);//mysplit方法放回int型代表了分开了num节-1
 7 //        合并后的文件
 8         File fi=new File("D:\\zz.JPG");
 9         myHebin(num,fi);
10     }
11 //开始切啦
12     private static int mysplit(File file) throws IOException {
13         BufferedInputStream bis=
14                 new BufferedInputStream(new FileInputStream(file));
15         
16         BufferedOutputStream bos=null;//由于要多次写入所以只定义不new
17         
18         byte[] buf=new byte[1024*1024];//一兆
19         
20         int len=0,count=1;
21         
22         while((len=bis.read(buf))!=-1){
23 //            没满一兆就写入一个新文件,注意每次改名字后缀名随便取
24             bos=new BufferedOutputStream(new FileOutputStream("D:\\22\\"+(count++)+".part"));
25             bos.write(buf,0,len);
26             bos.close();//每次关闭
27         }
28         bis.close();
29         return count;        
30     }    
31     public static void myHebin(int num,File file)throws IOException
32     {
33 //        使用ArrayList
34         ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
35         for(int x=1;x<num;x++){
36             al.add(new FileInputStream("D:\\22\\"+x+".part"));
37         }
38 //        Enumeration是Vector的特有方法，所以要创建匿名内包内改写
39         ListIterator<FileInputStream> it=al.listIterator();
40         Enumeration<FileInputStream> en=new Enumeration<FileInputStream>() {        
41             public FileInputStream nextElement() {
42                 return it.next();
43             }            
44             @Override
45             public boolean hasMoreElements() {
46                 return it.hasNext();
47             }
48         };
49         
50 //        关联枚举对象
51         SequenceInputStream sis=new SequenceInputStream(en);
52 //        关联要写入的文件
53         FileOutputStream fos=new FileOutputStream(file);
54         
55 //        一下考虑封装一下
56         byte[] buf=new byte[1024*1024];
57         int len=0;
58         while((len=sis.read(buf))!=-1){
59             fos.write(buf,0,len);
60         }
61         sis.close();
62         fos.close();
63     }
64 }