字节流
1. InputStream 和OutputStream
inputStream 和OutputStream 的作用是用来表示那些从不同数据源产生输入输出的类
抽象了应用程序读取数据的方式。
2. EOF=end 读到-1就结尾
3. 输入流的基本方法（对应读方法）
int b=in.read();读取一个字节无符号，填充到int的低八位，-1为EOF
in.read(byte[] buf)读取数据填充到数组buf
in.read(byte[] buf,int start,int size)读取数据到字节数组buf,从buf的start位置开始存放长度为size的数据
4. 输出流的基本方法（对应写方法）
out.write(int b);写出一个字节到流，b的低八位。
out.write(byte[] buf)将buf数据都写到流
out.write(byte[] buf,int start,int size)数组buf 从start位置开始写size长度的字节到流
5. FileInputStream 具体实现了在文件上读取数据
实例代码：
/**
* 批量读取，对大文件而言效率高，也是我们最常用的读文件的方式
* @param fileName
* @throws IOException
*/
public static void printHexByByteArray(String fileName)throws IOException{
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[8 * 1024];
/*从in中批量读取字节，放入到buf这个字节数组中，
* 从第0个位置开始放，最多放buf.length个
* 返回的是读到的字节的个数
*/
/*int bytes = in.read(buf,0,buf.length);//一次性读完，说明字节数组足够大
int j = 1;
for(int i = 0; i < bytes;i++){
System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
if(j++%10==0){
System.out.println();
}
}*/
int bytes = 0;
int j = 1;
while((bytes = in.read(buf,0,buf.length))!=-1){
for(int i = 0 ; i < bytes;i++){
System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
if(j++%10==0){
System.out.println();
}
}
}
in.close();
}
6. FileOutStream实现了向文件中写出byte的方法
实例代码：
package com.imooc.io;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutDemo1 {
/**
* @param args
*/
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
//如果该文件不存在，则直接创建，如果存在，删除后创建
FileOutputStream out = new FileOutputStream("demo/out.dat");
out.write('A');//写出了'A'的低八位
out.write('B');//写出了'B'的低八位
int a = 10;//write只能写八位,那么写一个int需要些4次每次8位
out.write(a >>> 24);
out.write(a >>> 16);
out.write(a >>> 8);
out.write(a);
byte[] gbk = "中国".getBytes("gbk");
out.write(gbk);
out.close();
IOUtil.printHex("demo/out.dat");
}
}
**输入输出综合应用： **
/**
* 文件拷贝，字节批量读取
* @param srcFile
* @param destFile
* @throws IOException
*/
public static void copyFile(File srcFile,File destFile)throws IOException{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
FileInputStream in = new FileInputStream(srcFile);
FileOutputStream out = new FileOutputStream(destFile);
byte[] buf = new byte[8*1024];
int b ;
while((b = in.read(buf,0,buf.length))!=-1){
out.write(buf,0,b);
out.flush();//最好加上
}
in.close();
out.close();
}
7. DataOutputStream/DataInputStream
对“流”功能的扩展，可以更加方便地读取int,long,string等类型的数据（相当于对字节流的包装）
**示例代码：
写：
public class DosDemo {
public static void main(String[] args) throws IOException {
String file = "demo/dos.dat";
DataOutputStream dos = new DataOutputStream(
new FileOutputStream(file));
dos.writeInt(10);
dos.writeInt(-10);
dos.writeLong(10l);
dos.writeDouble(10.5);
//采用utf-8编码写出
dos.writeUTF("中国");
//采用utf-16be编码写出
dos.writeChars("中国");
dos.close();
IOUtil.printHex(file);
}
读：
public static void main(String[] args) throws IOException{
// TODO Auto-generated method stub
String file = "demo/dos.dat";
IOUtil.printHex(file);
DataInputStream dis = new DataInputStream(
new FileInputStream(file));
int i = dis.readInt();
System.out.println(i);
i = dis.readInt();
System.out.println(i);
long l = dis.readLong();
System.out.println(l);
double d = dis.readDouble();
System.out.println(d);
String s = dis.readUTF();
System.out.println(s);
dis.close();
}
8. BufferedInputStream&BufferedOutputStream（效率最高）
这两个流泪提供了带缓冲的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
从应用程序中把输入放入文件，相当于把一缸水倒入另一个缸中
FileOutputStream->wite()方法相当一一滴一滴（一个字节）地转移水
DataOutputStream->writeXXX()方法相当于一勺一勺地转移水
BufferedOutputStream->write()更便捷，相当于一勺一勺放入桶中，再从桶中倒入另一个桶。
示例代码：
/**
* 进行文件的拷贝，利用带缓冲的字节流
* @param srcFile
* @param destFile
* @throws IOException
*/
public static void copyFileByBuffer(File srcFile,File destFile)throws IOException{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件:"+srcFile+"不存在");
}
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
}
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(srcFile));
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int c ;
while((c = bis.read())!=-1){
bos.write(c);
bos.flush();//刷新缓冲区
}
bis.close();
bos.close();
}
测试代码：
public class IOUtilTest4 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
long start = System.currentTimeMillis();
/*IOUtil.copyFileByByte(new File("e:\\javaio\\1.mp3"), new File(
"e:\\javaio\\2.mp3"));*/ //两万多毫秒
/*IOUtil.copyFileByBuffer(new File("e:\\javaio\\1.mp3"), new File(
"e:\\javaio\\3.mp3"));//一万多毫秒*/
IOUtil.copyFile(new File("e:\\javaio\\1.mp3"), new File(
"e:\\javaio\\4.mp3"));//7毫秒
long end = System.currentTimeMillis();
System.out.println(end - start );
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
