javaIO系统小总结

IO流分类

• 根据流动方向分为输入流与输出流。
• 根据处理的数据类型分为字节流与字符流
• 根据功能层次分为节点流（底层流）与（处理流）
  
  
  字节流
  字节流是将内容转换成字节形式进行传输，1字节->8位二进制，二进制可以传输任何类型的数据，因此字节流可以传输任何类型的数据。
  字符流
  字符流是16位Unicode字符流，只用于处理字符，处理文本文件。

字节输入流

//从文件到内存
	InputStream in=new FileInputStream(new File("C:\\Users\\86183\\myProject\\src\\abc.txt"));
//	InputStream in=new FileInputStream("c://abc.txt");
	System.out.println(in.available());//文件大小
	byte[] buf=new byte[in.available()];
	//read()单字节读取 读到底返回-1
	//read(byte[] b)读取一组数据，返回读取个数
	in.read(buf);//将文件内容读取到buf中
	//buf:byte[]->String
	System.out.println(new String(buf));
	//readAllBytes()读取所有数据

字节输出流

public class OutputStream01 {
public static void main(String[] args) {
	//抽象类 靠子类实例化
	OutputStream out=null;
	try {
		File file=new File("c:xyz.txt");
		//采用的是覆盖的形式
		out=new FileOutputStream(file);
		//out=new FileOutputStream("c:xyz.txt");
		//
		//追加形式
		//out=new FileOutputStream(file,true);
		//参数是字节数组 
		out.write("hellow123".getBytes());//内存-》xyz.txt
	}catch(FileNotFoundException e) {
		e.printStackTrace();
	}catch(IOException e) {
		e.printStackTrace();
	}finally {
		try {
			out.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
}

字符输出流

File file=new File("文件名");
Writer out=new FileWriter(file);
out.write("可以直接输出字符串");
out.append("追加");
out.close;

字符输入流

Reader in=new FileReader(file);
char data[]=new char[1024]//缓冲区
in.skip();//跨过九个字符长度
int len=in.read(data);
System.out.println(new String(data,0,len));
in.close();

轮换流

//将字节输出流转换成字符输出流
OutputStream output=new FileOutputStream(file);
Writer out=OutputStreamWriter(output);
out.close();
output.close();
//同理可知InputStreamReader()将字节输入流转换成字符输入流

文件复制

//输入输出字节流
import java.io.*;
//
public class FileCopy {
public static void main(String[] args) {
	InputStream in=null;
	OutputStream out=null;
	try {
		 in=new FileInputStream("C:\\Users\\86183\\myProject\\abc.txt");
		 out=new FileOutputStream("C:\\Users\\86183\\myProject\\xy.txt");
		//开辟10字节的内存  每次读取十字节
		 byte []buf=new byte[10];
		 int len=-1;
		 while((len=in.read(buf))!=-1) {//边读边写,read返回值为读取文件字符数
			 out.write(buf,0,len);
		 }
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	
}
}

字符操作文件复制

import java.io.*;
public class FileCopyCharacter {
	//
public static void main(String[] args) {
	Reader reader=null;
	Writer writer = null;
	BufferedReader br=null;
	BufferedWriter bw=null;
	try {
		reader =new FileReader("C:\\Users\\86183\\myProject\\个人介绍.txt ");
		writer=new FileWriter("C:\\Users\\86183\\myProject\\个人完整介绍.txt");
		//字符流
		//char[] buf=new char[4];
		//可变字符串类
		//StringBuffer sb=new StringBuffer();
		//
		/*int len=-1;
		while((len=reader.read(buf))!=-1) {
		  //将读取的字符串拼接
			sb.append(buf,0,len); 
		}
		String content=sb.toString();//->tostring
		content=content.replace("{name}", "熊迪");
		content=content.replace("{age}", "12");
		  //  System.out.println(content);
		writer.write(content);*/
		//
		//自带缓冲区 缓冲区大小一行
		 br=new BufferedReader(reader);
		 bw=new BufferedWriter(writer);
		StringBuffer sb=new StringBuffer();
		String line=null;
		while((line=br.readLine())!=null) {
			sb.append(line);
		}
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		try {
			 if(bw != null) bw.close();
             if(br!=null )  br.close();
              if(writer!=null) writer.close();
               if(reader!=null) reader.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
}

关闭流时，先关输出流，再关输入流，先关包装外流，再关包装内流；

内存操作流
以内存为终端的IO操作流
字节内存操作流程 ByteArrayOutputStream，ByteArrayInputStream。
字符内存操作流 CharArrayWriter CharArrayReader

“
打印流
PrintStream继承自FileOutputStream

File file=new File("文件名");
	 try {
		PrintWriter pu=new PrintWriter(new FileOutputStream(file));
		 //直接写入字符串 并换行
		pu.println("姓名");
		// 不换行
		pu.print("a");
		
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

System类对IO的支持
System类中有三个IO常量

public static final PrintStream err;
public static final PrintStream out;
public static final InputStream in;

err与out输出结果基本一致，但在IDE中颜色会有差异

System.in可以实现键盘数据输入

 try {
		 InputStream input=System.in;
		 byte[] data=new byte[1024];
		int len=input.read(data);
		System.out.println(new String(data,0,len));
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

新IO
java1.4java.nio*包中引入了新的JavaI/O类库，其目的在于提高速度。实际上，旧的I/O包已经使用nio重新实现过。
速度的提高来自所使用的结构更接近于操作系统执行I/O的方式：通道和缓冲器。唯一直接与通道交互的缓冲器是ByteBuffer，可以储存未加工的字节缓冲器。

import java.nio.*;
import java.nio.channels.*;
import java.io.*;
//新IO   
//ByteBuffer 通道
public class GetChannel {
  private static final int BSIZE = 1024;
  public static void main(String[] args) throws Exception {
    // Write a file:
    //得到通道
    FileChannel fc =new FileOutputStream("data.txt").getChannel();
    //写入
    fc.write(ByteBuffer.wrap("Some text ".getBytes()));
    fc.close();
    // Add to the end of the file:
    fc =new RandomAccessFile("data.txt", "rw").getChannel();
    //到最后
    fc.position(fc.size()); 
    fc.write(ByteBuffer.wrap("Some more".getBytes()));
    fc.close();
    // Read the file:
    fc = new FileInputStream("data.txt").getChannel();
    //allocate()分配大小
    ByteBuffer buff = ByteBuffer.allocate(BSIZE);
    fc.read(buff);
    //读入准备
    buff.flip();
    while(buff.hasRemaining())
      System.out.print((char)buff.get());
  }
} /* Output:
Some text Some more
*///:~