IO流大总结

时间 2020-04-23

标签总结繁體版

原文原文链接

- - - - - - - - - - - - - - - 写在前面 - - - - - - - - - - - - - - - java

1.概念
- IO流用来处理设备之间的数据传输
- Java对数据的操做是经过流的方式
- Java用于操做流的类都在IO包中
- 流按流向分为两种：输入流，输出流
- 流按操做类型分为两种：
  - 字节流 : 字节流能够操做任何数据，由于在计算机中任何数据都是以字节的形式存储的
  - 字符流 : 字符流只能操做纯字符数据，比较方便
2.IO流经常使用父类
- 字节流的抽象父类：
  - InputStream
  - OutputStream
- 字符流的抽象父类：
  - Reader
  - Writer
3.IO程序书写
- 使用前，导入IO包中的类
- 使用时，进行IO异常处理
- 使用后，释放资源

- - - - - - - - - - - - - - - windows

目&emsp;录设计模式

- - - - - - - - - - - - - - - 数组

1.read()一次读取一个字节dom

2.read()方法返回值为何是intide

3.定义小数组实现缓冲优化

4.实现了缓冲区的BufferedInputStream和BufferOutputStreamui

5.flush方法和close方法this

6. 字节流读写中文

7.流的标准处理异常代码1.6版本及其之前

8.流的标准处理异常代码1.7版本以后

9.拷贝文件

10.录入数据拷贝到文件

11.字符流 FileReader

12.字符流 FileWriter

13.字符流的拷贝

14.什么状况下使用字符流

15.字符流是否能够拷贝非纯文本的文件

16.自定义字符数组的拷贝

17.带缓冲的字符流

18.readLine()和newLine()方法

19.LineNumberReader

25.定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

26.对象操做流ObjecOutputStream

27.对象操做流ObjectInputStream

28.对象操做流优化

29.id号

30.打印流的概述和特色

31.标准输入输出流概述和输出语句

36.Properties的概述和做为Map集合的使用

37.获取Properties中的每个键

38.Properties的load()和store()功能

39.ZIP文档

- - - - - - - - - - - - - - -

read()一次读取一个字节

FileInputStream fis = new FileInputStream("乌合之众.txt");	
	//建立一个文件输入流对象，并关联乌合之众.txt
	int b;													
	//定义变量，记录每次读到的字节
	while((b = fis.read()) != -1) {							
	//将每次读到的字节赋值给b并判断是不是-1
		System.out.println(b);								
		//打印每个字节
	}
	
	fis.close();											
//关闭流释放资源

read()方法返回值为何是int

read()方法读取的是一个字节，为何返回是int，而不是byte
由于字节输入流能够操做任意类型的文件，好比图片音频等，这些都是以二进制形式的存储的，若是每次读取都返回byte，有可能在读到中间的时候遇到11111111，那么这11111111是byte类型的-1，程序是遇到-1就会中止，后面的数据就读不到了。因此在读取的时候用int类型接收，会在其前面补上24个0凑足4个字节，那么byte类型的-1就变成int类型的255了这样能够保证整个数据读完，而结束标记的-1就是int类型。

定义小数组实现缓冲

write(byte[] b)
write(byte[] b， int off， int len)写出有效的字节个数
定义小数组的标准格式

FileInputStream fis = new FileInputStream("李志 - 梵高先生.flac");
		FileOutputStream fos = new FileOutputStream("梵高先生.flac");
		int len;
		byte arr[] = new byte[8*1024];
		//自定义字节数组
		while((len=fis.read(arr))!=-1){
			fos.write(arr， 0， len);
			//写出字节数组写出有效个字节个数
		}
		fis.close();
		fos.close();

实现了缓冲区的BufferedInputStream和BufferOutputStream

BufferedInputStream
- BufferedInputStream内置了一个缓冲区(数组)
- 从BufferedInputStream中读取一个字节时，BufferedInputStream会一次性从文件中读取8192个，存在缓冲区中，而后返回给程序一个字符。
- 程序再次读取时，就不用找文件了，直接从缓冲区中获取。
- 直到缓冲区中全部的都被使用过，才从新从文件中读取8192个
BufferedOutputStream
- BufferedOutputStream也内置了一个缓冲区(数组)
- 程序向流中写出字节时，不会直接写到文件，先写到缓冲区中，
- 直到缓冲区写满， BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。
组合流过滤器实现拷贝

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("李志 - 梵高先生.flac"));
		//建立缓冲区对FileInputStream对象的装饰
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2004-梵高先生.flac"));
		//建立缓冲区对FileOutputStream对象的装饰
int b;
while((b = bis.read()) != -1) {		
	bos.write(b);
}
		
bis.close();//只关装饰后的对象便可
bos.close();

小数组的读写和带Buffered的读取哪一个更快?
- 定义小数组若是是8192个字节大小和Buffered比较的话，定义小数组会略胜一筹，由于读和写操做的是同一个数组，而Buffered操做的是两个数组.

flush方法和close方法

flush()方法
- 用来刷新缓冲区的，刷新后能够再次写出
close()方法
- 用来关闭流释放资源的的，若是是带缓冲区的流对象的close()方法，不但会关闭流，还会再关闭流以前刷新缓冲区，关闭后不能再写出

字节流读写中文

字节流读取中文的问题
- 字节流在读中文的时候有可能会读到半个中文，形成乱码
字节流写出中文的问题
- 字节流直接操做的字节，因此写出中文必须将字符串转换成字节数组
- 写出回车换行 write("\r\n".getBytes());

## ~~**流的标准处理异常代码1.6版本及其之前**~~

try finally嵌套

FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("from.txt");
			fos = new FileOutputStream("to.txt");
			int b;
			while((b = fis.read()) != -1) {
				fos.write(b);
			}
		} finally {
			try {
				if(fis != null)
					fis.close();
			}finally {
				if(fos != null)
					fos.close();
			}
		}

流的标准处理异常代码1.7版本以后

try close

try(
	FileInputStream fis = new FileInputStream("from.txt");
	FileOutputStream fos = new FileOutputStream("to.txt");
){
	int b;
	
	while((b = fis.read()) != -1) {
		fos.write(b);
	}
	
}

在try()中建立的流对象必须实现了AutoCloseable这个接口，若是实现了，在try后面的{. . .}执行后就会自动调用流对象的close方法将流关掉.

拷贝文件

在控制台录入文件的路径，将文件拷贝到当前项目下

Scanner sc = new Scanner(System.in);
System.out.println("请输入一个文件路径");
String line = sc.nextLine();				//将键盘录入的文件路径存储在line中
File file = new File(line);					//封装成File对象
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(file.getName());

int len;
byte[] arr = new byte[8192];				//定义缓冲区
while((len = fis.read(arr)) != -1) {
	fos.write(arr，0，len);
}

fis.close();
fos.close();

## **录入数据拷贝到文件**

将键盘录入的数据拷贝到当前项目下的text.txt文件中，键盘录入数据当遇到quit时就退出

Scanner sc = new Scanner(System.in);
FileOutputStream fos = new FileOutputStream("text.txt");
System.out.println("请输入:");
while(true) {
	String line = sc.nextLine();
	if("quit".equals(line))
		break;
	fos.write(line.getBytes());
	fos.write("\r\n".getBytes());
}

fos.close();

## **字符流 FileReader**

字符流是什么
- 字符流是能够直接读写字符的IO流
- 字符流读取字符，就要先读取到字节数据，而后转为字符. 若是要写出字符，须要把字符转为字节再写出.
FileReader
- FileReader类的read()方法能够按照字符大小读取

FileReader fr = new FileReader("from.txt"); 
 //建立输入流对象，关联from.txt 
 int ch; 
 while((ch = fr.read()) != -1) { 
 //将读到的字符赋值给ch 
 System.out.println((char)ch); 
 //将读到的字符强转后打印 
 }

 fr.close();
 //关流

## **字符流 FileWriter**

FileWriter类的write()方法能够自动把字符转为字节写出

FileWriter fw = new FileWriter("to.txt");
fw.write("write");
fw.close();

## **字符流的拷贝**

FileReader fr = new FileReader("from.txt");
FileWriter fw = new FileWriter("to.txt");

int ch;
while((ch = fr.read()) != -1) {
    fw.write(ch);
}

fr.close();
fw.close();

什么状况下使用字符流

字符流也能够拷贝文本文件，但不推荐使用。由于读取时会把字节转为字符，写出时还要把字符转回字节。
程序须要读取一段文本，或者须要写出一段文本的时候可使用字符流。读取的时候是按照字符的大小读取的，不会出现读取半个中文，形成乱码的状况。写出的时候能够直接将字符串写出，不用转换为字节数组。

字符流是否能够拷贝非纯文本的文件

不能够拷贝非纯文本的文件
- 由于在读的时候会将字节转换为字符，在转换过程当中，可能找不到对应的字符，就会用"?"代替，写出的时候会将"?"字符转换成字节写出去。如此这般，写出以后的文件就错乱了。

自定义字符数组的拷贝

FileReader fr = new FileReader("form.txt");          
//建立字符输入流，关联aaa.txt
FileWriter fw = new FileWriter("to.txt");          
//建立字符输出流，关联bbb.txt

int len;
char[] arr = new char[1024*8];                      
//建立字符数组
while((len = fr.read(arr)) != -1) {                 
//将数据读到字符数组中
    fw.write(arr， 0， len);                          
    //从字符数组将数据写到文件上
}

fr.close();
//关流释放资源
fw.close();

## **带缓冲的字符流**

BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区，而后逐个返回给程序，减小读取次数，以期提升效率。
BufferedWriter的write()方法写出字符时会先写到缓冲区，缓冲区写满时才会写到文件，减小写入次数，以期提升效率。

BufferedReader br = new BufferedReader(new FileReader("form.txt")); 
//建立字符输入流对象，关联aaa.txt 
BufferedWriter bw = new BufferedWriter(new FileWriter("to.txt")); 
//建立字符输出流对象，关联bbb.txt

int ch;             
while((ch = br.read()) != -1) {
//read一次，会先将缓冲区读满，从缓冲去中一个一个的返给临时变量ch
	bw.write(ch);
	//write一次，是将数据装到字符数组，装满后再一块儿写出去
}
    
br.close(); 
//关流
bw.close();

readLine()和newLine()方法

BufferedReader的readLine()方法能够读取一行字符(不包含换行符号)
BufferedWriter的newLine()能够输出一个跨平台的换行符号"\r\n"

BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
String line; 
while((line = br.readLine()) != null) {
   bw.write(line); 
   //bw.write(""); //只支持windows系统 
   bw.newLine(); //跨平台的 
}

br.close();
bw.close();

LineNumberReader

LineNumberReader是BufferedReader的子类，具备相同的功能，而且能够统计行号
- 调用getLineNumber()方法能够获取当前行号
- 调用setLineNumber()方法能够设置当前行号

LineNumberReader lnr = new LineNumberReader(new FileReader("form.txt")); 
String line; 
lnr.setLineNumber(100); //设置行号 
while((line = lnr.readLine()) != null) {
	System.out.println(lnr.getLineNumber() + ":" + line);//获取行号 
}

lnr.close();

装饰设计模式

interface Coder {
	public void code(); 
 }

class Persion implements Coder {
    
        @Override
        public void code() {
            System.out.println("It's none of my business during the daytime");
            System.out.println("Write java at night");
        }
        
    }

class XPersion implements Coder {
        private Persion s;                      
        //被包装的类的引用
        public XPersion (Persion s) {       
        //构造方法将被包装的对象做为参数传入
            this.s = s;
        }
        @Override
        public void code() {
        //对其原有功能进行升级
            s.code();
            System.out.println("Get cervical spondum buff");
            System.out.println("......");
            System.out.println("sudden death");
            System.out.println("......");
        }
        
    }

使用指定的码表读写字符

FileReader是使用默认码表读取文件，若是须要使用指定码表读取，那么可使用InputStreamReader(字节流，编码表)
FileWriter是使用默认码表写出文件，若是须要使用指定码表写出，那么可使用OutputStreamWriter(字节流，编码表)

BufferedReader br =  new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt")， "UTF-8"));
BufferedWriter bw =  new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt")， "GBK")); 
int ch; 
while((ch = br.read()) != -1) { 
	bw.write(ch); 
}

br.close();
bw.close();

序列流

1.什么是序列流
- 序列流能够把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个以后继续读第二个, 以此类推.
2.使用方式
- 整合两个: SequenceInputStream(InputStream, InputStream)

FileInputStream fis1 = new FileInputStream("a.txt");			
//建立输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");			
//建立输入流对象,关联b.txt
SequenceInputStream sis = new SequenceInputStream(fis1, fis2);	
//将两个流整合成一个流
FileOutputStream fos = new FileOutputStream("c.txt");			
//建立输出流对象,关联c.txt
		
int b;
while((b = sis.read()) != -1) {									
//用整合后的输入流
	fos.write(b);												
	//写到指定文件上
}
		
sis.close();
fos.close();

序列流整合多个

整合多个: SequenceInputStream(Enumeration)

FileInputStream fis1 = new FileInputStream("a.txt");	
//建立输入流对象,关联a.txt
FileInputStream fis2 = new FileInputStream("b.txt");	
//建立输入流对象,关联b.txt
FileInputStream fis3 = new FileInputStream("c.txt");	
//建立输入流对象,关联c.txt
Vector<InputStream> v = new Vector<>();					
//建立vector集合对象
v.add(fis1);											
//将流对象添加
v.add(fis2);
v.add(fis3);
Enumeration<InputStream> en = v.elements();				
//获取枚举引用
SequenceInputStream sis = new SequenceInputStream(en);	
//en传递给SequenceInputStream的构造方法
FileOutputStream fos = new FileOutputStream("d.txt");
int b;
while((b = sis.read()) != -1) {
	fos.write(b);
}
	
sis.close();
fos.close();

内存输出流

1.什么是内存输出流
- 该输出流能够向内存中写数据, 把内存看成一个缓冲区, 写出以后能够一次性获取全部数据
2.使用方式
- 建立对象: new ByteArrayOutputStream()
- 写出数据: write(int), write(byte[])
- 获取数据: toByteArray()

FileInputStream fis = new FileInputStream("a.txt");
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int b;
while((b = fis.read()) != -1) {
	baos.write(b);
}
			
//byte[] newArr = baos.toByteArray();				
//将内存缓冲区中全部的字节存储在newArr中
//System.out.println(new String(newArr));
System.out.println(baos);
fis.close();

定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)

FileInputStream fis = new FileInputStream("a.txt");				
//建立字节输入流,关联a.txt
ByteArrayOutputStream baos = new ByteArrayOutputStream();		
//建立内存输出流
byte[] arr = new byte[5];										
//建立字节数组,大小为5
int len;
while((len = fis.read(arr)) != -1) {							
//将文件上的数据读到字节数组中
	baos.write(arr, 0, len);									
	//将字节数组的数据写到内存缓冲区中
}
System.out.println(baos);										
//将内存缓冲区的内容转换为字符串打印
fis.close();

对象操做流ObjecOutputStream

1.什么是对象操做流
- 该流能够将一个对象写出, 或者读取一个对象到程序中. 也就是序列化和反序列化的操做.
2.使用方式
- 写出: new ObjectOutputStream(OutputStream)，writeObject()

public class ObjectOutputStream {

	/**
	 * @param args
	 * @throws IOException 
	 * 将对象写出,序列化
	 */
	 
	public static void main(String[] args) throws IOException {
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//建立对象输出流
		oos.writeObject(p1);
		oos.writeObject(p2);
		oos.close();
	}

}

对象操做流ObjectInputStream

读取: new ObjectInputStream(InputStream), readObject()

public class ObjectInputStream {

		/**
		 * @param args
		 * @throws IOException 
		 * @throws ClassNotFoundException 
		 * @throws FileNotFoundException 
		 * 读取对象,反序列化
		 */
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
		Person p1 = (Person) ois.readObject();
		Person p2 = (Person) ois.readObject();
		System.out.println(p1);
		System.out.println(p2);
		ois.close();
		}			
}

对象操做流优化

将对象存储在集合中写出

Person p1 = new Person("Tom", 20);
Person p2 = new Person("Jerry", 22);
Person p3 = new Person("Jack", 10);
Person p4 = new Person("Herry", 20);

ArrayList<Person> list = new ArrayList<>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
oos.writeObject(list);									
//写出集合对象

oos.close();

读取到的是一个集合对象

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
ArrayList<Person> list = (ArrayList<Person>)ois.readObject();	
//泛型在运行期会被擦除,索引运行期至关于没有泛型
//想去掉黄色能够加注解@SuppressWarnings("unchecked")
for (Person person : list) {
	System.out.println(person);
}
		
ois.close();

id号

要写出的对象必须实现Serializable接口才能被序列化
不用必须加id号

打印流的概述和特色

1.什么是打印流
- 该流能够很方便的将对象的toString()结果输出, 而且自动加上换行, 并且可使用自动刷出的模式
- System.out就是一个PrintStream, 其默认向控制台输出信息

PrintStream ps = System.out;
ps.println(97);					
//底层用的是Integer.toString(x),将x转换为数字字符串打印
ps.println("a string");
ps.println(new Person("Tom", 20));
Person p = null;
ps.println(p);					//若是是null,就返回null,若是不是null,就调用对象的toString()

2.使用方式
- 打印: print(), println()
- 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)

PrintWriter pw = new PrintWriter(new FileOutputStream("g.txt"), true);
//若是为 true，则 println、printf 或 format 方法将刷新输出缓冲区
pw.write(97);
pw.print("Hello");
pw.println("你好");

pw.close();

标准输入输出流概述和输出语句

1.什么是标准输入输出流
- System.in是InputStream, 标准输入流, 默承认以从键盘输入读取字节数据
- System.out是PrintStream, 标准输出流, 默承认以向Console中输出字符和字节数据
2.修改标准输入输出流
- 修改输入流: System.setIn(InputStream)
- 修改输出流: System.setOut(PrintStream)

System.setIn(new FileInputStream("a.txt"));				
//修改标准输入流
System.setOut(new PrintStream("b.txt"));				
//修改标准输出流

InputStream in = System.in;								
//获取标准输入流
PrintStream ps = System.out;							
//获取标准输出流
int b;
while((b = in.read()) != -1) {							
//从a.txt上读取字节
	ps.write(b);										
	//将数据写到b.txt上
}

in.close();
ps.close();

修改标准输入输出流拷贝图片

System.setIn(new FileInputStream("png.png"));		
//改变标准输入流
System.setOut(new PrintStream("copy.png")); 		
//改变标准输出流

InputStream is = System.in;							
//获取标准输入流
PrintStream ps = System.out;						
//获取标准输出流

int len;
byte[] arr = new byte[1024 * 8];

while((len = is.read(arr)) != -1) {
	ps.write(arr, 0, len);
}

is.close();
ps.close();

两种方式实现键盘录入

A:BufferedReader的readLine方法。
- BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
B:Scanner

随机访问流概述和读写数据

A:随机访问流概述
- RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
- 支持对随机访问文件的读取和写入。
B:read(),write(),seek()

数据输入输出流

1.什么是数据输入输出流
- DataInputStream, DataOutputStream能够按照基本数据类型大小读写数据
- 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也能够按照Long类型读取, 一次读取8个字节.
2.使用方式
- DataOutputStream(OutputStream), writeInt(), writeLong()
- DataInputStream(InputStream), readInt(), readLong()

DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
dos.writeInt(998);
dos.writeInt(1998);
dos.writeInt(2998);

dos.close();

DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
int x = dis.readInt();
int y = dis.readInt();
int z = dis.readInt();
System.out.println(x);
System.out.println(y);
System.out.println(z);
dis.close();

Properties的概述和做为Map集合的使用

A:Properties的概述
- Properties 类表示了一个持久的属性集。
- Properties 可保存在流中或从流中加载。
- 属性列表中每一个键及其对应值都是一个字符串。

Properties prop = new Properties();
prop.put("abc", 123);
System.out.println(prop);

获取Properties中的每个键

A:Properties的特殊功能
- public Object setProperty(String key,String value)
- public String getProperty(String key)
- public Enumeration<String> stringPropertyNames()

Properties prop = new Properties();
prop.setProperty("name", "Tom");
prop.setProperty("tel", "18000000000");

//System.out.println(prop);
Enumeration<String> en = (Enumeration<String>) prop.propertyNames();
while(en.hasMoreElements()) {
	String key = en.nextElement();				//获取Properties中的每个键
	String value = prop.getProperty(key);		//根据键获取值
	System.out.println(key + "="+ value);
}

Properties的load()和store()功能

Properties prop = new Properties();
prop.load(new FileInputStream("config.properties"));		
//将文件上的键值对读取到集合中
prop.setProperty("tel", "18912345678");
prop.store(new FileOutputStream("config.properties"), null);
//第二个参数是对列表参数的描述,能够给值,也能够给null
System.out.println(prop);

Output:
{tel=18912345678}

ZIP文档

private static void zipdemo1() throws IOException {
	try (
		ZipInputStream zin = new ZipInputStream(new FileInputStream("code.zip"));
		ByteArrayOutputStream baos = new ByteArrayOutputStream();//内存输入流
		) {
			
		ZipEntry entry;
		int len;
		byte arr[] = new byte[1024];
			
		while ((entry = zin.getNextEntry()) != null) {
				
			String name = entry.getName();//压缩项目的文件名
			System.out.println("文件"+name+"\n解压后大小："+entry.getSize());
			while ((len = zin.read(arr)) != -1) {//读取数据内容
				baos.write(arr, 0, len);//内容写入内存输入流
			}
				
			System.out.println("缓冲区大小："+baos.size());
			System.out.println(baos);
			baos.reset();//将此 byte 数组输出流的 count 字段重置为零，从而丢弃输出流中目前已累积的全部输出
			zin.closeEntry();
				
		}
	}
}

Output:

文件code.txt
解压后大小：29
缓冲区大小：29
AW9C2-JN9T2-H5CBV-24QT7-G4YB8
文件code1.txt
解压后大小：39
缓冲区大小：39
激活码：W9WW6-JN9W2-M8CTX-24QR7-M4HB8

——@guoyangde http://www.cnblogs.com/LittleTreasureBox/p/8904016.html

IO流大总结

<font color="#FF6600" size="4">read()一次读取一个字节</font>

<font color="#FF6600" size="4">read()方法返回值为何是int</font>

<font color="#FF6600" size="4">定义小数组实现缓冲</font>

<font color="#FF6600" size="4">实现了缓冲区的BufferedInputStream和BufferOutputStream</font>

<font color="#FF6600" size="4">flush方法和close方法</font>

<font color="#FF6600" size="4">字节流读写中文</font>

<font color="#FF6600" size="4">流的标准处理异常代码1.7版本以后</font>

<font color="#FF6600" size="4">拷贝文件</font>

<font color="#FF6600" size="4">什么状况下使用字符流</font>

<font color="#FF6600" size="4">字符流是否能够拷贝非纯文本的文件</font>

<font color="#FF6600" size="4">自定义字符数组的拷贝</font>

<font color="#FF6600" size="4">readLine()和newLine()方法</font>

<font color="#FF6600" size="4">LineNumberReader</font>

<font color="#FF6600" size="4">装饰设计模式</font>

<font color="#FF6600" size="4">使用指定的码表读写字符</font>

<font color="#FF6600" size="4">序列流</font>

<font color="#FF6600" size="4">序列流整合多个</font>

<font color="#FF6600" size="4">内存输出流</font>

<font color="#FF6600" size="4">定义一个文件输入流,调用read(byte[] b)方法,将a.txt文件中的内容打印出来(byte数组大小限制为5)</font>

<font color="#FF6600" size="4">对象操做流ObjecOutputStream</font>

<font color="#FF6600" size="4">对象操做流ObjectInputStream</font>

<font color="#FF6600" size="4">对象操做流优化</font>

<font color="#FF6600" size="4">id号</font>

<font color="#FF6600" size="4">打印流的概述和特色</font>

<font color="#FF6600" size="4">标准输入输出流概述和输出语句</font>

<font color="#FF6600" size="4">修改标准输入输出流拷贝图片</font>

<font color="#FF6600" size="4">两种方式实现键盘录入</font>

<font color="#FF6600" size="4">随机访问流概述和读写数据</font>

<font color="#FF6600" size="4">数据输入输出流</font>

<font color="#FF6600" size="4">Properties的概述和做为Map集合的使用</font>

<font color="#FF6600" size="4">获取Properties中的每个键</font>

<font color="#FF6600" size="4">Properties的load()和store()功能</font>

<font color="#FF6600" size="4">ZIP文档</font>