JAVA IO流最详解
IO流上:概述、字符流、缓冲区(java基础)
一、IO流概述
二、字符流
2.字符流读写:
示例1:在硬盘上创建一个文件,并写入一些文字数据
- class FireWriterDemo {
- public static void main(String[] args) throws IOException { //需要对IO异常进行处理
- //创建一个FileWriter对象,该对象一被初始化就必须要明确被操作的文件。
- //而且该文件会被创建到指定目录下。如果该目录有同名文件,那么该文件将被覆盖。
- FileWriter fw = new FileWriter("F:\\1.txt");//目的是明确数据要存放的目的地。
- //调用write的方法将字符串写到流中
- fw.write("hello world!");
- //刷新流对象缓冲中的数据,将数据刷到目的地中
- fw.flush();
- //关闭流资源,但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候,必须close();
- fw.write("first_test");
- fw.close();
- //flush和close的区别:flush刷新后可以继续输入,close刷新后不能继续输入。
- }
- }
- class FileReaderDemo {
- public static void main(String[] args) {
- characters();
- }
- /*****************字符数组进行读取*********************/
- private static void characters() {
- try {
- FileReader fr = new FileReader("Demo.txt");
- char [] buf = new char[6];
- //将Denmo中的文件读取到buf数组中。
- int num = 0;
- while((num = fr.read(buf))!=-1) {
- //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
- sop(new String(buf,0,num));
- }
- sop('\n');
- fr.close();
- }
- catch (IOException e) {
- sop(e.toString());
- }
- }
- /*****************单个字母读取*************************/
- private static void singleReader() {
- try {
- //创建一个文件读取流对象,和指定名称的文件关联。
- //要保证文件已经存在,否则会发生异常:FileNotFoundException
- FileReader fr = new FileReader("Demo.txt");
- //如何调用读取流对象的read方法?
- //read()方法,一次读取一个字符,并且自动往下读。如果到达末尾则返回-1
- int ch = 0;
- while ((ch=fr.read())!=-1) {
- sop((char)ch);
- }
- sop('\n');
- fr.close();
- /*int ch = fr.read();
- sop("ch=" + (char)ch);
- int ch2 = fr.read();
- sop("ch2=" + (char)ch2);
- //使用结束注意关闭流
- fr.close(); */
- }
- catch (IOException e) {
- sop(e.toString());
- }
- }
- /**********************Println************************/
- private static void sop(Object obj) {
- System.out.print(obj);
- }
- }
- import java.io.*;
- class FileWriterDemo3 {
- public static void main(String[] args) {
- try {
- //传递一个参数,代表不覆盖已有的数据。并在已有数据的末尾进行数据续写
- FileWriter fw = new FileWriter("F:\\java_Demo\\day9_24\\demo.txt",true);
- fw.write(" is charactor table?");
- fw.close();
- }
- catch (IOException e) {
- sop(e.toString());
- }
- }
- /**********************Println************************/
- private static void sop(Object obj)
- {
- System.out.println(obj);
- }
- }
步骤:
源码:
- import java.io.*;
- import java.util.Scanner;
- class CopyText {
- public static void main(String[] args) throws IOException {
- sop("请输入要拷贝的文件的路径:");
- Scanner in = new Scanner(System.in);
- String source = in.next();
- sop("请输入需要拷贝到那个位置的路径以及生成的文件名:");
- String destination = in.next();
- in.close();
- CopyTextDemo(source,destination);
- }
- /*****************文件Copy*********************/
- private static void CopyTextDemo(String source,String destination) {
- try {
- FileWriter fw = new FileWriter(destination);
- FileReader fr = new FileReader(source);
- char [] buf = new char[1024];
- //将Denmo中的文件读取到buf数组中。
- int num = 0;
- while((num = fr.read(buf))!=-1) {
- //String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符
- fw.write(new String(buf,0,num));
- }
- fr.close();
- fw.close();
- }
- catch (IOException e) {
- sop(e.toString());
- }
- }
- /**********************Println************************/
- private static void sop(Object obj) {
- System.out.println(obj);
- }
- }
三、缓冲区
BufferedReader示例:
- import java.io.*;
- class BufferedReaderDemo {
- public static void main(String[] args) throws IOException {
- //创建一个字符读取流流对象,和文件关联
- FileReader rw = new FileReader("buf.txt");
- //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
- BufferedReader brw = new BufferedReader(rw);
- for(;;) {
- String s = brw.readLine();
- if(s==null) break;
- System.out.println(s);
- }
- brw.close();//关闭输入流对象
- }
- }
- import java.io.*;
- class BufferedWriterDemo {
- public static void main(String[] args) throws IOException {
- //创建一个字符写入流对象
- FileWriter fw = new FileWriter("buf.txt");
- //为了提高字符写入效率,加入了缓冲技术。
- //只要将需要被提高效率的流作为参数传递给缓冲区的构造函数即可
- BufferedWriter bfw = new BufferedWriter(fw);
- //bfw.write("abc\r\nde");
- //bfw.newLine(); 这行代码等价于bfw.write("\r\n"),相当于一个跨平台的换行符
- //用到缓冲区就必须要刷新
- for(int x = 1; x < 5; x++) {
- bfw.write("abc");
- bfw.newLine(); //java提供了一个跨平台的换行符newLine();
- bfw.flush();
- }
- bfw.flush(); //刷新缓冲区
- bfw.close(); //关闭缓冲区,但是必须要先刷新
- //注意,关闭缓冲区就是在关闭缓冲中的流对象
- fw.close(); //关闭输入流对象
- }
- }
- class MyBufferedReader1 extends Reader{
- private Reader r;
- MyBufferedReader1(Reader r){
- this.r = r;
- }
- //一次读一行数据的方法
- public String myReaderline() throws IOException {
- //定义一个临时容器,原BufferReader封装的是字符数组。
- //为了演示方便。定义一个StringBuilder容器。最终要将数据变成字符串
- StringBuilder sb = new StringBuilder();
- int ch = 0;
- while((ch = r.read()) != -1)
- {
- if(ch == '\r')
- continue;
- if(ch == '\n') //遇到换行符\n,返回字符串
- return sb.toString();
- else
- sb.append((char)ch);
- }
- if(sb.length()!=0) //当最后一行不是以\n结束时候,这里需要判断
- return sb.toString();
- return null;
- }
- /*
- 需要覆盖Reader中的抽象方法close(),read();
- */
- public void close()throws IOException {
- r.close();
- }
- public int read(char[] cbuf,int off, int len)throws IOException { //覆盖read方法
- return r.read(cbuf,off,len);
- }
- public void myClose() throws IOException{
- r.close();
- }
- }
一、字节流
练习:
需求:复制一张图片F:\java_Demo\day9_28\1.BMP到F:\java_Demo\day9_28\2.bmp
- import java.io.*;
- class CopyPic {
- public static void main(String[] args){
- copyBmp();
- System.out.println("复制完成");
- }
- public static void copyBmp() {
- FileInputStream fis = null;
- FileOutputStream fos = null;
- try {
- fis = new FileInputStream("F:\\java_Demo\\day9_28\\1.bmp"); //写入流关联文件
- fos = new FileOutputStream("F:\\java_Demo\\day9_28\\2.bmp"); //读取流关联文件
- byte[] copy = new byte[1024];
- int len = 0;
- while((len=fis.read(copy))!=-1) {
- fos.write(copy,0,len);
- }
- }
- catch (IOException e) {
- e.printStackTrace();
- throw new RuntimeException("复制文件异常");
- }
- finally {
- try {
- if(fis!=null) fis.close();
- }
- catch (IOException e) {
- e.printStackTrace();
- throw new RuntimeException("读取流");
- }
- }
- }
- }
注意事项:
练习:
代码:
- import java.io.*;
- //自己的BufferedInputStream
- class MyBufferedInputStream {
- private InputStream in; //定义一个流对象
- private byte [] buf = new byte[1024*4];
- private int count = 0,pos = 0;
- public MyBufferedInputStream(InputStream in){
- this.in = in;
- }
- public int MyRead() throws IOException{
- if(count==0) { //当数组里的数据为空时候,读入数据
- count = in.read(buf);
- pos = 0;
- byte b = buf[pos];
- count--;
- pos++;
- return b&255; //提升为int类型,在前面三个字节补充0。避免1111 1111 1111 1111
- }
- else if(count > 0) {
- byte b = buf[pos];
- pos++;
- count--;
- return b&0xff; //提升为int类型,在前面三个字节补充0。避免1111 1111 1111 1111
- }
- return -1;
- }
- public void myClose() throws IOException{
- in.close();
- }
- }
- class BufferedCopyDemo {
- public static void main(String[] args) {
- long start = System.currentTimeMillis();
- copy();
- long end = System.currentTimeMillis();
- System.out.println("时间:"+(end-start)+"ms");
- start = System.currentTimeMillis();
- copy1();
- end = System.currentTimeMillis();
- System.out.println("时间:"+(end-start)+"ms");
- }
- public static void copy1() { // 应用自己的缓冲区缓冲数据
- MyBufferedInputStream bis = null;
- BufferedOutputStream bos = null;
- try {
- bis = new MyBufferedInputStream(new FileInputStream("马旭东-入戏太深.mp3"));//匿名类,传入一个InputStream流对象
- bos = new BufferedOutputStream(new FileOutputStream("3.mp3"));
- int buf = 0;
- while((buf=bis.MyRead())!=-1) {
- bos.write(buf);
- }
- }
- catch (IOException e) {
- e.printStackTrace();
- throw new RuntimeException("复制失败");
- }
- finally {
- try {
- if(bis!=null) {
- bis.myClose();
- bos.close();
- }
- }
- catch (IOException e) {
- e.printStackTrace();
- }
- }
- }
- }
二、流操作规律
- /*================从键盘录入流,打印到控制台上================*/
- public static void InOutDemo(){
- //键盘的最常见的写法
- BufferedReader bufr = null;
- BufferedWriter bufw = null;
- try {
- /*InputStream ips = System.in; //从键盘读入输入字节流
- InputStreamReader fr = new InputStreamReader(ips); //将字节流转成字符流
- bufr = new BufferedReader(fr); */ //将字符流加强,提升效率
- bufr = new BufferedReader(new InputStreamReader(System.in)); //匿名类。InputSteamReader:读取字节并将其解码为字符
- bufw = new BufferedWriter(new OutputStreamWriter(System.out)); //OutputStreamWriter:要写入流中的字符编码成字节
- String line = null;
- while((line = bufr.readLine())!=null){
- if("over".equals(line)) break;
- bufw.write(line.toUpperCase()); //打印
- bufw.newLine(); //为了兼容,使用newLine()写入换行符
- bufw.flush(); //必须要刷新。不然不会显示
- }
- if(bufw!=null) {
- bufr.close();
- bufw.close();
- }
- }
- catch (IOException e) {
- e.printStackTrace();
- }
- }
- }
3. 转换流
2.OutputStreamWriter:字符流通向字节流
示例:
- /*================把键盘录入的数据存到一个文件中==============*/
- public static void inToFile() {
- //键盘的最常见的写法
- BufferedReader bufr = null;
- BufferedWriter bufw = null;
- try {
- /*InputStream ips = System.in; //从键盘读入输入字节流
- InputStreamReader fr = new InputStreamReader(ips); //将字节流转成字符流
- bufr = new BufferedReader(fr); */ //将字符流加强,提升效率
- bufr = new BufferedReader(new InputStreamReader(System.in)); //匿名类。InputSteamReader:读取字节并将其解码为字符
- bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt"))); //OutputStreamWriter:要写入流中的字符编码成字节
- String line = null;
- while((line = bufr.readLine())!=null){
- if("over".equals(line)) break;
- bufw.write(line.toUpperCase()); //打印
- bufw.newLine(); //为了兼容,使用newLine()写入换行符
- bufw.flush(); //必须要刷新。不然不会显示
- }
- if(bufw!=null) {
- bufr.close();
- bufw.close();
- }
- }
- catch (IOException e) {
- e.printStackTrace();
- }
- }
- /*
- 流操作的基本规律。
- 一、两个明确:(明确体系)
- 1. 明确源和目的
- 源:输入流 InputStream Reader
- 目的:输出流 OutputStream Writer
- 2. 操作的数据是否是纯文本
- 是: 字符流
- 否: 字节流
- 二、明确体系后要明确具体使用的对象
- 通过设备区分:内存,硬盘,键盘
- 目的设备:内存,硬盘,控制台
- 示例1:将一个文本文件中的数据存储到另一个文件中: 复制文件
- 一、明确体系
- 源:文件-->读取流-->(InputStream和Reader)
- 是否是文本:是-->Reader
- 目的:文件-->写入流-->(OutputStream Writer)
- 是否纯文本:是-->Writer
- 二、 明确设备
- 源:Reader
- 设备:硬盘上一个文本文件 --> 子类对象为:FileReader
- FileReader fr = new FileReader("Goods.txt");
- 是否提高效率:是-->加入Reader中的缓冲区:BufferedReader
- BufferedReader bufr = new BufferedReader(fr);
- 目的:Writer
- 设备:键盘上一个文本文件 --> 子类对象:FileWriter
- FileWriter fw = new FileWriter("goods1.txt");
- 是否提高效率:是-->加入Writer的缓冲区:BufferedWriter
- BufferedWriter bufw = new BufferedWriter(fw);
- 示例2:将一个图片文件数据复制到另一个文件中:复制文件
- 一、明确体系
- 源:文件-->读取流-->(InputStream和Reader)
- 是否是文本:否-->InputStream
- 目的:文件-->写入流-->(OutputStream Writer)
- 是否纯文本:否-->OutputStream
- 二、 明确设备
- 源:InputStream
- 设备:硬盘上一个媒体文件 --> 子类对象为:FileInputStream
- FileInputStream fis = new FileInputStream("Goods.txt");
- 是否提高效率:是-->加入InputStream中的缓冲区:BufferedInputStream
- BufferedInputStream bufi = new BufferedInputStream(fis);
- 目的:OutputStream
- 设备:键盘上一个媒体文件 --> 子类对象:FileOutputStream
- FileOutputStream fos = new FileOutputStream("goods1.txt");
- 是否提高效率:是-->加入OutputStream的缓冲区:BufferedOutputStream
- BufferedOutputStream bufo = new BufferedOutputStream(fw);
- 示例3:将键盘录入的数据保存到一个文本文件中
- 一、明确体系
- 源:键盘-->读取流-->(InputStream和Reader)
- 是否是文本:是-->Reader
- 目的:文件-->写入流-->(OutputStream Writer)
- 是否纯文本:是-->Writer
- 二、 明确设备
- 源:InputStream
- 设备:键盘 --> 对用对象为:System.in --> InputStream
- 为了操作方便,转成字符流Reader --> 使用Reader中的转换流:InputStreamReader
- InputStreamReader isr = new InputStreamReader(System.in);
- 是否提高效率:是-->加入Reader中的缓冲区:BufferedReader
- BufferedReader bufr = new BufferedReader(isr);
- 目的:Writer
- 设备:键盘上一个文本文件 --> 子类对象:FileWriter
- FileWriter fw = new FileWriter("goods1.txt");
- 是否提高效率:是-->加入Writer的缓冲区:BufferedWriter
- BufferedWriter bufw = new BufferedWriter(fw);
- import java.io.*;
- public class IOStreamLaw {
- /**
- * @param args
- */
- public static void main(String[] args) throws IOException {
- //键盘的最常见写法
- BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
- BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("goods1.txt"),"UTF-8"));
- String line = null;
- while((line=bufr.readLine())!=null){
- if("over".equals(line)) break;
- bufw.write(line.toUpperCase());
- bufw.newLine();
- bufw.flush();
- }
- bufr.close();
- }
- }
Java NIO流
对于JavaNIO还是不是很了解,之前认为NIO的N是non-block IO的意思,非阻塞;但是原来是New IO的意思。这个新表示的是和原来的BIO而言是一种新的IO吧。NIO的主要特性就是缓冲区,通道,和选择器(这个可能不是)。
Java在JDK1.4版本呢,引入了NIO这个新的api。Sun公司官方说明NIO的特性如下:
1. 为所有的原始类型提供了(Buffer)缓存支持;
2. 字符集编码解码解决方案
3. Channel(通道):一个新的原始I/O抽象;
4. 支持锁和内存映射文件的文件访问接口;
5. 提供多路(non-blocking)非阻塞式的高伸缩网络I/O。
对于上面的特性,我是不大了解的。不过,不影响,我们继续介绍。
NIO创建的目的是,实现高速的I/O,而无需编写自定义的本机代码。
那NIO大概是怎么做到的呢?它将最耗时的I/O操作转回操作系统,因而可以极大的提高速度。而最耗时的I/O操作是填充和提取缓冲区。
原来的io和现在NIO最重要的区别就是,数据打包和传输的方式。以前是以流,现在是以块的方式处理数据。
之前用流的方式呢,只能一次一个字节的处理数据。一个输入流产生一个字节的数据,而一个输出流则消耗一个字节的数据。这样的好处是,创建过滤器特别容易,可以创建多个过滤器,每个过滤器处理只处理一部分的数据。坏处就是,比较慢。
而NIO用块的方式呢,可以一次一个块的处理数据。每一步的操作都在产生或者消耗一个块,好处是相对于流快得多,坏处是,不够优雅和简单。
缓冲区
然后开始介绍缓冲区,缓冲区就是上面介绍到的NIO的特性第一条,为所有的原始数据都提供了Buffer缓存的支持。它主要是将所有的原始数据放在数组中,以块的形式处理。
而每种缓冲区的类都有四个属性:容量(Capacity),上界(Limit),位置(Position),以及标记(Mark),用于提供关于其所包含的数据元素的信息。
容量:缓冲区能够容纳的数据元素的最大数量,缓冲区创建时确定,永远不能被改变;
上界:缓冲区第一个不能被读或写的元素,或者说,缓冲区现存元素的计数。
位置:下一个要被读或写的元素的索引。该值会自动由相应的get(),put()函数更新;
标记:一个备忘的位置。调用mark()来设定mark=position。调用reset()来设定position = mark;标记在设定前是未定义的undefined。
缓冲区的分类有,ByteBuffer(字节缓冲区),CharBuffer(字符缓冲区),ShortBuffer(短整型缓冲区),IntBuffer(整型缓冲区),LongBuffer(长整型缓冲区),FloatBuffer(单精度浮点缓冲区),DoubleBuffer(双精度浮点缓冲区),就是没有布尔缓冲区。
他们都是抽象类,所以不能实例化,然后他们都继承了Buffer类,所以都有存get(),取set()方法,也都可以通过各自的静态方法allocation,创建缓冲区。该方法是通过warpping将现有的数组包装到缓冲区中来为缓冲区的内容分配空间,或者通过创建现有字节缓冲区的视图来创建。
下面这是一个简单的实例,从上到下,创建一个整型的缓冲区,然后将现有的数组放到该缓冲区中。可以通过put改变数组中的数据,并且由于缓冲区中的数据对数组是可见的,所以改变缓冲区也会改变数据,可以认为是传引用。flip(),由于get()每调用一次,position位置都会改变,本来pos会等于3的,而用flip可以让pos变为0;clear()效果也一样。而duplicate()可以复制一个缓冲区,一模一样,也是传引用,修改哪个都会影响到另一个。
- import java.nio.IntBuffer;
- import java.util.Arrays;
- /**
- * Created by liuyanling on 2017/6/30.
- */
- public class BufferTest {
- public static void main(String[] args) {
- //创建缓冲区,并指定大小
- IntBuffer intBuffer = IntBuffer.allocate(10);
- //给缓冲区赋值,建立数组
- int[] intArray = new int[]{3,5,7};
- intBuffer = intBuffer.wrap(intArray);
- //修改元素
- intBuffer.put(0,9);
- //打印缓冲区数据
- for(int i=0;i<intBuffer.limit();i++) {
- System.out.print(intBuffer.get()+"\t");
- //System.out.print(intBuffer+"\t"); //
- }
- System.out.println("\n缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用");
- //打印原始数组
- Arrays.stream(intArray).forEach(temp-> System.out.print(temp+"\t"));
- //intBuffer.flip();//get()会使pos改变,对缓冲区进行反转,将limit=pos;pos=0; (将当前位置给limit,然后变为0)
- intBuffer.clear();
- System.out.println(intBuffer);
- IntBuffer intBuffer2 = intBuffer.duplicate();
- System.out.println(intBuffer2);
- intBuffer2.put(0,11);
- //0 <= mark <= position <= limit <= capacity
- //打印缓冲区数据
- for(int i=0;i<intBuffer.limit();i++) {
- System.out.print(intBuffer.get()+"\t");
- }
- System.out.println("\n复制的缓冲区对原来的缓冲区也是可见的;传引用");
- //打印原始数组
- for(int i=0;i<intBuffer2.limit();i++) {
- System.out.print(intBuffer2.get()+"\t");
- }
- }
- }
结果是这样
9 5 7
缓冲区的数据对数组是可见的,修改视图,数组中的数据也会变;传引用
9 5 7 java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
java.nio.HeapIntBuffer[pos=0 lim=3 cap=3]
11 5 7
复制的缓冲区对原来的缓冲区也是可见的;传引用
11 5 7
未完待续!