IO流#

File类#

文件和文件目录(文件夹)的抽象表示，File对象代表了系统中的某个文件或文件夹，对File对象的操作就是对文件或文件夹的操作了。

File类的构造器

File(String path)

File(File parent,String name)

File(String parent,String name)

File类的方法

createNewFile() : 创建一个文件

1
  //d:/lession/java2601中创建一个a.txt的文件
2
 //File file = new File("d:\\lession\\java2601\\a.txt");
3
 //File file = new File("d:/lession/java2601","a.txt");
4
 //File file1 = new File("d:/lession/java2601");
5
 //File file = new File(file1,"a.txt");
6
 File file = new File("d:/lession/java2601/test/a.txt");
7
 try {
8
    file.createNewFile();
9
 } catch (IOException e) {
10
    e.printStackTrace();
11
 }

如果文件存在则不会再次创建，文件和文件夹在同一个目录中不能重名

文件的后缀的作用：识别这个文件默认用什么软件运行，不影响文件的内容。

mkdir() : 创建文件夹

1
File file = new File("d:/lession/java2601/test/a");
2
 file.mkdir();

mkdirs() : 创建多级文件夹

1
File file = new File("d:/lession/java2601/test/a/b/c");
2
file.mkdirs();

createTempFile：创建临时文件

1
 File file = new File("d:/lession/java2601/test");
2
 try {
3
    File.createTempFile("1111","0000",file);
4
 } catch (IOException e) {
5
    e.printStackTrace();
6
 }

isFile() : 是否是文件

isDirectory() :是否是文件夹

delete() : 删除文件或文件夹。如果删除的是文件夹，只能删除空文件夹

equals() : 比较两个文件是否相等，重写了Object的equals方法比较的是两个File对象的路径是否相等。

getParentFile() : 获得父文件夹的File对象

getPath() : 获得路径

length() : 获得文件或文件夹的大小(byte数) ，返回结果是long

listFiles() : 获得文件夹中所有的File对象(包括文件和文件夹) ，获得的只是子文件及文件夹。返回File[]数组

1
 File file = new File("d:/lession/java2601");
2
 File[] files = file.listFiles();
3
 for(File f:files){
4
    System.out.println(f);
5
 }

递归算法#

在方法中调用当前（本身）的方法

1
 public class Test {
2
    public static void main(String[] args) {
3
        System.out.println(jiecheng(4));
4
        //第5个数是什么
5
        System.out.println(feibo(6));
6
        //汉诺塔递归
7
    }
8
    public static int jiecheng(int i){
9
        if(i==1) return 1;
10
        return jiecheng(i-1)*i;
11
    }
12
    public static int feibo(int i){
13
        if(i==2 || i == 1){
14
            return 1;
15
        }
16
        return feibo(i-2)+feibo(i-1);
17
    }
18
 }

文件查找的递归：

找出d:/lession/java2601中所有的后缀是.pdf的文件，输出文件路径

找出d:/lession/java2601中所有的后缀是.pdf的文件，存储到集合中

删除d:/lession/java2601/test/a文件夹

1
 public class TestFile {
2
    public static void main(String[] args) {
3
 /*        File file = new File("d:/lession/java2601");
4
        //queryFile(file);
5
        List<File> list = new ArrayList<>();
6
        queryFileToList(file,list);
7
        for(File file1:list){
8
            System.out.println(file1);
9
        }*/
10
        File file = new File("D:\\Lession\\java2601\\test\\a");
11
        deleteDir(file);
12
    }
13
    //输出所有的pdf文件
14
    public static void queryFile(File file){
15
        File[] files = file.listFiles();
16
        for(File f:files){
17
            if(f.isFile()){
18
                String name = f.getName();
19
                int index = name.lastIndexOf(".");
20
                if(index!=-1){
21
                    String hzm = name.substring(index);
22
                    if(".pdf".equals(hzm)){
23
                        System.out.println(f);
24
                    }
25
                }
26
            }else{
27
                queryFile(f);
28
            }
29
        }
30
    }
31
    //pdf文件存储到ArrayList中
32
    public static void queryFileToList(File file,List<File> list){
33
        File[] files = file.listFiles();
34
        for(File f:files){
35
            if(f.isFile()){
36
                String name = f.getName();
37
                int index = name.lastIndexOf(".");
38
                if(index!=-1){
39
                    String hzm = name.substring(index);
40
                    if(".pdf".equals(hzm)){
41
                        list.add(f);
42
                    }
43
                }
44
            }else{
45
                queryFileToList(f,list);
46
            }
47
        }
48
    }
49
    public static void deleteDir(File file){
50
        File[] files = file.listFiles();
51
        for (File f:files){
52
            if(f.isDirectory()){
53
                deleteDir(f);
54
            }
55
            f.delete();
56
        }
57
    }
58
}

IO流概念#

输出、输出的数据流，也就是IO流代表了，从内存输出的数据（写数据）和输入内存的数据（读数据），数据都是有序的二进制数据。

Java中提供了一些处理IO流的工具类，称为IO流类，能够实现数据的读写。

IO流类的分类#

根据需求选择不同分类的IO流的类

从方向分为输入流和输出流，输入流负责读数据，输入流具有read方法；输出流负责写数据，输出流具有write方法。InputStream和Reader的子类都是输入流；OutputStream和Writer的子类都是输出流。
从处理数据的能力分为：字节字符流，每read/write一次处理一个字节，就是字节流，字符流同理。一般在处理文字并显示文字时，要使用字符流。InputStream和OutputStream的子类都是字节流；Reader和Writer的子类都是字符流。
从装饰的角度分为：节点流(基础流)和处理流(高级流) 。节点流能处理所有的功能但是效率低；处理流只能处理特定的功能但是效率高。

装饰模式：将一些功能组合在一起，例如有杯子、杯垫、杯盖、贴纸等东西，现在我想美观的喝水，将杯子和贴纸装饰在一起；我想保温、美观的喝水，将杯子、杯盖、贴纸装饰在一起。

引申到IO流类中：文件读写的IO流(节点流) 、带缓冲的IO流(处理流)、读写对象的IO流（处理流）等，我想快速的将对象写到文件中，我们就可以对三个IO流类进行装饰。

IO流的使用思路：

分析需求，选择符合需求功能的IO流
IO流装饰在一起
IO流的方法几乎都是 read 或 write

FileInputStream/FileOutputStream#

读写文件的IO流类

FileInputStream的read方法有三个：

read() : 读取1个字节，返回字节的字符编码值，如果没有读到数据（读到末尾了）返回-1
read(byte[] bytes) : 读取byte[]长度字节，读到byte[]中，返回读取个数
read(byte[] bytes, int index, int length) : 读取指定长度的数据，读到byte[]指定的index位置

示例：读取d:/lession/java2601/test/a.txt文件中的内容

1
public static void main(String[] args) {
2
        //File file = new File("d:/lession/java2601/test/a.txt");
3
        try {
4
            //FileInputStream fis = new FileInputStream(file);
5
            FileInputStream fis = new FileInputStream("d:/lession/java2601/test/a.txt");
6
            //读一个字节
7
            int i = fis.read();
8
            System.out.println(i);
9
            //一次读3个字节
10
            byte[] bytes = new byte[3];
11
            fis.read(bytes);
12
            for (int j = 0; j < bytes.length; j++) {
13
                System.out.println(bytes[j]);
14
            }
15
            bytes = new byte[1000];
16
            //虽然byte是1000长度，读的时候读了1个读到byte[]的0位置上
17
            fis.read(bytes,0,1);
18
            System.out.println(fis.read());
19
        } catch (FileNotFoundException e) {
20
            e.printStackTrace();
21
        } catch (IOException e) {
22
            e.printStackTrace();
23
        }
24
    }

读取所有的内容：

1
 //File file = new File("d:/lession/java2601/test/a.txt");
2
        try {
3
            //FileInputStream fis = new FileInputStream(file);
4
            FileInputStream fis = new FileInputStream("d:/lession/java2601/test/a.txt");
5
            //一个一个读的循环
6
 /*            int temp = 0;
7
            while((temp = fis.read())!=-1){
8
                System.out.println(temp);
9
            }*/
10
            //一批一批读的循环  批量读取效率高
11
            //byte[] 就是一个 自定义的缓冲区
12
            //System.out.println(fis.available());
13
            byte[] bytes = new byte[2];
14
            int temp = 0;
15
            while((temp=fis.read(bytes))!=-1){
16
                for (int i = 0; i < temp; i++) {
17
                    System.out.println(bytes[i]);
18
                }
19
            }
20
        } catch (FileNotFoundException e) {
21
    e.printStackTrace();
22
} catch (IOException e) {
23
    e.printStackTrace();
24
}

IO流得关闭，使用try-with-resource 语法糖写法：

1
try(
2
        FileInputStream fis= new FileInputStream("d:/lession/java2601/test/a.txt")
3
    ) {
4
        byte[] bytes = new byte[2];
5
        int temp = 0;
6
        while((temp=fis.read(bytes))!=-1){
7
            for (int i = 0; i < temp; i++) {
8
                System.out.println(bytes[i]);
9
            }
10
        }
11
    } catch (FileNotFoundException e) {
12
        e.printStackTrace();
13
    } catch (IOException e) {
14
        e.printStackTrace();
15
    }

FileOutputStream : 向文件中写内容

构造器中有两个参数的构造器，其中一个参数 boolean append代表是否追加内容，默认是false不追加(覆盖)

1
 public class TestFileInputStream {
2
    public static void main(String[] args) {
3
        //向a.txt中写入一段内容 ：  ABCDEFG
4
        try(
5
            FileOutputStream fos = new FileOutputStream("d:/lession/java2601/test/a.txt",true);
6
        ) {
7
            //fos.write('A');
8
            fos.write("ABCDEFG".getBytes());
9
        } catch (FileNotFoundException e) {
10
            e.printStackTrace();
11
        } catch (IOException e) {
12
            e.printStackTrace();
13
        }
14
    }
15
 }

复制文件的示例：封装一个方法

BufieredInputStream和BufieredOutputStream#

处理流，构造对象时需要传入InputStream、OutputStream

自带缓冲区的IO流

写内容的最后，需要fiush ，冲刷缓冲区

1
public class TestFileInputStream {
2
    public static void main(String[] args) {
3
        copy2("d:/1022-01.mp4","d:/lession/java2601/test/test.mp4");
4
    }
5
    public static void copy(String srcPath,String destPath){
6
        try(
7
            FileInputStream fis = new FileInputStream(srcPath);
8
            FileOutputStream fos = new FileOutputStream(destPath);
9
        ) {
10
            int temp = 0;
11
            while((temp=fis.read())!=-1){
12
                fos.write(temp);
13
            }
14
        } catch (FileNotFoundException e) {
15
            e.printStackTrace();
16
        } catch (IOException e) {
17
            e.printStackTrace();
18
        }
19
    }
20
    public static void copy2(String srcPath,String destPath){
21
        try(
22
                FileInputStream fis = new FileInputStream(srcPath);
23
                FileOutputStream fos = new FileOutputStream(destPath);
24
        ) {
25
            int temp = 0;
26
            byte[] bytes = new byte[1024];
27
            while((temp=fis.read(bytes))!=-1){
28
                fos.write(bytes,0,temp);
29
            }
30
        } catch (FileNotFoundException e) {
31
            e.printStackTrace();
32
        } catch (IOException e) {
33
            e.printStackTrace();
34
        }
35
    }
36
    public static void copy3(String srcPath,String destPath){
37
        try(
38
                FileInputStream fis = new FileInputStream(srcPath);
39
                FileOutputStream fos = new FileOutputStream(destPath);
40
                BufieredInputStream bis = new BufieredInputStream(fis);
41
                BufieredOutputStream bos = new BufieredOutputStream(fos);
42
        ) {
43
            int temp = 0;
44
            while((temp=bis.read())!=-1){
45
                bos.write(temp);
46
            }
47
            //冲刷缓冲区的数据到设备上
48
            bos.fiush();
49
        } catch (FileNotFoundException e) {
50
            e.printStackTrace();
51
        } catch (IOException e) {
52
            e.printStackTrace();
53
        }
54
    }
55
}

FileReader/FileWriter#

文件读写的字符流，天然是一个缓冲流，在write后需要fiush操作

1
/*try {
2
     FileReader fr = new FileReader("d:/lession/java2601/test/a.txt");
3
     *//*int temp = 0;
4
     while((temp=fr.read())!=-1){
5
         System.out.println((char)temp);
6
     }*//*
7
     int temp = 0;
8
     char[] chars = new char[4];
9
     while((temp=fr.read(chars))!=-1){
10
         System.out.println(new String(chars,0,temp));
11
     }
12
 } catch (FileNotFoundException e) {
13
     e.printStackTrace();
14
 } catch (IOException e) {
15
     e.printStackTrace();
16
 }*/
17
 try {
18
     FileWriter fw = new FileWriter("d:/lession/java2601/test/a.txt");
19
     fw.write("1234567890");
20
     fw.fiush();
21
 } catch (IOException e) {
22
     e.printStackTrace();
23
 }

BufieredReader/BufieredWriter#

BufieredReader具有readLine方法：成行读

BufieredReader/BufieredWriter 能设置缓冲区大小

1
public static void main(String[] args) {
2
       try {
3
           FileReader fr = new FileReader("d:/lession/java2601/test/a.txt");
4
           BufieredReader br = new BufieredReader(fr);
5
           String temp = null;
6
           while((temp=br.readLine())!=null){
7
                System.out.println(temp);
8
            }
9
        } catch (FileNotFoundException e) {
10
            e.printStackTrace();
11
        } catch (IOException e) {
12
            e.printStackTrace();
13
        }
14
/*        try {
15
            FileWriter fw = new FileWriter("d:/lession/java2601/test/a.txt");
16
            BufieredWriter bw = new BufieredWriter(fw,1024<<2);
17
            bw.write("1234567890");
18
            bw.fiush();
19
        } catch (IOException e) {
20
            e.printStackTrace();
21
        }*/
22
    }

InputStreamReader/OutputStreamWriter#

是Reader和Writer的子类，字符流；功能是将字节流转为字符流，在构造InputStreamReader对象时需要传入一个InputStream（字节流）

1
try(
2
    FileInputStream fis = new FileInputStream("d:/lession/java2601/test/a.txt");
3
    InputStreamReader reader = new InputStreamReader(fis);
4
    BufieredReader br = new BufieredReader(reader);
5
   ) {
6
    String temp = null;
7
    while((temp = br.readLine())!=null){
8
        System.out.println(temp);
9
    }
10
} catch (FileNotFoundException e) {
11
    e.printStackTrace();
12
} catch (IOException e) {
13
    e.printStackTrace();
14
}

DataInputStream / DataOutputStream#

读写基本类型的数据例如要把1024(int值)写入到文件中，如果用String存储1024四个字符；如果用DateOutputStream存储是 1024的二进制四字节数据

1
public static void main(String[] args) {
2
   try(
3
       FileOutputStream fos = new FileOutputStream("d:/lession/java2601/test/a.txt");
4
       DataOutputStream dos = new DataOutputStream(fos);
5
        ) {
6
        dos.writeDouble(100.0);
7
    } catch (FileNotFoundException e) {
8
        e.printStackTrace();
9
    } catch (IOException e) {
10
        e.printStackTrace();
11
    }
12
    try(
13
        FileInputStream fis= new FileInputStream("d:/lession/java2601/test/a.txt");
14
        DataInputStream dis = new DataInputStream(fis);
15
        ) {
16
        double d = dis.readDouble();
17
        System.out.println(d);
18
    } catch (FileNotFoundException e) {
19
        e.printStackTrace();
20
    } catch (IOException e) {
21
        e.printStackTrace();
22
    }
23
}

序列化和反序列化#

将对象变成byte[]数组过程叫序列化；byte[]数组变回对象叫反序列化；当要传输对象时，向网络传输、向文件传输。

一个类的对象要实现序列化和反序列化，这个类一定要实现Serializable接口

序列化和反序列化的封装实现：

1
public class SerUtil {
2
   public static void main(String[] args) {
3
       Person person = new Person("tom",20,"13312345678");
4
       byte[] bytes = serialize(person);
5
       Person p2 = (Person)unSerialize(bytes);
6
       System.out.println(p2);
7
   }
8
   //序列化
9
   public static byte[] serialize(Object obj){
10
       try(
11
           ByteArrayOutputStream baos = new ByteArrayOutputStream();
12
           ObjectOutputStream oos = new ObjectOutputStream(baos);
13
       ) {
14
           oos.writeObject(obj);
15
           return baos.toByteArray();
16
        } catch (IOException e) {
17
            e.printStackTrace();
18
        }
19
        return null;
20
    }
21
    //反序列化
22
    public static Object unSerialize(byte[] bytes){
23
        try(
24
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
25
            ObjectInputStream ois = new ObjectInputStream(bais);
26
                ) {
27
            return ois.readObject();
28
        } catch (IOException e) {
29
            e.printStackTrace();
30
        } catch (ClassNotFoundException e) {
31
            e.printStackTrace();
32
        }
33
        return null;
34
    }
35
}

注意：序列化和反序列化的JDK版本要一致

PrintWriter#

写文件、封装字节或字符流、缓冲、带ln的写

1
 public static void main(String[] args) {
2
    try(
3
    PrintWriter pw = new PrintWriter("d:/lession/java2601/test/a.txt");
4
    ){
5
        pw.println("你好啊");
6
        pw.println("中午吃什么");
7
        pw.fiush();
8
    } catch (FileNotFoundException e) {
9
        e.printStackTrace();
10
    }
11
 }

Properties类#

用来读取properties配置文件的类。

配置文件：可以将一些数据写到配置文件中，程序在运行时读取到配置文件中的数据，这些数据是用户可以改变的数据，不能固化在程序中的数据。

Java的配置文件的种类：

xml配置文件：具有结构化，编写比较困难，解析也比较麻烦
properties配置文件 : 编写简单，name=值的写法，结构化非常弱
yaml / yml 配置文件： springboot再使用，待续

需求：将properties配置文件中的数据赋给两个Person对象的属性

创建Properties对象
将配置文件加载到 Properties对象中 : load方法

Properties对象中封装了一个Map

调用Properties对象的get方法

1
public static void main(String[] args) {
2
        Person p1 = new Person();
3
        Person p2 = new Person();
4
        Properties properties = new Properties();
5
        try(
6
            FileInputStream fis = new
7
FileInputStream("D:\\Lession\\java2601\\workspace\\pjt0128\\src\\myinfo.properties");
8
        ) {
9
            properties.load(fis);
10
            p1.name = (String)properties.get("p1.name");
11
            p1.age = Integer.parseInt((String)properties.get("p1.age"));
12
            p2.name = (String)properties.get("p2.name");
13
            p2.age = Integer.parseInt((String)properties.get("p2.age"));
14
            System.out.println(p1);
15
            System.out.println(p2);
16
        } catch (FileNotFoundException e) {
17
            e.printStackTrace();
18
        } catch (IOException e) {
19
            e.printStackTrace();
20
        }
21
        //写
22
        properties.setProperty("p3.name","tom");
23
        properties.setProperty("p3.age","22");
24
        try {
25
            properties.store(new
26
FileOutputStream("D:\\Lession\\java2601\\workspace\\pjt0128\\src\\myinfo.properties")
27
                ,"这是第三个人的信息");
28
        } catch (FileNotFoundException e) {
29
            e.printStackTrace();
30
        } catch (IOException e) {
31
            e.printStackTrace();
32
        }
33
    }

POI#

是apache软件基金会中的一个子项目功能，实现excel、word等文档内容的读写

POI实现一个简单的Excel读写功能

需求：读取学生成绩.xls的sheet1中的数据，计算学生的平均成绩，写入sheet2中

欢迎来到 SuifengFlying!