JAVASE基础（十二）

一、流

概念：内存与存储设备之间传输数据的通道。

数据借助流传输。

流的分类：

1、按方向：

（1）输入流：将<存储设备>中的内容读入到<内存>中。

（2）输出流：将<内存>中的内容写入到<存储设备>中。

2、按单位：

（1）字节流：以字节为单位，可以读写所有数据。

（2）字符流：以字符为单位，只能读写文本数据。

3、按功能：

（1）节点流：具有实际传输数据的读写功能。

（2）过滤流：在节点流的基础上增强功能。

二、字节流

字节流的父类（抽象类）：

InputStream：字节输入流

OutputStream：字节输出流

1、文件字节流

FileInputStream：public int read（byte[] b）//从流中读取多个字节，将读到的内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。

FileOutputStream：public void write（byte[] b）//一次写多个字节，将b数组中所有字节，写入输出流。

package com.io;

import java.io.FileInputStream;

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1.创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //2.读取文件
        //(1)fis.read()单个字节读取
//        int data = 0;
//        while ((data = fis.read())!=-1){
//            System.out.println((char) data);
//        }
        //(2)一次读取多个字符
//        byte[] buf = new byte[3];
//        int count = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count);
//        int count2 = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count2);

        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3.关闭
        fis.close();
        System.out.println("执行完毕");

    }
}

package com.io;

import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;

/**
 * 演示文件字节输出流
 * FileOutputStream
 */
public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1.创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);//加true后文件不再被覆盖，而是继续添加
        //2.写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');

        String string = "helloworld";
        fos.write(string.getBytes(StandardCharsets.UTF_8));
        //3.关闭
        fos.close();
        System.out.println("执行完毕");

    }
}

package com.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 使用文件字节流实现文件复制
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        //（1）文件字节输入流
        FileInputStream fis = new FileInputStream("d:001.jpg");
        //（2）文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:002.jpg");
        //2.边读边写，实现复制
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //3.关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");

    }
}

2、字节缓冲流

缓冲流：

BufferedInputStream

BufferedOutputStream

提高IO效率，减少访问磁盘的次数；

数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close。

package com.io;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节缓存流读取
 * BufferedInputStream
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2.读取
        int data = 0;
        while ((data=bis.read())!=-1){
            System.out.print((char) data);
        }
        //3.关闭
        bis.close();

    }
}

package com.io;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

/**
 * 使用字节缓冲流写入文件
 * BufferedOutputStream
 */
public class Demo05 {
    public static void main(String[] args) throws  Exception{
        //1.创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //2.写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("helloworld".getBytes());//写入8k缓冲区
            bos.flush();//刷新到硬盘
        }
        //3.关闭(内部调用flush方法)
        bos.close();
    }
}

3、对象流

ObjectOutputStream（序列化，将对象写入到硬盘上）

ObjectInputStream（反序列化）

增强了缓冲区功能；

增强了读写8种基本数据类型和字符串功能；

增强了读写对象的功能：readObject（）从流中读取一个对象；

​ writeObject（Object obj）向流中写入一个对象。

使用流传输对象的过程称为序列化、反序列化。

package com.io;

import java.io.Serializable;

public class Student implements Serializable {
    /**
     * serialVersionUID:序列化版本号ID
     */
    private static final long serialVersionUID = -4638253220549992163L;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.io;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

/**
 * 使用ObjectOutputStream实现对象的序列化
 * 要求：
 * (1)序列化类必须要实现Serializable接口
 * (2)序列化类中对象属性要求实现Serializable接口
 * (3)序列化版本号ID，保证序列化的类和反序列化的类是同一个类
 * (4)使用transient(瞬间的)修饰属性，这个属性不能序列化
 * (5)静态属性不能被序列化
 * (6)序列化多个对象，可以借助集合
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2.序列化（写入操作）
        Student zhangsan = new Student("张三",20);
        Student lisi = new Student("李四",22);
        ArrayList<Student> list = new ArrayList<>();
        list.add(zhangsan);
        list.add(lisi);
        oos.writeObject(list);
        //3.关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

package com.io;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
 * 使用ObjectInputStream实现反序列化（读取重构成对象）
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1.创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2.读取文件（反序列化）
//        Student s = (Student) ois.readObject();
//        Student s2 = (Student)ois.readObject();
        ArrayList<Student> list = (ArrayList<Student>) ois.readObject();
        //3.关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(s.toString());
//        System.out.println(s2.toString());
        System.out.println(list.toString());

    }
}

三、编码方式

• ISO-8859-1收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号
• UTF-8针对Unicode码表的可变长度字符编码
• GB2312简体中文
• GBK简体中文、扩充
• BIG5台湾、繁体中文

当编码方式与解码方式不一样时，就会出现乱码。

四、字符流

1、字符流的父类（抽象类）

Reader：字符输入流

public int read(){}

public int read(char[] c){}

public int read(char[] b,int off,int lec){}

Write：字符输出流

public void write(int n){}

public void write (String str){}

public void write(char[] c){}

2、文件字符流

FileReader：

public int read(char[] c)//从流中读取多个字符，将读到的内容存入c数组，返回实际读到的字符数；如果达到文件的底部，则返回-1。

FileWrite：

public void write(String str)//一次写多个字符，将b数组中所有字符，写入输出流。

package com.io;

import java.io.FileReader;

/**
 * 使用FileReader读取文件
 */
public class Demo08 {
    public static void main(String[] args) throws Exception{
        //1.创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:hello.txt");
        //2.读取
        //（1）单个字符读取
//        int data = 0;
//        while ((data=fr.read())!=-1){
//            System.out.print((char) data);
//        }
        //（2）多个字符读取
        char[] buf = new char[1024];
        int count = 0;
        while ((count= fr.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }

        //3.关闭
        fr.close();
    }
}

package com.io;

import java.io.FileWriter;

/**
 * 使用FileWrite写入文件
 */
public class Demo09 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWrite对象
        FileWriter fw = new FileWriter("d:write.txt");
        //2.写入
        for (int i = 0; i < 10; i++) {
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();
        }
        //3.关闭
        fw.close();
        System.out.println("执行完毕");
    }
}

package com.io;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReader和FileWrite复制文本文件，不能复制图片等二进制文件
 * 使用字节流可以复制任意文件
 */
public class Demo10 {
    public static void main(String[] args) throws Exception{
        //1.创建流
        FileReader fr = new FileReader("d:write.txt");
        FileWriter fw = new FileWriter("d:write2.txt");
        //2.读写
        int data = 0;
        while ((data= fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3.gb
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

3、字符缓冲流

缓冲流：

BufferedReader

BufferedWrite

高效读写

支持输入换行符

可一次写一行、读一行

package com.io;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * 使用字符缓存流读取文件
 * BufferedReader
 */
public class Demo11 {
    public static void main(String[] args) throws Exception{
        //1.创建缓存流
        FileReader fr = new FileReader("d:write.txt");
        BufferedReader br = new BufferedReader(fr);
        //2.读取
        //1.（1）
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count=br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //（2）一行一行读
        String line = null;
        while ((line= br.readLine())!=null){
            System.out.println(line);
        }

        //3.关闭
        br.close();
    }
}

package com.io;

import java.io.BufferedWriter;
import java.io.FileWriter;

/**
 * 演示BufferedWrite的使用
 */
public class Demo12 {
    public static void main(String[] args) throws Exception{
        //1.创建BufferedWrite对象
        FileWriter fw = new FileWriter("d:buffer1.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //2.写入
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习天天向上");
            bw.newLine();//写入一个换行符 windows:\r\n linux:\n
            bw.flush();
        }
        //3.关闭
        bw.close();
        System.out.println("执行完毕");
    }
}

4、打印流

PrintWrite

封装了print（）/println（）方法，支持写入后换行

支持数据原样打印

package com.io;

import java.io.PrintWriter;

/**
 * 演示PrintWrite的使用
 */
public class Demo13 {
    public static void main(String[] args) throws Exception{
        //1.创建打印流
        PrintWriter pw = new PrintWriter("d:print.txt");
        //2.打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //3.关闭
        pw.close();
        System.out.println("执行完毕");
    }
}

5、转换流

桥转换流

InputStreamReader

OutputStreamWrite

可将字节流转换为字符流

可设置字符的编码方式

package com.io;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

/**
 * 使用OutputStreamWrite写入文件，使用指定的编码
 */
public class Demo15 {
    public static void main(String[] args) throws Exception{
        //1.创建OutputStreamWrite
        FileOutputStream fos = new FileOutputStream("d:\\info.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        //2.写入
        for (int i = 0; i < 10; i++) {
            osw.write("中国\r\n");
            osw.flush();
        }
        //3.关闭
        osw.close();
        System.out.println("执行完毕");
    }
}

五、File类

概念：代表物理潘符中的一个文件或者文件夹

方法：

createNewFile()//创建一个新文件

mkdir()//创建一个新目录

delete()//删除文件或空目录

exists()//判断File对象所代表的文件是否存在

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

1、File类的使用

package com.io;

import javax.xml.crypto.Data;
import java.io.File;
import java.util.Date;

/**
 * File类的使用
 * （1）分隔符
 * （2）文件操作
 * （3）文件夹操作
 */
public class Demo16 {
    public static void main(String[] args) throws Exception{
//        separator();
//        fileOpe();
        directoryOpe();
    }
    //(1)分隔符
    public static void separator() {
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    //(2)文件操作
    public static void fileOpe() throws Exception{
        //1.创建文件
        File file = new File("d:\\file.txt");
        //System.out.println(file.toString());
        if (!file.exists()) {
            boolean b = file.createNewFile();
            System.out.println("创建结果：" + b);
        }
        //2.删除文件
        //(1)直接删除
//        System.out.println("删除结果："+file.delete());
        //(2)使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);//休眠5秒删除
        //3.获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取路径："+file.getPath());
        System.out.println("获取文件名称："+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("文件创建时间："+new Date(file.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否是文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());

    }
    //(3)文件夹操作
    public static void directoryOpe() throws Exception{
        //1.创建文件夹
        File dir = new File("d:\\aaa\\bbb\\ccc");
        System.out.println(dir.toString());
        if (!dir.exists()){
//            dir.mkdir();//只能创建单级目录
            System.out.println("创建结果："+dir.mkdirs());//可以创建多级目录
        }
        //2.删除
        //(1)直接删除
//        System.out.println("删除结果："+dir.delete());//只能删除空目录
        //(2)使用jvm删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);
        //3.获取文件夹信息
        System.out.println("获取绝对路径："+dir.getAbsolutePath());
        System.out.println("获取路径："+dir.getPath());
        System.out.println("获取文件夹名称："+dir.getName());
        System.out.println("获取父目录："+dir.getParent());
        System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());
        //4.判断
        System.out.println("是否是文件夹："+dir.isDirectory());
        System.out.println("是否是隐藏："+dir.isHidden());
        //5.遍历文件夹
        File dir2 = new File("d:\\图片");
        String[] files = dir2.list();
        for (String string:files
             ) {
            System.out.println(string);
        }

    }

}

2、FileFilter接口

public interface FileFilter

boolean accpet(File pathname)

当调用File类中的ListFile（）方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在ListFiles（）的返回值中。

        //FileFilter接口的使用
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")) {
                    return true;
                }
                return false;
            }
        });
        for (File file:files2
             ) {
            System.out.println(file.getName());
        }

3、递归遍历和递归删除

package com.io;

import java.io.File;

/**
 * 案例1：递归遍历文件夹
 * 案例2：递归删除文件夹
 */
public class ListDemo {
    public static void main(String[] args) {
        listDir(new File("d:\\myfiles"));
        deleteDir(new File("d:\\myfiles"));
    }
    //案例1：递归遍历文件夹
    public static void listDir(File dir){
        File[] files = dir.listFiles();
        System.out.println(dir.getAbsolutePath());
        if (files!=null&&files.length>0){
            for (File file:files
                 ) {
                if (file.isDirectory()){
                    listDir(file);//递归
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }

    //案例2：递归删除文件夹
    public static void deleteDir(File dir){
        File[] files = dir.listFiles();
        if (files!=null&&files.length>0){
            for (File file:files
                 ) {
                if (file.isDirectory()){
                    deleteDir(file);//递归
                }else {
                    //删除
                    System.out.println(file.getAbsolutePath()+"删除："+file.delete());
                }
            }
        }
        System.out.println(dir.getAbsolutePath()+"删除:"+dir.delete());
    }

}

4、Properties

Properties：属性集合

特点：

• 存储属性名和属性值
• 属性名和属性值都是字符串类型
• 没有泛型
• 和流有关

package com.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import java.util.Properties;
import java.util.Set;

/**
 * 演示Properties集合的使用
 */
public class Demo17 {
    public static void main(String[] args) throws Exception{
        //1.创建集合
        Properties properties = new Properties();
        //2.添加
        properties.setProperty("username","zhangsan");
        properties.setProperty("age","20");
        System.out.println(properties.toString());
        //3.遍历
        //(1)keySet
        //(2)entrySet
        //(3)stringPropretyNames()
        Set<String> pronames = properties.stringPropertyNames();
        for (String pro:pronames
             ) {
            System.out.println(pro+"-"+properties.getProperty(pro));
        }
        //4.和流有关的方法
        //(1)list方法
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();
        //(2)store方法 保存
        FileOutputStream fos = new FileOutputStream("d:\\store.properties");
        properties.store(fos,"注释");
        fos.close();
        //(3)load方法 加载
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\store.properties");
        properties2.load(fis);
        fis.close();
        System.out.println(properties2.toString());
        
    }
}