Java之IO流基础流对象

输入流和输出流是相对于内存设备而言

即将外设中的数据读取到内存中就是输入

将内存中的数据写入到外设中就是输出

字符流的由来：

其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。

再对这个文字进行操作，其实就是字节流+编码表

字节流的两个顶层父类：

1，InputStream  2，OutputStream

字符流的两个顶层父类：

1，Reader   2，Writer

这些体系的子类都以父类名作为后缀。

而子类名的前缀就是该对象的功能。

如果要操作文字数据，建议优先考虑字符流。

而且要将数据从内存写到硬盘上。要使用字符流中的输出流，Writer

输出流代码演示：

import java.io.FileWriter;
import java.io.IOException;

public class IODemo {

 private static final String LINE_SPEARATOR = System.getProperty("line.separator");

 /**
  * @param args
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  /**
   * 创建一个可以往文件中写入字符数据的字符输出流对象
   * 既然是往一个文件中写入文字数据，那么在创建对象时，就必须明确该对象文件（用于存储数据的目的地）
   * 如果文件不存在，则创建。
   * 如果文件存在，则覆盖
   *
   * 如果构造函数中加入ture，可以实现文件的续写。
   */
  FileWriter wf = new FileWriter("E:\\Workspaces\\MyEclipse 10\\a.txt",true);
  /**
   * 调用Writer对象中的writer(String s)方法,写入数据。
   * 其实数据写入到临时存储缓冲区中。
   */
  wf.write("my data"+LINE_SPEARATOR+"again line ");

  /**
   * 进行刷新，将数据直接写到目的地中。
   */
  wf.flush();
  /**
   * 关闭流，关闭资源。在关闭前会调用flush刷新缓冲中的数据到目的地中。
   * 如果在关闭流后再进行flush方法的调用，则会导致IOException
   * 如需要继续写入，则使用flush进行数据写入，如果不需要再写数据则直接调用close即可。
   *
   */
  wf.close();
 }
}

　　

输入流代码演示一：

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo1 {

 /**
  * @param args
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  // 1,创建一个能够读取字符流数据的流对象
  /**
   * 在创建读取刘对象时，必须要明确被读取的文件，一定要确定该文件是存在的。
   *
   * 用一个读取流关联一个已存在的文件。
   */
  FileReader fr = new FileReader("E:\\Workspaces\\MyEclipse 10\\a.txt");
  /**
   * 用reader中的read方法读取
   * 简单读取，一个字符一个字符的读。
   */

  int ch = 0;
  while((ch=fr.read())!=-1){
   System.out.println((char)ch);
  }

  fr.close();
 }

}

输入流代码演示二：

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo2{

 /**
  * @param args
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  FileReader fr = new FileReader("E:\\Workspaces\\MyEclipse 10\\a.txt");
  /**
   * 使用read(char[] ch)读取文本文件数据。
   * 先创建字符数组
   */
  char[] buf = new char[1024];
  int len = 0;

  while((len = fr.read(buf))!=-1){//将读到的字符存储到数组中。
  System.out.println(new String(buf));
  }
  fr.close();
 }

}

复制功能实现：

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

public class CopyTextDemo {

 private static final int BUFFER_SIZE = 1024;

 /**
  * @param args
  */
 public static void main(String[] args) {
  FileReader fr = null;
  FileWriter fw = null;

  try {
  fr = new FileReader("E:\\Workspaces\\MyEclipse 10\\a.txt");
  fw = new FileWriter("E:\\Workspaces\\MyEclipse 10\\b.txt");
  //创建一个临时容器，用于缓存读取到的字符
  char[] buf = new char[BUFFER_SIZE];
  //定义一个变量记录读取到的字符数其实就是往数组里装的字符个数。
  int len = 0;
  while((len = fr.read(buf))!= -1){
   fw.write(buf,0,len);
  }
  } catch (Exception e) {
   throw new RuntimeException("失败了");
  }finally{
   if(fw!=null){
    try {
     fw.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
   if(fr!=null){
    try {
     fr.close();
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
  }
 }

}

缓冲区的写入使用代码演示：

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

public class BufferedWriterDemo {

 /**
  * @param args
  * @throws IOException
  */
 public static void main(String[] args) throws IOException {
  FileWriter fw = new FileWriter("E:\\Workspaces\\MyEclipse 10\\b.txt");
  //为了提高写入的效率，使用了字符流的缓冲区。
  //创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联
  BufferedWriter bufw = new BufferedWriter(fw);
  //使用缓冲区的写入方法将数据先写入到缓冲区中
  bufw.write("buffered write");
  bufw.newLine();
  bufw.write("again line");
  //使用缓冲区的刷新方法将数据刷到目的地中。
  bufw.flush();

  //关闭缓冲区。其实关闭的就是被缓冲的流对象。
  bufw.close();

 }

}

缓冲区读取代码演示：

  FileReader fr = new FileReader("E:\\Workspaces\\MyEclipse 10\\a.txt");
  BufferedReader bufr = new BufferedReader(fr);

  String line = null;

  while((line=bufr.readLine())!=null){
   System.out.println(line);
  }

BufferedReader原理代码演示:

import java.io.FileReader;
import java.io.IOException;

public class MyBufferedReader {

 /**
  * @param args
  * 自定义的读取缓冲区，模拟一个BufferedReader.
  * 分析：
  * 缓冲区中无非就是封装了一个数组，
  * 并对外提供了更多的方法对数组进行访问，
  * 其实这些方法最终操作的都是数组的角标
  *
  * 缓冲的原理：
  * 其实就是从源中获取一批数据装进缓冲区中
  * 在从缓冲区中不断的取出一个一个数据。
  *
  * 当此次取完后，再从源中继续取一批数据进缓冲区。
  * 当源中的数据取光时，用-1作为结束标记。
  *
  */
 private FileReader r;
 private char[] buf = new char[1024];//定义一个数组作为缓冲区

 //定义一个指针用于操作这个数组中的元素，当操作到最后一个元素后，指针应该归零。
 private int pos = 0;

 //定义一个计数器，用于记录缓冲区中的数据个数。当该数据减到0，就从源中继续获取数据到缓冲区中。
 private int count = 0;

 MyBufferedReader(FileReader r){
  this.r = r;
 }
 /**
  * 该方法从缓冲区中一次取一个字符
  * @return
  * @throws IOException
  */
 public int myRead() throws IOException{
  //从源中获取一批数据到缓冲区中。需要先做判断，只有计数器为0时，才需要从源中获取数据。

  /*if(count==0){
   count = r.read(buf);
   if(count<0){
    return -1;
   }
   pos = 0;//每次获取数据到缓冲区后，角标归0
   char ch = buf[pos];
   pos++;
   count--;
   return ch;
  }else if(count>0){
   char ch = buf[pos];
   pos++;
   count--;
   return ch;
  }
  */
 //方法简化重写
  if(count==0){
   count =  r.read(buf);
   pos = 0;
  }
  if(count<0){
   return -1;
  }
  char ch = buf[pos];
  pos++;
  count--;
  return ch;
 }

 public String myReadLine() throws IOException{
  StringBuilder sb = new StringBuilder();
  int ch = 0;
  while((ch = myRead())!=-1){
   if(ch == ‘\r‘){
    continue;
   }
   if(ch == ‘\n‘){
    return sb.toString();
   }
   //将从缓冲区中读到的字符存储到缓存行数据的缓冲区中。
   sb.append((char)ch);
  }
  if(sb.length()!=0){
   return sb.toString();
  }
  return null;
 }
}

IO缓冲区之装饰设计模式：

当对一组对象的功能进行增强时，就可以使用该模式进行问题的解决。

装饰和继承都能够实现一样的特点：进行功能的扩展和增强。

区别在于：

首先有一个集成体系。

假设体系如下：

Writer

--TextWriter:用于操作文本

--MediaWriter:用于操作媒体

想要对操作的动作进行效率的提高。

按照面向对象，可以通过继承对具体的进行功能的扩展。

效率提高需要加入缓冲技术。

Writer

--TextWriter:用于操作文本

--BufferTextWriter:加入了缓冲技术的操作文本的对象。

--MediaWriter:用于操作媒体

到这里其实就已经实现了，但是并不理想。

如果这个体系进行功能扩展，那么就又多了流对象。

那么这个流要提高效率，就一定要产生子类，这时就会发现只为提高功能而进行的继承就会导致继承体系越来越臃肿。就不够灵活。

那么重新进行思考：

既然加入的都是同一种技术---缓冲。

前一种是让缓冲和具体的流对象相结合。

那么我们就对缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联。

class Buffer{

Buffer(TextWriter w){}

Buffer(MediaWriter w){}

}

class BufferWriter extends Writer{

Buffer(Writer w){}

}

那么体系就变成如下结构

Writer

--TextWriter:用于操作文本

--MediaWriter:用于操作媒体

--BufferWriter：用于提高效率的。

结论如下：

装饰比继承更为灵活。

特点：装饰类和被装饰类都必须所属同一个接口或者父类。

装饰设计模式思想重写MyBufferedReader

import java.io.IOException;
import java.io.Reader;

public class MyBufferedReader extends Reader {

 private Reader r;
 private char[] buf = new char[1024];
 private int pos = 0;
 private int count = 0;

 MyBufferedReader(Reader r){
  this.r = r;
 }

 public int myRead() throws IOException{
  if(count==0){
   count =  r.read(buf);
   pos = 0;
  }
  if(count<0){
   return -1;
  }
  char ch = buf[pos];
  pos++;
  count--;
  return ch;
 }

 public String myReadLine() throws IOException{
  StringBuilder sb = new StringBuilder();
  int ch = 0;
  while((ch = myRead())!=-1){
   if(ch == ‘\r‘){
    continue;
   }
   if(ch == ‘\n‘){
    return sb.toString();
   }
   sb.append((char)ch);
  }
  if(sb.length()!=0){
   return sb.toString();
  }
  return null;
 }
 @Override
 public int read(char[] cbuf, int off, int len) throws IOException {

  return 0;
 }
 @Override
 public void close() throws IOException {
  r.close();
 }

}
时间： 2024-11-06 15:48:54

Java之IO流基础流对象的相关文章

JAVA之IO技术-字符流对象Writer的子类对象FileWriter的使用

  package ioTest.io1; import java.io.File; import java.io.FileWriter; /* * IO技术,按照操作数据的方式分类如下: * 字节流和字符流 * 字节流的两个基类: * InputStream,OutputStream * 字节流的两个基类: * Reader,Writer * 思考一个问题:为什么有了字节流还要出现字符流? * * 先学习字符流的特点. * * 既然IO是操作数据的,那么数据最常见的体现形式 文件 * 需求:

IO流常用方法,流的用法,代码例子

/** * 一个汉字是一个字符,就是2个字节,就是16位,所以,要读取汉字,还得用字符流 *-------------------------------------- 基础流---------------------------------------------- */FileInputStream ://(字节输入流,一次读取1个字节(就是8位)) FileInputStream fis = new FileInputStream("文件路径");//字节输入流 FileOutp

Java I/O— 梳理各种“流”

背景 Java的核心库java.io提供了全面的IO接口.包括:文件读写.标准设备输出等.Java中IO是以流为基础进行输入输出的,所有数据被串行化写入输出流,或者从输入流读入. -- 百度百科 Java.io中有很多类,我们如何清楚地知道什么时候该用什么类呢? 目标 本文的目标是梳理java.io中各个类的关系,了解各个类的应用场景. 概念 数据源,数据流,目的地.在看关于java io的相关代码时,每次都要问问自己此时这三者各指的是谁.而本文主要是说数据流的. 归类 按不同分类方法,将各种"

【JAVA】IO详解

综合各种网文得出此文 引用 [1]http://blog.csdn.net/yczz/article/details/38761237 [2]http://www.cnblogs.com/pepcod/archive/2013/01/20/2913435.html [3]http://blog.csdn.net/zhangerqing/article/details/8466532 首先 先挂一图,这个图是java中类的层次结构 引用自[1] . Java的IO是基于流的. 流是什么: 流相当于

Java之IO(一)InputStream和OutputStream

转载请注明源出处:http://www.cnblogs.com/lighten/p/6964702.html 1.前言 计算机的IO操作一直都是比较重要的一环,IO顾名思义,就是输入输出流.不管是磁盘IO还是网络IO,数据流转就离不开IO,理解Java的IO操作类很重要,本文介绍IO的抽象父类InputStream和OutputStream,这是Java的IO操作基础,理解完抽象类,对于其它的IO流也有很大的帮助. 流都实现了Closeable接口,也就是都需要关闭.输出流额外实现了一个Flus

黑马程序员——java基础---IO(input output)流字符流

黑马程序员——java基础---IO(input output)流字符流 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- io(input output)流特点: 1,io流用来处理数据之间的传输 2,java对数据的操作是通过流的方式: 3,java用于操作流的对象都在io包中: 4,流按操作数据分为两种:字节流和字符流: 5,流按流向分为:输入流和输出流. 注意:流只能操作数据,而不能操作文件. 3.IO流的常用基类: 1)字节流的抽象

Java 基础 IO流(转换流，缓冲)

一,前言 在学习字符流(FileReader.FileWriter)的时候,其中说如果需要指定编码和缓冲区大小时,可以在字节流的基础上,构造一个InputStreamReader或者OutputStreamWriter,这又是什么意思呢 二,转换流 2.1 OutputStreamWriter类 查阅OutputStreamWriter的API介绍,OutputStreamWriter 是字符流通向字节流的桥梁:可使用指定的字符编码表,将要写入流中的字符编码成字节.它的作用的就是,将字符串按照指

Java基础知识强化之IO流笔记37：字符流缓冲流之BufferedWriter / BufferedReader使用

1. 字符流缓冲流: 字符流为了高效读写,也提供了对应的字符缓冲流. BufferedWriter:字符缓冲输出流 BufferedReader:字符缓冲输入流 2. BufferedWriter使用:     将文本写入字符输出流,缓冲各个字符,从而提供单个字符.数组和字符串的高效写入.可以指定缓冲区的大小,或者接受默认的大小.在大多数情况下,默认值就足够大了. (1)BufferedWriter的构造方法: 构造方法摘要 BufferedWriter(Writer out)         

java学习--基础知识进阶第十天--标准输入流 &amp; 转换流 &amp; 打印流、对象操作流 、Properties集合

今日内容介绍 u  标准输入流 & 转换流 & 打印流 u  对象操作流 u  Properties集合 第1章 标准输入流 & 转换流 & 打印流 1.1 标准输入输出流 public static final InputStream in:标准输入流 public static final PrintStream out:标准输出流 package com.itheima_05; /* * 标准输入输出流: public static final InputStream