java之IO其它类型的流

一、操作基本数据类型的流

DataInputStream

DataOutputStream

数据输出流允许应用程序以适当方式将基本java数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

package a;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 操作基本数据类型的流
 */
public class DataInputStreamAndDatOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		//写
		writer();

		//读
		reader();

	}

	private static void reader() throws IOException {
		//创建基本类型输入流
		DataInputStream dis = new DataInputStream(new FileInputStream("dos.txt"));

		//读基本类型的数据
		int num = dis.readInt();
		System.out.println("int类型的数据是："+num);
		short s = dis.readShort();
		System.out.println("short类型的数据是："+s);
		byte b = dis.readByte();
		System.out.println("byte类型的数据是："+b);
		double d = dis.readDouble();
		System.out.println("double类型的数据是："+d);
		long l = dis.readLong();
		System.out.println("long类型的数据是:"+l);
		char c = dis.readChar();
		System.out.println("char类型的数据是："+c);
		boolean bo = dis.readBoolean();
		System.out.println("boolean类型的数据是："+bo);

		//关闭流
		dis.close();

	}

	private static void writer() throws IOException {
		//创建基本类型输出流
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("dos.txt"));

		//输出基本类型的数据
		dos.writeInt(2);
		dos.writeShort(200);
		dos.writeByte(2);
		dos.writeDouble(2564231);
		dos.writeLong(20L);
		dos.writeChar(‘a‘);
		dos.writeBoolean(true);

		//关闭流
		dos.close();

	}
}

二、内存操作流

内存操作流一般用于处理临时信息，因为临时信息不需要保存，使用后就可以删除。

操作字节数组：

ByteArrayInputStream

ByteArrayOutputStream

操作字符数组

CharArrayReader

CharArrayWriter

操作字符串

StringReader

StringWriter

package a;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/*
 *  字节数组输入流和字节数组输出流
 *  ByteArrayOutputStream和ByteArrayInputStream
 *  
 *  ByteArrayOutputStream:
 *  		实现了一个输出流，其中的数据被写入了一个byte数组。
 *  		缓冲区会随着数据的不断写入而自动增长。
 *  		但是注意的是，字节数组输出流是将数据输出到内存中，所以，构造方法没有提供文件，因为目的地是内存哦
 *  		但是，我们怎么获得写入到内存中的数据呢？
 *  		幸好，ByteArrayOutputStream提供了toByteArray()和	toString()方法来获取数据 
 *  
 */
public class ByteArrayStream {
	public static void main(String[] args) throws IOException {
		//字节数组输出流对象
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		//输出数据
		baos.write("helloworld".getBytes());
		//关闭流对象
		baos.close();
		//通过toByteArray()和	toString()方法来获取数据 
		byte[] b = baos.toByteArray();
		System.out.println("通过toByteArray()来获得数据："+new String(b));
		System.out.println("通过toString()来获得数据："+baos.toString());

		System.out.print("通过字节数组输入流获得数组：");
		//创建字节数组输入流对象
		ByteArrayInputStream bais = new  ByteArrayInputStream(b);
		int by = 0;
		while((by = bais.read()) != -1){
			System.out.print((char)by);
		}

	}

}

三、打印流

打印流概述：

字节打印流：PrintStream

字符打印流：PrintWriter

打印流特点：

只能操作目的地，不能操作数据。

可以操作任意类型的数据。

如果启动了自动刷新，能够自动刷新。

可以操作文件的流

package a;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * 字节打印流
 * PrintStream：字节打印流。使用字节输出流能够方便的打印出各种类型的数据
 * 
 * PrintStream(OutputStream out, boolean autoFlush) 通过这个构造方法可以实现自动刷新
 * autoFlush - boolean 变量；如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 (‘\n‘) 时都会刷新输出缓冲区
 */
public class PrintStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节打印流对象
		PrintStream ps = new PrintStream(new FileOutputStream("ps"),true);

		ps.write("helloworld".getBytes());
		ps.write(2);
		ps.print("你好");
		ps.print(true);
		ps.print(‘a‘);
		ps.print(2.0);
		ps.print(0.1f);

		//释放资源
		ps.close();
	}
}
package a;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * 字节打印流
 * PrintStream：字节打印流。使用字节输出流能够方便的打印出各种类型的数据
 * 
 * PrintStream(OutputStream out, boolean autoFlush) 通过这个构造方法可以实现自动刷新
 * autoFlush - boolean 变量；如果为 true，则每当写入 byte 数组、调用其中一个 println 方法或写入换行符或字节 (‘\n‘) 时都会刷新输出缓冲区
 */
public class PrintStreamDemo {
	public static void main(String[] args) throws IOException {
		//创建字节打印流对象
		PrintStream ps = new PrintStream(new FileOutputStream("ps"),true);

		ps.write("helloworld".getBytes());
		ps.write(2);
		ps.print("你好");
		ps.print(true);
		ps.print(‘a‘);
		ps.print(2.0);
		ps.print(0.1f);

		//释放资源
		ps.close();
	}
}

四、标准输入输出流

System类中有两个静态变量：in、out。

它们分别各自代表了系统标准的输入和输出设备。

默认输入设备是键盘，输出设备是显示器。

System.in的类型是InputStream。

System.out的类型时PrintStream。

五、随机访问文件

RandomAccessFile类不属于类，是Object的子类。

但是它融合了InputStream和OutputStream的功能，支持对随机访问文件的读取和写入。

package a;

import java.io.IOException;
import java.io.RandomAccessFile;

/**
 *	RandomAccessFile
 *  RandomAccessFile(String name, String mode) 
 *      创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。 
 *      "r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。  
 *		"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。  
 *	    "rws" 打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。  
 *		"rwd" 打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。 
 *		一般使用rw模式。
 *
 */
public class RandomAccessFileDemo {
	public static void main(String[] args) throws IOException {
		writer();
		reader();
	}

	private static void reader() throws IOException {
		RandomAccessFile rf = new RandomAccessFile("rf.txt","rw");
		byte b = rf.readByte();
		boolean bo = rf.readBoolean();
		char c = rf.readChar();
		String str = rf.readUTF();
		System.out.println("int类型的数值："+b);
		System.out.println("boolean类型的数值:"+bo);
		System.out.println("char类型的数值："+c);
		System.out.println("String类型的数值："+str);
		rf.close();

	}

	private static void writer() throws IOException {
		RandomAccessFile rf = new RandomAccessFile("rf.txt","rw");
		rf.writeByte(20);
		rf.writeBoolean(true);
		rf.writeChar(‘a‘);
		rf.writeUTF("你好，世界");
		rf.close();
	}

}

int类型的数值：20

boolean类型的数值:true

char类型的数值：a

String类型的数值：你好，世界

六、合并流

sequenceInputStream类可以将多个输入流串流在一起，合并为一个输入流，因此，该流 也称为合并流。

构造方法：

public SequenceInputStream(InputStream s1,InputStream s2)
public SequenceInputStream(Enumeration<? extends InputStream> e)
package a;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SequenceInputStream;

public class SequenceInputStreamDemo1 {
	public static void main(String[] args) throws IOException {
		InputStream is1 = new BufferedInputStream(new FileInputStream("a.txt"));
		InputStream is2 = new BufferedInputStream(new FileInputStream("b.txt"));

	    OutputStream os = new BufferedOutputStream(new FileOutputStream("c.txt"));
	    
	    SequenceInputStream sis = new SequenceInputStream(is1, is2);
	    
	    byte[] b = new byte[1024];
	    int len = 0;
	    while((len = sis.read(b)) != -1){
	    	os.write(b, 0, len);
	    }
	    
	    sis.close();
	    os.close();
	    is1.close();
	    is2.close();
	    
	    
	}
}
package a;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.SequenceInputStream;
import java.util.Vector;

public class SequenceInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		InputStream is1 = new BufferedInputStream(new FileInputStream("a.txt"));
		InputStream is2 = new BufferedInputStream(new FileInputStream("b.txt"));
		InputStream is3 = new BufferedInputStream(new FileInputStream("c.txt"));

		 OutputStream os = new BufferedOutputStream(new FileOutputStream("d.txt"));

		Vector<InputStream> v = new Vector<InputStream>();
		v.addElement(is1);
		v.addElement(is2);
		v.addElement(is3);

		SequenceInputStream sis = new SequenceInputStream(v.elements());

		 byte[] b = new byte[1024];
		    int len = 0;
		    while((len = sis.read(b)) != -1){
		    	os.write(b, 0, len);
		    }
		    
		    sis.close();
		    os.close();
		    is1.close();
		    is2.close();
	}

}

六、序列化流

序列化流：ObjectOutputStream

反序列化流：ObjectInputStream

对象序列化是将对象状态转换为可保持或传输的过程。一般的格式是与平台无关的二进制流，可以将这种二进制流持久保存在磁盘上，也可以通过网络将这种二进制流传输到另一个网络节点。

对象反序列化，是把这种二进制流数据还原为对象。

序列化

package a;

import java.io.Serializable;

public class Student implements Serializable{
	private static final long serialVersionUID = -4300404356607362590L;
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

}
package a;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStream {
	public static void main(String[] args) throws IOException {
		//创建序列化流对象
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
		//创建学生对象
		Student s1 = new Student("哈哈",2);
		Student s2 = new Student("呵呵",3);
		Student s3 = new Student("嘻嘻",4);
		Student s4 = new Student("笨笨",5);

		oos.writeObject(s1);
		oos.writeObject(s2);
		oos.writeObject(s3);
		oos.writeObject(s4);

		oos.close();

	}

}

反序列化

package a;

import java.io.Serializable;

public class Student implements Serializable{
	private static final long serialVersionUID = -4300404356607362590L;
	private String name;
	private int age;

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

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

}
package a;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ObjectStream {
	public static void main(String[] args) throws IOException {
		//创建反序列化流对象
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));

		Student ss1 = (Student) ois.readObject();
		Student ss2 = (Student) ois.readObject();
		Student ss3 = (Student) ois.readObject();
		Student ss4 = (Student) ois.readObject();

		System.out.println(ss1);
		System.out.println(ss2);
		System.out.println(ss3);
		System.out.println(ss4);

		ois.close();

	}

}

Student [name=哈哈, age=2]

Student [name=呵呵, age=3]

Student [name=嘻嘻, age=4]

Student [name=笨笨, age=5]

如果不想某个属性被序列化，那么只要在属性前用transient修饰属性。

package a;

import java.io.Serializable;

public class Student implements Serializable{
	private static final long serialVersionUID = -4300404356607362590L;
	private String name;
	private transient int age;

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

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}

}
package a;

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

public class ObjectStream {
	public static void main(String[] args) throws  Exception {
		//创建序列化流对象
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt"));
		//创建学生对象
		Student s1 = new Student("哈哈",2);
		Student s2 = new Student("呵呵",3);
		Student s3 = new Student("嘻嘻",4);
		Student s4 = new Student("笨笨",5);

		oos.writeObject(s1);
		oos.writeObject(s2);
		oos.writeObject(s3);
		oos.writeObject(s4);

		oos.close();

		//创建反序列化流对象
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt"));

		Student ss1 = (Student) ois.readObject();
		Student ss2 = (Student) ois.readObject();
		Student ss3 = (Student) ois.readObject();
		Student ss4 = (Student) ois.readObject();

		System.out.println(ss1);
		System.out.println(ss2);
		System.out.println(ss3);
		System.out.println(ss4);

		ois.close();

	}

}

Student [name=哈哈, age=0]

Student [name=呵呵, age=0]

Student [name=嘻嘻, age=0]

Student [name=笨笨, age=0]

七、Properties集合

package a;

import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

public class PropertiesDemo {
	public static void main(String[] args) {
		Properties p = new Properties();

		p.put("玉帝", "王母");
		p.put("嫦娥", "后羿");

		//遍历输出方式一
		Set<Object> set = p.keySet();
		for(Object o : set){
			String str = (String) p.get(o);
			System.out.println(o+":"+str);
		}

		//遍历输出方式二
		Set<Map.Entry<Object,Object>> entrySet = p.entrySet();
		for(Map.Entry<Object,Object> s : entrySet){
			String key = (String) s.getKey();
			String value = (String) s.getValue();
			System.out.println(key+":"+value);

		}
	}

}
package a;
import java.util.Properties;
import java.util.Set;

/**
 * Properties
 *	特有功能：
 * public Object setProperty(String key, String value)  
 * public String getProperty(String key)
 * public Set<String> stringPropertyNames()
 */
public class PropertiesDemo {
	public static void main(String[] args) {
		Properties p = new Properties();
		p.setProperty("玉帝", "王母");
		p.setProperty("嫦娥", "后羿");

		Set<String> keys = p.stringPropertyNames();
		for(String key:keys){
			System.out.println(key+":"+p.getProperty(key));
		}

	}

}

玉帝:王母

嫦娥:后羿

Properties和IO流的结合使用

package a;

import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Properties;
import java.util.Set;

/**
 * public void load(Reader reader)
 * public void store(Writer writer,String comments)
 */
public class PropertiesDemo2 {
	public static void main(String[] args) throws Exception{
		Properties p = new Properties();
		p.setProperty("玉帝", "王母");
		p.setProperty("嫦娥", "后羿");

		p.store(new BufferedWriter(new FileWriter("p.properties")), "这是注释");

		Properties p2 = new Properties();
		p2.load(new FileReader("p.properties"));

		Set<String> keys = p2.stringPropertyNames();
		for(String key : keys){
			System.out.println(key+":"+p2.getProperty(key));
		}

	}

}

玉帝:王母

嫦娥:后羿

时间： 2024-10-18 15:39:52

java之IO其它类型的流的相关文章

JAVA的IO编程：管道流

掌握线程通讯流(管道流)的使用 管道流的主要作用是可以进行两个线程间的通讯,分为管道输入流(PipeOutputStream)和管道输出流(PipeInputStream). 如果要想进行管道输出,则必须把输出流连在输入流之上,在PipeOutputStream上有如下方法用于连接管道. void connect(PipedInputStream snk) 将此管道输出流连接到接收者. 要想连接输入和输出,必须使用此方法. PipeOutputStream输出方法: void write(byt

Java基础IO类之打印流

package IODemo; import java.io.*; /* 打印流 : 很方便的进行输出 字节打印流 增强输出功能 字符打印流 */ public class PrintStreamDemo { private static void charPrint(){ File file = new File("d:\\test\\t.txt"); try { Writer w = new FileWriter(file,true); BufferedWriter br = ne

Java基础IO类之对象流与序列化

对象流的两个类: ObjectOutputStream:将Java对象的基本数据类型和图形写入OutputStream ObjectInputStream:对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化 序列化一组对象: 在系列化操作中,同时序列化多个对象时,反序列化也必须按顺序操作,如果想要序列化一组对象该如何操作呢? 序列化一组对象可采用,对象数组的形式,因为对象数组可以向Object进行转型操作. 把对象序列化到文件当中,然而文件中存的是字节.我们对象里面相

Java基础IO类之字符串流（查字符串中的单词数量）与管道流

一.字符串流 定义:字符串流(StringReader),以一个字符为数据源,来构造一个字符流. 作用:在Web开发中,我们经常要从服务器上获取数据,数据返回的格式通常一个字符串(XML.JSON),我们需要把这个字符串构造为一个字符流.然后再用第三方数据解析器来解析数据. 代码示例:计算一个字符串有多少个单词 package IODemo; import java.io.IOException; import java.io.StreamTokenizer; import java.io.St

java进阶 ------ IO流

[本文是自己学习所做笔记,欢迎转载,但请注明出处:http://blog.csdn.net/jesson20121020] 流的概念和基本分类: 流的概念: 流是一个很形象的概念,当程序需要读取数据的时候,就会开启一个通向数据的源的流,这个数据源可以是文件,内存,或是网络连接.类似的,当程序需要写入数据的时候,就会开启一个通向目的地的流.这时候你就可以想象数据好像在这其中"流动一样". 流的分类: 按数据方向分:输入流和输出流 输入流:InputStream/Reader 输出流:Ou

java里IO流的逻辑关系

在InputStream里和OutputStream里,提供了以下的针对不同信息来源的IO处理对象: 1)以字节形式,读写内存缓冲区中内容得到的ByteArrayInputStream和ByteArrayOutputStream对象 2)以字符串为对象,读写String累心数据的StringBufferInputStream和StringBufferOutputStream对象. 3)针对文件读写操作的FileInputStream和FileOutputStream对象. 4)针对管道数据读写操

Java之IO流---字节流

1.1 IO流的引入 IO流在很多语言已有体现,诸如C语言的stdio.h,C++中的iostream.Java中的IO流大抵是用于在控制台.磁盘.内存上进行数据的读写操作,完成数据的传递. 我们可以对它进行如下分类: 按处理的数据类型可分为字节流与字符流 按流的流向可分为输入流(in)与输出流(out) 按流的功能可分为节点流(Node)和过滤流(Filter) 本篇侧重于梳理字节流相关的知识,毕竟作为字符流的前辈,它还是非常重要的.下篇继续梳理字符流. 1.2 IO流的继承体系图 大概描述了

Java IO 字节流与字符流 （三）

Java的IO流分为字符流(Reader,Writer)和字节流(InputStream,OutputStream),字节流顾名思义字节流就是将文件的内容读取到字节数组,然后再输出到另一个文件中.而字符流操作的最小单位则是字符.可以先看一下IO流的概述: 下面首先是通过字符流对文件进行读取和写入: 1 package lib; 2 3 import java.io.BufferedReader; 4 import java.io.File; 5 import java.io.FileNotFou

Java笔记-IO流的运用

1.InputStream和System.in(Scanner) InputStream 输出流以字节为单位来获取数据,且需要复杂的判断并创建字节数组作为缓冲 另外字节转换为字符时容易出现中文乱码的情况:Scanner Java扫描器类,可以从输入流中读取指定类型的数据或字符串. 对于字符数据的读取,应该使用Scanner扫描器进行封装,然后获取字符串类型的数据 2. out和err out和err是System类的两个static类成员变量: out:主要是输出调试信息的输出流,以黑色显示 e