IO流的常识

字符流
Writer 写 FileWriter
Reader 读 FileReader 
BufferedReader 读缓冲
BufferedWriter 写缓冲

演示字符流

import java.io.*;
class  iol
{
public static void main(String[] args) throws IOException
{
diaoyong();
}
public static void diaoyong()throws IOException
{
Reader re=new FileReader("d:\\123.txt"); 
BufferedReader buffr=new BufferedReader(re);//将数据读到缓冲区中 
//缓冲区中就是多了一次读一行
Writer wr=new FileWriter("d:\\gaga.txt");//一创建对象就在硬盘上创建了一个文件
//如果已有会覆盖的
BufferedWriter buffw=new BufferedWriter(wr);//缓冲区中多了换行功能
String str=null;
while ((str=buffr.readLine())!=null)
{
buffw.write(str);
buffw.newLine();
buffw.flush() ;
}
buffr.close();//关掉资源
buffw.close();//关掉资源
}
}

Writer 继承OutputStreamWriter 写桥梁   将字节转变成字符 编码表UTF-8 默认的是GBK
Reader 继承InputStreamReader  读桥梁


注：字符流使用字符数组  字节流使用字节数组


字节流 
OutputStream 写 FileOutputStream
InputStream  读 FileInputStream
BufferedOutputStream 写缓冲
BufferedInputStream  读缓冲




源： “读”输入流 Reader  InputStream
目的 “写”输出流 Writer  OutputStream

log4j

//演示上面的方法

import java.io.*;
class  iol
{
public static void main(String[] args) throws IOException
{
diaoyong();
}
public static void diaoyong()throws IOException
{
BufferedReader buffr=null;
buffr=new BufferedReader(new InputStreamReader(new FileInputStream("d:\\123.txt"),"utf-8"));//指定了编码
BufferedWriter buff=null;
buff=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("d:\\gg.txt"),"utf-8"));//指定了编码
String str=null;
while ((str=buffr.readLine())!=null)//一次读一行
{
buff.write(str);
buff.newLine();//换行 
buff.flush();//刷新
}
buffr.close();//关闭资源
buff.close();
}
}

PrintStream 字节打印流  
构造函数可以接收的参数类型有
1.file对象
2.字符串路径String
3.字节输出流 OutputStream


PrintWriter 字符打印流
构造函数可以接收的参数类型有
1.file对象
2.字符串路径String
3.字节输出流 OutputStream
4.字符输出流 Writer

演示PrintWriter从键盘录入数据存到硬盘上 , PrintStream 跟PrintWriter功能差不多  不过PrintWriter可以输出字符流

import java.io.*;
class  ii
{
public static void main(String[] args) throws IOException
{
BufferedReader xx=new BufferedReader(new InputStreamReader(System.in));
//PrintWriter x=new PrintWriter(System.out);
//PrintWriter x=new PrintWriter(new FileWriter("d:\\xx11.txt"),true);
PrintWriter x=new PrintWriter(System.out,true);//PrintWriter 带有刷新功能
String hh=null;
while ((hh=xx.readLine())!=null)//一次读一行
{
if(hh.equals("voer"))
break;
x.println(hh);
//x.flush();
}
xx.close();
}
}

SequenceInputStream

对多个流进行合并

代码演示：

import java.io.*;
import java.util.*;
class cccc 
{
public static void main(String[] args) throws IOException
{
Vector<FileInputStream>v=new Vector<FileInputStream>();//利用集合添加于硬盘文件关联的对象
v.add(new FileInputStream("d:\\1.txt"));//将多个文件封住成对象添加到Vector
v.add(new FileInputStream("d:\\2.txt"));
v.add(new FileInputStream("d:\\3.txt"));
Enumeration<FileInputStream>e=v.elements();
SequenceInputStream sis=new  SequenceInputStream(e);//将多个FileInputStream相关联的文件都装一起

FileOutputStream FOS=new FileOutputStream("d:\\4.txt");//将多个文件都装在一个文件上
byte[]a=new byte[1024];
int aa;
while((aa=sis.read(a))!=-1)
{
FOS.write(a,0,aa);
System.out.println(aa);
}
sis.close();  //关闭流
FOS.close();//关闭流
}
}

//管道流就类似于两条通道  这边进那边出    这边写那边读

//这里使用到了多线程  那么就是不管谁抢到cpu执行权当读的抢到cpu执行权那么他就会阻塞在哪里  直到另一边有数据它才会去读

//read类似于阻塞  

import java.io.*;
class a implements Runnable
{
PipedInputStream p;
a(PipedInputStream p)
{
this.p=p;
}
public void run()
{
try
{
System.out.println("PipedInputStream 抢到");
byte [] by=new byte[1024];
int a=0;
a=p.read(by);                                         //读  没有数据就等
System.out.println(new String(by,0,a));
p.close();
}
catch (IOException a)
{
System.out.println("读取失败");
}
}
}
class b implements Runnable
{
PipedOutputStream p;
b(PipedOutputStream p)
{
this.p=p;
}
public void run()
{
try
{
System.out.println("PipedOutStream 抢到");
p.write("nihaoa ".getBytes());
p.close();


}
catch (IOException o)
{
System.out.println("写入失败");
}
}
}
class gdl 
{
public static void main(String[] args) throws IOException
{
PipedInputStream p=new PipedInputStream();//创建读取管道流
PipedOutputStream po=new PipedOutputStream();//创建写入管道流
p.connect(po);
a aa=new a(p);
b bb=new b(po);
new Thread(aa).start();
new Thread(bb).start();

}
}