Java IO流常用类

一、FileInputStream和FileOutputStream（字节流）
1、java.io.FileInputStream:
①文件字节输入流，任何类型的文件都可以用这个流来读，万能的
②以字节的方式完成输入（硬盘--->内存）
③创建文件字节输入流：(filename是绝对路径或者相对路径都行)(关闭流的前提是流不是空)
FileInputStream fis=null;
try:{
fis=new FileInputStream("filename");
//开始读
while(true){
int readData=fis.read();//指针向后移一下，以字节为单位读取，并返回其ASCCI码。当没有字节可读时，返回-1
if(readData!=-1){
break;
}
}

//开始读
int readData=0;
while((readData=fis.read())!=-1){
System.out.println(readData);
}

//开始读
byte[]bytes=new byte[4];
while(true){
int readCount=fis.read(bytes);//返回的是读到的字节数int型
if(readCount==-1){
break;
}
System.out.print(new String(bytes,0,readCount));//将从文件中读的byte数组转换成字符串。数组只有一个，readCount代表读到（数组中）多少个字节，如果最后只有两个字节了，则读到数组中前两个位置，而不是4个了，数组中后两个位置的数没变。0代表从数组下标为0开始读。bytes代表读的数组。
}

//开始读(掌握这一个)
byte[]bytes=new byte[4];
int readCount=0;
while((readCount=fis.read(bytes))!=-1){
System.out.print(new String(bytes,0,readCount)
}

}catch(IOException e){
e.printStackTrace();
}finally{
if (fis!=null){
try{
fis.close();
}catch(IOException e){
e.printStackTrace();
}
}
}

2、java.io.FileOutputStream:
①文件字节输出流，任何类型的文件都可以用这个流来输出，万能的
②以字节的方式完成输出（内存--->硬盘）
③创建文件字节输出流：
FileOutputStream fos=null;
try:{
fos=new FileOutputStream("filename");//(会将目标文件清空再写入，谨慎使用此方法)
fos=new FileOutputStream("filename"，true);//会在目标文件基础上追加写入，不会清空）

//开始写
byte[]bytes={97,98,99,100};
fos.write(bytes);//将abcd写入到目标文件
fos.write(bytes,0,2);//将ab写入到目标文件（从数组下标0开始输入2个字节）
//开始写
String s="我是中国人，我骄傲！！";
byte[] bs=s.getBytes();//将字符串s转换成byte数组
fos.write(bs);//输入到目的文件（以字符串的形式“我是中国人，我骄傲！！”）

fos.flush();
}catch(IOException e){
e.printStackTrace();
}finally{
if (fos!=null){
try{
fos.close();
}catch(IOException e){
e.printStackTrace();
}
}
}

二、FileReader和FileWriter（字符流）
1、java.io.FileReader:（将之前的byte改成char）
①文件字符输入流，只能读取普通文本。读取文本内容时方便快捷。
②创建摸板：
FileReader reader=null;
try{
reader =new FileReader("filename");//创建文件字符输入流

//开始读
char []chars=new char[4];//一次读取四个字符
int readCount=0;
while((readCount=reader.read(chars))!=-1){
System.out.print(new String(chars,0,readCount));//从文件读多少字符到char数组，就输出多少字符
}

//开始读
char[]chars=new char[4];
reader.read(chars);//往char数组里面读
for(char c:chars){
System.out.println(c);//往char数组读了多少字节，就输出多少字节
}

}catch(IOException e){
e.printStackTrace();
}finally{
if(reader!=null){
try{
reader.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}

2、java.io.FileWriter:
①文件字符输出流。
②只能输出普通文本。（能用记事本打开编辑的文件都是普通文件）（不能读媒体文件和word文件）
③创建摸板：
FileWriter Out=null;
try{
out =new FileWriter("filename");//创建文件字符输出流对象,并将目标文件清空
out =new FileWriter("filename");//创建文件字符输出流对象,不清空目标文件，以追加形式写入

//开始写
char []chars={'我','是','中','国','人'}；
out.write(chars);//向目标文件写入“我是中国人”
out.write(chars,2,3);//从数组下标为2开始写3个字符到目标文件，即写入“中国人”
out.write("我是中国人！");//直接写字符串到目标文件

out.flush();//向目标文件写都要刷新
}catch(IOException e){
e.printStackTrace();
}finally{
if(out!=null){
try{
out.close();
}
catch(IOException e){
e.printStackTrace();
}
}
}

3、复制普通文本文件：
①模板：
FileReader in=null;
FileWriter out=null;

try{
in=new FileReader("filename");
out=new FileWriter("filewriter");

//边读边写
char[]chars=new char[1024*512];//1M
int readCount=0;
while((readCount=in.read(chars))!=-1){
out.write(chars,0,readCount);//从数组下标0开始读了多少写多少
}

out.flush();//刷新
}catch(IOException e){
e.printStackTrace();
}finally{
if(in!=null){
try{
in.close();
}catch(IOException e){
e.printStackTrace();
}
}

if(out!=null){
try{
out.close();
}catch(IOException e){
e.printStackTrace();
}
}

}

三、BufferedReader和BufferedWriter：（字符缓冲流）
1、java.io.BufferedReader：
①自带缓冲区的字符输入流
②不需要自定义char数组或byte数组
③构造方法的参数不是字符串（filename）了，是一个（Reader in）,Reader是一个抽象类，是字符流。如果传入的是字节流（Stream结尾）要用转换流（InputStreamReader或OutputStreamWriter）转换成字节流（Reader结尾）再传入。
④模板：(采用在main方法抛出异常方式处理)
public static void main(String[]args) throws Exception{

//当一个流的构造方法需要传入一个流时：FileReader是节点流，BufferedReader是包装流/处理流
//这只是取一个名字，别多想。这种情况下关闭流时，只需要关闭最外层（br.close();）
FileReader reader=new FileReader("filename");
BufferedReader br=new BufferedReader(reader);

//开始读
//readLine()方法：依次读一行，换行符不读出来，返回String类型，当读到末尾返回null，所以输出时要用println
//String firstLine=br.readLine();
//System.out.println(firstLine);
//String secondLine=br.readLine();
//System.out.println(secondLine);

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

br.close();//关闭包装流后，里面的节点流也会被关闭（可以看源代码）
}

四、InputStreamReader和OutputStreamWriter(转换流)（将字节流转换为字符流）
1、InputStreamReader
①将读的字节流转换为读的字符流
②构造方法的参数是要转换为字符流的字节流（InputStream in）
③模板：（合并以后）
public tatic void main(String[]args) throws Exception{
BufferedReader br=new BufferReader(new InputStreamReader(
new FileInputStream("filename")))

//开始读
String line=null;
while((line=br.readLine())!=null){
System.out.println(line);

//关闭最外层
br.close();
}
}

2、OutputStreamWriter
①将写的字节流转换为写的字符流

五、System.in和System.out（标准输入、输出流）
1、System.in:
①标准输入流：默认从键盘输入（返回类型为InputStream字节输入流）(类似new InputStream)
②System类的setIn（InputStream is）方法重新指定输入的方向
③System.in-->转换为字符输入流-->BufferedReader的readLine方法
④模板：
public static void main(String []args) throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
while(true){
String data=br.readLine();//每次读一行，换行符不读出来，末尾为null
if(String!=null){
System.out.println(String); //split(" ")方法是将字符串以空格分开组成字符串数组
//String[] s=br.readLine().split(" ");
}else{
break;
}
}
br.close();
}

2、System.out:(java.io.PrintStream)
①标准输出流：默认从控制台输出(返回类型为PrintStream字节输出流)(类似new PrintStream)
②System类的setOut（PrintStream ps）方法重新指定输出的方向
③模板：
public static void main(String[]args) throws Exception{
//System.out.println("helle world!");输出到控制台，等价于以下代码
PrintStream ps=System.out;
ps.println("hello world!");//标准输出流不需要手动close()关闭

//将标准输出流指向filename文件
PrintStream printStream=new PrintStream(new FileOutputStream("filename"，true));
//修改输出方向，将输出方向指向“filename”文件
System.setOut(printStream);
//再输出（以下三句都输出到filename文件）
System.out.println("hello");
System.out.println("world");
System.out.println("!!1!!");

}

六、对象流。