黑马程序员_88_IO中的其他类

　——- android培训、java培训、期待与您交流！ ———-

对象序列化

ObjectInputStream与ObjectOutputStream
被操作的对象需要实现Serializable。

类通过实现java.io.Serializable接口以启用序列化功能，Serializable只是一个标记接口。

示例

import java.io.Serializable;

class Person implements Serializable{
       private String name;
       private int age;

       public Person(String name,int age){
             this.name = name;
             this.age = age;
      }

       public String getName(){
             return name;
      }

       public void setName(String name){
             this.name = name;
      }

       public int getAge(){
             return age;
      }

       public void setAge(int age){
             this.age = age;
      }
}

运行结果图

创建了obj.object文件

示例2

读取obj.object文件

import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectStreamDemo{
       public static void main(String[] args) throws Exception {
            readObj();
      }

       public static void readObj() throws Exception {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object" ));

            Person p = (Person)ois.readObject();

            System.out.println(p.getName() + ":" + p.getAge());

            ois.close();
      }
}

运行结果图

示例3

writeObject方法不能写入类及其所有超类型的瞬态和静态字段的值。

 import java.io.Serializable;

class Person implements Serializable{
       private static final long serialVersionUID = 9527;

       private transient String name;
       private static int age;

       public Person(String name,int age){
             this.name = name;
             this.age = age;
      }

       public String getName(){
             return name;
      }

       public void setName(String name){
             this.name = name;
      }

       public int getAge(){
             return age;
      }

       public void setAge(int age){
             this.age = age;
      }
}

运行结果图

RandomAccessFile

随机访问文件，自身具备读写的方法。
通过skipBytes(int x),seek(int x)等方法来达到随机访问。

特点：
1. 该对象即能读，又能写。
2. 该对象内部维护了一个byte数组，并通过指针可以操作数组中的元素。
3. 可以通过getFilePointer方法获取指针的位置，和通过seek方法设置指针的位置。
4. 其实该对象就是将字节输入流和输出流进行了封装。
5. 该对象的源或者目的只能是文件。通过构造函数就可以看出。

RandomAccessFile不是io体系中的子类。

示例

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo{
       public static void main(String[] args) throws IOException {
            writeFile();
      }

       //使用RandomAccessFile对象写入一些人员信息，比如姓名和年龄
       public static void writeFile() throws IOException {
             //如果文件不存在，则创建，如果文件存在，不创建
            RandomAccessFile raf = new RandomAccessFile("ranacc.txt" ,"rw" );

            raf.write( "张三".getBytes());
             //使用write方法之写入最后一个字节
            raf.write(97);
             //使用writeInt方法写入四个字节（int类型）
            raf.writeInt(97);

            raf.write( "小强".getBytes());
            raf.writeInt(99);

            raf.close();
      }
}

运行结果图

示例2

打印在控制台

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo{
       public static void main(String[] args) throws IOException {
            readFile();
      }

       public static void readFile() throws IOException {
            RandomAccessFile raf = new RandomAccessFile("ranacc.txt" ,"r" );

             //通过seek设置指针的位置
            raf.seek(9); //随机的读取，只要指定指针的位置即可

             byte[] buf = new byte[4];           
            raf.read(buf);

            String name = new String(buf);
            System.out.println( "name=" + name);

             int age = raf.readInt();
            System.out.println( "age=" + age);

            System.out.println( "pos:" + raf.getFilePointer());

            raf.close();
      }
}

运行结果图

示例3

往指定位置写数据

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo{
       public static void main(String[] args) throws IOException {
            randomWrite();
      }

       public static void randomWrite() throws IOException {
            RandomAccessFile raf = new RandomAccessFile("ranacc.txt" ,"rw" );

             //往指定位置写入数据
            raf.seek(3*8);

            raf.write( "哈哈".getBytes());
            raf.writeInt(102);

            raf.close();
      }
}

运行结果图

管道流

PipedInputStream和PipedOutputStream：输入输出可以直接进行连接，通过结合线程使用。

示例

import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStream{
       public static void main(String[] args) throws Exception {
            PipedInputStream input = new PipedInputStream();
            PipedOutputStream output = new PipedOutputStream();

            input.connect(output);

             new Thread(new Input(input)).start();
             new Thread(new Output(output)).start();
      }
}

class Input implements Runnable{
       private PipedInputStream in;

      Input(PipedInputStream in){
             this.in = in;
      }

       public void run(){
             try{
                   byte[] buf = new byte[1024];
                   int len = in.read(buf);

                  String s = new String(buf,0,len);
                  System.out.println( "s=" + s);
                  in.close();
            } catch(Exception e){
                  e.printStackTrace();
            }
      }
}

class Output implements Runnable{
       private PipedOutputStream out;

      Output(PipedOutputStream out){
             this.out = out;
      }

       public void run(){
             try{
                  out.write( "hi,管道来了！" .getBytes());
                  out.close();
            } catch(Exception e){
                  e.printStackTrace();
            }
      }
}

运行结果图

操作基本数据类型

DataInputStream与DataOutputStream

示例

示例1

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamDemo{
       public static void main(String[] args) throws IOException {
            writeData();
      }

       public static void writeData() throws IOException {
            DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt" ));

            dos.writeUTF( "您好");

            dos.close();
      }
}

运行结果图

示例2

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataStreamDemo{
       public static void main(String[] args) throws IOException {
            readData();
      }

       public static void readData() throws IOException {
            DataInputStream dis = new DataInputStream(new FileInputStream("data.txt" ));

            String str = dis.readUTF();

            System.out.println(str);

            dis.close();
      }
}

运行结果图

操作字节数组

ByteArrayInputStream与ByteArrayOutputStream
 关闭字节数组输出输出流无效，因为它们没有调用底层资源，所有的操作都是在内存中完成的。

示例

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class ByteArrayStreamDemo{
       public static void main(String[] args) throws IOException {
            ByteArrayInputStream bis = new ByteArrayInputStream("abcdef" .getBytes());
            ByteArrayOutputStream bos = new ByteArrayOutputStream();

             int ch = 0;

             while((ch = bis.read()) != -1){
                  bos.write(ch);
            }

            System.out.println(bos.toString());
      }
}

运行结果图

编码表

编码表的由来
计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。
就将各个国家的文字用数字来表示，并一一对应，形成一张表，这就是编码表。

常见的编码表
ASCII：美国标准信息交换码，用一个字节的7位可以表示。
ISO8859-1：拉丁码表。欧洲码表，用一个字节的8位表示。
GB2312：中国的中文编码表。
GBK：中国的中文编码表升级，融合了更多的中文文字符号。
Unicode：国际标准码，融合了多种文字。
所有文字都用两个字节来表示,Java语言使用的就是unicode
UTF-8：最多用三个字节来表示一个字符。

##示例

  import java.io.IOException;

public class EncodeDemo{
       public static void main(String[] args) throws IOException{
             //字符串-->字节数组：编码
             //字符数组-->字符串：解码
            String str = "您好";

             //编码
             byte[] buf1 = str.getBytes("GBK" );
            printBytes(buf1);

             byte[] buf2 = str.getBytes("UTF-8" );
            printBytes(buf2);

             //解码
            String s1 = new String(buf1);
            System.out.println( "s1 = " + s1);

            String s2 = new String(buf2,"UTF-8" );
            System.out.println( "s2 = " + s2);
      }

       private static void printBytes(byte[] buf){
             for(byte b : buf){
                  System.out.print(b + " ");
            }
            System.out.println();
      }
}

运行结果图