java io流

HappyGirlWang

浏览: 2123 次
性别:
来自: 杭州

最近访客更多访客>>

u011418776

qq_26207125

woodding2008

youcp999

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

java web

java

流的概念和作用

学习Java IO，不得不提到的就是JavaIO流。

流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类

根据处理数据类型的不同分为：字符流和字节流

根据数据流向不同分为：输入流和输出流

字符流和字节流
字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。字节流和字符流的区别：

（1）读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

（2）处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

（3）字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件，我们将在下面验证这一点。

结论：优先选用字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

输入流和输出流
对输入流只能进行读操作，对输出流只能进行写操作，程序中需要根据待传输数据的不同特性而使用不同的流。

Java流操作有关的类或接口：

加载中...

Java流类图结构：

加载中...

Java IO流对象

1. 输入字节流InputStream

定义和结构说明：

从输入字节流的继承图可以看出：

InputStream 是所有的输入字节流的父类，它是一个抽象类。

ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。

ObjectInputStream 和所有FilterInputStream的子类都是装饰流（装饰器模式的主角）。意思是FileInputStream类可以通过一个String路径名创建一个对象，FileInputStream(String name)。而DataInputStream必须装饰一个类才能返回一个对象，DataInputStream(InputStream in)。如下图示：

加载中...

实例操作演示：

【案例】读取文件内容

/**
* 字节流
* 读文件内容
* */
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 InputStream in=new FileInputStream(f);
 byte[] b=new byte[1024];
 in.read(b);
 in.close();
 System.out.println(new String(b));
 }
}
注意：该示例中由于b字节数组长度为1024，如果文件较小，则会有大量填充空格。我们可以利用in.read(b);的返回值来设计程序，如下案例：

【案例】读取文件内容

/**
* 字节流
* 读文件内容
* */
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 InputStream in=new FileInputStream(f);
 byte[] b=new byte[1024];
 int len=in.read(b);
 in.close();
 System.out.println("读入长度为："+len);
 System.out.println(new String(b,0,len));
 }
}
注意：观察上面的例子可以看出，我们预先申请了一个指定大小的空间，但是有时候这个空间可能太小，有时候可能太大，我们需要准确的大小，这样节省空间，那么我们可以这样做：

【案例】读取文件内容

/**
* 字节流
* 读文件内容,节省空间
* */
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 InputStream in=new FileInputStream(f);
 byte[] b=new byte[(int)f.length()];
 in.read(b);
 System.out.println("文件长度为："+f.length());
 in.close();
 System.out.println(new String(b));
 }
}
【案例】逐字节读

/**
* 字节流
* 读文件内容,节省空间
* */
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 InputStream in=new FileInputStream(f);
 byte[] b=new byte[(int)f.length()];
 for (int i = 0; i < b.length; i++) {
 b=(byte)in.read();
 }
 in.close();
 System.out.println(new String(b));
 }
}
注意：上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。

【案例】字节流读取文件

/**
* 字节流
*读文件
* */
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 InputStream in=new FileInputStream(f);
 byte[] b=new byte[1024];
 int count =0;
 int temp=0;
 while((temp=in.read())!=(-1)){//当读到文件末尾的时候会返回-1，一般不会返回-1
 b[count++]=(byte)temp;
 }
 in.close();
 System.out.println(new String(b));
 }
}
【案例】DataInputStream类
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class DataOutputStreamDemo{
 public static void main(String[] args) throws IOException{
 File file = new File("d:" + File.separator +"hello.txt");
 DataInputStream input = new DataInputStream(new FileInputStream(file));
 char[] ch = new char[10];
 int count = 0;
 char temp;
 while((temp = input.readChar()) != 'C'){
 ch[count++] = temp;
 }
 System.out.println(ch);
 }
}

【案例】PushBackInputStream回退流操作
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;

/**
* 回退流操作
* */
public class PushBackInputStreamDemo{
 public static void main(String[] args) throwsIOException{
 String str = "hello,rollenholt";
 PushbackInputStream push = null;
 ByteArrayInputStream bat = null;
 bat = new ByteArrayInputStream(str.getBytes());
 push = new PushbackInputStream(bat);
 int temp = 0;
 while((temp = push.read()) != -1){
 if(temp == ','){
 push.unread(temp);
 temp = push.read();
 System.out.print("(回退" +(char) temp + ") ");
 }else{
 System.out.print((char) temp);
 }
 }
 }
}
2. 输出字节流OutputStream

定义和结构说明：

IO 中输出字节流的继承图可见上图，可以看出：

OutputStream 是所有的输出字节流的父类，它是一个抽象类。

ByteArrayOutputStream、FileOutputStream是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据，

ObjectOutputStream 和所有FilterOutputStream的子类都是装饰流。具体例子跟InputStream是对应的。

实例操作演示：
【案例】向文件中写入字符串
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 OutputStream out =new FileOutputStream(f);
 String str="Hello World";
 byte[] b=str.getBytes();
 out.write(b);
 out.close();
 }
}

//琢字写入文件
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 OutputStream out =new FileOutputStream(f);
 String str="Hello World！！";
 byte[] b=str.getBytes();
 for (int i = 0; i < b.length; i++) {
 out.write(b[i]);
 }
 out.close();
 }
}
//如果想要给文章中加入新的内容,在FileOutputStream(f,[i]true)中加入true，参数。如果不加的话，默认是覆盖。
OutputStream out =new FileOutputStream(f,true);

【案例】复制文件
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 if(args.length!=2){
 System.out.println("命令行参数输入有误，请检查");
 System.exit(1);
 }
 File file1=new File(args[0]);
 File file2=new File(args[1]);

 if(!file1.exists()){
 System.out.println("被复制的文件不存在");
 System.exit(1);
 }
 InputStream input=new FileInputStream(file1);
 OutputStream output=new FileOutputStream(file2);
 if((input!=null)&&(output!=null)){
 int temp=0;
 while((temp=input.read())!=(-1)){
 output.write(temp);
 }
 }
 input.close();
 output.close();
 }
}
【案例】使用内存操作流将一个大写字母转化为小写字母
import java.io.*;
class hello{
 public static void main(String[] args) throws IOException {
 String str="ROLLENHOLT";
 ByteArrayInputStream input=new ByteArrayInputStream(str.getBytes());
 ByteArrayOutputStream output=new ByteArrayOutputStream();
 int temp=0;
 while((temp=input.read())!=-1){
 char ch=(char)temp;
 output.write(Character.toLowerCase(ch));
 }
 String outStr=output.toString();
 input.close();
 output.close();
 System.out.println(outStr);
 }
}
【案例】验证管道流：进程间通信
/**
* 验证管道流
* */
import java.io.*;

/**
* 消息发送类
* */
class Send implements Runnable{
 private PipedOutputStream out=null;
 public Send() {
 out=new PipedOutputStream();
 }
 public PipedOutputStream getOut(){
 return this.out;
 }
 public void run(){
 String message="hello , Rollen";
 try{
 out.write(message.getBytes());
 }catch (Exception e) {
 e.printStackTrace();
 }try{
 out.close();
 }catch (Exception e) {
 e.printStackTrace();
 }
 }
}

/**
* 接受消息类
* */
class Recive implements Runnable{
 private PipedInputStream input=null;
 public Recive(){
 this.input=new PipedInputStream();
 }
 public PipedInputStream getInput(){
 return this.input;
 }
 public void run(){
 byte[] b=new byte[1000];
 int len=0;
 try{
 len=this.input.read(b);
 }catch (Exception e) {
 e.printStackTrace();
 }try{
 input.close();
 }catch (Exception e) {
 e.printStackTrace();
 }
 System.out.println("接受的内容为 "+(new String(b,0,len)));
 }
}
/**
* 测试类
* */
class hello{
 public static void main(String[] args) throws IOException {
 Send send=new Send();
 Recive recive=new Recive();
 try{
//管道连接
 send.getOut().connect(recive.getInput());
 }catch (Exception e) {
 e.printStackTrace();
 }
 new Thread(send).start();
 new Thread(recive).start();
 }
}
【案例】DataOutputStream类示例
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataOutputStreamDemo{
 public static void main(String[] args) throws IOException{
 File file = new File("d:" + File.separator +"hello.txt");
 char[] ch = { 'A', 'B', 'C' };
 DataOutputStream out = null;
 out = new DataOutputStream(new FileOutputStream(file));
 for(char temp : ch){
 out.writeChar(temp);
 }
 out.close();
 }
}
File类文件（File.separator，File.pathSeparator：为file类的两个常量）
File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。

创建文件
import java.io.*;
class hello{
 public static void main(String[] args) {
 File f=new File("D:\\hello.txt");
 try{
 f.createNewFile();
 }catch (Exception e) {
 e.printStackTrace();
 }
 }
}
【案例4】删除一个文件（或者文件夹）
import java.io.*;
class hello{
 public static void main(String[] args) {
 String fileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 if(f.exists()){
 f.delete();
 }else{
 System.out.println("文件不存在");
 }

 }
}
【案例5】创建一个文件夹
/**
* 创建一个文件夹
* */
import java.io.*;
class hello{
 public static void main(String[] args) {
 String fileName="D:"+File.separator+"hello";
 File f=new File(fileName);
 f.mkdir();
 }
}
【案例6】列出目录下的所有文件
/**
* 使用list列出指定目录的全部文件
* */
import java.io.*;
class hello{
 public static void main(String[] args) {
 String fileName="D:"+File.separator;
 File f=new File(fileName);
 String[] str=f.list();
 for (int i = 0; i < str.length; i++) {
 System.out.println(str[i]);
 }
 }
}
注意使用list返回的是String数组，。而且列出的不是完整路径，如果想列出完整路径的话，需要使用listFiles.它返回的是File的数组。

【案例7】列出指定目录的全部文件（包括隐藏文件）：
/**
* 使用listFiles列出指定目录的全部文件
* listFiles输出的是完整路径
* */
import java.io.*;
class hello{
 public static void main(String[] args) {
 String fileName="D:"+File.separator;
 File f=new File(fileName);
 File[] str=f.listFiles();
 for (int i = 0; i < str.length; i++) {
 System.out.println(str[i]);
 }
 【案例8】判断一个指定的路径是否为目录
/**
* 使用isDirectory判断一个指定的路径是否为目录
* */
import java.io.*;
class hello{
 public static void main(String[] args) {
 String fileName="D:"+File.separator;
 File f=new File(fileName);
 if(f.isDirectory()){
 System.out.println("YES");
 }else{
 System.out.println("NO");
 }
 }
}
【案例9】递归搜索指定目录的全部内容，包括文件和文件夹
/*
* 列出指定目录的全部内容
* */
import java.io.*;
class hello{
 public static void main(String[] args) {
 String fileName="D:"+File.separator;
 File f=new File(fileName);
 print(f);
 }
 public static void print(File f){
 if(f!=null){
 if(f.isDirectory()){
 File[] fileArray=f.listFiles();
 if(fileArray!=null){
 for (int i = 0; i <filearray.length; i++)="" {="" 递归调用="" print(filearray[i]);="" }="" else{="" system.out.println(f);="" }<="" pre="">

<h2>10.RandomAccessFile类</h2>
该对象并不是流体系中的一员，其封装了字节流，同时还封装了一个缓冲区（字符数组），通过内部的指针来操作字符数组中的数据。该对象特点：
该对象只能操作文件，所以构造函数接收两种类型的参数：a.字符串文件路径；b.File对象。
该对象既可以对文件进行读操作，也能进行写操作，在进行对象实例化时可指定操作模式(r,rw)
注意：该对象在实例化时，如果要操作的文件不存在，会自动创建；如果文件存在，写数据未指定位置，会从头开始写，即覆盖原有的内容。可以用于多线程下载或多个线程同时写数据到文件。
【案例】使用RandomAccessFile写入文件

<pre class="brush:java;">/**
* 使用RandomAccessFile写入文件
* */
import java.io.*;
class hello{
 public static void main(String[]args) throws IOException {
 StringfileName="D:"+File.separator+"hello.txt";
 File f=new File(fileName);
 RandomAccessFile demo=newRandomAccessFile(f,"rw");
 demo.writeBytes("asdsad");
 demo.writeInt(12);
 demo.writeBoolean(true);
 demo.writeChar('A');
 demo.writeFloat(1.21f);
 demo.writeDouble(12.123);
 demo.close();
 }
}</pre>

<h1>Java IO流的高级概念</h1>
<h2>编码问题</h2>
【案例】取得本地的默认编码

<pre class="brush:java;">/**
* 取得本地的默认编码
* */
publicclass CharSetDemo{
 public static void main(String[] args){
 System.out.println("系统默认编码为："+ System.getProperty("file.encoding"));
 }
}</pre>

【案例】乱码的产生

<pre class="brush:java;">import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
* 乱码的产生
* */
public class CharSetDemo2{
 public static void main(String[] args) throws IOException{
 File file = new File("d:" + File.separator + "hello.txt");
 OutputStream out = new FileOutputStream(file);
 byte[] bytes = "你好".getBytes("ISO8859-1");
 out.write(bytes);
 out.close();
 }//输出结果为乱码，系统默认编码为GBK，而此处编码为ISO8859-1
}</pre>
<h2>对象的序列化</h2>
对象序列化就是把一个对象变为二进制数据流的一种方法。
一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。先让我们实现一个具有序列化能力的类吧：
【案例】实现具有序列化能力的类

<pre class="brush:java;">import java.io.*;
/**
* 实现具有序列化能力的类
* */
public class SerializableDemo implements Serializable{
 public SerializableDemo(){

 }
 publicSerializableDemo(String name, int age){
 this.name=name;
 this.age=age;
 }
 @Override
 public String toString(){
 return "姓名："+name+" 年龄："+age;
 }
 private String name;
 private int age;
}</pre>

【案例】序列化一个对象 – ObjectOutputStream

<pre class="brush:java;">import java.io.Serializable;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* 实现具有序列化能力的类
* */
public class Person implements Serializable{
 public Person(){
 }
 public Person(String name,int age){
 this.name = name;
 this.age = age;
 }
 @Override
 public String toString(){
 return "姓名：" +name + " 年龄：" +age;
 }
 private String name;
 private int age;
}
/**
* 示范ObjectOutputStream
* */
public class ObjectOutputStreamDemo{
 public static voidmain(String[] args) throws IOException{
 File file = newFile("d:" + File.separator + "hello.txt");
 ObjectOutputStream oos= new ObjectOutputStream(new FileOutputStream(
 file));
 oos.writeObject(newPerson("rollen", 20));
 oos.close();
 }
}</pre>

【案例】反序列化—ObjectInputStream

<pre class="brush:java;">import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
* ObjectInputStream示范
* */
public class ObjectInputStreamDemo{
 public static voidmain(String[] args) throws Exception{
 File file = new File("d:" +File.separator + "hello.txt");
 ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(
 file));
 Object obj =input.readObject();
 input.close();
 System.out.println(obj);
 }
}</pre>

注意：被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。
当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。
现在我们来演示一下序列化和反序列话：
【案例】使用Externalizable来定制序列化和反序列化操作

<pre class="brush:java;">package IO;

import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

/**
* 序列化和反序列化的操作
* */
public class ExternalizableDemo{
 public static voidmain(String[] args) throws Exception{
 ser(); // 序列化
 dser(); // 反序列话
 }

 public static void ser()throws Exception{
 File file = newFile("d:" + File.separator + "hello.txt");
 ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(
 file));
 out.writeObject(newPerson("rollen", 20));
 out.close();
 }

 public static void dser()throws Exception{
 File file = newFile("d:" + File.separator + "hello.txt");
 ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(
 file));
 Object obj =input.readObject();
 input.close();
 System.out.println(obj);
 }
}

class Person implements Externalizable{
 public Person(){

 }

 public Person(String name,int age){
 this.name = name;
 this.age = age;
 }

 @Override
 public String toString(){
 return "姓名：" +name + " 年龄：" +age;
 }

 // 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
 @Override
 public voidwriteExternal(ObjectOutput out) throws IOException{
 out.writeObject(this.name);
 out.writeInt(age);
 }

 // 复写这个方法，根据需要读取内容反序列话的时候需要
 @Override
 public voidreadExternal(ObjectInput in) throws IOException,
 ClassNotFoundException{
 this.name = (String)in.readObject();
 this.age =in.readInt();
 }

 private String name;
 private int age;
}</pre>

注意：Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，
当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：
【案例】使用transient关键字定制序列化和反序列化操作

<pre class="brush:java;">package IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
* 序列化和反序列化的操作
* */
public class serDemo{
 public static voidmain(String[] args) throws Exception{
 ser(); // 序列化
 dser(); // 反序列话
 }

 public static void ser()throws Exception{
 File file = newFile("d:" + File.separator + "hello.txt");
 ObjectOutputStream out= new ObjectOutputStream(new FileOutputStream(
 file));
 out.writeObject(newPerson1("rollen", 20));
 out.close();
 }

 public static void dser()throws Exception{
 File file = newFile("d:" + File.separator + "hello.txt");
 ObjectInputStreaminput = new ObjectInputStream(new FileInputStream(
 file));
 Object obj =input.readObject();
 input.close();
 System.out.println(obj);
 }
}

class Person1 implements Serializable{
 public Person1(){

 }

 public Person1(Stringname, int age){
 this.name = name;
 this.age = age;
 }

 @Override
 public String toString(){
 return "姓名：" +name + " 年龄：" +age;
 }

 // 注意这里
 private transient Stringname;
 private int age;
}</pre>

【运行结果】：
姓名：null 年龄：20
【案例】序列化一组对象

<pre class="brush:java;">import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
* 序列化一组对象
* */
public class SerDemo1{
 public static voidmain(String[] args) throws Exception{
 Student[] stu = { newStudent("hello", 20), new Student("world", 30),
 newStudent("rollen", 40) };
 ser(stu);
 Object[] obj = dser();
 for(int i = 0; i <obj.length; ++i){="" student="" s="(Student)" obj[i];="" system.out.println(s);="" }="" 序列化="" public="" static="" voidser(object[]="" obj)="" throws="" exception{="" file="" +="" file.separator="" "hello.txt");="" objectoutputstream="" out="new" objectoutputstream(new="" fileoutputstream(="" file));="" out.writeobject(obj);="" out.close();="" 反序列化="" object[]dser()="" objectinputstreaminput="new" objectinputstream(new="" fileinputstream(="" object[]="" obj="(Object[])" input.readobject();="" input.close();="" return="" obj;="" class="" implements="" serializable{="" student(){="" student(stringname,="" int="" age){="" this.name="name;" this.age="age;" @override="" string="" tostring(){="" "姓名：="" "="" name="" 年龄："="" age;="" private="" name;="" }<="" pre="">
<h1>参考文献：</h1>
1、http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html
2、http://www.cnblogs.com/oubo/archive/2012/01/06/2394638.html
<h3></h3> </obj.length;></pre></filearray.length;>

分享到：