【21】IO流4_序列化，管道，随机，字节数组流，字符编码

7.14  IO流中的其他类

ObjectInputStream与ObjectOutputStream

被操作的对象需要实现Serializable （标记接口);

 

练习一：ObjectInputStream与ObjectOutputStream

import java.io.*; class ObjectStreamDemo{         public static void main(String[] args) throws Exception         {                   //writeObj();                   readObj();         }         public static void readObj()throws Exception         {                   ObjectInputStream  ois = new ObjectInputStream(new FileInputStream("obj.txt"));                    Personp = (Person)ois.readObject();                    System.out.println(p);                   ois.close();         }          public static void writeObj()throws IOException         {                   ObjectOutputStreamoos =                            new ObjectOutputStream(new FileOutputStream("obj.txt"));                    oos.writeObject(newPerson("lisi0",399,"kr"));                    oos.close();         }}

 

 

import java.io.*;class Person implements Serializable{                 public static final long serialVersionUID = 42L;          private String name;         transient int age;         static String country = "cn";         Person(Stringname,int age,String country)         {                   this.name= name;                   this.age= age;                   this.country= country;//非静态不能调用静态方法country         }         public String toString()         {                   return name+":"+age+":"+country;         }}

 

7.15管道流

PipedInputStream和PipedOutputStream

输入输出可以直接进行连接，通过结合线程使用

 

练习二：PipedInputStream和PipedOutputStream的应用

 

import java.io.*; class Read implements Runnable{         private PipedInputStream in;         Read(PipedInputStreamin)         {                   this.in= in;         }         public void run()         {                   try                   {                            byte[] buf = new byte[1024];                             System.out.println("读取前。。没有数据阻塞");                            int len = in.read(buf);                            System.out.println("读到数据。。阻塞结束");                               String s= new String(buf,0,len);                             System.out.println(s);                             in.close();                    }                   catch(IOException e)                   {                            thrownew RuntimeException("管道读取流失败");                   }         }} class Write implements Runnable{         private PipedOutputStream out;         Write(PipedOutputStreamout)         {                   this.out= out;         }         public void run()         {                   try                   {                            System.out.println("开始写入数据，等待6秒后。");                            Thread.sleep(6000);                            out.write("pipedlai la".getBytes());                            out.close();                   }                   catch(Exception e)                   {                            thrownew RuntimeException("管道输出流失败");                   }         }} class PipedStreamDemo{         public static void main(String[] args) throws IOException         {                    PipedInputStream in = new PipedInputStream();                   PipedOutputStream out = new PipedOutputStream();                   in.connect(out);                    Readr = new Read(in);                   Writew = new Write(out);                   newThread(r).start();                   newThread(w).start();           }}

 

7.16 RandomAccessFile

随机访问文件，自身具备读写的方法。

通过skipBytes(int x),seek(int x)来达到随机访问。

 

该类不是算是IO体系中子类。

而是直接继承自Object。

 

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

 

 

其实完成读写的原理就是内部封装了字节输入流和输出流。

 

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，，读写rw等。

 

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。

如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

 

练习三：RandomAccessFile随机读写访问的应用

 

 

import java.io.*; class RandomAccessFileDemo{         public static void main(String[] args) throws IOException         {                   //writeFile_2();                   //readFile();                    //System.out.println(Integer.toBinaryString(258));          }          public static void readFile()throws IOException         {                   RandomAccessFile raf = new RandomAccessFile("ran.txt","r");                                     //调整对象中指针。                   //raf.seek(8*1);                    //跳过指定的字节数                   raf.skipBytes(8);                    byte[] buf = new byte[4];                    raf.read(buf);                    String name = new String(buf);                    int age = raf.readInt();                     System.out.println("name="+name);                   System.out.println("age="+age);                    raf.close();           }          public static void writeFile_2()throws IOException         {                   RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");                   raf.seek(8*0);                   raf.write("周期".getBytes());                   raf.writeInt(103);                    raf.close();         }          public static void writeFile()throws IOException         {                   RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");                    raf.write("李四".getBytes());                   raf.writeInt(97);                   raf.write("王五".getBytes());                   raf.writeInt(99);                    raf.close();         }}

 

7.17 DataInputStream与DataOutputStream

 

可以用于操作基本数据类型的数据的流对象。

 

 

练习四：DataInputStream与DataOutputStream的应用

 

import java.io.*;class DataStreamDemo{         public static void main(String[] args) throws IOException         {                   //writeData();                   //readData();                    //writeUTFDemo(); //               OutputStreamWriter osw = new OutputStreamWriter(newFileOutputStream("gbk.txt"),"gbk");////               osw.write("你好");//               osw.close(); //               readUTFDemo();          }         public static void readUTFDemo()throws IOException         {                   DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));                    String s = dis.readUTF();                    System.out.println(s);                   dis.close();         }            publicstatic void writeUTFDemo()throws IOException         {                   DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));                    dos.writeUTF("你好");                    dos.close();         }          publicstatic void readData()throws IOException         {                   DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));                    int num = dis.readInt();                   boolean b = dis.readBoolean();                   double d = dis.readDouble();                    System.out.println("num="+num);                   System.out.println("b="+b);                   System.out.println("d="+d);                    dis.close();         }         publicstatic void writeData()throws IOException         {                   DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));                    dos.writeInt(234);                   dos.writeBoolean(true);                   dos.writeDouble(9887.543);                    dos.close();                    ObjectOutputStream oos = null;                   oos.writeObject(newO());                            }}

 

7.18  操作字节数组

ByteArrayInputStream与ByteArrayOutputStream

 

用于操作字节数组的流对象。

 

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

 

ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

这就是数据目的地。

 

因为这两个流对象都操作的数组，并没有使用系统资源。

所以，不用进行close关闭。

 

在流操作规律讲解时：

 

源设备，

         键盘 System.in，硬盘FileStream，内存 ArrayStream。

 

目的设备：

         控制台System.out，硬盘FileStream，内存 ArrayStream。

 

用流的读写思想来操作数据。

 

练习五：ByteArrayInputStream与ByteArrayOutputStream

 

import java.io.*;class ByteArrayStream{         public static void main(String[] args)         {                   //数据源。getBytes（）是将一个字符串转化为一个字节数组                   ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());                    //数据目的                   ByteArrayOutputStream bos = new ByteArrayOutputStream();                    int by = 0;                    while((by=bis.read())!=-1)                   {                            bos.write(by);                   }                      System.out.println(bos.size());//输出流的大小                   System.out.println(bos.toString());          //      bos.writeTo(newFileOutputStream("a.txt"));          }}

 

 

7.19字符编码

 

字符流的出现为了方便操作字符。

更重要是的加入了编码转换。

通过子类转换流来完成。

InputStreamReader

OutputStreamWriter

在两个对象进行构造的时候可以加入字符集。

 

编码表的由来

 

计算机只能识别二进制数据，早期由来是电信号。

为了方便应用计算机，让它可以识别各个国家的文字。

就将各个国家的文字用数字来表示，并一一对应，形成一张表。

这就是编码表。

 

常见的编码表

 

ASCII：美国标准信息交换码。

用一个字节的7位可以表示。

ISO8859-1：拉丁码表。欧洲码表

用一个字节的8位表示。

GB2312：中国的中文编码表。

GBK：中国的中文编码表升级，融合了更多的中文文字符号。

Unicode：国际标准码，融合了多种文字。

所有文字都用两个字节来表示,Java语言使用的就是unicode

UTF-8：最多用三个字节来表示一个字符。

......

 

转换流的编码应用

 

可以将字符以指定编码格式存储。

可以对文本数据指定编码格式来解读。

指定编码表的动作由构造函数完成

 

 

练习六：转换流中的字符编码应用

 

 

import java.io.*; class EncodeStream{         public static void main(String[] args) throws IOException         {                            //writeText();                            readText();         }          public static void readText()throws IOException         {                   InputStreamReader isr = new InputStreamReader(newFileInputStream("utf.txt"),"gbk");                    char[] buf = new char[10];                   int len = isr.read(buf);                    String str = new String(buf,0,len);                    System.out.println(str);                    isr.close();         }         public static void writeText()throws IOException         {                   OutputStreamWriter osw = new OutputStreamWriter(newFileOutputStream("utf.txt"),"UTF-8");                    osw.write("你好");                    osw.close();         } }

 

 

字符编码

 

编码：字符串-à字节数组

解码：字节数组-à字符串

 

 

String-->byte[];  str.getBytes(charsetName);

 

 

byte[] -->String: newString(byte[],charsetName);

 

练习七：字符编码解码

 

import java.util.*;class EncodeDemo{         public static void main(String[] args)throws Exception         {                   String s = "哈哈";                                     //对s进行GBK编码                   byte[] b1 = s.getBytes("GBK");                    System.out.println(Arrays.toString(b1));                                     //对b1进行utf-8解码                   String s1 = new String(b1,"utf-8");                   System.out.println("s1="+s1);                    //对s1进行iso8859-1编码。                   byte[] b2 = s1.getBytes("utf-8");                   System.out.println(Arrays.toString(b2));                    //对b2进行gbk解码                   String s2 = new String(b2,"gbk");                    System.out.println("s2="+s2);          }}

 

练习八：Txt文件中存储”联通”练习

 

class EncodeDemo2{         public static void main(String[] args) throws Exception         {                   String s = "��ͨ";                    byte[] by = s.getBytes("gbk");                    for(byte b : by)                   {                            System.out.println(Integer.toBinaryString(b&255));                   }                     System.out.println("HelloWorld!");         }}

 

练习九：按照从高到低顺序排列学生信息，并存储到硬盘文件中

/*有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括姓名，三门课成绩），输入的格式：如：zhagnsan，30，40，60计算出总成绩，并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。 1，描述学生对象。2，定义一个可操作学生对象的工具类。 思想：1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。         所以可以使用TreeSet。3，将集合的信息写入到一个文件中。  */ import java.io.*;import java.util.*; class Student implementsComparable<Student>{         private String name;         private int ma,cn,en;         private int sum;          Student(Stringname,int ma,int cn,int en)         {                   this.name= name;                   this.ma= ma;                   this.cn= cn;                   this.en= en;                   sum= ma + cn + en;         }           public int compareTo(Student s)         {                   int num = new Integer(this.sum).compareTo(new Integer(s.sum));                   if(num==0)                            return this.name.compareTo(s.name);                   return num;         }          public String getName()         {                   returnname;         }         public int getSum()         {                   returnsum;         }          public int hashCode()         {                   returnname.hashCode()+sum*78;          }         public boolean equals(Object obj)         {                   if(!(objinstanceof Student))                            thrownew ClassCastException("类型不匹配");                   Student s = (Student)obj;                    return this.name.equals(s.name) && this.sum==s.sum;         }          public String toString()         {                   return "student["+name+", "+ma+", "+cn+","+en+"]";         }} class StudentInfoTool{         public static Set<Student> getStudents()throws IOException         {                   return getStudents(null);         }          public static Set<Student> getStudents(Comparator<Student> cmp)throwsIOException         {                   BufferedReader bufr =                            new BufferedReader(new InputStreamReader(System.in));                    String line = null;                                     Set<Student> stus  = null;                   if(cmp==null)                            stus= new TreeSet<Student>();                   else                            stus= new TreeSet<Student>(cmp);                   while((line=bufr.readLine())!=null)                   {                            if("over".equals(line))                                     break;                                                       String[] info = line.split(",");                                                       Student stu = new Student(info[0],Integer.parseInt(info[1]),                            Integer.parseInt(info[2]),                            Integer.parseInt(info[3]));                                                        stus.add(stu);                   }                    bufr.close();                    return stus;         }          public static void write2File(Set<Student> stus)throws IOException         {                   BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));                    for(Studentstu : stus)                   {                            bufw.write(stu.toString()+"\t");                            bufw.write(stu.getSum()+"");                            bufw.newLine();                            bufw.flush();                   }                    bufw.close();          }}   class StudentInfoTest{         public static void main(String[] args) throws IOException         {                    Comparator<Student> cmp = Collections.reverseOrder();                    Set<Student> stus = StudentInfoTool.getStudents(cmp);                    StudentInfoTool.write2File(stus);         }}