文档章节

java io 相关

道酬勤
 道酬勤
发布于 2016/05/09 09:35
字数 3025
阅读 23
收藏 0
点赞 2
评论 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

共有 人打赏支持
道酬勤
粉丝 12
博文 39
码字总数 20898
作品 0
深圳
程序员
DirectByteBuffer更快吗?

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

智深
2012/12/04
0
0
Java编程基础知识点和技术点归纳

Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互...

Java小辰
05/23
0
0
Java FileInputStream

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

pczhangtl
2014/08/03
0
0
JAVA NIO之浅谈内存映射文件原理与DirectMemory

JAVA类库中的NIO包相对于IO 包来说有一个新功能是内存映射文件,日常编程中并不是经常用到,但是在处理大文件时是比较理想的提高效率的手段。本文我主要想结合操作系统中(OS)相关方面的知识...

pczhangtl
2013/11/19
0
0
分别使用Java IO、NIO、Netty实现的一个Echo Server示例

分别使用Java IO、Java NIO、Netty来实现一个简单的EchoServer(即原样返回客户端的输入信息)。 Java IO int port = 9000;ServerSocket ss = new ServerSocket(port);while (true) {final S...

zgw06629
2015/05/24
0
0
Java NIO系列教程(一) Java NIO 概述

Java NIO 由以下几个核心部分组成: Channels Buffers Selectors 虽然Java NIO 中除此之外还有很多类和组件,但在我看来,Channel,Buffer 和 Selector 构成了核心的API。其它组件,如Pipe和...

只想一个人静一静
2014/02/22
0
0
Java深度理解——Java字节代码的操纵

导读:Java作为业界应用最为广泛的语言之一,深得众多软件厂商和开发者的推崇,更是被包括Oracle在内的众多JCP成员积极地推动发展。但是对于 Java语言的深度理解和运用,毕竟是很少会有人涉及...

刘学炜
2012/01/13
0
0
Tomcat 性能优化方案,针对7.0

Tomcat 性能优化方案 综述。 这里只列出生产中需要优化的几个点,每个配置点详细讲解以后进行。 1. 启用 Tomcat NIO 协议 Connector 协议启用 org.apache.coyote.http11.Http11NioProtocol 2...

从前
2012/10/12
0
0
树莓派使用DHT11温湿度传感器

一、相关介绍 DHT11介绍: DHT11是一款比较便宜的温湿度传感器模块。读取数据只需要占用一个IO口。能够同时测量温度和相对湿度。 DHT11的数据手册可以看这里:http://wenku.baidu.com/view/1...

李鱼跃龙门
2014/06/07
0
18
面试必看!2018年4月份阿里最新的java程序员面试题目

目录 技术一面(23问) 技术二面(3大块) 性能优化(21点) 项目实战(34块) JAVA方向技术考察点(15点) JAVA开发技术面试中可能问到的问题(17问) 阿里技术面试1 1.Java IO流的层次结构...

美的让人心动
04/16
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

shell中的函数、shell中的数组、告警系统需求分析

shell中的函数 格式: 格式: function f_name() { command } 函数必须要放在最前面 示例1(用来打印参数) 示例2(用于定义加法) 示例3(用于显示IP) shell中的数组 shell中的数组1 定义数...

Zhouliang6
今天
2
0
用 Scikit-Learn 和 Pandas 学习线性回归

      对于想深入了解线性回归的童鞋,这里给出一个完整的例子,详细学完这个例子,对用scikit-learn来运行线性回归,评估模型不会有什么问题了。 1. 获取数据,定义问题     没有...

wangxuwei
今天
1
0
MAC安装MAVEN

一:下载maven压缩包(Zip或tar可选),解压压缩包 二:打开终端输入:vim ~/.bash_profile(如果找不到该文件新建一个:touch ./bash_profile) 三:输入i 四:输入maven环境变量配置 MAVEN_HO...

WALK_MAN
今天
0
0
33.iptables备份与恢复 firewalld的9个zone以及操作 service的操作

10.19 iptables规则备份和恢复 10.20 firewalld的9个zone 10.21 firewalld关于zone的操作 10.22 firewalld关于service的操作 10.19 iptables规则备份和恢复: ~1. 保存和备份iptables规则 ~2...

王鑫linux
今天
2
0
大数据教程(2.11):keeperalived+nginx高可用集群搭建教程

上一章节博主为大家介绍了目前大型互联网项目的系统架构体系,相信大家应该注意到其中很重要的一块知识nginx技术,在本节博主将为大家分享nginx的相关技术以及配置过程。 一、nginx相关概念 ...

em_aaron
今天
1
0
Apache Directory Studio连接Weblogic内置LDAP

OBIEE默认使用Weblogic内置LDAP管理用户及组。 要整理已存在的用户及组,此前办法是导出安全数据,文本编辑器打开认证文件,使用正则表达式获取用户及组的信息。 后来想到直接用Apache Dire...

wffger
今天
2
0
HFS

FS,它是一种上传文件的软件。 专为个人用户所设计的 HTTP 档案系统 - Http File Server,如果您觉得架设 FTP Server 太麻烦,那么这个软件可以提供您更方便的档案传输系统,下载后无须安装,...

garkey
今天
1
0
Java IO类库之BufferedInputStream

一、BufferedInputStream介绍 /** * A <code>BufferedInputStream</code> adds * functionality to another input stream-namely, * the ability to buffer the input and to * sup......

老韭菜
今天
0
0
STM 32 窗口看门狗

http://bbs.elecfans.com/jishu_805708_1_1.html https://blog.csdn.net/a1985831055/article/details/77404131...

whoisliang
昨天
1
0
Dubbo解析(六)-服务调用

当dubbo消费方和提供方都发布和引用完成后,第四步就是消费方调用提供方。 还是以dubbo的DemoService举例 -- 提供方<dubbo:application name="demo-provider"/><dubbo:registry address="z...

青离
昨天
2
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部