/*RandomAccessFile java提供对文件内容的访问，既可以读文件，也可以写文件。*RandomAccessFile支持随机访问文件，可以访问文件的任意位置**1）JAVA文件模型*  在硬盘上的文件时byte存储的，是数据的集合*2）打开文件 *   两种模式 rw （读写）,r(只读)*RandomAccessFile raf=new RandomAccessFile(file,"rw");*文件指针，打开文件时指针在开头pointer=0;*3）写方法*raf.write(int)-->只写一个字节（后8位），同时指针指向下一个字节位置*4）读方法*raf.read()-->读一个字节*5)关闭文件*/
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
public class RandomAccessFileDemo {/*** @param args* @throws IOException */public static void main(String[] args) throws IOException {// TODO Auto-generated method stubFile demo=new File("demo");//相对路径，项目下if(!demo.exists()){demo.mkdir();}File file=new File(demo,"raf.dat");if(!file.exists()){file.createNewFile();}RandomAccessFile raf =new RandomAccessFile(file,"rw");//指针的位置System.out.println(raf.getFilePointer()); //0 //用write只写了一个字节raf.write('A');  System.out.println(raf.getFilePointer());  //1raf.write('B');System.out.println(raf.getFilePointer());  //2//可以writeInt直接写一个intint i=0x7fffffff;raf.writeInt(i);System.out.println(raf.getFilePointer());  //6String s="中";  //utf-16bebyte[] gbk=s.getBytes();raf.write(gbk);System.out.println(raf.getFilePointer());  //8//读文件，必须把指针移到头部raf.seek(0);//一次性读取,把文件中的内容都读到字节数组中byte[]buf=new byte[(int)raf.length()];raf.read(buf);System.out.println(Arrays.toString(buf));//[65, 66, 127, -1, -1, -1, -42, -48, 45]for(byte b:buf){System.out.println(Integer.toHexString(b));  //十六进制输出}String s1=new String(buf);System.out.println(s1); //AB???//关闭文件raf.close();}}

5.字节流  InputStream、OutputStream  FIleInputStream/ FIleOutputStream

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;/** IO流（输入流，输出流）* 字节流、字符流* 1.字节流* 1）InputStream、OutputStream 抽象类*    InputStream抽象了应用程序读取数据的方式*    OutputStream抽象了应用程序写出数据的方式* 2）EOF=End  读到-1就读到结尾* 3）输入流基本方法*    int b=in.read(); //读取一个字节无符号填充到整形的低8位。-1是EOF*    in.read(byte[] buf);*    in.read(byte[] buf,int start,int size);*4）输出流基本方法*    out.write(int b)//写出一个byte到流，低8位*    out.write(byte[] buf) //将byte字节数组都写入到流*    out.write(byte[] buf,int start,int size);*5） FIleInputStream继承InputStream,具体实现了在文件上读取 *6） FIleOutputStream实现了向文件中写出byte数据的方法*//** BufferedInputStream/BufferedOutputoutStream* 这两个流为IO提供了带缓冲区的操作，一般打开文件进行写入* 或读取操作时，都会加入缓冲，这种流模式提高了IO的性能* 从应用程序中把输入放入文件，相当将一缸水倒入另一个缸中* FileOutputStream-->wrie()方法相当于一滴滴转移* DataOutputStream-->writeXXx()方法，相当于一瓢瓢转移* BufferedOutputStream-->wrie()方法，相当将一瓢瓢先放入桶，再从桶倒入缸中*/public class FileInputDemo {/*读取制定文件内容，按照16进制输出*每输出10个换行*单字节读取不适合大文件*/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){//单位数前面补0System.out.print("0");}System.out.print(Integer.toHexString(b)+" ");if((i++)%10==0)System.out.println();}System.out.println();in.close();  //关闭操作}/*** 大文件适于批量读取* @param fileName* @throws IOException*/public static void printHexByByteArray(String fileName) throws IOException{FileInputStream in=new FileInputStream(fileName);byte[] buf=new byte[20*1024];/*//从In中批量读取字节，从第0个位子开始放，最多放buf.length个，返回读取字节个数int bytes=in.read(buf, 0, buf.length);//若一次性读完，说明buf足够大        for(int i=0;i<bytes;i++){if(buf[i]<=0xf){//单位数前面补0System.out.print("0");}System.out.print(Integer.toHexString(buf[i])+" ");if((i+1)%10==0)System.out.println();}*///有可能一次性读不完 int bytes=0;while((bytes=in.read(buf, 0, buf.length))!=-1){for(int i=0;i<bytes;i++){if(buf[i]<=0xf){//单位数前面补0System.out.print("0");}System.out.print(Integer.toHexString(buf[i])+" ");if((i+1)%10==0)System.out.println();}}System.out.println();in.close();}/*** 文件拷贝，批量读取，最快* @param srcFile* @param desrFile* @throws IOException*/public static void copyFile(File srcFile,File destFile) throws IOException{if(!srcFile.exists()){throw new IllegalArgumentException("文件不存在");}if(!srcFile.isFile()){throw new IllegalArgumentException("文件不存在");}FileInputStream in = new FileInputStream(srcFile);FileOutputStream out = new FileOutputStream(destFile);byte[] buf=new byte[8*1024];int bytes;while((bytes=in.read(buf, 0, buf.length))!=-1){out.write(buf, 0, bytes);out.flush();  //带缓冲区要刷新}in.close();out.close();     }/*** 文件拷贝，单字节读取，最慢* @param srcFile* @param desrFile* @throws IOException*/public static void copyFileByByte(File srcFile,File destFile) throws IOException{if(!srcFile.exists()){throw new IllegalArgumentException("文件不存在");}if(!srcFile.isFile()){throw new IllegalArgumentException("文件不存在");}FileInputStream in = new FileInputStream(srcFile);FileOutputStream out = new FileOutputStream(destFile);       int bytes;while((bytes=in.read())!=-1){out.write(bytes);}in.close();out.close();}/** 带有缓冲区的读取*/public static void copyFileByBuffered(File srcFile,File destFile) throws IOException{if(!srcFile.exists()){throw new IllegalArgumentException("文件不存在");}if(!srcFile.isFile()){throw new IllegalArgumentException("文件不存在");}BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));int b;while((b=bis.read())!=-1){bos.write(b);bos.flush();//带缓冲区要刷新}bis.close();bos.close();}/*** @param args* @throws IOException * @throws IOException */public static void main(String[] args) throws IOException  {// TODO Auto-generated method stubtry {FileInputDemo.printHex("demo\\raf.txt");} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}try {long start=System.currentTimeMillis();FileInputDemo.printHexByByteArray("demo\\raf.txt");long end=System.currentTimeMillis();System.out.println(end-start);} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}//如果该文件不存在，则直接创建，如果存在，删除后删除重建//若第二个参数为true，则appendFileOutputStream out=new FileOutputStream("demo\\raf.txt");out.write('A');  //低8位out.write('B');byte[] gbk="中国".getBytes("gbk");out.write(gbk);FileInputDemo.printHex("demo\\raf.txt");FileInputDemo.copyFile(new File("demo\\raf.txt"),new File( "demo\\raf1.txt"));}}

6.DataOutputStream、DataInputStream

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;/** DataInputStream / DataOutputStream* 对“流”功能的扩展，可以更加方面的读取int,long,字符等类型数据* DataOutputStream* writeInt()/writeDouble/writeUTF()*/
public class DataInputDemo {/*** @param args*/public static void main(String[] args) throws IOException{// TODO Auto-generated method stubString file="demo\\raf.txt";//DataOutputStreamDataOutputStream dos=new DataOutputStream(new FileOutputStream(file));dos.writeInt(10);dos.writeLong(10l);dos.writeDouble(10.5);//采用utf-8编码写出dos.writeUTF("中国");//采用utf-16be编码写出dos.writeChars("中国");dos.close();//DataInputStreamDataInputStream dis=new DataInputStream(new FileInputStream(file));int 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);}}

7.字符流  InputStreamReader/OutputStreamReader   BufferedReader  BufferedWriter/PrintWriter

<p><span style="font-size:14px;">
/*
* 字符流
* 1）编码问题
* 2）认识文本和文本文件
*    JAVA的文本（char）是16位无符号整数，是自负的unicode编码（双字节编码）
*    文件是byte byte byte---的数据序列
*        文本文件是文本（char）序列按照某种编码方案（utf-8,.utf-16be,gbk）序列化为byte的存储
* 3）字符流（Reader Writer）
*        字符的</span>处理，一次处理一个字符</p> *    字符的底层仍然是基本的字符序列*    字符流的基本实现*    InputStreamReader 完成byte流解析为char流，按照编码解析*    OutputStreamReader 提供char流到byte流，按照编码处理* 4）FileReader FileWriter * 5)字符流的过滤器*   BufferedReader -->readLine()一次读取一行*   BufferedWriter/PrintWriter  --写一行*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
public class InputStreamReaderDemo {/*** @param args* @throws IOException */public static void main(String[] args) throws IOException {// TODO Auto-generated method stub//字节字符转换流InputStreamReader isr=new InputStreamReader(new FileInputStream("demo\\raf.txt"),"gbk");OutputStreamWriter osr=new OutputStreamWriter(new FileOutputStream("demo\\raf3.txt"));int c;/*while((c=isr.read())!=-1){System.out.print((char)c);osr.write(c);}*///批量读取char []buf=new char[8*1024];while((c=isr.read(buf, 0, buf.length))!=-1){String s=new String(buf,0,c);System.out.print(s);osr.write(buf,0, c);osr.flush();         }isr.close();osr.close();//字符流之文件读写流FileReader fr=new FileReader("demo\\raf.txt");FileWriter fw=new FileWriter("demo\\raf4.txt");char []buffer=new char[8*1024];while((c=fr.read(buffer, 0, buffer.length))!=-1){fw.write(buffer,0, c);fw.flush();         }fr.close();fw.close();//字符流的过滤器BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("demo\\raf.txt")));//BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo\\raf5.txt")));PrintWriter pw=new PrintWriter("demo\\raf5.txt");String line;while((line=br.readLine())!=null){/*bw.write(line);bw.newLine();bw.flush();*/pw.println(line);pw.flush();}br.close();pw.close();}}

8.序列化和反序列化

/*** 对象的序列化和反序列化* 1）将Object转换成byte序列，反之为对象的反序列化* 2）序列化流（ObjectOutputStream） ---->writeObject*    反序列化流（ObjectInputStream） ---->readObject* 3）序列化接口（Serializable）*    对象必须实现序列化接口，才能进行序列化，否则出现异常*    这个借口，没有任何方法，只是一个标准* 4）transient关键字  该元素不会被进行jvm默认序列化，也可以自己完成元素的序列化*    private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{}*    private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException{}* 5）父类实现序列化接口，其子类都可进行初始化* 6）对子类对象进行序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用*/import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;public class SeriablizableDemo implements Serializable{  //声明Serializable接口，否则异常private String stu;private String stuname;private transient int stuage;@Overridepublic String toString() {return "SeriablizableDemo [stu=" + stu + ", stuage=" + stuage+ ", stuname=" + stuname + "]";}public SeriablizableDemo(String stu, String stuname, int stuage) {super();this.stu = stu;this.stuname = stuname;this.stuage = stuage;}private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException{  //ArrayList方法名粘贴s.defaultWriteObject(); //默认s.writeInt(stuage);  //自己完成}private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {s.defaultReadObject();//默认this.stuage=s.readInt(); //自己完成 }/*** @param args* @throws IOException * @throws ClassNotFoundException * @throws FileNotFoundException */public static void main(String[] args) throws  IOException, ClassNotFoundException {// TODO Auto-generated method stubString file="demo\\raf6.txt";  //保存到此文件中//序列化ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(file));SeriablizableDemo  stu=new SeriablizableDemo("张三","小",20);oos.writeObject(stu);oos.flush();oos.close();//反序列化ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));SeriablizableDemo  stu2=(SeriablizableDemo)ois.readObject();System.out.println(stu2.toString());ois.close();}}