字节流Stream(Output 、Input)、字符流(Reader、Writer)

Summarize：

IO流分两种：①字节流②字符流

刚上来可能会被字符字节流给绕进去，但仔细想一下其实它俩都一个样，只是节和符的区别！字节流和字符流都是有输入和输出 只要性质不同

字节流分：

①OutpStream：字节输出流  写入数据

先创建一个存储数据的文件，

注意：输出流目的是文件，无则创建，有则覆盖

File file =new  File("d:\java\a.txt")

FileOutputStream fos= new FileOutputStream(file)

 ②InputStream ：字节输入流  读取数据

字节输出流 OutputStream 

是抽象类，是输出字节流所有类的超类，操作数据都是字节

字节流：什么都可以传  分为 输出流和输入流

字符流：只能传输文本文件 

 

  FileOutputStream类

文件输出流：将数据写入File的输出流

构造方法：

FileOutputStream类写入数据到文件

package com.oracle.demo01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) throws IOException {
//        创建字节流输出流对象(输出的值能是文件，不能输出目录)
//        当构造方法指定文件地址时，如果存在，则覆盖 ,不存在就创建,只能写文件路径 不能创建目录
        FileOutputStream fos=new
                FileOutputStream("f:\java\d.txt");//报异常是因为
/*        向文件写入一个字节 write(写数字)得到ASCII码值 一次方法只能写入一个字节
        0 - 48
        a - 97
        A - 65
        fos.write(49);
        fos.write(48);
        fos.write(48);*/
//        向文件写入一个字节数组write(byte[] b)
        byte[] bytes={-66,-67,-68,-69};//正数是走表，负数显示汉字，两个字节=一个汉字
        //fos.write(bytes);
        fos.write(bytes, 2, 2);//第一个2是从下标2开始，第二个2是长度
//        释放资源  
        fos.close();
    }
}

给文件中续写和换行

 new FileOutputStream(file) 创建对象，写入数据，会覆盖原有文件，如果我们续写

构造方法：

package com.oracle.demo01;
//字节输出流 续写
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*public class Demo02 {
    public static void main(String[] args) throws IOException {
//        创建字节输出流(开启续写功能)
        FileOutputStream fos=new
                FileOutputStream("f:\java\d.txt",true);默认false
//        字符串->字节数组  getBytes() 串转字节数组
        //续写往d.txt里面写数据
        fos.write("abc".getBytes());
//        换行 "
"
        fos.write("
换行了".getBytes());
//        释放资源
        fos.close();
    }
}*/
//下面处理异常 复制上面
public class Demo02 {
    public static void main(String[] args){
*处理异常，close必须放在finally里面
  涉及fos定义问题，在外面赋值定义*/
        FileOutputStream fos=null;
        try {
        fos=new 
                    FileOutputStream("f:\Java\d.txt",true);
            fos.write("abc".getBytes());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                fos.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }        
    }
}

 字节输入流 InputStream

 抽象类，字节输入流所有类的超类

int read():读一个字节，并返回，无字节 返回-1

 int read(byte[ ])：读一定量字节数，存储到字节数组，返回读取到的字节数

package com.oracle.demo01;
//创建一个字节输入流 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo04 {
    public static void main(String[] args) throws IOException {
//        创建字节输入流(明确从哪个文件读取数据)
        FileInputStream fis=new FileInputStream("f:\java\d.txt");
//        一个字节一个字节读取文件所有数据局
//        一个循环全部读出来
        int len=0;
        while((len=fis.read())!=-1){ //!=-1  是结束标记，一次读个字符数组，当读完后得返回-1
            System.out.println((char)len);
        }
        //        释放资源
        fis.close();
    }
}

 FileInputStream类

构造方法

读取数据 read方法：读取文件中的数据时，调read方法，实现从文件中读取数据

 

 读取数据read(byte[])方法

字节输入流：InputStream

子类：FileInputStream  加个File  就是文件输入流

package com.oracle.demo01;
//读取输入流字节数组
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo05 {
    public static void main(String[] args) throws IOException {
        
        FileInputStream fis=new FileInputStream("f:\java\d.txt");
//        创建字节数组
        byte[] bytes=new byte[2];
/*//        读取一个字节数组
        int len=fis.read(bytes);
//        实际读取的有效字节数
        System.out.println(len);
//        字节数组->字符串
        System.out.println(new String(bytes));
//        循环读取字节数组
*/        int len=0;
        while((len=fis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
//        释放资源
        fis.close();
    }
}

字节流 复制文件

package com.oracle.demo01;
//复制字节流
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class copy {
    public static void main(String[] args) throws IOException {
//        先读   明确数据源  
        FileInputStream fis=new FileInputStream("f:\java\d.txt");
//        明确目的地
        FileOutputStream fos=new FileOutputStream("f:\java\e.txt");
//        开始复制
        int len=0;
        while((len=fis.read())!=-1){
            fos.write(len);
        }
//        释放资源
        fis.close();
        fos.close();
    }
}

复制字节流数组

package com.oracle.demo01;
//复制数组字节流
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class ArrStreamCopy {
    public static void main(String[] args) throws IOException {
        File srcFile = new File("c:\YesDir	est.JPG");
        File destFile = new File("copyTest.JPG");
        // 明确字节流 输入流和源相关联，输出流和目的关联。
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);
        //定义一个缓冲区。
        byte[] buf = new byte[1024];
        int len = 0;
        while ((len = fis.read(buf)) != -1) {
            fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
        }
        // 关闭资源。
        fos.close();
        fis.close();
    }
}    

 pm

字符流

分两种，字符输出流 write  和 字符输入流reader   只要看到reader和write 就是 字符流  只要看到结尾是 Stream 就是字节流

 字符流理解：

对文本文件判定：只要一个文件用笔记本打开，能看懂的就是文本

 字符输入流 Reader

 

read()：读去一个字符 返回

read(char[ ])：把数据读到数组，返回读取个数

 FileReader类

构造方法

package com.oracle.demo02;
//字符输入流Reader
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
//字符输入流
public class Demo01 {
    public static void main(String[] args) throws IOException {
//        创建字符输入流
        FileReader fr=new FileReader("f:\java\d.txt");
        int len=0;
//        一个字符一个字符读
        while((len=fr.read())!=-1){
            System.out.println((char)len);
        }
//        释放资源
        fr.close();
    }
}

package com.oracle.demo02;
//字符输入流数组
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo02 {
    public static void main(String[] args) throws IOException {
//        创建字符输入流
        FileReader fr=new FileReader("f:\java\d.txt");
//        创建字符数组
        char[] ch=new char[1024];
//        一个字符数组一个字符数组的读
        int len=0;
        while((len=fr.read(ch))!=-1){
            System.out.println(new String(ch,0,len));
        }
//        释放资源
        fr.close();
    }
}

字符输出流  Writer

 write是写入字符流的抽象类

 

 FileWriter类

 构造方法

FileWriter写入中文到文件中

 flush()和close()的区别

flush()：缓冲的数据刷新到目的地，刷新流 刷一次更新一次

close()：关闭 只有一次

package com.oracle.demo02;
//字符输出流 write
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileWrite {
    public static void main(String[] args) throws IOException {
//        创建字符输出流 
        FileWriter fw=new FileWriter("f:\java\d.txt",true);//续写字符串 ，不管输入输出
//        写入一个字符
//        fw.write(100);
//        写入一个字符串
        fw.write("你好呀");
        fw.flush();//刷新流 刷一次 更新一次
//        写入字符数组
        char[] ch={'a','1','r'};
        fw.write(ch);
        fw.flush();
//        释放资源 
//        fw.close();
    }
}

package com.oracle.demo02;
//复制字符流
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileReaderCopy {
    public static void main(String[] args) throws IOException {
//        明确数据源
        FileReader fr=new FileReader("f:\java\d.txt");
//        明确目的地
        FileWriter fw=new FileWriter("f:\java\e.txt");
        int len=0;
//        开始复制
        while((len=fr.read())!=-1){
            fw.write(len);
            fw.flush();//写一个刷一个
        }
//        释放资源
        fr.close();
    }
}

package com.oracle.demo02;
\加上时间 复制完后 显示用时
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class zuoye {
public static void main(String[] args) throws IOException {        
        //单字节复制文件
        //开始时间毫秒值
        long starttime =System.currentTimeMillis();
        copy("F:\jdk1.8\JDK_API_1_6_zh_CN.CHM","F:\jdk1.8\JDK.CHM");
        long endtime = System.currentTimeMillis();
        System.out.println("单字节复制时间毫秒值："+(endtime-starttime));
    }
    // byte数组复制文件
    public static void copys(String source, String destination) throws IOException {
        // 明确数据源
        FileInputStream fis = new FileInputStream(source);
        // 明确目的地
        FileOutputStream fos = new FileOutputStream(destination);
        // 开始复制
        byte[] bytes = new byte[10240 * 10240];// 读取容器
        int len = 0; // 读取的有效长度
        while ((len = fis.read(bytes)) != -1) {
            // 写入文件
            fos.write(bytes, 0, len);
        }
        // 关闭流
        fos.close();
        fis.close();
    }
    // 单字节复制方法
    public static void copy(String source, String destination) throws IOException{
        // 明确数据源
        FileInputStream fis = new FileInputStream(source);
        // 明确目的地
        FileOutputStream fos = new FileOutputStream(destination);
        // 开始复制
        int len = 0;
        while ((len = fis.read()) != -1) {
            fos.write(len);
        }
        // 释放资源
        fis.close();
        fos.close();
    }
}