IO流
 java.io包
 1.什么是流？
 io流就是java中运输数据的一种载体
 它能够把数据从一个地方运输到另一个地方
 
2.流的分类
 a 根据流运输数据的方向<以内存为参考物>
 输入流
 输出流
 
 b 根据数据传输时转换的类型
           字节流    byte           
           字符流    char  
           
           字符流主要运用于纯文本的传输   
 
3.流的体系
 以上两种流的分类可以互相组合成下面四种
 字节输入流 字节输出流 字符输入流 字符输出流
 
    整个流的体系结构如下
     closeable<可关闭的>(close())          flushable<可刷新的>(flush())
 
inputStream   OutputStream   Reader    Writer
   所有的字节输入流都是 inputStream的子类
   所有的字节输出流都是 OutputStream的子类
   所有的字符输入流都是 Reader的子类
   所有的字符输出流都是 Writer的子类
   以上4个流都实现了closeable接口
   以上2个输出流都实现了flushable接口 
 
4.我们要学习的流<16>
 4个文件流<掌握>
 FileInputStream
 FileOutputStream
 FileReader
 FileWriter
 
FileInputStream fis = new FileInputStream("D:/c.txt");
	byte [] bytes = new byte[1024];
	int temp;
	while((temp=fis.read(bytes))!=-1){
		System.out.print(new String(bytes,0,temp));
	}
	
	fis.close();
 
 
/*
 * 文件输出流如果指向的文件不存在
 * 则会自动创建一个
 */
 FileOutputStream fos = new FileOutputStream(“D:/a.txt”);
 
	String info = "许俊皇是个皇军";
	
	//把数据转成byte数组《String-->数组》
	byte [] bytes = info.getBytes();
	
	//fos.write(bytes);
	fos.write(bytes,0,12);
	
	//刷新  强制写入
	fos.flush();
	
	fos.close();
 
 
public static void main(String[] args) {
 
	FileReader fr=null;
	FileWriter fw=null;
	
	try {
		
		fr=new FileReader("D:\\b.txt");
		fw=new FileWriter("D:\\c.txt");
		
		char [] bytes=new char[100];
		int i;
		while((i=fr.read(bytes))!=-1) {
			
			fw.write(bytes,0,i);
			
		}
		
		fw.flush();
		
	}catch(IOException e){
		
		e.printStackTrace();
		
	}finally {
		
		if(fr!=null) {
			
			try {
				fr.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
		
		if(fw!=null) {
			try {
				fw.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
			
		}
	}
}
 
 
public static void main(String[] args) {
 FileInputStream file1 = null ;
 FileOutputStream file2 = null;
 try {
 
		byte[] bytes = new byte[1024];
		int a;
		while((a=file1.read(bytes))!=-1){
			file2.write(bytes,0,a);
		}
		
		file2.flush();
		
	}catch(IOException e){
		e.printStackTrace();
	}finally {
		if(file1 != null) {
			try {
				file1.close();
			}catch(IOException e){
				e.printStackTrace();
			}
			
		}
		if(file2 != null) {
			try {
				file2.close();
			}catch(IOException e){
				e.printStackTrace();
			}
			
		}
	}
}
 
4个缓冲流<掌握>
 BufferedInputStream
 BufferedOutputStream
 BufferedReader
 BufferedWriter
 
public static void main(String[] args) throws IOException {
	
	FileInputStream fis = new FileInputStream("D:/b.txt");
	
	InputStreamReader  isr = new InputStreamReader(fis);
	
	BufferedReader br = new BufferedReader(isr);
	
	String temp;
	
	while((temp=br.readLine())!=null){
		System.out.println(temp);
	}
	
	br.close();

}
 
 
public static void main(String[] args) throws IOException {

	FileWriter fw = new FileWriter("D:/b.txt");
	
	BufferedWriter bw = new BufferedWriter(fw);
    		
	bw.write("哈哈哈  许俊黄");
	bw.newLine();
	bw.write("哈哈哈  张建兵");
	bw.write("哈哈哈  许俊慌");
	
	bw.flush();		
	bw.close();

}
 
2个转换流<掌握>
 InputStreramReader
 OutputSTreamWriter
 
2个打印流<掌握>
 PrintWriter
 PrintStream
 
2个数据流
 DataInputStream
 DataOutputStream
 
 序列化与反序列化流
 
ObjectInputStream
 ObjectOutputStream
 
java.io.File: 表示文件和文件夹类
 File不是流 不能直接操作文件

 
C++三大IO流类总结——标准IO流、文件IO流、内存IO流 
 
IO流类一览
标准IO流
标准IO流的条件状态
条件状态标志
条件状态函数
     
标准IO流的输入输出成员函数
代码示例
条件状态
put和get函数
getline函数
     
标准IO的格式控制
输出格式控制
缓冲区控制
控制bool类型格式
进制控制
      
其他常用输出格式控制
输入格式控制
    
    
文件输入输出流
字符串输入输出流类
  
 

 
IO流类一览
 
ios:流基类（抽象类）
istream:通用输入流类和其他输入流的基类
ostream:通用输出流类和其他输出类的基类
iostream:通用输入输出流类和其他输入输出流类的基类
ifstream:输入文件流类
ofstream：输出文件流类
fstream:输入输出文件流
istrstream:输入字符串流类
ostrstream:输出字符串流类
strstream:输入输出字符串类
iostream_withassign: 通用输入输出流类和其他输入输出流类iostream的的派生类
 
关系图如下：
 

 
 
标准IO流
 
C++中包含几个预定义的流对象，即标准IO流，它们是标准输入流对象cin、标准输出流对象cout、非缓冲型的标准出错流对象cerr、缓冲型的标准出错流对象clog。
 
cin是istream的派生类istream_withassign的对象，它与标准输入设备(通常是键盘)相联系。
cout是ostream的派生类ostream_withassign的对象，它与标准输出设备(通常是显示器)相联系。
cerr是ostream的派生类ostream_withassign的对象，它与标准错误输入设备(通常是显示器)相联系。
clog是ostream的派生类ostream_withassign的对象，它与标准错误输入设备(通常是显示器)相联系。
 
标准IO流的条件状态
 
C++语言IO类中定义了一些函数和标志，可以用来访问IO流的条件状态。
 
一旦一个流发生错误，对其进行IO操作都无法进行。可以将流作为条件判断，这也是最简单的一种方式，但这样无法知晓 流的具体错误。通过IO类中的条件状态函数，可以知道流操作为什么失败。
 
条件状态标志
 
strm::iostate：条件状态集合
 strm::badbit:指示流是否崩溃
 strm::failbit:表示一个IO操作失败
 strm::eofbit:表示到流遇到结束标志
 strm::goodbit:表示流正常使用
 
条件状态函数
 
对于标准IO流s，有如下成员函数
 s.setstate(flag):将流s状态置为flag，返回void
 s.rdstate():返回流s的当前状态，返回类型为strm::iostate
 s.eof():若eofbit置位则返回true,表示到达流s末尾
 s.fail():若badbit或failbit置位，则返回true
 s.good():若流s处于有效状态，则返回true
 s.clear():清空各个状态位，将流置为有效
 s.clear(flag):复位flag中设置的标志位。可以先使用rdstate()读取到流标志位，进行位操作，作为flag参数传入。
 
标准IO流的输入输出成员函数
 
 
put函数
 put函数用于输出一个字符格式：cout.put(char ch)
 例如：输出A可以采用以下方法：
 cout.put('A'); cout.put(65) ; cout.put(25+40);
 
 
get函数
 get函数的功能与提取运算符>>类似,主要不同之处是get函数在读入数据时可以包括空白字符,而后者不可以。
 
  
get函数用于读入一个字符，调用形式：cin.get()
get函数用于传入一个字符到char型变量，调用形式：cin.get(char ch)
 
 
getline函数
 getline函数用于从输入流读取n-1个字符，赋给指定的字符数组(或字符指针指向的数组)，然后插入一个字符串结束志"\n"。("\n"可以用其他字符代替)遇到’\n‘会提前终止读取字符。
 
getline函数调用格式：
 
  
cin.getline(字符数组,字符个数n,终止标志字符)
cin.getline(字符指针,字符个数n,终止标志字符)
 
 
ignore函数
 ignore函数的功能是跳过输入流的n个字符(默认的个数为1)，或在遇到指定的终止符时 提前结束。
 调用格式：cin.ignore(n,终止字符);cin.ignore();cin.ignore(1,EOF)
 
 
代码示例
 
条件状态
 
#include <iostream>
using namespace std;

int main() {

    cout<<"初始状态:"<<endl;
    //cout<<"failbit: "<<cin.failbit<<endl;
    cout<<"fail(): "<<cin.fail()<<endl;
    //cout<<"badbit: "<<cin.badbit<<endl;
    cout<<"bad(): "<<cin.bad()<<endl;
    //cout<<"eofbit: "<<cin.eofbit<<endl;
    cout<<"eof(): "<<cin.eof()<<endl;
    //cout<<"goodbit: "<<cin.goodbit<<endl;
    cout<<"good(): "<<cin.good()<<endl;

    int i;

    cout<<"在这里我们输入EOF:"<<endl;
    cin>>i;

    cout<<"输入EOF后:"<<endl;
    cout<<"fail(): "<<cin.fail()<<endl;
    cout<<"bad(): "<<cin.bad()<<endl;
    cout<<"eof(): "<<cin.eof()<<endl;
    cout<<"good(): "<<cin.good()<<endl;

    cout<<"先clear(),在这里我们正常输入一个数字:"<<endl;

    cin.clear();
    cin>>i;

    cout<<"正常输入数字后:"<<endl;

    cout<<"fail(): "<<cin.fail()<<endl;
    cout<<"bad(): "<<cin.bad()<<endl;
    cout<<"eof(): "<<cin.eof()<<endl;
    cout<<"good(): "<<cin.good()<<endl;

    cout<<"在这里我们输入一个字符串:"<<endl;
    cin>>i;
    cout<<"输入字符串后:"<<endl;

    cout<<"fail(): "<<cin.fail()<<endl;
    cout<<"bad(): "<<cin.bad()<<endl;
    cout<<"eof(): "<<cin.eof()<<endl;
    cout<<"good(): "<<cin.good()<<endl;
    
    return 0;
}
 
put和get函数
 
#include<iostream>
using namespace std;
int main()
{
 char ch;
 cout<<"Input:";
 while(cin.get(ch))   //读取输入的字符，直到结束为止 
  {
   cout.put(ch);      //输出字符 
  } 
  return 0;
}
/*
程序运行结果是：
 input:123 abc xyz
 123 abc xyz 
*/
 
getline函数
 
#include<iostream>
using namespace std;
int main()
{
 char ch[20];
 cout<<"输入一行字符:"<<endl;
 cin.getline(ch,21,'t');
 cout<<ch<<endl;;
 return 0;
}
/*
程序运行结果是：
输入一行字符:
shdfjsfefrsdfjt
shdfjsfefrsdfj 
*/
 
标准IO的格式控制
 
输出格式控制
 
缓冲区控制
 
<<endl: 输出换行符, 刷新缓冲区
<<ends: 输出空字符, 刷新缓冲区
flush: 刷新缓冲区
 
控制bool类型格式
 
<<boolalpha: 输出true 或者 false
<<noboolalpha: 输出0或1
 
进制控制
 
<<oct: 八进制格式输出
<<dec: 十进制格式输出
<<hex: 十六进制格式输出
<<showbase: 输出指明进制类型, 0代表八进制,0x代表16进制
<<noshowbase: 输出不指明进制类型
 
其他常用输出格式控制
 
cout.precision(int n)或者cout<<prcision(int n): 设置浮点数打印位数为n
<<showwpoint: 总是打印浮点数小数点
<<noshowpoint: 有小数部分才打印小数点
<<setw(int n): 指定打印宽度为n
<<left'或<<right`: 设置左对齐或者右对齐(默认对齐)
<<setfill(char ch): 设定填充字符,默认是空格
 
输入格式控制
 
>>skipws: 输入跳过空白符
>>noskipws: 输入不跳过空白符
 
文件输入输出流
 
根据继承关系可以知道,文件输入输出流继承了iostream流类的所有成员函数,同时多了一些自身特有的成员函数和操作如下:
 
 
文件流的关联
 fin.open(“test.txt”,ios::binary) //从文件读取数据
 fout.open(“test.txt”,ios::binary) //输出到文件,向文件写数据
 fboth.open(“test.txt”,ios::in|ios::out|ios::binary) //读写都可以
 或者
 ifstream fin(“test.txt”,ios::binary) 
 ofstream fout(“test.txt”,ios::binary)
 fstream fboth(“test.txt”,ios::in|ios::out|ios::binary)
 
 
标志位含义:
 ios::in 打开文件做读操作
 ios::out 打开文件做写操作，会删除原有数据
 ios::app 在每次写之前找到文件尾
 ios::trunc 打开文件时清空已存在的文件流
 ios::ate 打开文件后立即定位到文件末尾
 ios::binary 以二进制模式进行IO操作
 ios::nocreate： 不建立文件，所以文件不存在时打开失败
 ios::noreplace：不覆盖文件，所以打开文件时如果文件存在失败
 
 
文件流的关闭: 调用close()成员函数
 
 
字符串输入输出流类
 
字符串流和文件流操作基本一致相同,区别在于:
 
输出时数据不是流向外存文件，而是流向内存中的一个存储空间。输入时从内存中的存储空间读取数据,因此又称内存输入输出流类.
字符串流对象关联的不是文件，而是内存中的一个存储空间，因此不需要打开和关闭文件。

 
目录
 
什么是IO流
IO流的分类
输入输出流
字节字符流
  
  
File类
IO四大家族
常用类
文件流
FileInputStream：文件字节输入流
FileOutputStream：文件字节输出流
FileReader：文件字符输入流
FileWriter：文件字符输出流
代码实现文件的拷贝
   
缓冲流
BufferedInputStream带缓冲的字节输入流
BufferedOutputStream带缓冲的字节输出流
BufferedReader带缓冲的字符输入流
BufferedWriter带缓冲的字符输出流
   
转换流（字节流--->字符流）
InputStreamReader字节输入流-->字符输入流
OutputStreamWriter字节输出流-->字符输出流
   
数据流
DataOutputStream（数据输出字节流）
DataInputStream（数据输入字节流）
   
标准输出流
PrintStream
PrintWriter
   
对象流
ObjectOutputStream对象输出字节流
ObjectInputStream对象输入字节流
  
  
总结

 
什么是IO流
 
 
 
在我们的程序运行当中，不可避免的要与数据打交道，我们应该如何获取这些数据？这就用到IO流了
 IO:Input/Output，输入/输出流
 作用：通过IO流可以完成硬盘文件的读写操作
 
 
IO流的分类
 
 
输入输出流
 
 
输入（Input）：也就是从外部文件中获取数据(即读取外部数据)
 eg：在腾讯视频上看一部电影
 
 输出（Output）：也就是把内存中的文件保存到硬盘上（即把数据写到电脑中）
 eg：保存world文档到C盘
 
 
字节字符流
 
字节流：一看这个名字就知道它是以字节为单位传送数据的，一次传送一个字节byte（即一次传送8个二进制位）
 注意：它是一个万能流，什么数据都可以传输，eg：视频、文本、语音、图片（以Stream结尾的类都是字节流）
 字符流：字符字符，以字符为单位进行数据的传输，一次传输一个字符
 注意：它只能传输普通的文本信息，不能读取非文本信息（以Reader/Writer结尾的类都是字符流）
 挺抽象的，举个例子：
 假设一个temp文件的内容为
 
 在Windows系统中，字母占用1个字节，汉字占用两个字节
 用字节流的方式读取的话，第一次会读取到97（a对应的字节码），第二次读取到98（b对应的字节码），第三次是99（c），第四次会是206（因为’我’对应的字节码为25105，它是两个字节，所以一次会输出一半，也就是一个字节），so第五次会是210…
 
 用字符流的方式读取的话，第一次会读取到’a’,第二次会读取到’b’,第三次是’c’，第四次是’我’，第五次是’爱’（一个汉字也是一个字符）
 
 
File类
 
咱先来说一下这个File类，它也是java.io下的一个类，file是文件的意思，也就是一个文件类，它里面就是包括一下文件的基本方法，文件的基本属性，咱就先来测试一下
 
 
 
先补充一个小知识点：相对路径和绝对路径
 相对路径：相对嘛，肯定就是相对于当前文件来说的，例如你在MyEclipse的一个项目里创建了一个temp文件，那你就可以路径名就可以直接写成temp，这就是相对路径
 绝对路径，绝对嘛，肯定是在哪里都可以用这个路径，这个路径指的就是在电脑硬盘里真正的路径，eg：D:\java_projects\test2\temp就是绝对路径
 
 
File文件其实就是文件和目录路径名的抽象表示形式（原话在JDK帮助文档哈）
 话不多说，看代码（当当当，我想着直接把代码拷过来确实看着很费劲，so，I 换成了photo）哈哈
 
 
IO四大家族
 
 
常用类
 
java为我们提供了很多很多的IO相关的类，下面主要介绍十六种较为常见的类
 
文件流
 
 
 
java.io.FileInputStream：文件字节输入流
 java.io.FileOutputStream：文件字节输出流
 java.io.FileReader：文件字符输入流
 java.io.FileWriter：文件字符输出流
 
 
FileInputStream：文件字节输入流
 
当我们需要从文件中读取一些信息的时候就会用到这个流，直接上代码！！
 
 
 总结：
 FileInputStream是一个万能流，可以读取任意文件的数据，首先要定义一个文件字节输入流对象，把要读取的文件地址传进去，然后调用read()方法来进行字节的读取，read()方法返回的是一个int型的字节码数，当读完数据的时候回返回-1；我们也可以让它一下读取一个bye数组，读取的字节长度是byte[].length个字节，read(byte [])方法返回的是读取了几个字节，读取的字节码存储在byte[]数组中，读完数据压缩会返回-1，读取的时候建议采用循环来读取，最后不要忘记关闭流
 
FileOutputStream：文件字节输出流
 

 
 总结：
 首先创建一个 FileOutputStream字节输出流对象，将写入文件的地址信息传进去，如果文件不存在系统会自动新建，调用write()方法开始写，参数为要写入数据的字节码数，一次只能写一个；也可以一下写一个byte[]数组，调用read(byte[])方法；要写入字符串的时候可以调用getBytes()方法将字符串转化为byte[]数组，输出流最后要记得刷新flush()一下，清空要写入的数据以防止数据丢失，记得还要close()关闭一下。
 
FileReader：文件字符输入流
 

 
 总结：
 FileReader是一个纯文本的输入流，只能进行文本文件的读入，输入时，首先创建一个文件字符输入对象，把要读的文件地址放进去，调用read()方法开始读，它一次读取一个字符，返回的是int型的字符编码，读到最后无数据会返回-1,；也可以一下读取一个char[]数组，读取的长度为char[].length个长度，调用read(char[])开始读，返回的是读取了几个字符，读到最后也是返回-1，可以利用String的一个构造器String(char value[], int offset, int count)来进行char[]与String的转换，最后不要忘记关闭流
 
FileWriter：文件字符输出流
 

 
 总结：
 FileWriter是文件字符输出流，首先创建一个文件字符输出流对象，传入要写入的文件地址，调用write()方法，可以一次一个字符的形式写入，参数为字符码；也调用write(String str, int off, int len)这个方法，传进去一个String字符串；或者一次写一个char[]数组，长度为char[].length个字符，想要换行的时候可以调用write(String str)方法–>即writer("\n")以换行，最后记得刷新flush()+关闭close()
 
代码实现文件的拷贝
 

 总结：
 文件拷贝的思想就是一边读一边写，把读出来的数据放进一个byte[]数组里面，然后再写入到一个文件里面，byte的大小也可以弄个byte[1024*1024]（就是一次传输1M），具体可以根据自己的需求来设定
 
缓冲流
 
 
 
 
当一个流的构造器中需要一个流时，被传进来的这个流叫做节点流
 外部负责包装的这个流称为包装流，又叫处理流
 关闭流的时候只需要关闭包装流就可以了，里面的节点流会自动关闭
 Java缓冲流本身并不具有IO流的读取与写入功能，只是在别的流(节点流或其他处理流)上加上缓冲功能提高效率就像是把别的流包装起来一样，缓冲流是一种处理流(包装流)
 
 
当对文件或者其他数据源进行频繁的读写操作时，效率比较低，这时如果使用缓冲流就能够更高效的读写信息。
 因为缓冲流是先将数据缓存起来，然后当缓存区存满后或者手动刷新时再一次性的读取到程序或写入目的地。
 
BufferedInputStream带缓冲的字节输入流
 
有一个temp文件，内容如下：
 
 
 
 总结：
 BufferedInputStream是一个缓冲字节输入流，其实跟普通的字节输入流的方法差不多，因为它也实现了InputStream接口，有着同样的方法，那为什么会出现这种缓冲流呢，因为普通的输入流它与其他数据源进行频繁的读写操作时，效率较低，使用缓冲流的话就能够更高效的读写信息。
 因为缓冲流是先将数据缓存进缓冲区，然后当缓冲区存满后或者手动刷新时会再一次性的读取到程序或写入目的地，这样就极大的解决了它传输数据的效率问题。
 并且他相比与普通的输入流多了些方法，eg：mark、reset…等等，mark()方法时将在此输入流中标记当前的位置，reset ()方法的后续调用会在最后标记的位置重新定位此流，以便后续读取重新读取相同的字节
 说了这么多，就记着缓冲流比其他效率高就好了
 
BufferedOutputStream带缓冲的字节输出流
 

 
 总结：
 BufferedOutputStream是带缓冲的字节输出流，在我们使用的时候感觉跟普通的输出流差不多，其实他的底层是为我们知道创建了一个缓冲区，我们在想文件中写入数据的时候，数据会被先存放在缓冲区，等缓冲区满的时候，它会将缓冲区的数据一下子传输到输出流中，避免了一个字节一个字节地频繁与底层交互，提高了效率。
 通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统
 
BufferedReader带缓冲的字符输入流
 
存在一个temp文件，内容为：
 
 
 
 总结：
 BufferedReader是带缓存的字符缓存输入流，比普通的输入流多了一个readLine()方法，一下读取一行数据，显然比普通的效率要更快，它还有跟BufferedInputStream一样的mark()标记方法和reset()重置方法，这里就不在测试了。
 
BufferedWriter带缓冲的字符输出流
 

 
 总结：
 BufferedWriter是带缓冲区的字符输出流，写入数据的时候更加的方便，它提供了 write(String str)的方法，可以直接写入一个字符串，还有newLine()方法写入一个换行符，当然也可以用write("\n")，还有write(char cbuf[])方法写入一个char[]数组，底层也是有一个缓冲区来存放将要写入数据，缓冲区的大小也可以在构造器里自己定义，从源码中可以看到，private static int defaultCharBufferSize = 8192;它的么人大小为8192个字符，关闭的时候只需要关闭包装流就可以了，在调用这个方法的时候会把节点流也关闭，刷新flush也是一样，会把缓冲区内的数据给强行输出，缓冲流更高效的完成数据的传输工作
 
转换流（字节流—>字符流）
 
它用于字节流转为字符流，eg：在缓冲流中，一个字节输出流想要用Writer字符流，这就可以用到我们的转换流
 注意：字符流不能转为字节流（万能字节流才可以转换）
 
InputStreamReader字节输入流–>字符输入流
 

 总结：
 InputStreamReader实现了字节输入流（InputStream）向字符输入流（Reader）的转变
 
OutputStreamWriter字节输出流–>字符输出流
 

 总结：
 OutputStreamWriter实现了字节输出流（OutputStream）向字符输出流（Writer）的转变
 
数据流
 
DataOutputStream（数据输出字节流）
 
 
 
数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。
 
 总结：
 1.这个流可以将数据连同数据的类型一并写入文件。
 2.写出来的这个文件不是普通的文本文档（这个文件使用记事本打不开，会出现乱码，因为写入的数据包含数据类型和数据，需要使用它的兄弟DataInputStream来打开）
 
 
DataInputStream（数据输入字节流）
 
 
 
数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
 
 

 
 注意：DataOutputStream写出来的文件只能通过DataInputStream来读，并且读的时候应该提前知道写入的规则读的顺序需要和写的顺序一致，这样才能保证正确取出数据
 
标准输出流
 
PrintStream
 
PrintStream是标准输出流，默认情况下会输出到控制台
 我们平常写的System.out.println()其实就是用了PrintStream类，
 也就等价于：
 PrintStream ps = System.out;
 ps.out();
 
 
 PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError ()方法测试的内部标志。另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println ()方法，或写入一个换行符或字节 (’\n’)。
 
PrintWriter
 

 
 注意：如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作，如果没有，则需要手动flush
 
对象流
 
前边学到的数据流只能实现对基本数据类型和字符串类型的读写，并不能读取对象(字符串除外)，如果要对某个对象进行读写操作，我们需要用到对象专属的流———对象流（对对象进行读写操作）
 
ObjectOutputStream对象输出字节流
 
现在有一个完整的java bean对象Student类，属性有int型的id和String型的name（代码就不补充了）
 
 总结：
 想要传输对象信息的时候，首先创建一个序列化对象（先记住这个名词吧，下次说），通过调用writeObject()方法来写入数据，最后记得强制刷新一下流和关闭。
 另外，另外关于序列化与反序列化就放在下次吧，想不到已经写了万字+了哈哈
 
ObjectInputStream对象输入字节流
 

 总结：
 想要读取对象流信息时，首先要创建一个反序列化对象，通过调用readObject()方法来读取对象信息，该方法返回的是一个Object对象，最后记得关闭流。
 
总结
 
关于IO流呢，首先，咱们说了什么是IO流，IO流的两种分类方法，输入流（Input）和输出流（Output）、字节流（Stream）和字符流（Reader/Writer），然后又说到了File类，了解了它的几个常用的方法，接着有又谈了IO的四大家族（Writer、Reader、InputStream、OutputStream），又说了他们的实现类，就是那几种常用的类：文件流、缓冲流、数据流、对象流、标准输出流，挨个说了他们的常用方法与具体使用。
 终于写完了，竟然写了一万二多字哈哈，那下次见喽
 

 
 
 1. 下面哪个流类属于面向字符的输入流?
 
 
 A. BufferedWriter
 B. FileInputStream
 C. ObjectInputStream
 D. InputStreamReader
 
 
 答案：D
 
 
 解析：Java 的 IO 操作中有面向字节(Byte)和面向字符(Character)两种方式。
 
 
 面向字节的操作为以 8 位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是 InputStream 和 OutputStream 的子类。
 
 
 面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是 Reader 和 Writer 的子类。
 
 
 总结：以 InputStream（输入）/OutputStream（输出）为后缀的是字节流；以Reader（输入）/Writer（输出）为后缀的是字符流。
 
 
 扩展：Java 流类图结构，一目了然，解决大部分选择题：
 
 
 
 
 
 2. 阅读 Shape 和 Circle 两个类的定义。在序列化一个 Circle 的对象 circle 到文件时，下面哪个字段会被保存到文件中？
 
 
class Shape {

       public String name;

}

class Circle extends Shape implements Serializable{

       private float radius;

       transient int color;

       public static String type = "Circle";

}
 
 
 A. name B. radius C. color D. type
 
 
 答案：B
 
 
 解析：这里有详细的解释：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html
 
 
 3. 什么是 Java 序列化，如何实现 Java 序列化？
 
 
 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
 
 
 序列化的实现：将需要被序列化的类实现 Serializable 接口，该接口没有需要实现的方法， implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。