`

26、IO包中的管道流和随机访问文件

阅读更多

一、PipedOutputStream

 

  1. 可以将管道输出流连接到管道输入流来创建通信管道。
  2. 管道输出流是管道的发送端。
  3. 通常,数据由某个线程写入 PipedOutputStream 对象,
  4. 并由其他线程从连接的 PipedInputStream 读取。
  5. 不建议对这两个对象尝试使用单个线程,因为这样可能会造成该线程死锁。
  6. 如果某个线程正从连接的管道输入流中读取数据字节,但该线程不再处于活动状态,则该管道被视为处于 毁坏 状态。
public class PipedOutputStream extends OutputStream
{
	//创建尚未连接到管道输入流的管道输出流。必须在使用之前将管道输出流连接到管道输入流(既可由接收者连接,也可由发送者连接)。
	public PipedOutputStream(){}

	//创建连接到指定管道输入流的管道输出流。写入此流的数据字节稍后将用作 snk 的输入
	public PipedOutputStream(PipedInputStream snk)
                  throws IOException{}

	//将此管道输出流连接到接收者。如果此对象已经连接到其他某个管道输入流,则抛出 IOException
	public void connect(PipedInputStream snk)
             throws IOException{}
}

 

二、PipedInputStream

 

public class PipedInputStream extends InputStream
{
	//创建尚未连接的 PipedInputStream。在使用前必须将其连接到 PipedOutputStream
	public PipedInputStream(){}

	//创建一个尚未连接的 PipedInputStream,并对管道缓冲区使用指定的管道大小
	public PipedInputStream(int pipeSize){}

	//创建 PipedInputStream,使其连接到管道输出流 src。写入 src 的数据字节可用作此流的输入
	public PipedInputStream(PipedOutputStream src)
                 throws IOException{}

	//创建一个 PipedInputStream,使其连接到管道输出流 src,并对管道缓冲区使用指定的管道大小
	public PipedInputStream(PipedOutputStream src,
                        int pipeSize)
                 throws IOException{}

	//使此管道输入流连接到管道输出流 src。如果此对象已经连接到其他某个管道输出流,则抛出 IOException
	public void connect(PipedOutputStream src)
             throws IOException{}
}

 

三、示例

import java.io.*;

public class PipedStreamDemo {

	public static void main(String[] args) throws IOException {
		PipedInputStream pis = new PipedInputStream();
		PipedOutputStream pos = new PipedOutputStream(pis);
		new Thread(new Read(pis)).start();
		new Thread(new Write(pos)).start();
	}
}
//读取线程
class Read implements Runnable
{
	PipedInputStream pis;
	Read(PipedInputStream pis)
	{
		this.pis = pis;
	}
	public void run()
	{
		byte[] buf = new byte[1024];
		try {
			int len = pis.read(buf);
			String content = new String(buf,0,len);
			System.out.println(content);
			pis.close();
		} catch (IOException e) {
			System.out.println("读取失败");
		}
	}
}
//写入线程
class Write implements Runnable
{
	PipedOutputStream pos;
	Write(PipedOutputStream pos)
	{
		this.pos = pos;
	}
	public void run()
	{
		try {
			Thread.sleep(5000);
			pos.write("你好".getBytes());
			pos.close();
		} catch (IOException e) {
			System.out.println("写入失败");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

 

四、PiepedWriter,PiepedReader和PipedOutputStream,PipedInputStream一样的

 

五、RandomAccessFile

 

  1. 该类不是IO体系中的子类,但是它是IO包的成员,因为它具备读和写功能
  2. 此类的实例支持对随机访问文件的读取和写入。
  3. 其实完成读写的原理就是内部封装了直接输入流和输出流
  4. 内部封装了一个大型 byte 数组。
  5. 存在指向该隐含数组的光标或索引,称为文件指针;
  6. 输入操作从文件指针开始读取字节,并随着对字节的读取而前移此文件指针。
  7. 如果随机访问文件以读取/写入模式创建,则输出操作也可用;
  8. 输出操作从文件指针开始写入字节,并随着对字节的写入而前移此文件指针。
  9. 写入隐含数组的当前末尾之后的输出操作导致该数组扩展。
  10. 该文件指针可以通过 getFilePointer 方法读取,并通过 seek 方法设置。 
  11. 通常,如果此类中的所有读取例程在读取所需数量的字节之前已到达文件末尾,则抛出 EOFException(是一种 IOException)。
  12. 如果由于某些原因无法读取任何字节,而不是在读取所需数量的字节之前已到达文件末尾,则抛出 IOException,而不是 EOFException。
  13. 需要特别指出的是,如果流已被关闭,则可能抛出 IOException。 
public class RandomAccessFile implements DataOutput, DataInput, Closeable
{
	//创建从中读取和向其中写入(可选)的随机访问文件流,该文件由 File 参数指定。
	public RandomAccessFile(File file,
                        String mode)
                 throws FileNotFoundException{}

	//创建从中读取和向其中写入(可选)的随机访问文件流,该文件具有指定名称
	public RandomAccessFile(String name,
                        String mode)
                 throws FileNotFoundException{}

	/**
	 * 通过构造函数可以看出,该类只能操作文件,而且操作文件还有模式
	 * mode 参数指定用以打开文件的访问模式。
	 * "r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
	 * "rw" 打开以便读取和写入。如果该文件尚不存在,则尝试创建该文件,如果存在则不会覆盖
	 * "rws" "rwd"
	 */
	
	//关闭此随机访问文件流并释放与该流关联的所有系统资源。关闭的随机访问文件不能执行输入或输出操作,而且不能重新打开。
	public void close()
           throws IOException{}

	//返回此文件中的当前偏移量,到此文件开头的偏移量(以字节为单位),在该位置发生下一个读取或写入操作
	public long getFilePointer()
                    throws IOException{}

	//返回按字节测量的此文件的长度
	public long length()
            throws IOException{}

	//从此文件中读取一个数据字节。以整数形式返回此字节,范围在 0 到 255 (0x00-0x0ff)。
	public int read()
         throws IOException{}

	public int read(byte[] b)
         throws IOException{}

	public int read(byte[] b,
                int off,
                int len)
         throws IOException{}

	//从此文件读取一个 boolean。此方法从该文件的当前文件指针开始读取单个字节。值 0 表示 false。其他任何值表示 true
	public final boolean readBoolean()
                          throws IOException{}

	//从此文件读取一个有符号的八位值。此方法从该文件的当前文件指针开始读取一个字节。如果读取的字节为 b,其中 0 <= b <= 255\
	public final byte readByte()
                    throws IOException{}

	//从此文件读取一个字符。此方法从该文件的当前文件指针开始读取两个字节。如果按顺序读取的字节为 b1 和 b2,其中 0 <= b1, b2 <= 255
	public final char readChar()
                    throws IOException{}

	//从此文件读取一个 double,8个字节
	public final double readDouble()
                        throws IOException{}

	readInt readFloat 读4个字节 readLong readShort 类似的操作

	//按单字节值将 boolean 写入该文件。值 true 写出为值 (byte)1;值 false 写出为值 (byte)0。写入从文件指针的当前位置开始
	public final void writeBoolean(boolean v)
                        throws IOException{}

	//按两个字节将 short 写入该文件,先写高字节。写入从文件指针的当前位置开始
	public final void writeShort(int v)
                      throws IOException{}

	write方法和read方法一一对应

	//设置到此文件开头测量到的文件指针偏移量,在该位置发生下一个读取或写入操作。
	public void seek(long pos)
          throws IOException{}

	//设置此文件的长度。如果 length 方法返回的文件的现有长度大于 newLength 参数,则该文件将被截短
	public void setLength(long newLength)
               throws IOException{}

	//尝试跳过输入的 n 个字节以丢弃跳过的字节。返回跳过的实际字节数。如果 n 为负数,则不跳过任何字节
	public int skipBytes(int n)
              throws IOException{}
}

 

六、示例

 

    利用RandomAccessFile可以实现对文件的分段读写

 

import java.io.*;
public class RandomAccessFileDemo {

	public static void main(String[] args) throws IOException {
		RandomAccessFile raf = new RandomAccessFile("e:/mm.txt","rw");
		//writeFile(raf);
		//readFile(raf);
		//writeFile2(raf);
		readFile2(raf);
	}
	public static void writeFile(RandomAccessFile raf) throws IOException
	{
		raf.write("张三".getBytes());
		raf.writeInt(97);
		raf.write("李四".getBytes());
		raf.writeInt(98);
		raf.close();
	}
	public static void readFile(RandomAccessFile raf) throws IOException
	{
		byte[] buf = new byte[4];
		raf.read(buf);
		String name = new String(buf);
		int age = raf.readInt();
		System.out.println(name+":"+age);
	}
	public static void writeFile2(RandomAccessFile raf) throws IOException
	{
		raf.seek(8);
		raf.write("王武".getBytes());
		raf.writeInt(99);
		raf.close();
	}
	public static void readFile2(RandomAccessFile raf) throws IOException
	{
		raf.skipBytes(8);
		byte[] buf = new byte[4];
		raf.read(buf);
		String name = new String(buf);
		int age = raf.readInt();
		System.out.println(name+":"+age);
	}
}

 

分享到:
评论

相关推荐

    Java流和文件总结(二)

    在Java编程语言中,流(Stream)和文件操作是核心概念,它们对于处理输入和输出数据至关重要。在本文中,我们将深入探讨Java流和文件处理的一些关键知识点。 首先,流是Java中的一个抽象概念,它代表了数据的有序...

    Java 输入与输出流操作

    在Java中,I/O(Input/Output)处理是通过一系列的类和接口来实现的,这些都位于java.io包中。下面将详细阐述Java输入与输出流的相关知识点。 1. **流的概念**: 流是Java I/O的核心概念,它代表数据的源或目的地...

    io源代码

    - 这是一个特殊的文件流,支持随机访问文件,可以在文件的任意位置读写。 在阅读源代码时,注意理解类的继承关系、方法的实现以及异常处理机制。通过分析这些类的设计模式,我们可以学习到如何有效地组织代码,...

    新版Java_IO精讲(推荐版)

    - **顺序型/随机访问**:顺序型流按照数据的先后顺序读写,而随机访问流允许在任意位置读写数据。 #### Java I/O的包结构 Java I/O的相关类主要位于`java.io`包中,该包提供了丰富的API来支持各种I/O操作: - **...

    完整版 杭州电子科技大学JAVA语言程序设计 JAVA_07 IO输入输出(共30页).ppt

    - **随机访问文件**:RandomAccessFile类允许对文件进行随机读写。 - **对象序列化**:ObjectInputStream和ObjectOutputStream支持对象的序列化和反序列化。 - **管道流**:PipedInputStream和PipedOutputStream...

    java io java 输入输出

    Java的I/O库在`java.io`包中,提供了丰富的类和接口来支持各种类型的流操作。 ### I/O流概述 I/O流是Java对输入输出数据流的一种抽象,分为输入流(Input Stream)和输出流(Output Stream)。输入流是从数据源...

    北大Java--IO

    4. **文件操作与随机访问文件** - Java的`RandomAccessFile`类允许对文件进行随机读写操作,不仅可以按顺序读写,还能直接定位到文件的任意位置。 5. **对象流** - `ObjectInputStream`和`ObjectOutputStream`...

    Java I/O编程 java

    Java 中的I/O操作主要依赖于`java.io.*`包中的类和接口。程序作为数据的源或目的地,可以读取或写入数据流。输入流负责接收数据,输出流负责发送数据。 2. 字节流与字符流: 字节流处理单个字节的数据,如图像、...

    java复习题库习题7.1(可编辑修改word版).pdf

    6. **File类功能**:File类是Java.io包中的核心类,用于文件和目录的操作,如创建、删除、重命名等。 7. **随机访问文件**:RandomAccessFile类提供了随机访问文件的功能,可以读写文件的任意位置。 通过这些知识...

    Java写的文件加密器

    在IT行业中,文件的安全性是至关重要的,尤其是在网络...对于初学者,这个项目提供了一个实践文件加密和IO操作的平台,有助于提升对Java安全性和文件处理的理解。通过研究源代码,可以深入学习到上述知识点的实际应用。

    Java标准类库(java基础类)

    - **随机访问文件**:`RandomAccessFile`允许开发者以随机访问方式读写文件。 - **文件锁定**:在多线程或多进程环境中,通过文件锁定机制防止数据冲突。 #### 版本更新 随着Java版本的不断演进,`java.io`包也在...

    Java程序设计课件

    随机读写流RandomAccessFile允许在文件的任意位置进行读写操作,而文件锁(FileLock)则提供了在多线程或进程环境下对文件的独占访问控制。 Java的System类包含了三个预定义的流:System.in、System.out和System....

    Java_IO

    这个主题涵盖了许多类和接口,分布在java.io包中,为开发者提供了丰富的工具来读写文件、网络通信、标准输入输出等。在Java IO体系中,我们可以找到流(Streams)的概念,它们是数据传输的通道,可以将数据从一个源...

    JavaIO:OReilly.Java.I.O.2nd.Edition中文翻译和学习笔记

    11. **随机访问文件**:RandomAccessFile提供了对文件的随机访问能力,可以定位到文件的任意位置进行读写。 12. **网络IO**:Socket和ServerSocket用于网络通信,InputStream和OutputStream可以用来读写网络数据。 ...

    java代码-Java 输入输出命令

    - **RandomAccessFile**: 支持随机访问文件,可以跳过指定字节数进行读写。 4. **管道流(Piped Stream)** - 允许线程间数据传输,如`PipedInputStream`和`PipedOutputStream`。 5. **转换流(Wrapper Stream)...

Global site tag (gtag.js) - Google Analytics