JAVASE_20_#java高级IO_File对象和IO包中的其他类

来源：互联网发布：闲鱼怎么做淘宝链接编辑：程序博客网时间：2024/05/17 22:31

1，File类

------File的实例：--文件或者文件夹

------用来将文件或者文件夹封装成对象

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

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

1.1，创建File对象---三种构造方法
1
2
3
4
5
6
7
File f1 = new File("a.txt");

File f2 = new File("c:\\abc","b.txt");
File f2 = new File("C:","b.txt");//注意路径写法"c:"或者"c:\\",但是不可"c"
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");
1.2，目录分隔符

---File类中static String separator
---系统有关的默认名称分隔符,可以跨平台
1
2
File f4 = new File("c:\\abc\\zzz\\a.txt");
File f4 = new File("c:"+File.separator+"abc\\zzz\\a.txt");//

2，File对象常见方法

1，创建。

boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
static File createTempFile(String prefix, String suffix)//创建临时文件

boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。

2，删除。

boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回false。

如何想在程序时删除文件，却抛出异常，则无法删除。delete删除目录时，必须目录为空

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

3，判断。

Boolean canExecute()；//
boolean exists() :文件或者文件夹是否存在.
isFile();//记住在判断文件对象是否是文件或目录时，必须要先判断该文件对象封装的内容是否存在
isDirectory();//是否是目录
isHidden();//是否隐藏文件
isAbsolute();//绝对路径，即使文件不存在也可以判断，只看是否带盘符

4，获取信息。

getName():
getPath()://获取的时--封装的路径--无论此路径是相对还是绝对路径，和文件存在无关
getAbsolutePath();//真是的绝对路径，和文件存在无关
getParent()://该方法返回是绝对路径中的父目录，如果获取的是时相对的，返回的是null

//如果相对路径中有上一层目录那么该目录就会返回结果

long lastModified()；最后一次修改的时间
long length()；

renameTo(); //有点类似于剪切
1
2
3
File f1 = new File("c:\\Test.java");
File f2 = new File("d:\\hahah.java");
sop("rename:"+f2.renameTo(f1));

3，文件列表

static File[ ] listRoots();//列出系统根目录
1
2
3
4
File[] files = File.listRoots();
for(File f : files){
    System.out.println(f);
}
String[ ] list( );返回此目录下的文件盒目录名（包括隐藏的）
-----------调用list方法的file对象必须是封装了一个目录。该目录还必须存在
-----------如果是一个文件，则下面的高级for抛出NullPointerException
1
2
3
4
5
File f = new File("c:\\abc.txt");
String[] names = f.list();//
for(String name : names){
    System.out.println(name);
}
String[ ] list(FilenameFilter filter);
1
2
3
4
5
6
7
8
9
File f = new File("E:\\workspace");
String[] names = f.list(new FilenameFilter(){//此接口就一个方法，实现接口用匿名类
    public boolean accept(File dir,String name){
        return dir.exists()&&name.endsWith(".java");
    }
});
for(String name: names){
    System.out.println(name);
}
File[ ] listFiles( );//开发更常用这2个，因为返回的是对象，调用getName（）等等可以操作！
File[ ] listFiles(FIleFilter filter );
1
2
3
4
5
File dir = new File("c:\\");
File[] files = dir.listFiles();
for(File f : files){
    System.out.println(f.getName()+"::"+f.length());
}

4，列出目录下所有内容-----递归

也就是函数自身调用自身。这种表现形式，或者编程手法，称为递归。
递归要注意：

1，限定条件。否则无限循环
2，要注意递归的次数。尽量避免内存溢出。

-----递归只有到最后满足限制条件，才会从最后一次调用往上逐渐返回。
1
2
3
4
5
6
7
8
9
public static void toBin(int num){
    if(num>0){
        toBin(num/2);//递归
        System.out.println(num%2);
    }
}
public static void method(){//无限制条件是死循环
    method();
}
应用：1.列出目录下所有内容

2.删除带内容的目录-----删除原理：在window中，删除目录从里面往外删除的。

既然是从里往外删除。就需要用到递归。
3.创建java文件列表清单

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。
建立一个java文件列表文件。
思路：
1，对指定的目录进行递归。
2，获取递归过程所以的java文件的路径。
3，将这些路径存储到集合中。
4，将集合中的数据写入到一个文件中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import java.io.*;
import java.util.*;
class  JavaFileList{
    public static void main(String[] args) throws IOException{
        File dir = new File("d:\\java1223");
        List<File> list = new ArrayList<File>();
        fileToList(dir,list);
        //System.out.println(list.size());
        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)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();
                bufw.flush();
            }

        }
        catch (IOException e){throw e;}
        finally{
            try{
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e){throw e;}
        }
    }
}

5，类 Properties简述

-----------Properties是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中和IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
那么在加载数据时，需要数据有固定格式：键=值。

6，Properties存取配置文件

<1>，setProperty(String key, String value);
<2>，getProperty(String key);

1
2
3
4
Properties prop = new Properties();
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");
String value = prop.getProperty("lisi");
<3>,Properties存取配置文件

演示，如何将流中的数据存储到集合中。

想要将已存在info.txt中键值数据存到集合中进行操作。

1,用一个流和info.txt文件关联。
2，读取一行数据，将该行数据用"="进行切割。
3，等号左边作为键，右边作为值。存入到Properties集合中即可。
1
2
3
4
5
6
7
8
9
10
11
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]+"...."+arr[1]);
        prop.setProperty(arr[0],arr[1]);
    }
    bufr.close();
}

<4>.

load(InputStream inStream) ；

// 从输入流中读取属性列表(键值对).上述代码为其原理

void store(OutputStream out, String comments) ；

//将流中数据存储到配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void loadDemo()throws IOException{
    Properties prop = new Properties();
    FileInputStream fis = new FileInputStream("info.txt");
    //将流中的数据加载进集合。
    prop.load(fis);
    prop.setProperty("wangwu","39");//改变的是内存的结果，
    //将改变结果写入文件
    FileOutputStream fos = new FileOutputStream("info.txt");
    prop.store(fos,"haha");//注释“#”不会被Property类所加载
// System.out.println(prop);
    prop.list(System.out);
    fos.close();
    fis.close();
}

7，Properties练习

用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。

很容易想到的是:计数器。
可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。
可是随着该应用程序的退出，该计数器也在内存中消失了。
下一次在启动该程序，又重新开始从0计数。
这样不是我们想要的。
程序即使结束，该计数器的值也存在。
下次程序启动在会先加载该计数器的值并加1后在重新存储起来。
所以要建立一个配置文件。用于记录该软件的使用次数。
该配置文件使用键值对的形式。
这样便于阅读数据，并操作数据。
键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io -->properties.
配置文件可以实现应用程序数据的共享。

通常情况下java的配置文件都是"config.properties"这种文件形式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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");//time作为键
        if(value!=null){
            count = Integer.parseInt(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();
    }
}
注意事项：
1.在用IO流操作文件时，要先用File类把文件封装成对象。这样做的目的：流无法对文件进行判断

8.对于配置文件一点点小常识（了解即可day19-14末尾）

XML中的配置形式：
1
2
3
4
5
6
7
8
9
10
<persons>
    <person id="001">
        <name>zhagnsan</name>
        <age>30</age>
        <address>bj</address>
    </person>
    <person>
        <name
    </person>
</persons>
读取工具为----dom4j dom for java four

9.IO包中的其他类

（一）打印流：PrintStream和PrintWriter
该流提供了打印方法，可以将各种数据类型的数据都原样打印。

1,字节打印流： ------PrintStream

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

1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream

2,字符打印流： PrintWriter-----web开发时很常用

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

1，file对象。File
2，字符串路径。String
3，字节输出流。OutputStream
4，字符输出流，Writer。
b:常见构造

1
2
3
4
5
6
7
PrintWriter(OutputStream out);//
PrintWriter(OutputStream out, boolean autoFlush);//自动刷新,println，printf或format方法
PrintWriter(File file)
PrintWriter(File file, String csn);//csn字符集，编码
PrintWriter(String fileName);
PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);
//把String或者文件对象转换成流就可以自动刷新

（二）序列流SequenceInputStream----对多个流进行合并

构造函数
1.SequenceInputStream(InputStream s1, InputStream s2)
2.SequenceInputStream(Enumeration<? extends InputStream> e);//枚举找聚合Vector，效率低
应用：多个源一个目的地的时候！----小说把多个章节集合到一个txt里面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class SequenceDemo {
    public static void main(String[] args) throws IOException{
        Vector<FileInputStream> v = new Vector<FileInputStream>();//枚举就是Vector特有的取出方式
        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 = new FileOutputStream("c:\\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();
    }
}
（三）切割文件

等份切割，非要说部分等分，最后一个可以不等份。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
class SplitFile {
    public static void main(String[] args) throws IOException{
        //splitFile();
        merge();
    }
    public static void merge()throws IOException{
        ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
        for(int x=1; x<=3; x++){
            al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
        }
        final Iterator<FileInputStream> it = al.iterator();//内部类只能调用final修饰的
        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("c:\\splitfiles\\0.bmp");
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=sis.read(buf))!=-1){
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
    public static void splitFile()throws IOException{
        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();
    }
}

！！结尾！！

0 0