I/O Streams的运用

原创 2006年06月06日 15:29:00

import java.io.*;
import java.util.zip.GZIPOutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.CheckedOutputStream;
import java.util.zip.Adler32;
import java.util.zip.ZipOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.CheckedInputStream;
import java.util.zip.ZipInputStream;

public class IOStreams {
//采用字节流,以行为单位从一个文件读取数据
  public static void ByteIn() {
    String byteSource = null;
    try {
      DataInputStream byteIn =
          new DataInputStream(
          new FileInputStream("c://student.dat"));
      while (byteIn.available() != 0) {
        byteSource += byteIn.readLine() + '/n';
      }
      byteIn.close();
    }
    catch (Exception e) {
      System.err.println("File input error");
    }
  }

//采用字符流,以行为单位从一个文件读取数据
  public static void CharIn() {
    String charSource = null;
    String s;
    try {
      BufferedReader charIn =
          new BufferedReader(
          new FileReader("c://student.dat"));
      while ( (s = charIn.readLine()) != null)
        charSource += s + "/n";
      charIn.close();
    }
    catch (Exception e) {
      System.err.println(e.getMessage());
    }
  }

//采用字节流,接收键盘的输入
  public static void KeyboardByteIn() {
    try {
      BufferedInputStream byteIn2 =
          new BufferedInputStream(System.in);
      System.out.println("Enter a line:");
      while (byteIn2.available() != -1)
        System.out.print( (char) byteIn2.read());
      System.out.println();
      byteIn2.close();
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }
  }

//采用字符流,接收键盘的输入
  public static void KeyboardCharIn() {
    try {
      BufferedReader charIn2 =
          new BufferedReader(
          new InputStreamReader(System.in));
      System.out.println("Enter a line:");
      System.out.println(charIn2.readLine());
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }

  }

//采用字节流,从一个String对象中读取数据
  public static void StringByteIn() {
    String byteSource = "String";
    try {
      StringBufferInputStream byteIn3 =
          new StringBufferInputStream(byteSource);
      int c;
      while ( (c = byteIn3.read()) != -1)
        System.out.print( (char) c);
      byteIn3.close();
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }
  }

  //采用字符流,从一个String对象中读取数据
  public static void StringCharIn() {
    String charSource = "String";
    try {
      StringReader charIn3 = new StringReader(charSource);
      int c;
      while ( (c = charIn3.read()) != -1)
        System.out.print( (char) c);
      charIn3.close();
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }
  }

  //从内存取出格式化输入
  public static void MemoryIn() {
    String byteSource = "abcde";
    try {
      DataInputStream byteIn4 =
          new DataInputStream(
          new ByteArrayInputStream(byteSource.getBytes()));
      while (byteIn4.available() != 0)
        System.out.print( (char) byteIn4.readByte());
    }
    catch (EOFException e) {
      System.out.println("End of stream");
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }
  }

//采用字节流,输出到文件
  public static void ByteOut() {
    String byteSource = "";
    try {
      DataInputStream byteIn5 =
          new DataInputStream(
          new StringBufferInputStream(byteSource));
      PrintStream byteOut5 = new PrintStream(
          new FileOutputStream("D://IOStreamTestDemoByte.out"));
      while (byteIn5.available() != 0)
        byteOut5.println(byteIn5.readLine());
      byteOut5.close();
      byteIn5.close();
    }
    catch (Exception e) {
      System.out.println(e.getMessage());
    }
  }

  //采用字符流,输出到文件
  public static void CharOut() {
    String charSource = "";
    String s;
    try {
      BufferedReader charIn5 =
          new BufferedReader(
          new StringReader(charSource));
      PrintWriter charOut5 =
          new PrintWriter(
          new BufferedWriter(
          new FileWriter("D://IOStreamTestDemoChar.out")));
      int lineCount = 1;
      while ( (s = charIn5.readLine()) != null)
        charOut5.println(lineCount++ +":" + s);
      charOut5.close();
      charIn5.close();
    }
    catch (EOFException e) {
      System.err.println(e.getMessage());
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }

  }

//通过GZip文件流压缩文件
  public static void GZip() {
    try {
      //打开需压缩文件作为文件输入流
      BufferedInputStream fin =
          new BufferedInputStream(
          new FileInputStream("D://IOStreamTestDemo.in"));
      //建立gzip压缩输出流
      GZIPOutputStream gzout =
          new GZIPOutputStream(
          new FileOutputStream("D://IOStreamTestDemo.gzip"));
      //设定读入缓冲区尺寸
      byte[] buf = new byte[1024];
      int num;
      fin.read(buf);
      while ( (num = fin.read(buf)) != -1) {
        gzout.write(buf, 0, num);
      }
      //关闭流,必须关闭所有输入输出流.保证输入输出完整和释放系统资源
      gzout.close();
      fin.close();
    }
    catch (IOException e) {
      System.out.println(e);
    }
  }

  //通过GZip文件流解压缩文件
  public static void UnGZip() {
    try {
      //建立gzip解压工作流
      GZIPInputStream gzin =
          new GZIPInputStream(
          new FileInputStream("D://IOStreamTestDemo.gzip"));
      //建立解压文件输出流
      DataOutputStream byteOut8 =
          new DataOutputStream(
          new FileOutputStream("D://IOStreamTestDemoUngzip.out"));
      byte[] buf = new byte[1024];
      int num;
      while ( (num = gzin.read(buf, 0, buf.length)) != -1) {
        byteOut8.write(buf, 0, num);
      }
      gzin.close();
      byteOut8.close();
    }
    catch (IOException e) {
      System.out.println(e);
    }
  }

//运用Zip对多份文件进行压缩
  public static void Zip() {
    try {
      FileOutputStream f =
          new FileOutputStream("d://data.zip");
      CheckedOutputStream checkOutput =
          new CheckedOutputStream(f, new Adler32());
      ZipOutputStream zipOut =
          new ZipOutputStream(
          new BufferedOutputStream(checkOutput));
      File file = new File("D://data");
      String fileName;
      if (file.isDirectory()) {
        String[] files = file.list();
        for (int i = 0; i < files.length; i++) {
          System.out.println(i + "、Writing file:" + files[i]);
          fileName = file.getAbsolutePath() +
              System.getProperty("file.separator") + files[i];
          BufferedReader reader =
              new BufferedReader(
              new FileReader(fileName));
          zipOut.putNextEntry(new ZipEntry(fileName));
          int oneByte;
          while ( (oneByte = reader.read()) != -1) {
            zipOut.write(oneByte);
          }
          reader.close();
        }
        zipOut.close();
        System.out.println("Checksum:" +
                           checkOutput.getChecksum().getValue());
      }
    }
    catch (IOException e) {
      System.err.println(e.getMessage());
    }
  }

//运用Zip对压缩文件进行解压并写回到原来的目录
  public static void Unzip() {
    try
    {
      System.out.println("Reading file");
      FileInputStream fileInput =
          new FileInputStream("d://data.zip");
      CheckedInputStream checkIn =
          new CheckedInputStream(fileInput, new Adler32());
      ZipInputStream zipIn =
          new ZipInputStream(
          new BufferedInputStream(checkIn));
      ZipEntry zipEn;
      String fileName;
      while ( (zipEn = zipIn.getNextEntry()) != null)
      {
        fileName = zipEn.toString();
        System.out.println("Reading file:" + zipEn);
        String separator = System.getProperty("file.separator");
        int pos = fileName.lastIndexOf(separator);
        String path = fileName.substring(0, pos);
        File filePath = new File(path);
        if (!filePath.exists())
          filePath.mkdir();
        DataOutputStream writer =
            new DataOutputStream(
            new BufferedOutputStream(
            new FileOutputStream(fileName)));
        int oneByte;
        while ( (oneByte = zipIn.read()) != -1)
          writer.write(oneByte);
        writer.close();
      }
      System.out.println("Checksum:" +
                         checkIn.getChecksum().getValue());
      zipIn.close();
    }
    catch (IOException e)
    {
      System.err.println(e.getMessage());
    }
  }

  public static void main(String[] args) {
  }
}

《unix高级环境编程》高级 I/O——STREAMS(流)

STREAMS(流)是系统 V 提供的构造内核设备驱动程序和
  • chenhanzhun
  • chenhanzhun
  • 2014年11月15日 17:43
  • 1140

I/O处理几种方式

1.阻塞方式 该方式主要特点是调用阻塞的系统方法,是的用户线程阻塞在等待I/O的数据准备过程,其常用的方式是使用线程池的方式,将阻塞方法的调用和后续的处理流程放进单独的线程任务对象中,通过线程池来处...
  • CWeeYii
  • CWeeYii
  • 2016年09月04日 08:48
  • 547

彻底理解I/O架构

一个系统要能正确工作,必须要有数据通道(data paths)的机制,软件和硬件系统都概莫能外。对于计算机系统而言,必须要有data paths的机制来确保CPU, RAM和I/O设备之间的信息数据能...
  • acs713
  • acs713
  • 2015年01月21日 13:34
  • 6810

文件I/O和标准I/O的区别

一、先来了解下什么是文件I/O和标准I/O: 文件I/O:文件I/O称之为不带缓存的IO(unbuffered I/O)。不带缓存指的是每个read,write都调用内核中的一个系统调用。也就是一般所...
  • zqixiao_09
  • zqixiao_09
  • 2016年01月01日 10:12
  • 2336

《JAVA I/O最详解》

刚开始学Java时候,一直搞不懂Java里面的io关系,在网上找了很多大多都是给个结构图草草描述也看的不是很懂。而且没有结合到java7 的最新技术,所以自己结合API来整理一下,有错的话请指正,...
  • self_realian
  • self_realian
  • 2016年07月19日 17:31
  • 1785

异步式I/O与事件驱动--起步

Node.js使用的是单线程模型,对于所有I/O都采用异步式的请求方式,避免了频繁的上下文切换。Node.js在执行的过程中会维护一个事件队列,程序在执行时进入事件循环等待下一个事件到来,每个异步式I...
  • Saya_gt
  • Saya_gt
  • 2015年11月25日 22:38
  • 759

Linux网络编程——I/O复用之select详解

一、I/O复用概述 I/O复用概念: 解决进程或线程阻塞到某个 I/O 系统调用而出现的技术,使进程不阻塞于某个特定的 I/O 系统调 I/O复用使用的场合: 1.当客户处理多个描...
  • lianghe_work
  • lianghe_work
  • 2015年06月15日 17:46
  • 2428

NodeJS学习笔记(一)——异步I/O的理解

操作系统对I/O的操作分为阻塞I/O和非阻塞I/O。阻塞I/O造成了CPU的等待,使CPU不能得到充分的利用;而非阻塞I/O虽然不必等待完整I/O的返回,但需要通过轮询重复的调用判断操作,这种判断操作...
  • Jacie_chaochao
  • Jacie_chaochao
  • 2015年11月30日 21:47
  • 1457

模拟量I/O与数字量I/O有什么区别?

模拟量I/O与数字量I/O有什么区别?   在工业自动化控制中,经常会遇到开关量,数字量,模拟量,离散量,脉冲量等各种概念,而人们在实际应用中,对于这些概念又很容易混淆。现将各种概念罗列如下: ...
  • huwei2003
  • huwei2003
  • 2014年08月18日 10:40
  • 1283

操作系统:I/O

操作系统:I/O 参考 http://blog.csdn.net/bigpudding24/article/details/48901473 1 I/O设备及其分类​ I/O设备管...
  • huhaijing
  • huhaijing
  • 2016年06月21日 09:21
  • 1913
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:I/O Streams的运用
举报原因:
原因补充:

(最多只允许输入30个字)