IO

流

什么是流:内存与存储设备之间的传输.(所有的都是先进行Output在进行Input,我只是习惯先写Input在写Output)

流的分类

• 按方向[重点]:
  • 输入流:将<存储设备>中的内容读入到<内存>中.
  • 输出流:将<内存>中得到内容写入到<存储设备>中.
• 按单位:
  • 字节流:以字节为单位,可以读写所有数据.
  • 字符流:以字符为单位,只能读写文本数据.
• 按功能:
  • 节点流:具有实际传输数据的读写功能.
  • 过滤流:在节点流的基础之上增强功能.

文件字节流

FileInputStream:

• public int read(byte[] b)//从流中读取多个字节,将读到的内容存入b数组,返回实际读到的字节数;如果达到文件的尾部,则返回-1.

package IO.byteStream;

import java.io.FileInputStream;

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

FileOutputStream:

• public void write(byte[] b)//一次写多个字节,将b数组中所有字节,写入输出流.

package IO.byteStream;

import java.io.FileOutputStream;

/*
演示文件字节输出流的使用
FIleOutputStream
 */
public class fileOutStream {
    public static void main(String[] args) throws Exception {
        //1创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);//这里的true就是append的意思,如果是在true就把字节写在末尾而不是开头
        //2写入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        String string = "helloworld";
        fos.write(string.getBytes());
        //3关闭
        fos.close();
        System.out.println("执行完毕");
    }
}

字节流文件复制

package IO.byteStream;

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

public class fileCopy {
    public static void main(String[] args) throws Exception{
        //1创建流
        //1.1 文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\001.jpg");
        //1.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("执行完毕");
    }
}

字节缓冲流

• BufferedInputStream/BufferedOutputStream
  • 提高IO效率,减少访问磁盘的次数
  • 数据存储在缓冲区中,flush是将缓存区的内容写入文件中,也可以直接close.

BufferedInputStream

package IO.byteStream;

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

/*
使用字节缓冲流读取
BufferedInputStream
 */
public class bufferedInputStream {
    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);
//        }
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count=bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3关闭
        bis.close();
    }
}

BufferedOutputStream

package IO.byteStream;

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

/*
使用缓冲流写入文件
BufferedOutputStream
 */
public class bufferedOutputStream {
    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关闭
        bos.close();
    }
}

对象流

• ObjectOutputStream/ObjectInputStream
• 增强了缓冲区功能
• 增强了读写8种基本数据类型和字符串功能
• 增强了读写对象的功能:
  • readObject();从流中读取一个对象
  • writeObject(Object obj);向流中写入一个对象

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

使用ObjectOutputStream实现对象的序列化
要求:
(1)序列化类必须要实现Serializable接口;
(2)序列化类中对象属性要求实现Serializable接口;
(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类;
(4)使用transient(瞬间的)修饰属性,这个属性就不能序列化;
(5)静态属性不能被序列化;
(6)序列化多个对象,可以借助集合来实现

ObjectInputStream

package IO.Objectflow;
/*
使用ObjectInputStream实现反序列化(读取重构成对象)
 */

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

public class objectInputStream {
    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 list = (ArrayList) ois.readObject();
        //3关闭
        ois.close();
        System.out.println("执行完毕");
//        System.out.println(s.toString());
//        System.out.println(s2.toString());
        System.out.println(list.toString());
    }
}

ObjectOutputStream

package IO.Objectflow;
/*
使用ObjectOutputStream实现对象的序列化
要求:
(1)序列化类必须要实现Serializable接口;
(2)序列化类中对象属性要求实现Serializable接口;
(3)序列化版本号ID,保证序列化的类和反序列化的类是同一个类;
(4)使用transient(瞬间的)修饰属性,这个属性就不能序列化;
(5)静态属性不能被序列化;
(6)序列化多个对象,可以借助集合来实现
 */
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.io.Serializable;

public class objectOutputStream {
    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("执行完毕");
    }
}
class Student implements Serializable {
    //serialVersionUID序列化ID
    private static final long serialVersionUID = 100L;
    private String name;
    private transient 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 +
                '}';
    }
}

字符编码

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

字符流

• 字符流的父类（抽象类）
  • Reader：字符输入流
    • public int read（）{}
    • public int read （char[] c）{}
    • public int read (char[] b,int off,int len){}
  • Write:字符输出流
    • public void write (int n){}
    • public void write(String str){}
    • public void write(char[] c){}

文件字符流

FileReader

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

package IO.charStream;

import java.io.FileReader;

/*
使用FileReader读取文件
 */
public class fileReader {
    public static void main(String[] args) throws Exception{
        //1创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\write.txt");
        //2读取
        //2.1单个字符读取
//        int data = 0;
//        while ((data=fr.read())!=-1){//读取一个字符
//            System.out.print((char) data);
//        }
        //
        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();
    }
}

FileWrite

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

package IO.charStream;

import java.io.FileWriter;

/*
使用FileWrite写入文件
 */
public class fileWrite {
    public static void main(String[] args) throws Exception{
        //1创建File Write对象
        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();
    }
}

字符缓冲流

• 缓冲流:BufferedReader/BufferedWrite
  • 高效读写
  • 支持输入换行符
  • 可一次写一行、读一行

BufferedReader

package IO.charStream;

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

/*
BufferedReader
 */
public class bufferedReader {
    public static void main(String[] args) throws Exception{
        //1创建缓冲流
        FileReader fr = new FileReader("d:\\buffer.txt");
        BufferedReader br = new BufferedReader(fr);
        //2读取
        //2.1第一行种方式
//        char[] buf = new char[1024];
//        int count = 0;
//        while ((count= br.read(buf))!=-1){
//            System.out.println(new String(buf,0,count));
//        }
        //2.2第二种方式,一行一行的读取
        String line = null;
        while ((line= br.readLine())!=null){
            System.out.println(line);
        }
        //3关闭
        br.close();
    }

}

BufferedWrite

package IO.charStream;

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

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

字符流复制文件

package IO.charStream;

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

/*
使用File Reader和FileWrite复制文本,不能复制图片或二进制文件
 */
public class fileCopy {
    public static void main(String[] args) throws Exception{
        //1创建FileReader FileWrite
        FileReader fr = new FileReader("d:\\001.jpg");
        FileWriter fw = new FileWriter("d:\\003.jpg");
        //2读写
        int data = 0;
        while ((data=fr.read())!=-1){
            fw.write(data);
            fw.flush();
        }
        //3关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

打印流

• PrintWriter
  • 封装了print()/println()方法,支持写入后换行
  • 支持数据原样打印

package IO.charStream;

import java.io.PipedWriter;
import java.io.PrintWriter;

/*
演示PrintWrite的使用
 */
public class printWrite {
    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.checkError();
        System.out.println("执行完毕");
    }
}

转换流

• 桥接换流:InputStreamReader/OutputStreamWrite
  • 可将字节流转换为字符流
  • 可设置字符的编码方式

InputStreamReader

package IO.charStream;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/*
演示InputStreamReader读取文件,指定使用的编码
 */
public class inputStreamReader {
    public static void main(String[] args) throws Exception{
        //1创建InputStreamReader对象
        FileInputStream fis = new FileInputStream("d:\\info.txt");
        InputStreamReader isr = new InputStreamReader(fis,"gbk");
        //2读取文件
        int data = 0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //3关闭
        isr.close();
    }
}

OutputStreamWrite

package IO.charStream;

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

/*
使用OutputStreamWrite写入文件,使用指定编码
 */
public class outputStreamWrite {
    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()//获取文件的绝对路径
  • getName()//取的名字
  • getParent()/获取文件/目录所在的目录
  • isDirectory()//是否是目录
  • isFile()//是否是文件
  • length()//获得文件长度
  • listFiles()//列出目录中的所有目录
  • renameTo()//修改文件名为

File Filter接口

• public interface File Filter
  • boolean accept(File name)
• 当调用File类中的listFiles()方法时,支持传入FileFilter接口,接口实现类,对获取文件进行过滤,只有满足条件的文件的才可出现在listFiles()的返回值中

package IO.file;

import java.io.File;
import java.io.FileFilter;
import java.util.Date;

/*
File类的使用
(1)分隔符
(2)文件操作
(3)文件夹操作
 */
public class Demo01 {
    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删除文件
        //2.1直接删除
        //System.out.println("删除结果:"+file.delete());

        //2.2使用jvm退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);

        //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()).toString());

        //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删除文件夹
        //2.1直接删除(只能删除空目录)
        //System.out.println("删除结果:"+ dir.delete());//只删除最底层的目录并且是一个空目录
        //2.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:\\aaa");
        String[] files = dir2.list();
        System.out.println("==============");
        for (String string : files) {
            System.out.println(string);
        }
        System.out.println("----FileFilter接口的使用----");
        File[] files2 = dir2.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".jpg")) {
                    return true;//满足要求返回true,不满足返回false
                }
                return false;
            }
        });
        for (File file : files2) {
            System.out.println(file.getName());
        }
    }
}

遍历删除文件/文件夹

package IO.file;

import java.io.File;


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.getAbsoluteFile());
        if (files!=null&&files.length>0){
            for (File file : files) {
                if (file.isDirectory()){
                    listDir(file);
                }else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
    //案例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.getAbsoluteFile()+"删除"+file.delete());
            }
        }
        System.out.println(dir.getAbsoluteFile()+"删除"+dir.delete());
    }
}

补充

• Properties:属性集合
• 特点
  1. 存储属性名和属性值
  2. 属性名和属性值都是字符串类型
  3. 没有泛型
  4. 和流有关

package IO.Properties;

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

/*
演示Properties集合的使用
 */
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //1创建集合
        Properties properties = new Properties();
        //2添加数据
        properties.setProperty("username","zhangasan");
        properties.setProperty("age","29");
        System.out.println(properties.toString());
        //3遍历
        //3.1---keyset---
        //3.2--entryset--
        //3.3--stringPropertyName---
        Set<String> pronames=properties.stringPropertyNames();
        for (String pro:pronames) {
            System.out.println(pro+"=="+properties.getProperty(pro));
        }
        //4和流有关的方法
        //---list方法---
//        PrintWriter pw = new PrintWriter("d:\\print.txt");
//        properties.list(pw);
//        pw.close();

        //-----2store方法:保存----
//        FileOutputStream fos = new FileOutputStream("d:\\print.properties");
//        properties.store(fos,"注释");
//        fos.close();

        //----3load方法:加载---
        Properties properties2 = new Properties();
        FileInputStream fis = new FileInputStream("d:\\print.properties");
        properties2.load(fis);
        System.out.println(properties2.toString());
    }
}