Java学习——之I/O 流

1、File类

创建：File file = new File(路径字符串);

.exists();文件是否存在

.delete();删除文件

.getPath();路径

.isFile());是文件吗

.isDirectory();是目录吗

.getName();名称

.getAbsolutePath();绝对路径

.lastModified()；最后修改时间

.length();文件大小，不能判断目录/文件夹

.getParent();父路径，得到指定目录的前一级目录

.getAbsoluteFile();得到文件绝对路径文件

创建：

.createNewFile();创建文件

.mkdir();创建一层文件夹

.mkdirs();创建多层文件夹

File(String path)              通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例

File(String path,String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(File file,String child)

list() 返回一个字符串数组，这些字符串目录中的文件和目录。

list(FileNameFilter) 返回一个字符串数组，这些字符串指满足指定过滤器的文件和目录。

listFiles 返回一个抽象路径名数组，这些路径名目录中的文件。

listFiles(FileNameFilter) 返回抽象路径名数组，这些路径名满足指定过滤器的文件和目录。
2、遍历文件夹是用递归。

3、流的分类

按流分向：

输入流：从数据源到程序中的流   

输出流：从程序到数据源的流

按数据传输的单位：

字节流：以字节为单位传输数据的流

字符流：以字符为单位传输数据的流

按功能分：

节点流：直接与数据源打交道的流

处理流：不直接与数据源打交道，与其他流打交道

4、流类

        字节流                       字符流

输入流 InputStream 超类，抽象类 Reader 超类，抽象类

输出流 OutputStream 超类，抽象类 Write 超类，抽象类
5、流

read() 一个字节一个字节的读 返回值是读取到得数据的int表现形式

read(byte[]) 把字节读取到数组中 返回 的是读取到的个数 返回：读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。

read(byte[],int offset,int length)

   指定的数组中偏移的个数  指定的数组的下标  存储数据的长度

字符流

   FileInputStream   字节流 输入流 节点流 直接操作文件的

            read();

            read(byte[]);

            read(byte[],off,,len);   （byte[]接受数据，返回值！=-1）

   FileOutputStream  字节流 输出流 节点流

            write(int);

            write(byte[]);

            write(bute[],off,len);

    

        File file = new File("E:\ceshi.wmv");// 源文件

        File file2 = new File("E:\aaa\ceshi.wmv");// 目标文件

        // 1、创建流对象

        FileInputStream fis = new FileInputStream(file);

        FileOutputStream fos = new FileOutputStream(file2);

        // 2、读取文件

            byte[] bs = new byte[1024];

        int num = 0;

        while ((num = fis.read(bs)) != -1) {

            fos.write(bs);

        }

        // 3、刷新

        fos.flush();

        // 4、关闭流        

字符流

   FileReader        字符流 输入流 节点流

            read(char[]);            （char[]接收数据，返回值！=-1）

   FileWriter        字符流 输出流 节点流

            write(char,offset,length);

            循环读取判断 ！=-1

            

       File file=new File("E:\22.txt");

        File file2=new File("E:\aa\22.txt");

        FileReader fileReader=new FileReader(file);

        FileWriter fileWriter=new FileWriter(file2);

        char [] ch=new char[4];

        int num=0;

        while((num=fileReader.read(ch))!=-1){

        fileWriter.write(ch,0,num);

        }

        fileWriter.flush();

        关闭流

复制文件的流程

1、创建流对象

2、读取文件的文件（循环读取）FileInputStream、FileReader

3、写入目标文件 FileOutputStream、FileWriter

4、刷新关闭
缓冲流

BufferedInoutStream 字节流 输入流 处理流 （byte[]接受数据，返回值！=-1）

BufferedOutputStream 字节流 输出流

BufferedReader 字符流 输入流 （String接受数据，返回值！=null）resdLine();

BufferedWriter 字符流 输出流

        readLine();读取一行，返回值String 循环读取判断 ！=null

        newLine();换行

        \r\n换行

BufferedInputStream bis=new BufferedInputStream(new FileInputStream(new File("E:\ceshi.wmv")));

BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(new File("E:\aa\ceshi.wmv")));

byte []bs=new byte[1024];

int num=0;

long time=System.currentTimeMillis();

while((num=bis.read(bs))!=-1){

    bos.write(bs,0,num);

}

bos.flush();

关闭流

转换流

字节转字符 InputStreamReader 继承自Reader （String接收数据，返回值！=null）

字符转字节 OutputStreamWriter 继承自Wriiter

BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(new FileInputStream( new File("E:\ceshi.wmv"))));

BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File("E:\aa\demo\ceshi.wmv"))));

String string=null;

while((string=bufferedReader.readLine())!=null){

    bufferedWriter.write(string);

}

bufferedWriter.flush();

关闭流

对象流

ObjectInputStream readObject();

ObjectOutputStream writeObject(Object obj);

1、用对象流去存储对象的前提是 将对象序列化 实现接口Serializable

2、序列化和反序列化（将对象持久化储存）

将对象转成字节叫序列化

将字节转成对象叫反序列化

3、序列化ID，帮助区分版本，可写可不写。

4、transient修饰不想被序列化的属性，存储默认值

Person person =new Person("秋秋", 22);

Person person2=new Person("菜菜", 21);

ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(new File("a.txt")));

objectOutputStream.writeObject(person);

objectOutputStream.writeObject(person2);

objectOutputStream.flush();

if (objectOutputStream!=null) {

    objectOutputStream.close();

}

ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(new File("a.txt")));

    Person person3=(Person) objectInputStream.readObject();

    System.out.println(person3);

    Person person4=(Person) objectInputStream.readObject();

    System.out.println(person4);

    if (objectInputStream!=null) {

        objectInputStream.close();          

    }

数据包装流（了解）字节流，读取字节

   DataInputStream

   DataOutputStream

   1、新增了很多读取和写入基本数据类型的方法

   2、读取的顺序和写入的顺序一样，否则数据内容会和存入时的不同

    DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(new File("b.txt")));

    dataOutputStream.writeInt(22);

    dataOutputStream.writeLong(34567);

    dataOutputStream.writeBoolean(true);

    dataOutputStream.flush();

    if (dataOutputStream != null) {

        dataOutputStream.close();

    }

DataInputStream dataInputStream = new DataInputStream(new FileInputStream(new File("b.txt")));

System.out.println(dataInputStream.readInt());

System.out.println(dataInputStream.readLong());

System.out.println(dataInputStream.readByte());

if (dataInputStream != null) {

    dataInputStream.close();

}

标准输入/输出/错误流

System.in 会阻塞程序的运行等待用户输入

System.out 将内容打印到控制台上

System.err 将内容打印到控制台上，颜色是红色
标准输入/输出/错误流的重定向

System.setIn()

System.setOut()

System.setErr()

1、重定向的方法一定要放在标准输入输出错误流的前面
打印流

PrintStream 字节打印流 可以new可以通过System.out得到

PrintWriter 字符打印流 new
内存流

ByteArrayInputStream 输入流 （byte[]接受数据，返回值！=-1）

ByteArrayOutputStream 输出流

1、toByteArray() 返回值是byte，内存输出流调用的，byte[] bs=byteArrayOutputStream.toByteArray();

        //将内存中的数据转化成byte数组  

2、writeTo(OutputStream) 将内存流中的数据直接写入参数流中

// 1、创建文件输入流，读取文件内容

BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(new File("E:\11.txt")));

// 2、创建内存输入流，将读取后的文件存到内存中

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

byte[] bs = new byte[1024];

int num = 0;

// 3、循环读取文件内容

while ((num = bufferedInputStream.read(bs)) != -1) {

    // 4、将文件写入内存中

    byteArrayOutputStream.write(bs,0,num);

    byteArrayOutputStream.flush();

    将内存中的数据转化成byte数组

    byte[] bs2 = byteArrayOutputStream.toByteArray();因为读取的时候需要数组，所以在这儿写

    System.out.println("---" + new String(bs2));

    // 5、创建内存输入流。读取内存中的数据

    ByteArrayInputStream byteArrayInputStreamnew = new ByteArrayInputStream(bs2);

    // 7、创建文件输出流，将内存中的文件 读取到我文件中

    BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(

        new FileOutputStream(new File("E:\aaa\11.txt")));

    byte[] bs3 = new byte[1024];

    int num2=0;

    // 8、循环读取内存中的数据

    while ((num = byteArrayInputStreamnew.read(bs3)) != -1) {

        System.out.println("~~~" + new String(bs3));

        // 9、写入到文件中

        bufferedOutputStream.write(bs3,0,num2);

        bufferedOutputStream.flush();

    }

    //10、关闭各种流

随机读写流：在线程中使用较多

RandomAccessFile  字节流，即可以读又可以写

    // 1、文件的长度

File file = new File("E:\ceshi.wmv");

System.out.println(file.length());

int tlen = 0;

if (file.exists()) {

    tlen = (int) file.length();    //判断文件并计算文件总长度

}

int len = tlen % 4 == 0 ? tlen / 4 : tlen / 4 + 1;  //计算每一段长度

int last = tlen - len * 3;                          //最后一段长度=总长度-前三段长度      

Copy copy = new Copy(0, len); copy.start();                      //第一段长度从0到len

Copy copy2 = new Copy(len, len);    copy2.start();

Copy copy3 = new Copy(len * 2, len);    copy3.start();

Copy copy4 = new Copy(len * 3, len);copy4.start();                                                                                                                                                                                                                                                                                                                                                                                                      

    }

}

class Copy extends Thread {

    int star = 0; 

    int leng = 0;

    public Copy(int star, int leng) {

        super();

        this.star = star;

        this.leng = leng;

    }

    public void run() {

        RandomAccessFile read = null;

        RandomAccessFile write = null;

                read = new RandomAccessFile(new File("E:\ceshi.wmv"), "rw");

                System.out.println(Thread.currentThread().getName() + "开始！！！");

                write = new RandomAccessFile(new File("E:\aaa\bb\ceshi.wmv"), "rw");

                    read.seek(star);

                    write.seek(star);

                    byte[] bs = new byte[1024];

                    int num = 0;

                    int readlength = 0;

                    while (true) {

                        if (leng - readlength < 1024) {

                            read.read(bs, 0, leng - readlength);

                            write.write(bs, 0, leng - readlength);

                            break;

                        } else   {

                            num = read.read(bs);

                            write.write(bs, 0, num);

                            readlength += num;

                    }

                }

                System.out.println(Thread.currentThread().getName() + "完成~~~");