数组可能没放满，自己序列化数组的有效元素。提高性能

RandomAccessFile支持随机访问文件

也可以写文件。

rw(读写)  r（只读）

RandomAccessFile raf =new RandomeAccessFile(file,"rw")

写入的区别

字符流 (操作的是文本 文本文件) 注意默认的编码方式
1）编码问题
2）认识文本和文本文件
java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）
文件是byte byte byte 的数据序列
文本文件是文本（char）序列按照某种编码方案（utf-8,utf-16be,gbk）序列化byte的存储
3）字符流（Reader Writer）
字符的处理，一次处理一个字符
字符的底层依然是基本的字节序列
4）InputStreamreader 完成byte流解析成char流 按照编码解析
OutputStreamWrite 提供char流到byte流 按照编码处理

InputStreamReader和OutputStreamWriter的使用
public static void main(String[] args) throws IOException {
// 读出文件内容 使用默认编码方式，其他编码方式可加在文件路径后面加上用双引号括起来
InputStreamReader isr = new InputStreamReader(new FileInputStream(
"F:\\IO流\\IsrAndOsw\\isr.txt"),"gbk");
// 写入文件内容
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(
"F:\\IO流\\IsrAndOsw\\osw.txt"));

//覆盖写入
osw.write("你好");
//不覆盖写入，加入后面
osw.append("世界");

// 一次读取一个字符
/*int c;
while ((c = isr.read()) != -1) {
System.out.print((char) c);
}*/

char[] buffer = new char[1024];
// 批量读取，放入buffer这个字符数组
while ((isr.read(buffer)) != -1) {
osw.write(buffer);
osw.flush();
}
isr.close();
osw.close();
}

BufferedInputStream&BufferedOutputStream
提供了带缓存区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
从应用程序中把输入放入文件，相当于将一罐水倒入到另外一个罐中：
FileOutputStream-->write()方法相当于一滴一滴地把水“转移”过去
DataOutputStream-->writeXxx()方法会方便一些，相当于一瓢一瓢把水“转移”
BuffereOutputStream-->write()方法更方便，相当于一瓢一瓢先放入 桶中，在从桶中倒入到另外一个罐中

DataOutputStream/DataInputStream
    对"流"功能的扩展，可以更加方面的读取int,long，字符等类型数据
   DataOutputStream
        writeInt()/writeDouble()/writeUTF()
readInt readLong 方法都是对FileInputStream方法的包装
DataOutputStream/DataInputStream
对“流”功能的扩展，可以更加方便的读取 int,long, 字符等类型数据
DataOutputStream：使用FileOutputStream构造出来，通过包装FileOutput，可以调用FileOutput类的write方法来构造新的更方便的写方法：

其新建对象为嵌套创建，例：
String file = "xxx";
DataInputStream dis = new DataInputStream(new FileInputStream(file));
DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));

wrieteUTF()采用utf-8编码写出字符串
用utf-16be写出字符串，或字符串数组
写完之后一定要关闭流

数据输入输出流：
DataInputStream、DataOutputStream 是对“流”功能的扩展，方便读写
DataOutputStream dos = new DataOutputStream(new FileOutputStream(file));
dos.writeInt(10);
dos.writeLong(10l);字母l
dos.writeDouble(10.5);
//采用utf-8编码写出
dos.writeUTF("中国");
//采用utf-16be编码写出
dos.writeChars("中国");

1.如果字节数组的长度够大，（也就是比源文件的字节大小要大）则一次就能读取完流中的字节数据，此时循环只执行一次...
2.如果字节数组的长度不够大，（也就是比源文件的字节大小要小）则需要几次才能读完，每读取一次,把读取到的字节写入到输出流中，直到全部读写完毕
/* 假设源文件占250个字节，设定的字节数组长度为100
则第一次从输入流中读取100个字节存放到缓冲区的0-100的位置
并将缓冲区0-100位置的字节写入到输出流中。
第二次同样从输入流中读取100个字节存放到缓冲区的0-100的位置，这时会覆盖第一次存放在缓冲区的对应字节
并将缓冲0-100位置的字节存写入到输出流中
第三次从输入流中读取50个字节存放到缓冲区的0-50的位置,会覆盖第二次存放在缓冲区的对应字节
并将缓冲区0-50的字节写入到输出流中
第四次返回值是-1,也就是EOF标志,循环结束，已实现源文件和目标文件的完整复制
*/

输入、输出是相对于字节流或者字符流而言的：
1：输入，是将字节或者字符从文件中输入到流中
2：输出，是将字节或者字符从流中输出到文件中
/**
* 文件拷贝，字节批量读取
* @param srcFile
* @param destFile
* @throws IOException
*
* JAVA的throw和throws區別：
* http://zhidao.baidu.com/link?url=cOoyefusSFJRvXFuNK3vAVS_mGcE3jgWSy8CiwZk5y-N8Fa-m_cwRrNVEneXKkwMOTYHz8MIIS13gAz91Y4vZ_
*/
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){
    //講buf數組裡的內容讀入到該輸出流中（out）
    out.write(buf,0,b);
    out.flush();//最好加上
    }
    in.close();
    out.close();

}

关于read返回值的问题：

一开始read返回的是读取的字节数；当把内容都读完后，返回的数为-1

举个例子：

例如要读取的文件字节数是100，buf.length为60。

第一次read返回给bytes的是读取的字节数：大小为数组的长度60；

第二次read返回给bytes的还是读取的字节数，但大小为剩下的100-60=40了；

第三次由于到文件末尾，100个字节内容都读完了，read就返回-1给bytes

综上，文件没读完时，read返回的是读取的字节数；文件读完后，read返回的是-1，用于判断文件是否读取完成。

1、byte 类型 8 位，int 类型 32 位，为了避免数据转换错误，通过 & 0xff 将高 24 位清零
2、is.read() 单字节适合读取 小 文件
is.read(byte[] bytes,int star,int size) 字节数组适合读取 大 文件
读取文件最常用的是批量读取int bytes = fis.read(buf, 0 , buf.length);
FileInputStream文件输入
单字节输入即不用数组。

FileInputStream批量读取 long start = System.currentTimeMillis();获得系统时间
// 批量读取，对大文件而言效率高，也是我们最常用的读取方式
public static void printHexByByteArray(String fileName) throws IOException {
FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[20 * 1024];
// 从in中批量读取字节，放入到buf这个字节数组中，

// 从0个位置开始放，最多放buf.length个

// 返回的是读到的字节的个数
int bytes = in.read(buf, 0, buf.length);
// 一次性读完，说明字节数组足够大
int j = 1;
for (int i = 0; i < bytes; i++) {
if (buf[i] <= 0xf) {
System.out.println("0");
}
// 将整型b转换成16进制表示的字符串
System.out.print(Integer.toHexString(buf[i]) + " ");
if (j++ % 10 == 0) {
System.out.println();
}
}

int bytes2 = 0, k = 1;
while ((bytes2 = in.read(buf, 0, buf.length)) != -1) {
for (int i = 0; i < bytes2; i++) {
// byte类型为8位，int类型32位，为了避免数据转换错误，通过&0Xff将高24位清零
System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");
if (k++ % 10 == 0) {
System.out.println();
}
}
}
in.close();
}

IO流分为输入流、输出流
还有字节流、字符流
1、字节流：
（1）InputStream：抽象了应用程序读取数据的方式
（2）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)写出一个byte到流，b的低8位
out.write(byte[] buf)将buf字节数组都写到流
out.write(byte[] buf, int start,int size) 字节数组buf从start位置开始写size长度的字节到流

FileInputStream--->具体实现了在文件上读取数据
/**
* 读取指定文件内容，按照16进制输出到控制台
* 并且每输出10个byte换行
* @param fileName
* 单字节读取不适合大文件，大文件效率很低
*/
public static void printHex(String fileName)throws IOException{
//把文件作为字节流进行读操作
FileInputStream in = new FileInputStream(fileName);
int b ;
int i = 1;
while((b = in.read())!=-1){
if(b <= 0xf){
//单位数前面补0
System.out.print("0");
}
System.out.print(Integer.toHexString(b)+"  ");
if(i++%10==0){
System.out.println();
}
}
in.close();
}

字节流 
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) 写出一个byte到流，b的低8位 
out.write(byte[] buf) 将buf字节数组都写入到流 
out.write(byte[] buf,int start,int size)字节数组buf从start位置开始写size长度的字节到流 
5）FileInputStream 具体实现了在文件上读取数据

代码 https://www.imooc.com/notepad/2037a9

RandomAccessFile   Java提供的对文件内容的访问