文档章节

java io 相关

道酬勤
 道酬勤
发布于 2016/05/09 09:35
字数 3025
阅读 23
收藏 0

原文地址:http://blog.csdn.net/liufeng_king/article/details/12978101 

1)java io流相关概念

输出流:

 

输入流:


因此输入和输出都是从程序的角度来说的。

字节流:一次读入或读出是8位二进制

字符流:一次读入或读出是16位二进制

字节流和字符流的原理是相同的,只不过处理的单位不同而已。后缀是Stream是字节流,而后缀是ReaderWriter是字符流。 

节点流:直接与数据源相连,读入或读出。


直接使用节点流,读写不方便,为了更快的读写文件,才有了处理流。

处理流:与节点流一块使用,在节点流的基础上,再套接一层,套接在节点流上的就是处理流。


     2)java io流的分类

按流向分:
输入流: 程序可以从中读取数据的流。
输出流: 程序能向其中写入数据的流。
按数据传输单位分:
字节流: 以字节为单位传输数据的流
字符流: 以字符为单位传输数据的流
按功能分:
节点流: 用于直接操作目标设备的流
过滤流: 是对一个已存在的流的链接和封装,通过对数据进行处理为程序提供功能强大、灵活的读写功能。

     3)java io类结构图

     流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据源的流,这个数据源可以是文件,内存,或是网络连接。类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。Java把这些不同来源和目标的数据都统一抽象为数据流,在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流,java io 类结构如下:


[1]输入字节流InputStream:InputStream 是所有的输入字节流的父类,它是一个抽象类;ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流,它们分别从Byte 数组、StringBuffer、和本地文件中读取数据;PipedInputStream 是从与其它线程共用的管道中读取数据;ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

[2]输出字节流OutputStream:OutputStream 是所有的输出字节流的父类,它是一个抽象类。
ByteArrayOutputStream、FileOutputStream 是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据,ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

[3]字节流的输入与输出的对应


图中蓝色的为主要的对应部分,红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出Java IO 中的字节流是极其对称的。

不对称的类介绍如下:

1>LineNumberInputStream 主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个LineNumberOutputStream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。
2>PushbackInputStream 的功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。
3>StringBufferInputStream 已经被Deprecated,本身就不应该出现在InputStream 部分,主要因为String 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。
4>SequenceInputStream 可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除,还完全不影响IO 包的结构,却让其更“纯洁”――纯洁的Decorator 模式。
5>PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流,或者FileInputStream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包!System.out 和System.out 就是PrintStream 的实例!

[4]字符输入流Reader:Reader 是所有的输入字符流的父类,它是一个抽象类;CharReader、StringReader 是两种基本的介质流,它们分别将Char 数组、String中读取数据;PipedReader 是从与其它线程共用的管道中读取数据;BufferedReader 很明显就是一个装饰器,它和其子类负责装饰其它Reader 对象;FilterReader 是所有自定义具体装饰流的父类,其子类PushbackReader 对Reader 对象进行装饰,会增加一个行号;InputStreamReader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。

[5]字符输出流Writer:Writer 是所有的输出字符流的父类,它是一个抽象类;CharArrayWriter、StringWriter 是两种基本的介质流,它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据,BufferedWriter 是一个装饰器为Writer 提供缓冲功能;PrintWriter 和PrintStream 极其类似,功能和使用也非常相似;
OutputStreamWriter 是OutputStream 到Writer 转换的桥梁,它的子类FileWriter 其实就是一个实现此功能的具体类(具体可以研究一SourceCode)。

[6]字符流的输入与输出的对应


[8]字符流与字节流转换

转换流的特点:
其是字符流和字节流之间的桥梁
可对读取到的字节数据经过指定编码转换成字符
可对读取到的字符数据经过指定编码转换成字节
何时使用转换流?
当字节和字符之间有转换动作时;
流操作的数据需要编码或解码时。
具体的对象体现:
InputStreamReader:字节到字符的桥梁
OutputStreamWriter:字符到字节的桥梁
这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。

4)java 管道通信

     Java提供管道功能,实现管道通信的类有两组:PipedInputStream和PipedOutputStream或者是PipedReader和PipedWriter。管道通信主要用于不同线程间的通信
一个PipedInputStream实例对象必须和一个PipedOutputStream实例对象进行连接而产生一个通信管道。PipedOutputStream向管道中写入数据,PipedIntputStream读取PipedOutputStream向管道中写入的数据。一个线程的PipedInputStream对象能够从另外一个线程的PipedOutputStream对象中读取数据。

 //Sender类   
package pipeCommu;  
import java.io.PipedInputStream;  
import java.io.PipedOutputStream;  
public class Sender extendsThread{  
   private PipedOutputStream out=new PipedOutputStream();//发送者创建PipedOutputStream向外写数据;   
   public PipedOutputStream getOut(){  
       return out;  
   }  
   public void run(){  
       String strInfo="hello,receiver";  
       try{  
           out.write(strInfo.getBytes());//写入数据  
           out.close();  
       }catch(Exception e){  
           e.printStackTrace();  
       }  
   }  
}    
 //Reader类,负责接收数据   
package pipeCommu;  
import java.io.PipedInputStream;   
public class Reader extends Thread{  
   private PipedInputStream in=new PipedInputStream();//发送者创建PipedOutputStream向外写数据  
   public PipedInputStream getIn(){  
       returnin;  
   }  
   public void run(){  
       byte[] buf=new byte[1024];//声明字节数组  
       try{  
           int len=in.read(buf);//读取数据,并返回实际读到的字节数  
           System.out.println("receive from sender:"+newString(buf,0,len));  
           in.close();  
       }catch(Exception e){  
           e.printStackTrace();  
       }  
   }  
}  
package pipeCommu;   
import java.io.*;  
public class PipedStream {  
    public static void main(String[] args) throws Exception{  
       Sender send=new Sender();  
       Reader read=new Reader();  
       PipedOutputStream out=send.getOut();  
       PipedInputStream in=read.getIn();  
       out.connect(in);//或者也可以用in.connect(out);  
       send.start();  
       read.start();  
   }    
}    
package pipeCommu;   
import java.io.*;  
public class PipedCommu {  
    public static void main(String[] args) {  
        // TODOAuto-generatedmethodstub  
        try{  
             PipedReader reader=new PipedReader();  
             PipedWriter writer=new PipedWriter(reader);  
             Thread a=new Send(writer);  
             Thread b=new Read(reader);  
             a.start();  
             Thread.sleep(1000);  
             b.start();  
        }catch(IOException e){  
             e.printStackTrace();  
               
        }catch(InterruptedException e1){  
             e1.printStackTrace();             
        }  
    }  
}  
    class Send extends Thread{  
        PipedWriter writer;  
        public Send(PipedWriter writer){  
             this.writer=writer;  
        }  
        public void run(){  
             try{  
                  writer.write("this is a.hello world".toCharArray());  
                  writer.close();  
             }catch(IOException e){  
                  e.printStackTrace();  
             }              
        }  
    }  
    class Read extends Thread{  
        PipedReader reader;  
        public Read(PipedReader reader){  
             this.reader=reader;  
        }  
        public void run(){  
             System.out.println("this is B");  
             try{  
                  char[] buf=new char[1000];  
                  reader.read(buf,0,100);  
                  System.out.println(new String(buf));  
             }catch(Exception e){  
                  e.printStackTrace();  
             }  
        }  
    }


5)java 对象序列化

     对于一个存在Java虚拟机中的对象来说,其内部的状态只是保存在内存中。JVM退出之后,内存资源也就被释放,Java对象的内部状态也就丢失了。而在很多情况下,对象内部状态是需要被持久化的,将运行中的对象状态保存下来(最直接的方式就是保存到文件系统中),在需要的时候可以还原,即使是在Java虚拟机退出的情况下。 
     对象序列化机制是Java内建的一种对象持久化方式,可以很容易实现在JVM中的活动对象与字节数组(流)之间进行转换,使用得Java对象可以被存储,可以被网络传输,在网络的一端将对象序列化成字节流,经过网络传输到网络的另一端,可以从字节流重新还原为Java虚拟机中的运行状态中的对象。 

     对于任何需要被序列化的对象,都必须要实现接口Serializable,它只是一个标识接口,本身没有任何成员,只是用来标识说明当前的实现类的对象可以被序列化。

     如果在类中的一些属性,希望在对象序列化过程中不被序列化,使用关键字transient标注修饰就可以。当对象被序列化时,标注为transient的成员属性将会自动跳过。

     注:

      [1].当一个对象被序列化时,只保存对象的非静态成员变量,不能保存任何的成员方法,静态的成员变量和transient标注的成员变量。 
   [2].如果一个对象的成员变量是一个对象,那么这个对象的数据成员也会被保存还原,而且会是递归的方式。
   [3].如果一个可序列化的对象包含对某个不可序列化的对象的引用,那么整个序列化操作将会失败,并且会抛出一个NotSerializableException。可以将这个引用标记transient,那么对象仍然可以序列化。

       java对象序列化示例代码:

实体类:

class Student implements Serializable{          
    private String name;    
    private transient int age;    
    private Course course;          
    public void setCourse(Course course){    
        this.course = course;    
    }        
    public Course getCourse(){    
        return course;    
    }          
    public Student(String name, int age){    
        this.name = name;    
        this.age = age;    
    }     
    public String  toString(){    
        return "Student Object name:"+this.name+" age:"+this.age;    
    }    
}    
    
class Course implements Serializable{          
    private static String courseName;    
    private int credit;          
    public Course(String courseName, int credit){    
        this.courseName  = courseName;    
        this.credit = credit;    
    }          
    public String toString(){              
        return "Course Object courseName:"+courseName    
               +" credit:"+credit;    
    }    
}


将对象写入文件序列化

public class TestWriteObject{      
    public static void main(String[] args) {      
        String filePath = "C://obj.txt";    
        ObjectOutputStream objOutput = null;    
        Course c1 = new Course("C language", 3);    
        Course c2 = new Course("OS", 4);             
        Student s1 = new Student("king", 25);    
        s1.setCourse(c1);              
        Student s2 = new Student("jason", 23);    
        s2.setCourse(c2);     
        try {    
            objOutput = new ObjectOutputStream(new FileOutputStream(filePath));    
            objOutput.writeObject(s1);    
            objOutput.writeObject(s2);    
            objOutput.writeInt(123);    
        } catch (FileNotFoundException e) {    
            e.printStackTrace();    
        } catch (IOException e) {    
            e.printStackTrace();    
        }finally{    
            try {    
                objOutput.close();    
            } catch (IOException e) {    
                e.printStackTrace();    
            }    
        }              
        System.out.println("Info:对象被写入"+filePath);    
    }


从文件中读取对象,反序列化

public class TestReadObject  {    
        
    public static void main(String[] args) {    
            
        String filePath = "C://obj.txt";    
        ObjectInputStream objInput = null;    
        Student s1 = null,s2 = null;    
        int intVal = 0;    
        
        try {    
            objInput = new ObjectInputStream(new FileInputStream(filePath));    
            s1 = (Student)objInput.readObject();    
            s2 = (Student)objInput.readObject();    
            intVal = objInput.readInt();    
                
        } catch (FileNotFoundException e) {    
            e.printStackTrace();    
        } catch (IOException e) {    
            e.printStackTrace();    
        }catch(ClassNotFoundException cnfe){    
            cnfe.printStackTrace();    
        }finally{    
                
            try {    
                objInput.close();    
            } catch (IOException e) {    
                e.printStackTrace();    
            }    
        }              
        System.out.println("Info:文件"+filePath+"中读取对象");    
        System.out.println(s1);    
        System.out.println(s1.getCourse());    
        System.out.println(s2);    
        System.out.println(s2.getCourse());    
        System.out.println(intVal);    
    }    
}


    

本文转载自:http://blog.csdn.n​et/liufeng_king/article/details/12978101

共有 人打赏支持
上一篇: sitemesh使用
道酬勤
粉丝 12
博文 39
码字总数 20898
作品 0
深圳
程序员
私信 提问
DirectByteBuffer更快吗?

ByteBuffer.allocateDirect vs ByteBuffer.allocate 操作系统的IO机制 操作系统在内存区域上执行IO操作,这些内存区域是连续的字节。毫无疑问只有字节缓冲区才有资格参与IO操作的。同样操作系...

智深
2012/12/04
0
0
php程序员, java程序员, ruby程序员

由于php入门很简单, 很多没任何编程背景的同学, 想学学怎么做网页的人基本一开始都会找php. php里不是菜鸟就是牛人. 菜鸟: 做做个人网页, 改改页面, 就学些php的基本东西就够用了. win环境下...

大东哥
2012/05/20
1K
12
晒晒你看过的哪些Java相关的书。

@红薯 要我们晒Jar包 , 我倒想看看大家都看过什么Java编程相关的书籍,我先来:如下 1、iText in Action 主要内容: a、自动化静态和动态XFA表单 b、如何从XML生成动态PDF或数据库 c、如何添...

刘学炜
2012/09/27
317
4
Java FileInputStream

一、序言 IO操作,才程序中比较普遍,JAVA 中提出了IO/NIO 的概念,也一直在说NIO 比IO快,一直不知道原因,就想memcache 和ehcache 比较优劣一样,这些东西得自己看看如何实现的,才 知道区...

pczhangtl
2014/08/03
0
0
给Java新手的一些建议——Java知识点归纳(Java基础部分)

  写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会,主要是和一些java基础知识点相关的,所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们,...

Java工程师-10
2017/05/24
509
2

没有更多内容

加载失败,请刷新页面

加载更多

PHP生成CSV之内部换行

当我们使用PHP将采集到的文件内容保存到csv文件时,往往需要将采集内容进行二次过滤处理才能得到需要的内容。比如网页中的换行符,空格符等等。 对于空格等处理起来都比较简单,这里我们单独...

豆花饭烧土豆
56分钟前
1
0
使用 mjml 生成 thymeleaf 邮件框架模板

发邮件算是系统开发的一个基本需求了,不过搞邮件模板实在是件恶心事,估计搞过的同仁都有体会。 得支持多种客户端 支持响应式 疼彻心扉的 outlook 多数客户端只支持 inline 形式的 css 布局...

郁也风
今天
4
0
让哲学照亮我们的人生——读《医务工作者需要学点哲学》有感2600字

让哲学照亮我们的人生——读《医务工作者需要学点哲学》有感2600字: 作者:孙冬梅;以前读韩国前总统朴槿惠的著作《绝望锻炼了我》时,里面有一句话令我印象深刻,她说“在我最困难的时期,...

原创小博客
今天
3
0
JAVA-四元数类

public class Quaternion { private final double x0, x1, x2, x3; // 四元数构造函数 public Quaternion(double x0, double x1, double x2, double x3) { this.x0 = ......

Pulsar-V
今天
17
0
Xshell利用Xftp传输文件,使用pure-ftpd搭建ftp服务

Xftp传输文件 如果已经通过Xshell登录到服务器,此时可以使用快捷键ctrl+alt+f 打开Xftp并展示Xshell当前的目录,之后直接拖拽传输文件即可。 pure-ftpd搭建ftp服务 pure-ftpd要比vsftp简单,...

野雪球
今天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部