Java IO流的学习（1）

JAVA 通过 OutputStream InputStream 实现文件复制功能

 package org.iodemo;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;

 public class Copy {

     /**
      * @param args
      */
     public static void main(String[] args) throws Exception { //所有异常抛出
         // TODO Auto-generated method stub
         if (args.length != 2){ //参数不是两个
             System.out.println("输入的参数不正确");
             System.exit(1); //系统退出
         }

         if (args[0].equals(args[1])){
             System.out.println("输入的是同一个文件");
             System.exit(1); //系统退出
         }


         File file1 = new File(args[0]); //找到第一个文件的File 对象
         if (file1.exists()){
             File file2 = new File(args[1]); // 找到目标文件路径
             InputStream input = new FileInputStream(file1); //输入流
             OutputStream output = new FileOutputStream(file2); //输出流
             int temp = 0; 定义一个整数表示接收的内容
             while ((temp = input.read()) != -1 ){ //表示还有内容可以继续读
                 output.write(temp); //写入数据
             }
                         System.out.println("文件复制成功");
                         input.close();
             output.close();
         }else{
             System.out.println("文件不存在");
         }
     }

 }

内存操作流

在之前讲解FileInputStream 和 FileOutputStream 的时候所有的操作的目标是文件，那么如果现在假设有一些临时的信息要求通过IO操作的话，那么如果将这些临时的信息保存在文件之中则肯定很不合理，因为操作的最后还要把文件再删除掉，所以此时的IO中就提供了一个内存的操作流，通过内存操作流输入和输出的目标是内存。

使用ByteArrayOutputStream 和 ByteArrayInputStream 完成内存的操作流

在内存操作流中所有的输入和输出都是以内存为操作的源头

ByteArrayOutputStream 是用于从内存向程序输出的

ByteArrayInputStream 是用于从程序向内存写入的

ByteArrayInputStream 的构造方法： public ByteArrayInputStream(byte[] buf)

表示把内容向内存之中写入

ByteArrayOutputStream来讲，其基本的作用就是与OutputStream一样，一个个的读取数据。

 

范例：使用内存操作流，完成一个字符串小写小母变为大写字每的操作

 package org.bytearrarydemo;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;

 public class ByteArrayDemo01 {

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         String str ="helloworld"; //定义字符串，全部由小写字母组成
         ByteArrayInputStream input = new ByteArrayInputStream(str.getBytes());  //内存输入流 将内容存在内存之中
         ByteArrayOutputStream output = new ByteArrayOutputStream();     //内存输出流
         int temp = 0;
         while ((temp = input.read()) != -1){ //依次读取
             char c = (char)temp; //接收字符
             output.write(Character.toUpperCase(c)); //输出
         }
         String stra = output.toString(); //取出内存输出的内容
         System.out.println(stra);
     }

 }

内存操作流现在在Java SE阶段是感觉不出有什么作用，但是在学习Java WEB 中的AJAX技术的时候，会结合XML解析和JavaScript、AJAX完成一些动态效果的使用

 String newStr = output.toString(); //取出内存输出的内容

管道流

管道流就是进行两个线程间通讯的。使用PipedOutputStream 和 PipedInputStream 两个类完成。但是，这两个类使用的时候基本上都跟OutputStream 和InputStream类似，唯一区别的的是在于连接管道的操作上。

 public void connect(PipedInputStream snk) throws IOException

范例：进行管道流的操作

 package org.pipedinputdemo;

 import java.io.IOException;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;

 class Send implements Runnable{ //发送数据的线程
     private PipedOutputStream out = null;

     public Send(){
         this.out = new PipedOutputStream();
     }

     public PipedOutputStream getPipedOutputStream(){
         return this.out;
     }

     public void run(){
         String str = "Hello World"; //要发送的数据
         try {
             this.out.write(str.getBytes()); //发送
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         try {
             this.out.close();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

 }

 class Recives implements Runnable{ //接收数据的线程

     private PipedInputStream input = null;

     public Recives(){
         this.input = new PipedInputStream();
     }

     public PipedInputStream getPipedInputStream(){
         return this.input;
     }

     public void run(){
         byte b[] = new byte[1024]; //接收内容
         int len = 0;
         try {
             len = input.read(b); //内容读取
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         try {
             input.close();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         System.out.println(new String(b,0,len));
     }
 }

 public class PipedInputDemo {

     /**
      * @param args
      */
     public static void main(String[] args) throws Exception {
         // TODO Auto-generated method stub
         Send send = new Send();
         Recives rec = new Recives();
         send.getPipedOutputStream().connect(rec.getPipedInputStream()); //进行管道连接
         new Thread(send).start(); //启动线程
         new Thread(rec).start(); //启动线程
     }

 }

打印流

使用OutputStream 可以完成数据的输出，但是现在如果有一个float 型数据好输出吗？

也就是说虽然现在提供了输出流的操作类，但是这个类本身的输出的支持功能并不是十分的强大，所以，如果现在要想进行更方便的输出操作，则可以使用打印流。

打印流分两种：PrintStream、PrintWriter

观察打印流的定义：

 public class PrintStream

 extends FilterOutputstream

 implements Appendable,Closeable

PrintStream 是 OutputStream 的子类，继续观察其构造方法

 public PrintStream(OutputStream out)

在此就去中要接收OutputStream 子类的引用

实际上PrintStream 属于装饰。也就是说根据实例化 PrintStream 类对象的不同，输出的位置也不同

 package org.printoutputdemo;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.PrintStream;

 public class PrintOutputDemo {

     /**
      * @param args
      * @throws FileNotFoundException
      */
     public static void main(String[] args) throws FileNotFoundException {
         // TODO Auto-generated method stub
         File file = new File ("D:"+File.separator+"demo.txt");
         PrintStream output = new PrintStream(new FileOutputStream(file));
         output.print("Hello");
         output.print(" World");
         output.println("abco");
         output.println(1.0);
         output.close();
     }

 }

得出结论，使用打印流输出最为方便，所以建议以后在输出的时候就使用打印流完成

在JDK1.5之后对打印流进行了更新，可以使用格式化输出

 public PrintStream printf(String format,Object .... args)

可以设置格式和多个参数

 package org.printoutputdemo;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.PrintStream;

 public class PrintStreamDemo01 {

     /**
      * @param args
      * @throws FileNotFoundException
      */
     public static void main(String[] args) throws FileNotFoundException {
         // TODO Auto-generated method stub
         File file = new File ("D:"+File.separator+"demo.txt");
         PrintStream output = new PrintStream(new FileOutputStream(file));
         String name = "张三";
         int age = 20;
         double score =  99.1;
         char sex ='M';
         output.printf("姓名:%s 年龄:%d 分数:%5.2f 性别:%c",name,age,score,sex);
         output.close();
     }

 }

在打印流中一定要始终记住以下的原则：根据实例化其子类的不同，完成的打印输出也不同