java IO之序列流集合对象Properties 打印流流对象

2023-08-10 10:23:34

序列流

也称为合并流。

SequenceInputStream

　　序列流，对多个流进行合并。

　　SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从

　第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达

包含的最后一个输入流的文件末尾为止。

　　注意：

　　构造函数

　　SequenceInputStream(InputStream s1, InputStream s2)

　　合并两个流

　　使用构造函数SequenceInputStream(InputStream s1, InputStream s2)

private static void testSequenceInputStream() throws IOException {

        FileInputStream fis1 = new FileInputStream("c:\\a.txt");

        FileInputStream fis2 = new FileInputStream("c:\\b.txt");

        SequenceInputStream s1 = new SequenceInputStream(fis1, fis2);

        int len = 0;

        byte[] byt = new byte[1024];

        FileOutputStream fos = new FileOutputStream("c:\\z.txt");

        while ((len = s1.read(byt)) != -1) {

            fos.write(byt, 0, len);

        }

        s1.close();

    }

合并多个流:

public static void testSequenceInputStream() throws Exception {

        InputStream in1 = new FileInputStream("c:/a.txt");

        InputStream in2 = new FileInputStream("c:/b.txt");

        InputStream in3 = new FileInputStream("c:/c.txt");

        LinkedHashSet<InputStream> set = new LinkedHashSet<InputStream>();

        set.add(in1);

        set.add(in2);

        set.add(in3);

        final Iterator<InputStream> iter = set.iterator();

        SequenceInputStream sin = new SequenceInputStream(

                new Enumeration<InputStream>() {

                    @Override

                    public boolean hasMoreElements() {

                        return iter.hasNext();

                    }

                    @Override

                    public InputStream nextElement() {

                        return iter.next();

                    }

                });

        FileOutputStream out = new FileOutputStream("c:/z.txt");

        for (int b = -1; (b = sin.read()) != -1;) {

            out.write(b);

        }

        sin.close();

        out.close();

    }

案例:将map3歌曲文件进行切割拷贝,并合并.

public class Demo2 {

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

        split(new File("c:\\a.mp3"), 10, new File("c:\\"));

        System.out.println("切割完毕");

        LinkedHashSet<InputStream> hs = new LinkedHashSet<InputStream>();

        hs.add(new FileInputStream(new File("c:\\part.1.mp3")));

        hs.add(new FileInputStream(new File("c:\\part.2.mp3")));

        hs.add(new FileInputStream(new File("c:\\part.3.mp3")));

        hs.add(new FileInputStream(new File("c:\\part.4.mp3")));

        merage(hs, new File("c:\\merage.mp3"));

        System.out.println("合并完毕");

    }

    private static void merage(LinkedHashSet<InputStream> hs, File dest)

            throws IOException {

        final Iterator<InputStream> it = hs.iterator();

        FileOutputStream fos = new FileOutputStream(dest);

        SequenceInputStream seq = new SequenceInputStream(

                new Enumeration<InputStream>() {

                    @Override

                    public boolean hasMoreElements() {

                        return it.hasNext();

                    }

                    @Override

                    public InputStream nextElement() {

                        return it.next();

                    }

                });

        byte[] byt = new byte[1024 * 1024];

        int len = 0;

        while ((len = seq.read(byt)) != -1) {

            fos.write(byt, 0, len);

        }

        seq.close();

        fos.close();

    }

    // 1. 切割文件

    /*

     * 切割文件,切割份数, 切割后保存路径

     */

    private static void split(File src, int count, File dir) throws IOException {

        FileInputStream fis = new FileInputStream(src);

        FileOutputStream fos = null;

        byte[] byt = new byte[1024 * 1024];

        int len = 0;

        for (int i = 1; i <= count; i++) {

            len = fis.read(byt);

            if (len != -1) {

                fos = new FileOutputStream(dir + "part." + i + ".mp3");

                fos.write(byt, 0, len);

            }

            // fos.close();

        }

        fis.close();

    }

}

对象的序列化

　　当创建对象时，程序运行时它就会存在，但是程序停止时，对象也就消失了。但是如果希望

对象在程序不运行的情况下仍能存在并保存其信息，将会非常有用，对象将被重建并且拥有与程

序上次运行时拥有的信息相同。可以使用对象的序列化。

　　对象的序列化：将内存中的对象直接写入到文件设备中。

　　对象的反序列化：将文件设备中持久化的数据转换为内存对象

　　基本的序列化由两个方法产生：一个方法用于序列化对象并将它们写入一个流，另一个方法

用于读取流并反序列化对象。

ObjectOutput

  writeObject(Object obj)   将对象写入底层存储或流。

ObjectInput

  readObject()    读取并返回对象。

ObjectOutputStream

ObjectInputStream

由于上述ObjectOutput和ObjectInput是接口，所以需要使用具体实现类。

ObjectOutput

  ObjectOutputStream 被写入的对象必须实现一个接口:Serializable 否则会抛出：NotSerializableException

ObjectInput

  ObjectInputStream    该方法抛出异常：ClassNotFountException

ObjectOutputStream和ObjectInputStream 对象分别需要字节输出流和字节输入流对象来构建对象。也就是这两个流对象需要操作已有对象将对象进行本地持久化存储。

案例：

序列化和反序列化Cat对象。

public class demo3 {

    public static void main(String[] args) throws IOException,

            ClassNotFoundException {

        Cat cat = new Cat("tom", 3);

        FileOutputStream fos = new FileOutputStream(new File("c:\\Cat.txt"));

        ObjectOutputStream oos = new ObjectOutputStream(fos);

        oos.writeObject(cat);

        System.out.println("1"+cat);

        oos.close();

        // 反序列化

        FileInputStream fis = new FileInputStream(new File("c:\\Cat.txt"));

        ObjectInputStream ois = new ObjectInputStream(fis);

        Object readObject = ois.readObject();

        Cat cat2 = (Cat) readObject;

        System.out.println("2"+cat2);

        fis.close();

    }

}

    class Cat implements Serializable {

        public String name;

        public int age;

        public Cat() {

        }

        public Cat(String name, int age) {

            this.name = name;

            this.age = age;

        }

        @Override

        public String toString() {

            return "Cat [name=" + name + ", age=" + age + "]";

        }

    }

例子关键点：

声明Cat类实现了Serializable接口。是一个标示器，没有要实现的方法。
新建Cat对象。
新建字节流对象（FileOutputStream）进序列化对象保存在本地文件中。
新建ObjectOutputStream对象，调用writeObject方法序列化Cat对象。
writeObject方法会执行两个工作：序列化对象，然后将序列化的对象写入文件中。
反序列化就是调用ObjectInputStream的readObject()方法。
异常处理和流的关闭动作要执行。

Serializable：

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

所以需要被序列化的类必须是实现Serializable接口，该接口中没有描述任何的属性和方法，称之为标记接口。

如果对象没有实现接口Serializable，在进行序列化时会抛出：NotSerializableException 异常。

注意：

保存一个对象的真正含义是什么？如果对象的实例变量都是基本数据类型，那么就非常简单。但是如果实例变量是包含对象的引用，会怎么样？保存的会是什么？很显然在Java中保存引用变量的实际值没有任何意义，因为Java引用的值是通过JVM的单一实例的上下文中才有意义。通过序列化后，尝试在JVM的另一个实例中恢复对象，是没有用处的。

如下：

首先建立一个Dog对象，也建立了一个Collar对象。Dog中包含了一个Collar(项圈)

现在想要保存Dog对象，但是Dog中有一个Collar，意味着保存Dog时也应该保存Collar。假如Collar也包含了其他对象的引用，那么会发生什么？意味着保存一个Dog对象需要清楚的知道Dog对象的内部结构。会是一件很麻烦的事情。

Java的序列化机制可以解决该类问题，当序列化一个对象时，Java的序列化机制会负责保存对象的所有关联的对象（就是对象图），反序列化时，也会恢复所有的相关内容。本例中：如果序列化Dog会自动序列化Collar。但是，只有实现了Serializable接口的类才可以序列化。如果只是Dog实现了该接口，而Collar没有实现该接口。会发生什么？

Dog类和Collar类

import java.io.Serializable;

public class Dog implements Serializable {

    private Collar collar;

    private String name;

    public Dog(Collar collar, String name) {

        this.collar = collar;

        this.name = name;

    }

    public Collar getCollar() {

        return collar;

    }

}

class Collar {

    private int size;

    public int getSize() {

        return size;

    }

    public Collar(int size) {

        this.size = size;

    }

}

序列化

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectOutputStream;

public class Demo4 {

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

        Collar coll = new Collar(10);

        Dog dog = new Dog(coll, "旺财");

        FileOutputStream fis = new FileOutputStream(new File("c:\\dog.txt"));

        ObjectOutputStream os = new ObjectOutputStream(fis);

        os.writeObject(dog);

    }

}

执行程序，出现了运行时异常。

Exception in thread "main" java.io.NotSerializableException: Collar

所以我们也必须将Dog中使用的Collar序列化。但是如果我们无法访问Collar的源代码，或者无法使Collar可序列化，如何处理？

两种解决方法：

一：继承Collar类，使子类可序列化

但是：如果Collar是final类，就无法继承了。并且，如果Collar引用了其他非序列化对象，也无法解决该问题。

transient

此时就可以使用transient修饰符，可以将Dog类中的成员变量标识为transient

那么在序列化Dog对象时，序列化就会跳过Collar。

public class Demo4 {

    public static void main(String[] args) throws IOException,

            ClassNotFoundException {

        Collar coll = new Collar(10);

        Dog dog = new Dog(coll, "旺财");

        System.out.println(dog.getCollar().getSize());

        FileOutputStream fis = new FileOutputStream(new File("c:\\dog.txt"));

        ObjectOutputStream os = new ObjectOutputStream(fis);

        os.writeObject(dog);

        // 反序列化

        FileInputStream fos = new FileInputStream(new File("c:\\dog.txt"));

        ObjectInputStream ois = new ObjectInputStream(fos);

        Object readObject = ois.readObject();

        Dog dog2 = (Dog) readObject;

        // Collar未序列化。

        dog2.getCollar().getSize();

    }

}

这样我们具有一个序列化的Dog和非序列化的Collar。

此时反序列化Dog后，访问Collar，就会出现运行时异常

10

Exception in thread "main" java.lang.NullPointerException

注意：序列化不适用于静态变量，因为静态变量并不属于对象的实例变量的一部分。

静态变量随着类的加载而加载，是类变量。由于序列化只适用于对象。

基本数据类型可以被序列化

public class Demo5 {

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

        // 创建序列化流对象

        FileOutputStream fis = new FileOutputStream(new File("c:\\basic.txt"));

        ObjectOutputStream os = new ObjectOutputStream(fis);

        // 序列化基本数据类型

        os.writeDouble(3.14);

        os.writeBoolean(true);

        os.writeInt(100);

        os.writeInt(200);

        // 关闭流

        os.close();

        // 反序列化

        FileInputStream fos = new FileInputStream(new File("c:\\basic.txt"));

        ObjectInputStream ois = new ObjectInputStream(fos);

        System.out.println(ois.readDouble());

        System.out.println(ois.readBoolean());

        System.out.println(ois.readInt());

        System.out.println(ois.readInt());

        fos.close();

    }

}

serialVersionUID

用于给类指定一个UID。该UID是通过类中的可序列化成员的数字签名运算出来的一个long型的值。

只要是这些成员没有变化，那么该值每次运算都一样。

该值用于判断被序列化的对象和类文件是否兼容。

如果被序列化的对象需要被不同的类版本所兼容。可以在类中自定义UID。

定义方式：static final long serialVersionUID = 42L;

Properties.

可以和流相关联的集合对象Properties.

　　Map

　　　　|--Hashtable

　　　　|--Properties

　　Properties:该集合不需要泛型，因为该集合中的键值对都是String类型。

　　1，存入键值对：setProperty(key,value);

　　2，获取指定键对应的值：value getProperty(key);

　　3，获取集合中所有键元素：Enumeration propertyNames();

　　　　　　在jdk1.6版本给该类提供一个新的方法。Set<String> stringPropertyNames();

　　4，列出该集合中的所有键值对，可以通过参数打印流指定列出到的目的地。

　　　　list(PrintStream);

　　　　　　list(PrintWriter);

　　　　　　例：list(System.out):将集合中的键值对打印到控制台。

　　　　　　list(new PrintStream("prop.txt")):将集合中的键值对存储到prop.txt文件中。

　　5，可以将流中的规则数据加载进行集合，并称为键值对。

　　　　load(InputStream):

　　　　jdk1.6版本。提供了新的方法。　load(Reader):

　　　　　　注意：流中的数据要是"键=值" 的规则数据。

　　6，可以将集合中的数据进行指定目的的存储。　store(OutputStram,String comment)方法。

　　jdk1.6版本。提供了新的方法。store(Writer ,String comment):

　　使用该方法存储时，会带着当时存储的时间。

　　注意：

　　Properties只加载key=value这样的键值对，与文件名无关，注释使用#

　　练习：记录一个程序运行的次数，当满足指定次数时，该程序就不可以再继续运行了。

　　通常可用于软件使用次数的限定。

public static void sysPropList() throws IOException {

        Properties prop = System.getProperties();

        // prop.list(System.out);// 目的是控制台。

        // 需求是：将jvm的属性信息存储到一个文件中。

        prop.list(new PrintStream("java.txt"));

    }

    public static void sysProp() {

        Properties prop = System.getProperties();

        Set<String> keys = prop.stringPropertyNames();

        for (String key : keys) {

            System.out.println(key + ":" + prop.getProperty(key));

        }

    }

800x600

Normal
0

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE

MicrosoftInternetExplorer4

/* Style Definitions */
table.MsoNormalTable
{mso-style-name:普通表格;
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-priority:99;
mso-style-parent:"";
mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
mso-para-margin:0cm;
mso-para-margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.0pt;
font-family:"Times New Roman",serif;}

Properties类与配置文件

Map

|--Hashtable

|--Properties

注意：是一个Map集合，该集合中的键值对都是字符串。该集合通常用于对键值对形式的配置文件进行操作.

配置文件：将软件中可变的部分数据可以定义到一个文件中，方便以后更改，该文件称之为配置文件。

优势: 提高代码的维护性。

　　Properties: 该类是一个Map的子类，提供了可以快速操作配置文件的方法

　　load() : 将文件设备数据装载为Map集合数据

　　get(key): 获取Map中的数据

　　getProperty()获取Map中的数据特有方法

案例：

/*

     * 将配置文件中的数据通过流加载到集合中。

     */

    public static void loadFile() throws IOException {

        // 1,创建Properties(Map)对象

        Properties prop = new Properties();

        // 2.使用流加载配置文件。

        FileInputStream fis = new FileInputStream("c:\\qq.txt");

        // 3。使用Properties 对象的load方法将流中数据加载到集合中。

        prop.load(fis);

        // 遍历该集合

        Set<Entry<Object, Object>> entrySet = prop.entrySet();

        Iterator<Entry<Object, Object>> it = entrySet.iterator();

        while (it.hasNext()) {

            Entry<Object, Object> next = it.next();

            Object key = next.getKey();

            Object value = next.getValue();

        }

        // 通过键获取指定的值

        Object object = prop.get("jack");

        System.out.println(object);

        // 通过键修改值

        prop.setProperty("jack", "888888");

        // 将集合中的数据写入到配置文件中。

        FileOutputStream fos = new FileOutputStream("c:\\qq.txt");

        // 注释：

        prop.store(fos, "yes,qq");

        fos.close();

        fis.close();

    }

获取记录程序运行次数：

public class Demo6 {

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

        int count = 0;

        Properties pro = new Properties();

        File file = new File("c:\\count.ini");

        FileInputStream fis = null;

        if (!file.exists()) {

            file.createNewFile();

        }

        fis = new FileInputStream(file);

        pro.load(fis);

        String str = pro.getProperty("count");

        if (str != null) {

            count = Integer.parseInt(str);

        }

        if (count == 3) {

            System.out.println("使用次数已到，请付费");

            System.exit(0);

        }

        count++;

        System.out.println("欢迎使用本软件" + "你已经使用了：" + count + " 次");

        pro.setProperty("count", count + "");

        FileOutputStream fos = new FileOutputStream(new File("c:\\count.ini"));

        pro.store(fos, "请保护知识产权");

        fis.close();

        fos.close();

    }

}

打印流

PrintStream可以接受文件和其他字节输出流，所以打印流是对普通字节输出流的增强，

其中定义了很多的重载的print()和println()，方便输出各种类型的数据。

PrintStream

PrintWriter

1，打印流。

PrintStream：

　　是一个字节打印流，System.out对应的类型就是PrintStream。

　　它的构造函数可以接收三种数据类型的值。

　　　　1，字符串路径。

　　　　2，File对象。

　　　　3，OutputStream。

public class pp {

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

        PrintStream ps = System.out;

        // 普通write方法需要调用flush或者close方法才会在控制台显示

        // ps.write(100);

        // ps.close();

        // 不换行打印

        ps.print(100);

        ps.print('a');

        ps.print(100.5);

        ps.print("世界");

        ps.print(new Object());

        System.out.println("--------------");

        // 换行

        ps.println(100);

        ps.println('a');

        ps.println(100.5);

        ps.println("世界");

        ps.println(new Object());

        // 重定向打印流

        PrintStream ps2 = new PrintStream(new File("c:\\a.txt"));

        System.setOut(ps2);

        // 换行

        ps2.println(100);

        ps2.println('a');

        ps2.println(100.5);

        ps2.println("世界");

        ps2.println(new Object());

        // printf(); 格式化

        ps2.printf("%d,%f,%c,%s", 100, 3.14, '中', "世界你好!!!");

        ps2.printf("%4s和%8s 打价格战", "京东", "苏宁");

    }

}

//结果：

100a100.5世界java.lang.Object@40e455bf--------------

100

a

100.5

世界

java.lang.Object@4eb98fe1

aaarticlea/png;base64,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" alt="" />

注意: 打印流的三种方法

void print(数据类型变量)

　　println(数据类型变量)

　　printf(String format, Object... args)

可以自定数据格式

print 和println方法的区别在于,一个换行一个不换行

print 方法和write方法的却别在于,print提供自动刷新.

普通的write方法需要调用flush或者close方法才可以看到数据.

JDK1.5之后Java对PrintStream进行了扩展，增加了格式化输出方式，可以使用printf()重载方法直接格式化输出。但是在格式化输出的时候需要指定输出的数据类型格式。

aaarticlea/png;base64,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" alt="" />

PrintWriter

是一个字符打印流。构造函数可以接收四种类型的值。

　　1，字符串路径。

　　2，File对象。

　　对于1，2类型的数据，还可以指定编码表。也就是字符集。

　　3，OutputStream

　　4，Writer

　　对于3，4类型的数据，可以指定自动刷新。

　　注意：该自动刷新值为true时，只有三个方法可以用：println,printf,format.

　　如果想要既有自动刷新，又可执行编码。如何完成流对象的包装？

　　PrintWrter pw = new PrintWriter(new OutputSteamWriter(new FileOutputStream("a.txt"),"utf-8"),true);

　　如果想要提高效率。还要使用打印方法。

　　PrintWrter pw = newPrintWriter(new BufferdWriter(new OutputSteamWriter(

newFileOutputStream("a.txt"),"utf-8")),true);

public static void testPrintWriter() throws Exception {

        PrintWriter pw = new PrintWriter("c:/b.txt", "gbk");

        // pw.append("xxx");

        // pw.println(55);

        // pw.println('c');

        // pw.printf("%.1s与%4s打价格战, %c", "京东","苏宁", 'a');

        pw.close();

    }

Scanner

public static void testScanner() throws Exception {

        // Scanner scanner = new Scanner(new File("c:/test.txt"));

        Scanner scanner = new Scanner(System.in);

        System.out.println(scanner.nextInt());

        System.out.println(scanner.nextBoolean());

        scanner.close();

    }

操作数组的流对象

操作字节数组

　　ByteArrayInputStream 以及ByteArrayOutputStream

　　toByteArray();

　　toString();

　　writeTo(OutputStream);

public static void testByteArrayInputStream() throws Exception {

        InputStream in = new ByteArrayInputStream(new byte[] { 65, 66, 67 });

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        for (int b = -1; (b = in.read()) != -1;) {

            out.write(b);

        }

        in.close();

        out.close();

        System.out.println(Arrays.toString(out.toByteArray()));

        System.out.println(out);

    }

操作字符数组

CharArrayReader

CharArrayWriter

对于这些流，源是内存。目的也是内存。

而且这些流并未调用系统资源。使用的就是内存中的数组。

所以这些在使用的时候不需要close。

操作数组的读取流在构造时，必须要明确一个数据源。所以要传入相对应的数组。

对于操作数组的写入流，在构造函数可以使用空参数。因为它内置了一个可变长度数组作为缓冲区。

public static void testCharArrayReader() throws Exception {

        CharArrayReader reader = new CharArrayReader(new char[] { 'A', 'b', 'c' });

        CharArrayWriter writer = new CharArrayWriter();

        for (int b = -1; (b = reader.read()) != -1;) {

            writer.write(b);

        }

        reader.close();

        writer.close();

        System.out.println(writer.toCharArray());

    }

这几个流的出现其实就是通过流的读写思想在操作数组。

类似的对象同理：

StringReader

StringWriter。

public static void testStringReader() throws Exception {

        StringReader reader = new StringReader("test 中国");

        StringWriter writer = new StringWriter();

        for (int b = -1; (b = reader.read()) != -1;) {

            writer.write(b);

        }

        reader.close();

        writer.close();

        System.out.println(writer.toString());

    }

操作基本数据类型的流对象

DataInputStream

以及DataOutputStream

查看API文档DataInputStream的信息。发现从底层输入流中读取基本 Java 数据类型。查看方法,有读一个字节,读一个char读一个double 的方法,

DataInputStream 从数据流读取字节，并将它们转换为正确的基本数据类型值或字符串。

该流有操作基本数据类型的方法.

有读的,那么必定有对应的写的就是DataOutputStream 将基本类型的值或字符串转换为字节，并且将字节输出到数据流。

DataInputStream类继承FilterInputStream类，并实现了DataInput接口。DataOutputStream

类继承FilterOutputStream 并实现了DataOutput 接口。

例如：

DataInputStream

操作基本数据类型的方法：

int readInt():一次读取四个字节，并将其转成int值。

boolean readBoolean():一次读取一个字节。

short readShort();

long readLong();

剩下的数据类型一样。

String readUTF():按照utf-8修改版读取字符。注意，它只能读writeUTF()写入的字符数据。

DataOutputStream

DataOutputStream(OutputStream):

操作基本数据类型的方法:

writeInt(int)：一次写入四个字节。

注意和write(int)不同。write(int)只将该整数的最低一个8位写入。剩余三个8位丢弃。

writeBoolean(boolean);

writeShort(short);

writeLong(long);

剩下是数据类型也也一样。

writeUTF(String):按照utf-8修改版将字符数据进行存储。只能通过readUTF读取。

测试: DataOutputStream

使用DataOutputStream写数据文件。

public static void testDataInputStream() throws Exception {

        DataOutputStream out = new DataOutputStream(new FileOutputStream(

                "c:/a.txt"));

        out.writeBoolean(true);

        out.writeByte(15); // 0x05 1 个字节

        out.writeBytes("abc"); // 0x 0041 2个字节

        out.writeChar('X'); // ??

        out.writeChars("xyz");

        out.writeLong(111);

        out.writeUTF("中国");

        out.close();

        DataInputStream in = new DataInputStream(

                new FileInputStream("c:/a.txt"));

        System.out.println(in.readBoolean());

        System.out.println(in.readByte());

        System.out.println(in.readByte());

        System.out.println(in.readByte());

        System.out.println(in.readByte());

        System.out.println(in.readChar());

        System.out.println(in.readChar());

        System.out.println(in.readChar());

        System.out.println(in.readChar());

        System.out.println(in.readLong());

        System.out.println(in.readUTF());

        in.close();

    }

800x600

Normal
0

7.8 磅
0
2

false
false
false

EN-US
ZH-CN
X-NONE

MicrosoftInternetExplorer4

码农公寓

SequenceInputStream

对象的序列化

ObjectOutputStream

ObjectInputStream

Serializable：

Properties.

打印流

PrintStream

PrintWriter

操作数组的流对象

操作字节数组

操作字符数组

操作基本数据类型的流对象

DataInputStream

相关文章