JAVA-IO学习（笔记）

最新推荐文章于 2022-08-07 21:50:35 发布

jason_hacker_z

最新推荐文章于 2022-08-07 21:50:35 发布

阅读量101

点赞数

分类专栏： java基础文章标签： Java thread J# Blog

java基础专栏收录该内容

28 篇文章 0 订阅

订阅专栏

JAVA-IO
一．InputStream
1. 类图
附件
2. 子类说明
流的数据方法都用了native实现方式，都不知道哪里去看实现。
2.1 ByteArrayInputStream
把字节数组数据转化为输入流；通过byte数组实现数据的存取
重要变量：

protected byte buf[];    //缓冲区数据
protected int pos;      //下一个读取字符的位置
protected int mark = 0;  //当前位置标记
protected int count;     //需要读入（或现有）数据长度

2.2 FileInputStream
从文件中读取数据，他的子类中有socketInputStream
重要变量：

            private FileDescriptor fd;   //文件描述，文件类型读取方式的记录 
     private FileChannel channel = null;  //文件的链接

2.3 PipedInputStream
管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。管道输入流包含一个缓冲区，可在缓冲区限定的范围内将读操作和写操作分离开。如果向连接管道输出流提供数据字节的线程不再存在，则认为该管道已损坏

重要变量：

boolean closedByWriter = false;
             volatile boolean closedByReader = false;
             boolean connected = false;
             Thread readSide;     //当前读线程
    		 Thread writeSide;    //当前写线程
     		 protected byte buffer[] = new byte[PIPE_SIZE]; //缓冲区数据 初始PIPE_SIZE=1024

通过标记closedByWriter closedByReader 可以对当前数据进行锁处理，

例子：

--------------------------写数据--------------------------------
public class RunPipedMain {

    public static void main(String... strings) {
        ReceiverThread read = new ReceiverThread();
        WriterThread write = new WriterThread();
        PipedInputStream in = read.getIn();
        PipedOutputStream out = write.getOut();
        try {
            out.connect(in);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        write.start();

        read.start();
    }
}
--------------------------接受--------------------------------
public class ReceiverThread extends Thread {

    private PipedInputStream in;

    public PipedInputStream getIn() {
        if (in == null) in = new PipedInputStream();
        return in;
    }

    public void run() {
        System.out.println("read..............");
        byte[] buf = new byte[1024]; // 字节数组
        try { // read和close方法都可能有异常出现
            int len = in.read(buf); // 读取数据，len表示实际读取到的内容（长度）
            System.out.println("the following message comes from sender:\n" + new String(buf, 0, len));
            in.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

--------------------------运行---------------------------------
public class RunPipedMain {

    public static void main(String... strings) {
        ReceiverThread read = new ReceiverThread();
        WriterThread write = new WriterThread();
        PipedInputStream in = read.getIn();
        PipedOutputStream out = write.getOut();
        try {
            out.connect(in);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        write.start();

        read.start();
    }
}
--------------------------运行结果--------------------------------
1.  write..............
2.  read..............
3.  the following message comes from sender:
4.  test out...........

问1：看着结果，我想到一点，为什么不论是哪个线程先运行，都会先写后读呢？
即运行结果中1， 2两步的运行顺序是不可确定的。难道pipedInputStream会去等待么？

查看代码中: pipedInputStream中read()方法，通过判断connected变来，知道当前是否连接，如果链接则判断closedByWriter变量，看是否已经被out给关闭，然后如果没有关闭的话，判断in变量是否小于0（小于0代表数据还没读到），小于0就wait(1000)，大于零就开始取数据：
代码如下：

public synchronized int read()  throws IOException {
        if (!connected) {
            throw new IOException("Pipe not connected");
        } else if (closedByReader) {
	    throw new IOException("Pipe closed");
	} else if (writeSide != null && !writeSide.isAlive()
                   && !closedByWriter && (in < 0)) {
            throw new IOException("Write end dead");
        }

        readSide = Thread.currentThread();
	int trials = 2;
	while (in < 0) {
	    if (closedByWriter) {
		/* closed by writer, return EOF */
		return -1;
	    }
	    if ((writeSide != null) && (!writeSide.isAlive()) && (--trials < 0)) {
		throw new IOException("Pipe broken");
	    }
            /* might be a writer waiting */
	    notifyAll();
	    try {
	        wait(1000);
	    } catch (InterruptedException ex) {
		throw new java.io.InterruptedIOException();
	    }
 	}
	int ret = buffer[out++] & 0xFF;
	if (out >= buffer.length) {
	    out = 0;
	}
	if (in == out) {
            /* now empty */
	    in = -1;
	}
	return ret;
}

问2： in和 out变量是什么时候修改的？

2.4 SequenceInputStream
SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

重要变量:

  Enumeration e;  //存取InputStream的枚举类
    InputStream in;  //枚举类中，当前的InputStream对象

他是通过传入Enumeration，在之间取到Enumeration，进行IO操作。

例子：

public class EnumerationInputStreamTest {

    Enumeration         e    = null;       // 由内部类实现，如Vector
    String              sss  = "testsetst";
    SequenceInputStream seq  = null;
    Vector              coll = null;

    public void test() {
        try {
            FileInputStream file = new FileInputStream("c:\\boot.ini");
            ByteArrayInputStream byteArray = new ByteArrayInputStream(sss.getBytes());
            coll = new Vector();
            coll.add(byteArray);
            coll.add(file);
            e = ((Vector) coll).elements();
            seq = new SequenceInputStream(e);
            int i = 0;
            while (i != -1) {
                i = seq.read();
                System.out.println("out:" + i);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String... strings) {
        EnumerationInputStreamTest eee = new EnumerationInputStreamTest();
        eee.test();
    }
}

运行结果： 
out:116
out:101
out:115
…
out:13
out:-1

2.5 ObjectInputStream
这里转一下网上的文章，感觉写的不错。
源文件地址:
http://hi.baidu.com/mdbing/blog/item/4612cb13decfc4075aaf53fa.html
Java程序执行的过程中，很多数据都是以对象的方式存在于内存中。有时会希望直接将内存中整个对象存储至文件，而不是只存储对象中的某些基本类型成员信息，而在下一次程序运行时，希望可以从文件中读出数据并还原为对象。这时可以使用java.io.ObjectInputStream和java.io.ObjectOutputStream来进行这项工作
如果要直接存储对象，定义该对象的类必须实现java.io.Serializable接口，不过Serializable接口中并没有规范任何必须实现的方法，所以这里所谓实现的意义，其实像是对对象贴上一个标志，代表该对象是可序列化的(Serializable)。
为了说明如何直接存储对象，先来实现一个User类
Java代码

import java.io.Serializable;   

public class User implements Serializable {    
    private static final long serialVersionUID = 1L;    
    private String name;    
    private int number;    
    public User() {    
    }    
    public User(String name, int number) {   
        this.name = name;   
        this.number = number;   
    }    
    public String getName() {   
        return name;   
    }    
    public void setName(String name) {   
        this.name = name;   
    }    
    public int getNumber() {   
        return number;   
    }    
    public void setNumber(int number) {   
        this.number = number;   
    }    
}  
import java.io.Serializable; 
public class User implements Serializable { 
	private static final long serialVersionUID = 1L; 
	private String name; 
	private int number; 
	public User() { 
	} 

	public User(String name, int number) {
		this.name = name;
		this.number = number;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}

}

注意到serialVersionUID，它代表了可序列化对象的版本。如果没有提供这个版本信息，则实现Serializable接口的类会自动依类名称、实现的接口、成员等来产生。如果是自动产生的，则下次更改User类，自动产生的serialVersionUID也会跟着变更，从文件读回对象时若两个对象的serialVersionUID不相同，就会丢出java.io.InvalidClassException。如果想要维持版本信息的一致，则要明确声明 serialVersionUID。
ObjectInputStream和 ObjectOutputStream为InputStream、OutputStream的实例加上了可以让用户写入对象与读出对象的功能。在写入对象时，要使用writeObject()方法，读出对象时则使用readObject()方法，被读出的对象都是以Object的类型返回。所以必须将之转换为对象原来的类型，才能正确地实现被读回的对象。示范了如何存储User对象至文件中，然后再将它读回并还原为User实例
Java代码

import java.io.File;   
import java.io.FileInputStream;   
import java.io.FileNotFoundException;   
import java.io.FileOutputStream;   
import java.io.IOException;   
import java.io.ObjectInputStream;   
import java.io.ObjectOutputStream;   
import java.util.ArrayList;   
import java.util.List;   

public class ObjectStreamDemo {   

    public static void main(String args[]) {   
        User[] users = { new User("cater", 101), new User("justin", 102) };   
        // 写入新文件   
        writeObjectsToFile(users, args[0]);   
        try {   
            // 读取文件数据   
            users = readObjectsFromFile(args[0]);   
            // 显示读回的对象   
            for (User user : users) {   
                System.out.printf("%s\t%d%n", user.getName(), user.getNumber());   
            }   
            System.out.println();   

            users = new User[2];   
            users[0] = new User("momor", 103);   
            users[1] = new User("becky", 104);   

            // 附加新对象至文件   
            appendObjectsToFile(users, args[0]);   

            // 读取文件数据   
            users = readObjectsFromFile(args[0]);   
            // 显示读回的对象   
            for (User user : users) {   
                System.out.printf("%s\t%d\n", user.getName(), user.getNumber());   
            }   

        } catch (ArrayIndexOutOfBoundsException e) {   
            e.printStackTrace();   
        } catch (FileNotFoundException e) {   
            e.printStackTrace();   
        }   
    }   

    public static void writeObjectsToFile(Object[] objs, String filename) {   
        File file = new File(filename);   
        try {   
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(   
                    new FileOutputStream(file));   
            for (Object obj : objs) {   
                // 将对象写入文件   
                objectOutputStream.writeObject(obj);   
            }   
            objectOutputStream.close();   
        } catch (FileNotFoundException e) {   
            e.printStackTrace();   
        } catch (IOException e) {   
            // TODO Auto-generated catch block   
            e.printStackTrace();   
        }   
    }   

    public static User[] readObjectsFromFile(String fileName)   
            throws FileNotFoundException {   
        File file = new File(fileName);   
        // 如果文件不存在就丢出异常   
        if (!file.exists())   
            throw new FileNotFoundException("未找到文件" + fileName);   
        // 使用List先读取出对象   
        List<User> list = new ArrayList();   
        try {   
            FileInputStream fileInputStream = new FileInputStream(file);   
            ObjectInputStream objectInputStream = new ObjectInputStream(   
                    fileInputStream);   
            while (fileInputStream.available() > 0) {   
                list.add((User) objectInputStream.readObject());   
            }   
            objectInputStream.close();   

        } catch (IOException e) {   
            e.printStackTrace();   
        } catch (ClassNotFoundException e) {   
            // TODO Auto-generated catch block   
            e.printStackTrace();   
        }   
        User[] users = new User[list.size()];   
        return list.toArray(users);   
    }   

    public static void appendObjectsToFile(Object[] objs, String fileName)   
            throws FileNotFoundException {   
        File file = new File(fileName);   
        if (!file.exists())   
            throw new FileNotFoundException("未发现文件" + fileName);   
        try {   
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(   
                    new FileOutputStream(fileName, true)) {   
                // 如果要附加对象到文件后   
                // 必须重新定义这个方法   
                protected void writeStreamHeader() throws IOException {   
                }   
            };   
            for (Object obj : objs) {   
                objectOutputStream.writeObject(obj);   
            }   
            objectOutputStream.close();   

        } catch (IOException e) {   
            e.printStackTrace();   
        }   

    }   
}  
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class ObjectStreamDemo {

	public static void main(String args[]) {
		User[] users = { new User("cater", 101), new User("justin", 102) };
		// 写入新文件
		writeObjectsToFile(users, args[0]);
		try {
			// 读取文件数据
			users = readObjectsFromFile(args[0]);
			// 显示读回的对象
			for (User user : users) {
				System.out.printf("%s\t%d%n", user.getName(), user.getNumber());
			}
			System.out.println();

			users = new User[2];
			users[0] = new User("momor", 103);
			users[1] = new User("becky", 104);

			// 附加新对象至文件
			appendObjectsToFile(users, args[0]);

			// 读取文件数据
			users = readObjectsFromFile(args[0]);
			// 显示读回的对象
			for (User user : users) {
				System.out.printf("%s\t%d\n", user.getName(), user.getNumber());
			}

		} catch (ArrayIndexOutOfBoundsException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

	public static void writeObjectsToFile(Object[] objs, String filename) {
		File file = new File(filename);
		try {
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(
					new FileOutputStream(file));
			for (Object obj : objs) {
				// 将对象写入文件
				objectOutputStream.writeObject(obj);
			}
			objectOutputStream.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static User[] readObjectsFromFile(String fileName)
			throws FileNotFoundException {
		File file = new File(fileName);
		// 如果文件不存在就丢出异常
		if (!file.exists())
			throw new FileNotFoundException("未找到文件" + fileName);
		// 使用List先读取出对象
		List<User> list = new ArrayList();
		try {
			FileInputStream fileInputStream = new FileInputStream(file);
			ObjectInputStream objectInputStream = new ObjectInputStream(
					fileInputStream);
			while (fileInputStream.available() > 0) {
				list.add((User) objectInputStream.readObject());
			}
			objectInputStream.close();

		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		User[] users = new User[list.size()];
		return list.toArray(users);
	}

	public static void appendObjectsToFile(Object[] objs, String fileName)
			throws FileNotFoundException {
		File file = new File(fileName);
		if (!file.exists())
			throw new FileNotFoundException("未发现文件" + fileName);
		try {
			ObjectOutputStream objectOutputStream = new ObjectOutputStream(
					new FileOutputStream(fileName, true)) {
				// 如果要附加对象到文件后
				// 必须重新定义这个方法
				protected void writeStreamHeader() throws IOException {
				}
			};
			for (Object obj : objs) {
				objectOutputStream.writeObject(obj);
			}
			objectOutputStream.close();

		} catch (IOException e) {
			e.printStackTrace();
		}

	}
}

范例中必要的地方都已加上注释，虽然程序很长，但范例中已经将写入对象至文件、从文件读出对象、附加对象至文件的程序逻辑集中在writeObjectsToFile()、readObjectsFromFile()与appendObjectsToFile() 3个方法中

Java代码

ObjectOutputStream objOutputStream =   
     new ObjectOutputStream(   
         new FileOutputStream(file, true)) {   
             protected void writeStreamHeader()   
                                  throws IOException {}   
         };

2.6 BufferedInputStream
BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作使得在从包含的输入流中获取新字节之前，再次读取自最后一次 mark 操作后读取的所有字节。
修改上面代码 :

public class EnumerationInputStreamTest {

    Enumeration         e    = null;       // 由内部类实现，如Vector
    String              sss  = "testsetst";
    SequenceInputStream seq  = null;
    Vector              coll = null;

    public void test() {
        try {
            long begin = System.currentTimeMillis();
            System.out.println("开始::" + begin);
            FileInputStream file = new FileInputStream("c:\\boot.ini");
            BufferedInputStream fileBuffer = new BufferedInputStream(file);
            ByteArrayInputStream byteArray = new ByteArrayInputStream(sss.getBytes());
            BufferedInputStream byteArrayBuffer = new BufferedInputStream(byteArray);
            coll = new Vector();
            coll.add(fileBuffer);
            coll.add(byteArrayBuffer);
            e = ((Vector) coll).elements();
            seq = new SequenceInputStream(e);
            int i = 0;
            while (i != -1) {
                i = seq.read();
                System.out.println("out:" + i);
            }
            long end = System.currentTimeMillis();
            System.out.println("结束::" + end);
            System.out.println("耗时::" + (end - begin));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String... strings) {
        EnumerationInputStreamTest eee = new EnumerationInputStreamTest();
        eee.test();
    }
}

运行结果：
开始::1226545776404
out:91
out:98
                    …
out:-1	
结束::1226545776419
耗时::15

2.7 PushbackInputStream
用作缓冲数据，需要时可以将数据重新塞回流里面，相当于做了一个拦截和处理。
例子：

public class PushBackTest {

    String sss = "testsetst";
    int    res[];
    byte   byteArray[];

    public void test() {
        try {
            long begin = System.currentTimeMillis();
            System.out.println("开始::" + begin);
            ByteArrayInputStream byteArrayStream = new ByteArrayInputStream("这只是个测试啊".getBytes());
            BufferedInputStream byteArrayBuffer = new BufferedInputStream(byteArrayStream);
            /*
             * 这里必要时要设置pushback区大小，默认是1，如果长度太大,则会返回 java.io.IOException: Push back buffer is full 异常
             */
            PushbackInputStream filePBack = new PushbackInputStream(byteArrayBuffer, 1024);

            int intAvai = 0;
            intAvai = filePBack.available();
            System.out.println("intAvai:" + intAvai);
            res = new int[intAvai + 1];
            byteArray = new byte[intAvai];
            int i = 0;
            int j = 0;
            while ((i = filePBack.read()) != -1) {
                byteArray[j] = (byte) i;
                System.out.println("out:" + i);
                j++;
            }
            long end = System.currentTimeMillis();
            System.out.println("结束::" + end);
            System.out.println("耗时::" + (end - begin));
            // ===================================
            System.out.println("获取到的::" + byteArray);
            filePBack.unread(byteArray);
            i = 0;
            System.out.println("filePBack.available():" + filePBack.available());
            begin = System.currentTimeMillis();
            System.out.println("重新开始::" + begin);

            byte[] array = new byte[2];
            int tmp = 0;
            int count = 0;
            while ((i = filePBack.read(array)) != -1) {
                // 两个字节转换为整数
                tmp = (short) ((array[0] << 8) | (array[1] & 0xff));

                tmp = tmp & 0xFFFF;

                // 判断是否为BIG5，如果是则显示BIG5中文字
                if (tmp > 0xA440 && tmp < 0xFFFF) {
                    System.out.println("BIG5:" + new String(array));
                } else {
                    // 将第二个字节流推回
                    if (count == 2) {
                        filePBack.unread(array, 1, 1);
                    }
                    // 显示ASII范围的字符
                    System.out.println("ASCII:" + (char) array[0]);
                }
            }
            end = System.currentTimeMillis();
            System.out.println("又结束::" + end);
            System.out.println("再次耗时::" + (end - begin));
             byteArrayStream.close();
            byteArrayBuffer.close();
            filePBack.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String... strings) {
        PushBackTest eee = new PushBackTest();
        eee.test();
    }
}

运行结果：
开始::1226561001499
…
结束::1226561001499
耗时::0 
…
重新开始::1226561001499
BIG5:这
BIG5:只
BIG5:是
BIG5:个
BIG5:测
BIG5:试
BIG5:啊
又结束::1226561001499
再次耗时::0

3. 深入理解

二．OutputStream

三．Reader

四．Writer

jason_hacker_z

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA-IO学习（笔记）

JAVA-IO一．InputStream1. 类图附件2. 子类说明流的数据方法都用了native实现方式，都不知道哪里去看实现。2.1 ByteArrayInputStream 把字节数组数据转化为输入流；通过byte数组实现数据的存取重要变量：[code="java"]protected byte buf[]; //缓冲区数据p...
复制链接

扫一扫

专栏目录