io

流的分类

按方向：输入输出流

输入流：将<存储设备>中得内容读入到<内存>中，

输出流：将<内存>中得内容写入到<存储设备>中。

按单位：

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

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

按功能：

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

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

字节流

字节流有两个父类（抽象类）为流的读写提供基本操作。

InputStream 字节输入流   read

OutputStream 字节输出流  write

字节流抽象类的子类文件字节流

FileInputStream: read

FileOutputStream: write

package io;

import com.sun.org.apache.xml.internal.utils.res.StringArrayWrapper;

import java.io.FileInputStream;

/*
* FileInputStream
*
* */
public class Demo01 {
    public static void main(String[] args) throws Exception {
        //创建FileInputStream，并指定文件路径
        FileInputStream fis=new FileInputStream("d:\\AAA.txt");
        //一个个读取文件
        /*int data=0;
        while((data=fis.read())!=-1){
            System.out.print((char)data);
        }*/

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

 ackage io;

import java.io.FileOutputStream;


public class Demo02 {
public static void main(String[] args) throws Exception{
//创建一个FileOutStream对象
FileOutputStream fos=new FileOutputStream("d:\\BBB.txt",true);
//写入文件
fos.write(97);
fos.write('b');
fos.write(99);
fos.write('d');
String string="helloWorld";
fos.write(string.getBytes());

//关闭
fos.close();
System.out.println("执行完毕");
}

利用字节流复制文件

package io;

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

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //创建流
        //文件输入流
        FileInputStream fis=new FileInputStream("d:\\BBB.txt");
        //文件输出流
        FileOutputStream fos=new FileOutputStream("d:\\CCC.txt");
        //一边读一边写
        byte[] buf=new byte[1024];
        int count=0;
        while((count=fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
           fis.close();
           fos.close();
        System.out.println("复制完毕");
    }

}
字节缓冲流
: BufferedInputStream/BufferedOutputStream
提高io效率，减少访问磁盘的次数；
数据存储在缓冲区中，flush是缓冲区的内容写入文件中，也可以直接close。

package io;

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

public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建缓冲字节输入流
        FileInputStream fis=new FileInputStream("d:\\BBB.txt");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //读取
        int data=0;
        while((data=bis.read())!=-1){
            System.out.println((char)data);
        }
        //关闭
        bis.close();
        System.out.println("读取完毕");
    }
}

package io;

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


public class Demo05 {
    public static void main(String[] args) throws Exception{
        //创建缓冲字节输出流
        FileOutputStream fos=new FileOutputStream("Buffer.txt");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //写入文件
        for (int i = 0; i < 10; i++) {
            bos.write("cnmd".getBytes());//写入缓冲区
            bos.flush();//刷新到硬盘
        }
        bos.close();
        System.out.println("写出成功");
    }


}

对象流

ObjectIntputStream/ObjectOutputStream
增强了缓冲区功能
增强了的种基本数据类型和字符串功能
增强了读写对象的功能
向流中写入一个对象被称为序列化
在流中读取一个对象被称为反序列化
序列化类必须要实现Serializable接口
序列化中的对象属性也需要实现Serializable接口
使用transient(瞬间的)修饰的属性，该属性不能序列化。
静态属性也不能序列化。
在序列化类中添加序列化版本ID,以保证序列化和反序列化后的类是同一种类型
可以借助集合来序列化多个对象

private static final long serialVersionUID=xxxL;

package io;

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

//
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //序列化
        FileOutputStream fos=new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //序列化（写入对象）
        //创建对象
        Student s1=new Student("张三",24);
        Student s2=new Student("李四",24);
        ArrayList<Student> list=new ArrayList<Student>();
        list.add(s1);
        list.add(s2);
            oos.writeObject(list);
            //关闭
        oos.close();
        System.out.println("序列化完成");
    }
}

package io;

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

public class Demo07 {
    public static void main(String[] args) throws Exception{
        FileInputStream fis=new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois=new ObjectInputStream(fis);
        //反序列化
     // Student stu1=(Student) ois.readObject();
      //Student stu2=(Student) ois.readObject();
        ArrayList<Student> list=(ArrayList<Student>)ois.readObject();
      //关闭
        ois.close();
        System.out.println("反序列化完成");
        System.out.println(list.toString());
    }
}

字符流


字符流的父类（抽象类）
Reader/Writer

package io;

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

//用文件字节流实现文件复制
public class Demo10 {
    public static void main(String[] args) throws Exception{
        FileReader fr=new FileReader("d:\\hello.txt");
        FileWriter fw=new FileWriter("d:\\word.txt");
        //一边读一边写
        char []buf=new char[1024];
        int count=0;
        while((count=fr.read(buf))!=-1){
            fw.write(buf);
            fw.flush();
        }
        //关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");
    }
}

字符缓冲流
高效读写
支持换行符
支持读一行，写一行。

package io;

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

public class Demo11 {
    public static void main(String[] args) throws Exception{
        FileReader fr=new FileReader("d://hello.txt");
        BufferedReader br=new BufferedReader(fr);
       // 一行行读取
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        //关闭
        br.close();
    }
}

package io;

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

public class Demo12 {
    public static void main(String[] args) throws Exception{
        FileWriter fw=new FileWriter("d:\\cs.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        for (int i = 0; i < 10; i++) {
            bw.write("好好学习，天天向上");
            bw.newLine();
            bw.flush();

        }
        //关闭
        bw.close();
    }
}
打印流

printWriter
封装了print();和println();方法支持写入后换行。
支持原数据打印

package io;

import java.io.PrintWriter;

public class Demo13 {
    public static void main(String[] args)throws Exception {
        PrintWriter pw=new PrintWriter("d://cs.txt");
        //打印
        pw.println(97);
        pw.println(true);
        pw.println(3.14);
        pw.println('a');
        //关闭
        pw.close();

    }
}

File类
createNewFile()//创建新文件
mkdir()//创建新目录
delete()//删除文件或空目录
exists()//判断File对象所代表的对象是否存在
listFiles()//列出文件中所有内容.
package io;

import java.io.File;
import java.sql.Date;

/*
* File类的使用
* 分隔符
* 文件操作
* 文件夹操作
* */
public class Demo14 {
    public static void main(String[] args) throws Exception{
        separator();
        fileOpe();
    }

    //分隔符
    public static void separator() {
        System.out.println("路径分隔符" + File.pathSeparator);
        System.out.println("名称分隔符" + File.separator);
    }

    public static void fileOpe() throws Exception{
        //文件操作
        //创建文件
        File file = new File("d:\\file.txt");
        //System.out.println(file.toString());
        if(!file.exists()){
        boolean b=file.createNewFile();
        System.out.println("创建结果"+b);
        }
        //删除文件
      //  System.out.println("删除结果"+file.delete());
        //获取文件信息
        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());
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());
        System.out.println("是否隐藏"+file.isHidden());

    }
}