java中输入输出流的知识总结 以及小例子程序

处理流（包在其他管道上的管道）


缓冲流：
BufferedReader(Reader in)
BufferedReader(Reader in,int sz)//sz为自定义缓冲区的大小
BufferedWriter(Writer out)
BufferedInputStream(InputStream in)
BufferedOutputStream(OutputStream out)


public class BufferedCopy{
public static void main(String [] args){
try{
BufferedReader br = new BufferedReader(new FileReader("D;\\a\\a.txt"));
BufferedWriter bw = new BufferedReader(new FileWriter("D:\\a\\a.txt"));
String s= null;
for(int i;i<=100;i++){
s = String.valueOf(Math.random());
bw.write(s);
bw.newLine();


}
bw.flush();
while((s=br.readLine())!=null){
System.out.println((char)s);

}
bw.close();
br.close();
}catch(IOException ioe){
ioe.printStackTrace();
}
}
try{ 
OutputStreamWriter osw = new OutputStreamWriter(
new FileOutputStream(D:\\a.txt));
osw.write("abababababa");
System.out.println(osw.getEncoding);
osw.close();
osw  = new OutputStreamWriter(
new FileOutputStream("D:\\a.txt",true),"ISO08859_1");
//进行续写，不加true，直接覆盖
osw.write("fdfdfdfdsaafdsffdf");
System.out.pritln(osw.getEncoding());
osw.close();
}catch(IOException ioe){
e.printStackTrace();
}


System.in 标准输入流 inputStream
System.out 标准输出流
public class TransForm2{
public static void main(){
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
try{
while(s!=null){
if(s.equalsIgnoreCase("exit"))
break;
System.out.println(s.toUpperCase());
s = br.readLine();
}
br.close();
}catch(IOException){
e.printStackTrace();
}
}
}




数据流：(处理流)
PrintWriter
PrintStream


Public class TestPrintStream{
public static void main(){
PrintStream ps = null;
try{
FileOutputStream fos = new FileOutputStream
("D:\\a\\a.txt");
ps = new PrintStream(fos);
}catch(Exception e){
e.printStackTrace();
}
if(ps!=null){
System.setOut(ps);把向控制台输出改成向文件内部输出
}
int ln =0;
for(char c =0;c<60000;c++){
System.out.print(c+" "); //内容打印在a.txt内部
if(ln++>100){
System.out.println();
ln = 0;
}
}

}
}






printStream 包含着 FileOutputStream 关联着a.txt
当System调用setOut（ps），就不再向默认的控制台打印，而是指向了
printStream，因此 System.out.println时候就向着a.txt内部打印。




System.out是一种PrintStream
public class TestPrintStream{
public static void main(){
String filename = args[0];
if(filename!=null){
list(filename,System.out)
} 
}

public static void list(String filename, PrintStream ps){
try{
BufferedReader br =new BufferedReader(new FileReader(filename));
String s = null;
while((s=br.readLine())!=null){ //readLine是否到达文件尾部比较的是null
//BufferedReader 的readLine()一次读一行，返回字符串
//read是否到达文件尾部比较的是-1
//FileReader的read()一次读2个字节


ps.println(s);
}
br.close();
}catch(Exception e){
e.printStackTrace();
}
}
}








PrintStream 为其他输出流添加了功能，使它们能够方便地打印各种数据值表示形式。它还提供其他两项功能。与其他输出流不同，PrintStream 永远不会抛出 IOException；而是，异常情况仅设置可通过 checkError 方法测试的内部标志。另外，为了自动刷新，可以创建一个 PrintStream；这意味着可在写入 byte 数组之后自动调用 flush 方法，可调用其中一个 println 方法，或写入一个换行符或字节 ('\n')。


PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。


public class TestPrintStream3{
public static void main(){
String s =null;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try{
FileWriter fw = new FileWriter("d:/a.txt");
PrintWriter log = new PrintWriter(fw);
while((s=br.readLine())!=null){
if(s.equalsIgnoreCase("exit")){
break;
}
System.out.println(s.toUpperCase());
log.println(s.toUpperCase());
}
log.println(new Date());
log.flush();
log.close();
}catch(Exception e){
e.printStackTrace();
}
}


}


抽象类
Reader
Writer
InputStream
OutputStream


初始流
FileReader
FileWriter
FileInputStream
FileOutputStream


处理流
InputStreamReader 将字节流转换成字符流  中文是两个字节，单个字节输出显示？？
OutputStreamWritere 将字符流转换成字节流
处理流（包裹在初始流之上）
BufferedReader
BufferedWriter
BufferedOutputStream
BufferedInputStream
PrintWriter PrintStream都属于输出流，分别针对字符，字节，都属于处理流
提供了重载的print println（）用于多种类型数据的输出
println()用于多种数据类型的输出
PrintWriter和PrintStream 不会抛出异常，用户通过检测错误状态获取错误信息。
PrintWriter PrintStream具有自动flush功能


Serializable接口 ，没有方法，可以被序列化。标记的接口


某个对象需要被序列化，必须实现Serializable接口


处理流 ObjectInputStream 读一个对象
ObjectOutputStream 写一个对象（该对象应该实现系列化）
public class TestObjectIo {
public static void main(String [] args){
T t = new T();
FileOutputStream  fos = new FileOutputStream("D:\\a.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(t);
oos.flush();
oos.close();


FileInputStream fis = new FileInputStream("D:\\a.txt");
ObjectInputStream ois = new ObjectInputStream(fis);
T t = (T)ois.readObject();
System.out.println(t.i);
System.out.println(t.j);
System.out.println(t.k);
}
}


class T implements Serailizable{ //该对象应该实现序列化
int i =1;
double j =2.0;
transient int k = 5; //透明的
}






externalizable接口 //外部化（Serializable子接口）
readExternal(ObjectInput in)
writeExternal(ObjectOutput out)


InputStreamReader/OutputStreamWriter转换流
把字节转换成字符，没有把字符转换成字节的流。