黑马程序员——IO（对象序列化、管道流、其他流对象）

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

1.1，对象序列化
1，将堆内存中的对象存入硬盘，保留对象中的数据，称之为对象的持久化（或序列化）。
2，使用到的两个类：ObjectInputStream和ObjectOutputStream

1.2，特有方法
ObjectInputStream： readObject();//从ObjcetInputStream中读取对象

ObjectOutputStream：writeObject();//将指定对象写入ObjcetOutputStream

注意：被操作的对象需要实现Serializable接口（也称标记接口)
     对象的静态成员不能被序列化
     对象的非静态成员要不被序列化，可以用关键字transient修饰

示例：

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"));

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

        System.out.println(p);
        ois.close();
    }

public static void writeObj()throws IOException
    {
        ObjectOutputStream oos = 
new ObjectOutputStream(new FileOutputStream("obj.txt"));

        oos.writeObject(new Person("lisi0",399,"kr"));

        oos.close();
    }
}


class Person implements Serializable
{

public static final long serialVersionUID = 42L;

private String name;
transient int age;
static String country = "cn";
    Person(String name,int age,String country)
    {
this.name = name;
this.age = age;
this.country = country;
    }
public String toString()
    {
return name+":"+age+":"+country;
    }
}

2.1，管道流：PipedInputStream、PipedOutputStream
1，输入输出可以直接进行连接，不用再借助数组或集合等容器进行临时存储。
3，一般结合多线程使用。通常，数据由某个线程写入PipedOutputStream对象，
并由其他线程从连接的PipedInputStream 读取。

2.2，管道流的使用
1，要先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，
覆盖run方法，注意，需要在内部处理异常。
2，创建两个管道流，并用connect()方法将两个流连接
3，创建读写对象，并传入两个线程内，并start执行。

示例：

//管道流
import java.io.*;

class Read implements Runnable
{
private PipedInputStream in;
    Read(PipedInputStream in)
    {
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)
        {
throw new RuntimeException("管道读取流失败");
        }
    }
}

class Write implements Runnable
{
private PipedOutputStream out;
    Write(PipedOutputStream out)
    {
this.out = out;
    }
public void run()
    {
try
        {
            System.out.println("开始写入数据，等待6秒后。");
            Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
        }
catch (Exception e)
        {
throw new RuntimeException("管道输出流失败");
        }
    }
}

class  PipedStreamDemo
{
public static void main(String[] args) throws IOException
    {

        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
in.connect(out);

        Read r = new Read(in);
        Write w = new Write(out);
new Thread(r).start();
new Thread(w).start();


    }
}

3.1，RandomAccessFile
1，该类不是算是IO体系中子类，而是直接继承自Object。
2，但是它是IO包中成员。因为它具备读和写功能。
3，内部封装了一个数组，而且通过指针对数组的元素进行操作。
4，可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。
5，其实完成读写的原理就是内部封装了字节输入流和输出流。
6，通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r，，读写rw等。
7，如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

3.2，RandomAccessFile特有方法
1、seek(pos)：调整对象中指针。来进行指定位置的数据读取和写入。数据要有规律。
如果设置的指针位置已有数据，写入时将会将其修改。用seek可以表示随机读写访问。

2，skipBytes(n)：跳过指定字节数，不可往前跳
3，RandomAccessFile中也有对基本数据类型进行读写的方法。还有readLine方法。

示例：

import java.io.*;

/*
RandomAccessFile

该类不是算是IO体系中子类。
而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置，
同时可以通过seek改变指针的位置。


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

通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式：只读r，，读写rw等。

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。

*/
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();
    }
}

4.1，DataInputStream、DataOutputStream
1、操作基本数据类型的流对象

4.2，DataInputStream
1，readbyte()
2，readInt()
3，readBoolean()
4，readDouble()
5，readUTF();//对应writeUTF，读取以UTF-8修改版编码写入的字符串

4.3，DataOutputStream
1，writeByte(int b);
2，writeInt(int n)
3，writeBoolean(boolean b)
4，writeDouble(double d)
5，writeUTF(String str);//以与机器无关方式使用UTF-8修改版编码将一个字符串写入基础输出流。

 示例：

/*
DataInputStream与DataOutputStream

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

*/
import java.io.*;
class DataStreamDemo 
{
public static void main(String[] args) throws IOException
    {
//writeData();
//readData();

//writeUTFDemo();

// OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("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();
    }



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

        dos.writeUTF("你好");

        dos.close();
    }

public static 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();
    }
public static 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(new O());


    }
}

5.1，操作字节数组的流：ByteArrayInputStream、ByteArrayOutputStream
1、这个对象并没有调用底层资源，所以不用关闭流资源，即使关闭后，仍可调用。
2、内部包含缓冲区，相当于以内存作为流操作源和目的，不会产生任何IO异常。
3，ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

4，ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组
5、其实就是用流的思想操作数组

6，ByteArrayOutputStream中：
writeTo(OutputStream out);//将此 byte 数组输出流的全部内容写入到指定的输出流参数中
int size();//当前缓冲区的大小
toString();//使用平台默认的字符集，通过解码字节将缓冲区内容转换为字符串。

7，字符数组流：CharArrayReader和CharArrayWriter

8，字符串流： StringReader和StringWriter

示例：

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

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

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

因为这两个流对象都操作的数组，并没有使用系统资源。
所以，不用进行close关闭。


在流操作规律讲解时：

源设备，
 键盘 System.in，硬盘 FileStream，内存 ArrayStream。
目的设备：
 控制台 System.out，硬盘FileStream，内存 ArrayStream。


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


*/
import java.io.*;
class ByteArrayStream 
{
public static void main(String[] args) 
    {
//数据源。
        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(new FileOutputStream("a.txt"));

    }
}

6.1，字符编码
1，编码：字符串变成字节数组。
String–>byte[]; str.getBytes(charsetName);

2，解码：字节数组变成字符串。
byte[] –>String: new String(byte[],charsetName);

示例：

/*
编码：字符串变成字节数组。


解码：字节数组变成字符串。

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


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

*/
import java.util.*;
class  EncodeDemo
{
public static void main(String[] args)throws Exception 
    {
        String s = "哈哈";

byte[] b1 = s.getBytes("GBK");

        System.out.println(Arrays.toString(b1));
        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));

        String s2 = new String(b2,"gbk");

        System.out.println("s2="+s2);



    }
}

示例：

/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。

1，描述学生对象。
2，定义一个可操作学生对象的工具类。

思想：
1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。
2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。
 所以可以使用TreeSet。
3，将集合的信息写入到一个文件中。


*/

import java.io.*;
import java.util.*;

class Student implements Comparable<Student>
{
private String name;
private int ma,cn,en;
private int sum;

    Student(String name,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()
    {
return name;
    }
public int getSum()
    {
return sum;
    }

public int hashCode()
    {
return name.hashCode()+sum*78;

    }
public boolean equals(Object obj)
    {
if(!(obj instanceof Student))
throw new 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)throws IOException
    {
        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(Student stu : 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);
    }
}

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