JAVA 内存操作流

最新推荐文章于 2024-08-12 22:37:42 发布

轻迷

最新推荐文章于 2024-08-12 22:37:42 发布

阅读量558

点赞数

分类专栏： android

android 专栏收录该内容

76 篇文章 0 订阅

订阅专栏

 
  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一样，一个个的读取数据。

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

[java]view plaincopyprint? 
   
 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完成一些动态效果的使用

[java]view plaincopyprint? 
   
 String newStr = output.toString(); //取出内存输出的内容  

管道流

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

[java]view plaincopyprint? 
   
 public void connect(PipedInputStream snk) throws IOException  

范例：进行管道流的操作

[java]view plaincopyprint? 
   
 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

观察打印流的定义：

[java]view plaincopyprint? 
   
 public class PrintStream  
   
 extends FilterOutputstream  
   
 implements Appendable,Closeable

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

[java]view plaincopyprint? 
   
 public PrintStream(OutputStream out)  

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

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

[java]view plaincopyprint? 
   
 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之后对打印流进行了更新，可以使用格式化输出

[java]view plaincopyprint? 
   
 public PrintStream printf(String format,Object .... args)  

可以设置格式和多个参数

[java]view plaincopyprint? 
   
 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();  
     }  
   
 }  