Java基础-21-IO流3

最新推荐文章于 2022-12-04 23:09:49 发布

faith_yee

最新推荐文章于 2022-12-04 23:09:49 发布

阅读量412

点赞数

分类专栏： Java入门文章标签： java

本文链接：https://blog.csdn.net/faith_yee/article/details/44755315

版权

Java入门专栏收录该内容

30 篇文章 0 订阅

订阅专栏

Java基础-IO流

IO流进阶3

1、IO流（对象的序列化）

没有方法的接口称为标记接口。例如类Serializable，java.io.Serializable：类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

java.io.ObjectInputStream java.io.ObjectOutputStream

ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。

ObjectInputStream
Object readObject();//从 ObjectInputStream 读取对象。
ObjectOutputStream
void writeObject(Object obj);//  将指定的对象写入 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 ("d:\\JAVADEMO\\day21\\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("d:\\JAVADEMO\\day21\\obj.txt"));
        oos.writeObject(new Person("lisi0",39,"kr"));//传递的参数"kr"改变不了对象中参数，因为它是静态
        oos.close();
    }
}
class Person implements Serializable//接口，用来标记
{
    public static final long serialVersionUTD = 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、IO流（管道流）

PipedInputStream和PipedOutputStream

java.io.PipedInputStream:管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。

void connect(PipedOutputStream src);//使此管道输入流连接到管道输出流 src。
int read(byte[]b,int off,int len);//将最多 len 个数据字节从此管道输入流读入 byte 数组。

java.io.PipedOutputStream:可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入 PipedOutputStream 对象，并由其他线程从连接的PipedInputStream 读取。不建议对这两个对象尝试使用单个线程，因为这样可能会造成该线程死锁。

void connect(PipedInputStream snk);//将此管道输出流连接到接收者。
void write(int b );//将指定 byte 写入传送的输出流。

测试代码：

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

输出结果：

6秒后：

3、IO流（RandomAccessFile）

java.io.RandomAccessFile

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

void seek(long pos);//设置到此文件开头测量到的文件指针偏移量，在该位置发生下一个读取或写入操作。
int skipBytes(int n);//尝试跳过输入的 n 个字节以丢弃跳过的字节。

该类不算是io体系的子类，而是直接继承自Object

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

内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。

long getFilePointer();//返回此文件中的当前偏移量。

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

write();只写最低8位。
RandomAccessFile(File file,String mode);//创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
RandomAccessFile(String name,String mode);//创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。

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

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

测试代码：

import java.io.*;
class RandomAccessFileDemo
{
    public static void main(String [] args)throws Exception
    {
        //writeFile_2();
        writeFile();
        readFile();
    }
    public static void readFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");

        //调整对象中的指针
        raf.seek(8*0);

        //跳过指定的字节数
        //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、IO流（操作基本数据类型的流对象DataStream）

java.io.DataInputStream:数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。

DataInputStream(InputStream in);//使用指定的底层 InputStream 创建一个 DataInputStream。

java.io.DataOutputStream:数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入

DataOutputStream(OutputStream out);//创建一个新的数据输出流，将数据写入指定基础输出流。

测试代码：

import java.io.*;
class DataStreamDemo
{
    public static void main(String[]args)throws IOException
    {
        writeData();
        readData();
        writeUTFDemo();
        readUTFDemo();
    }
    public static void readUTFDemo()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("d:\\JAVADEMO\\day21\\utfdata.txt"));
        String s = dis.readUTF();
        System.out.println(s);
        dis.close();
    }
    public static void writeUTFDemo()throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("d:\\JAVADEMO\\day21\\utfdata.txt"));
        dos.writeUTF("您好");
        dos.close();
    }
    public static void readData()throws IOException
    {
        DataInputStream dis = new DataInputStream(new FileInputStream("d:\\JAVADEMO\\day21\\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("d:\\JAVADEMO\\day21\\data.txt"));
        dos.writeInt(321);
        dos.writeBoolean(true);
        dos.writeDouble(9324234.21);
        dos.close();
    }
}

输出结果：

5、IO流（ByteArrayStream）

java.io.ByteArrayInputStream:ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

ByteArrayInputStream(byte[] buf);//创建一个 ByteArrayInputStream，使用 buf 作为其缓冲区数组。
int read();//从此输入流中读取下一个数据字节。

java.io.ByteArrayOutputStream:数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

void write(int b);//将指定字节（参数 b 的八个低位）写入基础输出流。

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

ByteArrayInputStream:在构造的时候，需要接受数据源。而且数据源是一个字节数组。 ByteArrayOutputStream:在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组，这就是数据目的地。因为这两个流对象都操作的数组，并没有使用系统资源，所以，不用进行close关闭。

在流操作规律讲解时：源设备：键盘（System.in），硬盘（FileStream），内存（ArrayStream）目的设备：控制台（System.out），硬盘（FileStream），内存（ArrayStream）

用流的读写思想来操作数据：（测试代码）：

import java.io.*;
class  ByteArrayStream
{
    public static void main(String[] args)throws IOException 
    {
        //数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG".getBytes());

        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream ();

        int by = 0;
        while((by = bis.read())!=-1)
        {
            bos.write(by);
        }
        System.out.println("bos.size():"+bos.size());
        System.out.println("bos.toString():"+bos.toString());
    }
}

输出结果：

6、IO流（转换流的字符编码）

字符编码

*字符流的出现为了方便操作字符
*更重要的是加入了编码转换
*通过子类转换流来完成：InputStreamReader、OutputStreamWriter
*在两个对象进行构造的时候可以加入字符集。
编码表的由来
*计算机只能识别二进制数据，早起由来是电信号。
*为了方便应用计算机，让它可以识别各个国家的文字，就将各个国家的文字用数字来表示，并一一对应，形成一张表，这就是编码表。

常见编码表：

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

测试代码：

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(new FileInputStream("D:\\JAVADEMO\\day21\\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(new FileOutputStream("D:\\JAVADEMO\\day21\\utf.txt"),"UTF-8");
        osw.write("您好");
        osw.close();
    }
}

输出结果：

当在把代码段(读出乱码那行代码段)改成如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\JAVADEMO\\day21\\utf.txt"),"UTF-8");

输出结果：

这是为什么？如图：

7、IO流（字符编码）

编码：字符串变成字节数组：String--->byte[]; str.getBytes(); 解码：字节数组变成字符串：byte[]--->String; new String(byte[]);

测试代码：

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,"ISO8859-1");
        System.out.println("s1="+s1);
        //对s1进行iso8859-1编码
        byte[]b2=s1.getBytes("iso8859-1");
        System.out.println(Arrays.toString(b2));
        String s2 = new String (b2,"gbk");
        System.out.println("s2="+s2);
    }
}

输出结果：

8、IO流（练习）

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

（1）、描述学生对象
（2）、定义一个可操作学生对象的工具类

思想：

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

测试代码：

import java.util.*;
import java.io.*;
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.en = en;
        this.cn = cn;
        sum = ma+en+cn;
    }
    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
    {
        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("D:\\JAVADEMO\\day21\\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);
    }
}

输出结果：

faith_yee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础-21-IO流3

Java基础-IO流IO流进阶31、IO流（对象的序列化）没有方法的接口称为标记接口。例如类Serializable，java.io.Serializable：类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义
复制链接

扫一扫