hooyantsing's Blog

第35次课程

字数统计: 1.7k阅读时长: 7 min
2019/07/12

源辰74班

第35次课程

07.12.2019

**内容    **

Java_API_java.io包****[蒋斌]

1.File类

案例解析:

构造

File 变量名 = new  File(“文件路径”);

字段

File.pathSeparator:与系统有关的路径分隔符,为了方便,它被表示为一个字符串。在Windows下为“;”。

File.separator:与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。在Windows下为“\”。

方法

**File.createNewFile()**:创建文件,创建成功返回true,失败返回false。

**File.exists()**:判断文件是否存在,存在返回true,不存在返回false。

*File.***.listFiles()**:获取当前目录下所有子文件的抽象路径。

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
public class File_Test {
    public static void main(String[] args)  throws IOException {
       //按照不同系统,输出分隔符
       //打印;
       String pathseparator =  File.pathSeparator;
       System.out.println(pathseparator);
       //打印\
       String separator = File.separator;
       System.out.println(separator);
       //
       String path =  "G:\\YC74"+separator+"190712\\code\\lab\\mubiao.txt";
       System.out.println(path);
       
       //实例化File
       File f1 = new  File("G:\\YC74\\190712\\code\\lab\\mubiao.png");
       //创建文件,创建成功返回true,失败返回false
       System.out.println(f1.createNewFile());
       //判断文件是否存在,存在返回true,否则返回false
       System.out.println(f1.exists());
       
       //获取文件夹下下面的所有子文件
       File f2 = new  File("G:\\YC74\\190712\\code\\lab");
       //获取的文件名放入数组中
       File[] listFiles = f2.listFiles();
       //打印数组
       for(int i=0;i<listFiles.length;i++)  {
           System.out.println(listFiles[i]);
       }
    }
}

2.[案例]文件搜索

案例分析:

方法

**File.****getName()**:获取文件名

**File.getAbsolutePath()**:获取文件的绝对路径字符串。

**File.****getName().contains(key)**:以File所在路径为参照,获取其他文件的相对路径,key是关键字。

**File.****isDirectory()**:判断是否是目录(文件夹),存在且是目录返回true,否则返回false。

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
package hooy.file;
import java.io.File;
import java.util.ArrayList;

public class WenJianSouSuo {
    static ArrayList<String> list = new ArrayList<String>();
    private static int fileNum;  //统计
    private static int foldNum;
    public static void main(String[] args) {
        search("G:\\YC74","");
        for(String s:list) {
            System.out.println(s);
        }
        System.out.println("文件夹:"+foldNum+"\t文件:"+fileNum);

    }
    public static void search(String path,String key) {
        File f = new File(path);
        //判断是否存在文件和文件夹
        if(f.exists()) {
            //判断是否是文件还是文件夹
            if(f.isDirectory()) {
                //是文件夹 //获取子文件
                File[] listFiles = f.listFiles();
                for(int i=0;i<listFiles.length;i++) {
                    //获取子文件的 绝对路径
                    String absolutePath = listFiles[i].getAbsolutePath();
                    //递归
                    search(absolutePath,key);
                }
                foldNum++;
            }else {
                //是文件
                if(f.getName().contains(key)) {
                    //获取 相对路径
                    list.add(f.getPath());
                }
                fileNum++;
            }
        }
    }
}

*3.FileInputStream*

文件输入流

案例分析:

构造

InputStream in = new  FileInputStream(FILE)

方法

*FileInputStream(FILE)***.read()**:从此输入流中读取一个数据字节。如果没有输入可用,则此方法将阻塞。返回下一个数据字节,如果已到达文件末尾,则返回 -1。仅读取一次,继续向后读取。

案例:每次仅读取一个字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Demo3 {
    public static void main(String[] args) {
       //定位文件位置
       File f = new File("");
       try {
           //获取输入流
           InputStream in = new  FileInputStream(f);
           for(int i=0;i<f.length();i++) {
               //每次读取一个字节
               int v2 = in.read();
               System.out.println(v2);
           }
       }catch(FileNotFoundException e) {
           e.printStackTrace();
       }catch(IOException e) {
           e.printStackTrace();
       }
    }
}

案例:每次读取一个数组的字符量

FileInputStream(FILE).read()读取结束的标志是返回-1。

程序结束后,通过finally结束流。

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
package hooy.file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class Demo4 {
    public static void main(String[] args) {
        //定位文件位置
        File f = new File("网络端口.txt");
        InputStream in = null;
        try {
            //获取输入流
            in = new FileInputStream(f);
            byte[] b = new byte[1024];
            int len = -1;
            //.read()方法:每个字符仅读一次,继续往后读取
            while((len=in.read(b))!=-1) {
                //System.out.println(in.read(b));
                //String(数组,从哪开始,到哪里结束)
                String str = new String(b,0,len);
                System.out.println(str);
            }
        }catch(FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

4.[案例]文件复制(基于InputStream和OutputStream实现****)

案例分析:

构造

**OutputStream out = **new FileOutputStream(“地址”)

**OutputStream out = ****new FileOutputStream(“地址”,true)**:加入参数true,写入文件时,将在原有数据后面继续写入。

方法

*FileOutputStream(“”)***.write(b, 0, len)**:文件输出流,将内容写入文件中。(数据数组,开始下标,结束下标)。

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
package hooy.file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Demo5 {
    public static void main(String[] args) {
        //输入流
        InputStream in = null;
        //输出流
        OutputStream out = null;
        try {
            //获取输入流
            in = new FileInputStream("");
            //获取输出流
            out = new FileOutputStream("");
            byte[] b = new byte[1024];
            int len = -1;
            //文件读完的标志:返回不再是字节长度,而是-1
            while((len=in.read(b))!=-1) {
                //将输入流读到的内容放入输出流中
                out.write(b, 0, len);
            }
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null) {
                try {
                    in.close();
                }catch(IOException e) {
                    e.printStackTrace();
                }
            }
            if(out!=null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5.[案例]文件复制(基于ReaderWriter实现****)

案例分析:

构造

字符流和缓冲字符流应同时出现

**Reader r = ****new FileReader(“1.txt”)**:输入字符流

**BufferedReader br = new BufferedReader(r)**:读缓冲字符流

**Writer w = ****new FileWriter(“2.txt”)**:输出字符流

**BufferedWriter bw = new BufferedWriter(w)**:写缓冲字符流

方法

*BufferedReader(FileReader(“1.txt”))***.readLine()**:读取缓冲字符流中的数据,仅读取一次后继续向后读取,按照行读取。

*BufferedReader(FileReader(“1.txt”))***.readLine()**读取结束的标志是返回null。

*BufferedWriter(FileWriter(“2.txt”))***.write(value)**:将读到的value数据写入到文件当中,若文件不存在,则创建。

*BufferedWriter(FileWriter(“2.txt”))***.newLine()**:写入数据时,进行换行。

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
49
50
51
52
53
54
55
package hooy.file;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

//通过 字符输入、输出流 来实现文件的复制

public class Reader_Writer {
    public static void main(String[] args)  {
        //创建字符输入、输出流
        Reader r = null ;
        Writer w = null ;
        try {
            r = new FileReader("1.txt");
            w = new FileWriter("2.txt");
        //创建 读写缓冲字符流
        BufferedReader br = new BufferedReader(r);
        BufferedWriter bw = new BufferedWriter(w);
        String value = null;
        //文件读完的标志:返回不再是数据,而是null
        while((value=br.readLine())!=null) {
            //将读取出来的数据写入
            bw.write(value);
            //换行
            bw.newLine();
            }
        bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(r!=null) {
                try {
                    r.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(w!=null) {
                try {
                    w.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
CATALOG