字节流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=newFileOutputStream("f:\\java\\d.txt");//报异常是因为
/*        向文件写入一个字节 write(写数字)得到ASCII码值 一次方法只能写入一个字节0 - 48a - 97A - 65fos.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=newFileOutputStream("f:\\java\\d.txt",true);默认false
//        字符串->字节数组  getBytes() 串转字节数组//续写往d.txt里面写数据fos.write("abc".getBytes());
//        换行 "\r\n"fos.write("\r\n换行了".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  是结束标记，一次读个字符数组，当读完后得返回-1System.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\test.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();}
}

字符流

分两种，字符输出流 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();}
}

转载于:https://www.cnblogs.com/zs0322/p/11027128.html