黑马程序员 IO流总结

于 2014-06-18 10:59:26 发布
阅读量513 收藏
点赞数
分类专栏： 小结 文章标签： 黑马程序员 java io流 字符流 标准
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gexiaodong1129/article/details/32095659
版权

------- android培训、java培训、期待与您交流！ ---------------

一.序列流
        序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.

使用方式
        整合两个: SequenceInputStream(InputStream, InputStream)
        整合多个: SequenceInputStream(Enumeration) 
package cn.itcast.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class Demo1_SequenceInputStream {

	/**
	 * @param args
	 * @throws IOException 
	 * 序列流
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		//demo2();
		FileInputStream fis1 = new FileInputStream("a.txt");
		FileInputStream fis2 = new FileInputStream("b.txt");
		FileInputStream fis3 = new FileInputStream("c.txt");
		FileOutputStream fos = new FileOutputStream("d.txt");
		
		Vector<InputStream> v = new Vector<>();						//创建集合对象将集合对象添加到集合中
		v.add(fis1);
		v.add(fis2);
		v.add(fis3);
		
		Enumeration<InputStream> en = v.elements();					//获取枚举的引用
		SequenceInputStream sis = new SequenceInputStream(en);		//通过枚举获取流对象
		
		int b;
		while((b = sis.read()) != -1) {
			fos.write(b);
		}
		
		fos.close();
		sis.close();
	}

	private static void demo2() throws FileNotFoundException, IOException {
		FileInputStream fis1 = new FileInputStream("a.txt");
		FileInputStream fis2 = new FileInputStream("b.txt");
		FileOutputStream fos = new FileOutputStream("c.txt");
		SequenceInputStream sis = new SequenceInputStream(fis1, fis2);			//将fis1和fis2整合成一个字节流
		
		int b;
		while((b = sis.read()) != -1) {
			fos.write(b);
		}
		
		fos.close();
		sis.close();
	}

	private static void demo1() throws FileNotFoundException, IOException {
		FileInputStream fis1 = new FileInputStream("a.txt");
		FileInputStream fis2 = new FileInputStream("b.txt");
		FileOutputStream fos = new FileOutputStream("c.txt");
		
		int b1;
		while((b1 = fis1.read()) != -1) {
			fos.write(b1);
		}
		
		int b2;
		while((b2 = fis2.read()) != -1) {
			fos.write(b2);
		}
		
		fis1.close();
		fis2.close();
		fos.close();
	}
}

二.内存输出流*****
        该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据
使用方式
        创建对象: new ByteArrayOutputStream()
        写出数据: write(int), write(byte[])
        获取数据: toByteArray() 
package cn.itcast.otherio;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo2_ByteArrayOutputStream {
	/**
	 * @param args
	 * 内存输出流
	 * 把内存当作缓冲区,将文件读取的内容先写到内存中
	 * 弊端:如果文件过大容易内存溢出(但是这种情况很难出现)
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		FileInputStream fis = new FileInputStream("f.txt");
		ByteArrayOutputStream baos = new ByteArrayOutputStream();	//把内存当作缓冲区创建一个数组
		int b;
		while((b = fis.read()) != -1) {
			baos.write(b);
		}
		byte[] arr = baos.toByteArray();
		System.out.println(new String(arr));
		fis.close();
	}
	private static void demo1() throws FileNotFoundException, IOException {
		FileInputStream fis = new FileInputStream("f.txt");
		//int x = fis.read();
		//System.out.println((char)x);
		int len;
		byte[] arr = new byte[4];
		while((len = fis.read(arr)) != -1) {
			System.out.println(new String(arr,0,len));
		}
		fis.close();
	}
}

三.对象操作流*
        该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.
使用方式
        写出: new ObjectOutputStream(OutputStream), writeObject()
        读取: new ObjectInputStream(InputStream), readObject()
注意
        要写出的对象必须实现Serializable接口才能被序列化 
package cn.itcast.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

import cn.itcast.bean.Person;

public class Demo3_ObjectOutputStream {

	/**
	 * @param args
	 * @throws IOException 
	 * 将对象写出去序列化
	 * 写出的对象必须实现Serializable
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		Person p1 = new Person("张三", 23);
		Person p2 = new Person("李四", 24);
		Person p3 = new Person("王五", 25);
		ArrayList<Person> list = new ArrayList<>();
		list.add(p1);
		list.add(p2);
		list.add(p3);
		
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("g.txt"));
		oos.writeObject(list);
		oos.close();	
	}
	private static void demo1() throws IOException, FileNotFoundException {
		Person p1 = new Person("张三", 23);
		Person p2 = new Person("李四", 24);
		Person p3 = new Person("王五", 25);
		
		//FileOutputStream fos = new FileOutputStream("f.txt");
		//fos.write(p1);
		//FileWriter fw = new FileWriter("f.txt");
		//fw.write(p1);
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
		oos.writeObject(p1);
		oos.writeObject(p2);
		oos.writeObject(p3);
		
		oos.close();
	}
}

package cn.itcast.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

import cn.itcast.bean.Person;

public class Demo4_ObjectInputStream {

	/**
	 * @param args
	 * @throws Exception 
	 * @throws FileNotFoundException 
	 * 将文件上的对象读到程序中反序列化
	 */
	public static void main(String[] args) throws FileNotFoundException, Exception {
		//demo1();
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("g.txt"));
		ArrayList<?> list = (ArrayList<?>) ois.readObject();						//将集合读取出来
		for (Object object : list) {												//遍历集合
			System.out.println(object);
		}
		
		ois.close();
	}

	private static void demo1() throws IOException, FileNotFoundException,
			ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
		Person p1 = (Person) ois.readObject();
		Person p2 = (Person) ois.readObject();
		Person p3 = (Person) ois.readObject();
		System.out.println(p1);
		System.out.println(p2);
		System.out.println(p3);
		
		ois.close();
	}
}

四.打印流*****
        该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式
        System.out就是一个PrintStream, 其默认向控制台输出信息
使用方式
        打印: print(), println()
        自动刷出: PrintWriter(OutputStream out, boolean autoFlush)  
package cn.itcast.otherio;

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

import cn.itcast.bean.Person;

public class Demo5_PrintStream {

	/**
	 * @param args
	 * println打印对象的时候,会调用对象的toString方法将其转换成字符传打印
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		PrintStream ps = new PrintStream(new FileOutputStream("b.txt"));
		ps.write(97);					//写出一个字节
		ps.println(97);					//调用Integer.toString(97)将其转换为字符串
		ps.close();
	}

	private static void demo1() {
		Person p = new Person("张三", 23);
		PrintStream ps = System.out;
		ps.println(97);
		ps.println(p);
		//ps.close();
		System.out.close();				//因为没有和硬盘上的文件交换所以不用关
		
		System.out.println("大家好");
	}
}

package cn.itcast.otherio;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

public class Demo6_PrintWriter {

	/**
	 * @param args
	 * @throws IOException 
	 * PrintWrinter是操作数据目的,可以构造函数第二个参数传true自动刷新
	 */
	public static void main(String[] args) throws IOException {
		PrintWriter pw = new PrintWriter(new FileOutputStream("b.txt"));
		pw.println("今天是io最后一天");
		pw.close();
	}
}
五.标准输入输出流
        System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
        System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
修改标准输入输出流
        修改输入流: System.setIn(InputStream)
        修改输出流: System.setOut(PrintStream) 
package cn.itcast.otherio;

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

public class Demo7_SetInOut {

	/**
	 * @param args
	 * @throws IOException 
	 * System.in是标准的输入流,默认指向的键盘
	 * System.out是标准的输出流,默认指向的是控制台
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		System.setIn(new FileInputStream("a.txt"));						//改变标准输入流,指向a.txt
		System.setOut(new PrintStream(new FileOutputStream("b.txt")));	//改变标准输出流,指向b.txt
		
		InputStream is = System.in;										//获取InputStream对象,System.in不在是键盘录入,而是从a.txt上读数据
		PrintStream ps = System.out;									//获取OutputStream对象,System.out不在是控制台输出,而是指向的是b.txt
		int b;
		while((b = is.read()) != -1) {
			ps.write(b);
		}
		
		is.close();
		ps.close();
	}

	private static void demo1() throws IOException {
		InputStream is = System.in;
		int x = is.read();
		System.out.println(x);
	}

}

六.数据输入输出流
        DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
        例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.
使用方式
        DataInputStream(InputStream), readInt(), readLong()
        DataOutputStream(OutputStream), writeInt(), writeLong() 
package cn.itcast.otherio;

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

public class Demo8_DataStream {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//demo1();
		//demo2();
		//demo3();
		DataInputStream dis = new DataInputStream(new FileInputStream("a.txt"));
		int x = dis.readInt();			//可以一次读取四个字节,读到一个int数
		int y = dis.readInt();
		int z = dis.readInt();
		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
		dis.close();
	}

	private static void demo3() throws FileNotFoundException, IOException {
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("a.txt"));
		dos.writeInt(997);				//可以一次写出四个字节,写出一个int数
		dos.writeInt(998);
		dos.writeInt(999);
		
		dos.close();
	}

	private static void demo2() throws FileNotFoundException, IOException {
		FileInputStream fis = new FileInputStream("a.txt");
		int x = fis.read();
		int y = fis.read();
		int z = fis.read();
		
		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
		fis.close();
	}
	//997 的二进制 00000000 00000000 00000000 11100101
	private static void demo1() throws FileNotFoundException, IOException {
		FileOutputStream fos = new FileOutputStream("a.txt");
		fos.write(997);
		fos.write(998);
		fos.write(999);
		
		fos.close();
	}
}

七.Properties
    1.向内存中存入值,并通过键获取值setProperty(key,value) getProperty(key);
    2.通过load方法,读取配置文件,propertyNames获取所有的key,返回Enumeration
    3.根据键改值,并重新存入到配置文件setProperty(key,value),list(new PrintStream())
    System.getProperties();获取系统属性,propertyNames将所有的键返回到枚举里,就可以迭代了
package cn.itcast.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Properties;

public class Demo9_Properties {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException, IOException {
		//demo1();
		//demo2();
		Properties prop = new Properties();									//创建Properties对象
		prop.load(new FileInputStream("config.txt"));						//通过load方法读config.txt文件上的数据
		prop.setProperty("username", "lisi");								//修改username对应的值
		prop.list(new PrintStream(new FileOutputStream("config.txt")));		//将内容写到config.txt中
	}

	private static void demo2() throws IOException, FileNotFoundException {
		Properties prop = new Properties();
		prop.load(new FileInputStream("config.txt"));
		
		Enumeration<String> en = (Enumeration<String>) prop.propertyNames();
		while(en.hasMoreElements()) {
			String key = en.nextElement();
			System.out.println(key + "=" + prop.getProperty(key));
		}
	}

	private static void demo1() {
		Properties prop = new Properties();
		prop.setProperty("userName", "zhangsan");							//向集合中添加元素
		prop.setProperty("password", "123456");
		prop.setProperty("tel", "18987654321");
		prop.setProperty("qq", "66666");
		
		System.out.println(prop);
	}
}

八.IO总结
    1.字节流
        FileInputStream, FileOutputStream, 自定义数组拷贝文件
        BufferedInputStream, BufferedOutputStream, 内置缓冲区拷贝文件
    2.字符流
        FileReader, FileWriter
        InputStreamReader, OutputStreamWriter
        BufferedReader, BufferedWriter
        会读写各种码表的文件中的文本数据
    3.File
        掌握文件夹递归
        拷贝一个带内容的文件夹
练习 
package cn.itcast.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test1 {

	/**
	 * @param args
	 * 定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("a.txt");				//创建字节输入流对象,关联a.txt
		ByteArrayOutputStream baos = new ByteArrayOutputStream();		//创建内存输出流
		
		byte[] arr = new byte[5];										//定义字节数组
		int len;
		while((len = fis.read(arr)) != -1) {							//将文件上字节数读到内存中
			baos.write(arr, 0, len);									//将字节数组中的字节写到内存输出流中
		}
		System.out.println(new String(baos.toByteArray()));				//将字节数组转换为字符串
		fis.close();
	}

}



----------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ---------------------- 详细请查看：www.itheima.com

gexiaodong1129
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值