JAVA中IO流体系和使用（IO流）

1.  IO流：

    字节流：

                          抽象父类：

1.   InputStream

2.   OutputStream

                          文件流：

1.   FileInputStream

2.   FileOutputStream

                         字节缓冲流：

1.   BufferedInputStream

2.   BufferedOutputStream

                          ps:字节流可以操作任意类型的数据

           字符流：

                          抽象基类：

1.   Reader

2.   Writer

                 转换流:

1.   InputStreamReader

2.   OutputStreamWriter

   flush()

                          字符缓冲流：特点：可以按行读写数据

1.   BufferedReader

  readLine() - String

2.   BufferedWriter

  PrintWriter

                               i.      特殊的功能：自动行刷新

                             ii.      print  println

                         ps:字符流只能操作文本类型的数据

 

 对象流：

                           ObjectInputStream

1.   readObject() -Object

                          ObjectOutputStream

1.   writeObject()

                        序列化：

              1.   对象数据à字节数据   序列化

                  实现：

 

           让对象所属的类型实现Serializable接口

2.   字节数据à对象     反序列化

 

 注意的问题：

1.   反序列化时造成版本不兼容问题的原因以及解决办法：在对象所属的类中生成序列版本号

2.   如果一个对象是可序列化的，这个对象所属的类内部有其他的对象作为它的成员，那么作为成员的这个对象也一定是可序列化的

3.   如果一个对象内部的数据并非全部要持久化，此时可以用transient来修饰不持久化的数据

 

 

 

 

            RandomAccessFile文件操作:

                    Java提供了一个可以对文件随机访问的操作，访问包括读和写操作。该类名为RandomAccessFile。该类的读写是基于指针的操作。

                    RandomAccessFile也叫做随机访问流

                    RandomAccessFile在对文件进行随机访问操作时有两个模式，分别为只读模式(只读取文件数据)，和读写模式(对文件数据读写)。

                    

1.字节流：

 

//创建输入流/输出流对象
FileInputStream fis = new
        FileInputStream("fis.java");
FileOutputStream fos = new
        FileOutputStream("copy1.txt");

//按照单个字节复制
int by = -1;
while((by=fis.read())!=-1){
    //将by写入目标文件中
    fos.write(by);
}

//按照字节数组复制文件
byte[] bys = new byte[1024];
int  len = 0;
while((len=fis.read(bys))>0){
    //将读取到的字节数组写入目标文件中
    fos.write(bys, 0, len);
}
//关闭流对象
fis.close();
fos.close();

 

2.字节缓冲流

 

//创建流对象
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("1.jpg"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("2.jpg"));
//完成复制
byte[] bys = new byte[1024];
int len = -1;
while((len=bis.read(bys))!=-1){
    bos.write(bys, 0, len);
    bos.flush();
}

    bis.close();
    bos.close();

 

3.字符流

 

//创建输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("love.txt"),"UTF-8");
//创建输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"UTF-8");

//读取
//按照单个字符读取
//    int ch = -1;
//    while((ch=isr.read())!=-1){
//       osw.write(chs, 0, len);
//    }
//按照字符数组读取
char[]  chs = new char[1024];
int len = -1;
while((len=isr.read(chs))!=-1){
    //char[]-->String
    osw.write(chs, 0, len);
}
//释放资源
isr.close();
osw.close();

 

4.字符缓冲流

 

//创建输入，输出流对象
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("fis.java")));
PrintWriter pw = new PrintWriter(new FileOutputStream("buffer.txt"),true);

//复制
String str = null;
while((str=br.readLine())!=null){
    pw.println(str);
}
//流关闭
br.close();
pw.close();

 

 

5.对象流

 

/           //User类成员变量
private String name;
private String pass;
//transient关键字：
//当一个属性被transient修饰后,该属性在进行对象序列化时其值会被忽略.
//忽略不必要的属性值可以达到对象序列化"瘦身"的效果.
private transient String desc;

p

 

   * 将User对象序列化到文件中
   * 要实现将User对象中的desc数据不写入文件
   */
User user = new User("starry","123","描述");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("transient.txt"));

oos.writeObject(user);
oos.close();

//反序列化操作
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("transient.txt"));
User per = (User)ois.readObject();

System.out.println(per.getName()+per.getPass()+per.getDesc());

ois.close();

 

 

6.RandomAccessFile随机访问流

 

 RandomAccessFile ra = new RandomAccessFile("web/love.txt","rw");
    RandomAccessFile ra1 = new RandomAccessFile("web/love-copy.txt","rw");
    byte[] by = new byte[1024];
    int i= -1;
    while((i = ra.read(by)) != -1 ){
        ra1.write(by,0,i);
    }
    ra.close();
    ra1.close();

 

//创建RandomAccessFile对象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

//移动指针偏移量并读取偏移量之后的内容到临时文件中
raf.seek(3);
//创建临时文件
File tmp = File.createTempFile("copy", ".tmp");
//复制
RandomAccessFile raftmp = new RandomAccessFile(tmp, "rw");
byte[] bys = new byte[1024];
int len = -1;
while((len=raf.read(bys))!=-1){
    raftmp.write(bys, 0, len);
}

raf.seek(3);
//向raf.txt文件中插入数据
raf.write("hello".getBytes());

//将临时文件中的内容复制到本文件的最后
raftmp.seek(0);
len = -1;
while((len=raftmp.read(bys))!=-1){
    raf.write(bys, 0, len);
}

//删除临时文件
tmp.deleteOnExit();

raf.close();
raftmp.close();