Java中的IO整理完整版（二）

最新推荐文章于 2024-11-04 20:33:37 发布

编程是一门艺术

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量324

点赞数

分类专栏： java 文章标签： java io string file null input

java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

BufferedReader的小例子

注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：

   
   BufferedReader buf = new BufferedReader(  
                new InputStreamReader(System.in));

下面给一个实例：

   
   import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStreamReader;  
 
/**  
 * 使用缓冲区从键盘上读入内容  
 * */ 
public class BufferedReaderDemo{  
    public static void main(String[] args){  
        BufferedReader buf = new BufferedReader(  
                new InputStreamReader(System.in));  
        String str = null;  
        System.out.println("请输入内容");  
        try{  
            str = buf.readLine();  
        }catch(IOException e){  
            e.printStackTrace();  
        }  
        System.out.println("你输入的内容是：" + str);  
    }  
}

运行结果：

请输入内容

dasdas

你输入的内容是：dasdas

Scanner类

其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧

   
   import java.util.Scanner;  
 
/**  
 * Scanner的小例子，从键盘读数据  
 * */ 
public class ScannerDemo{  
    public static void main(String[] args){  
        Scanner sca = new Scanner(System.in);  
        // 读一个整数  
        int temp = sca.nextInt();  
        System.out.println(temp);  
        //读取浮点数  
        float flo=sca.nextFloat();  
        System.out.println(flo);  
        //读取字符  
        //...等等的，都是一些太基础的，就不师范了。  
    }  
}

其实Scanner可以接受任何的输入流

下面给一个使用Scanner类从文件中读出内容

   
   import java.io.File;  
import java.io.FileNotFoundException;  
import java.util.Scanner;  
 
/**  
 * Scanner的小例子，从文件中读内容  
 * */ 
public class ScannerDemo{  
    public static void main(String[] args){  
 
        File file = new File("d:" + File.separator + "hello.txt");  
        Scanner sca = null;  
        try{  
            sca = new Scanner(file);  
        }catch(FileNotFoundException e){  
            e.printStackTrace();  
        }  
        String str = sca.next();  
        System.out.println("从文件中读取的内容是：" + str);  
    }  
}

【运行结果】：

从文件中读取的内容是：这些文件中的内容哦！

数据操作流DataOutputStream、DataInputStream类

   
   import java.io.DataOutputStream;  
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
 
public class DataOutputStreamDemo{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.txt");  
        char[] ch = { 'A', 'B', 'C' };  
        DataOutputStream out = null;  
        out = new DataOutputStream(new FileOutputStream(file));  
        for(char temp : ch){  
            out.writeChar(temp);  
        }  
        out.close();  
    }  
}

A B C

现在我们在上面例子的基础上，使用DataInputStream读出内容

   
   import java.io.DataInputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.IOException;  
 
public class DataOutputStreamDemo{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.txt");  
        DataInputStream input = new DataInputStream(new FileInputStream(file));  
        char[] ch = new char[10];  
        int count = 0;  
        char temp;  
        while((temp = input.readChar()) != 'C'){  
            ch[count++] = temp;  
        }  
        System.out.println(ch);  
    }  
}

【运行结果】：

合并流 SequenceInputStream

SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：

   
   import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.io.SequenceInputStream;  
 
/**  
 * 将两个文本文件合并为另外一个文本文件  
 * */ 
public class SequenceInputStreamDemo{  
    public static void main(String[] args) throws IOException{  
        File file1 = new File("d:" + File.separator + "hello1.txt");  
        File file2 = new File("d:" + File.separator + "hello2.txt");  
        File file3 = new File("d:" + File.separator + "hello.txt");  
        InputStream input1 = new FileInputStream(file1);  
        InputStream input2 = new FileInputStream(file2);  
        OutputStream output = new FileOutputStream(file3);  
        // 合并流  
        SequenceInputStream sis = new SequenceInputStream(input1, input2);  
        int temp = 0;  
        while((temp = sis.read()) != -1){  
            output.write(temp);  
        }  
        input1.close();  
        input2.close();  
        output.close();  
        sis.close();  
    }  
}

【运行结果】

结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。

文件压缩 ZipOutputStream类

先举一个压缩单个文件的例子吧：

   
   import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.zip.ZipEntry;  
import java.util.zip.ZipOutputStream;  
 
public class ZipOutputStreamDemo1{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.txt");  
        File zipFile = new File("d:" + File.separator + "hello.zip");  
        InputStream input = new FileInputStream(file);  
        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(  
                zipFile));  
        zipOut.putNextEntry(new ZipEntry(file.getName()));  
        // 设置注释  
        zipOut.setComment("hello");  
        int temp = 0;  
        while((temp = input.read()) != -1){  
            zipOut.write(temp);  
        }  
        input.close();  
        zipOut.close();  
    }  
}

【运行结果】

运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。
不过结果肯定是正确的，我只是提出我的一个疑问而已。

上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。

   
   import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.util.zip.ZipEntry;  
import java.util.zip.ZipOutputStream;  
 
/**  
 * 一次性压缩多个文件  
 * */ 
public class ZipOutputStreamDemo2{  
    public static void main(String[] args) throws IOException{  
        // 要被压缩的文件夹  
        File file = new File("d:" + File.separator + "temp");  
        File zipFile = new File("d:" + File.separator + "zipFile.zip");  
        InputStream input = null;  
        ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(  
                zipFile));  
        zipOut.setComment("hello");  
        if(file.isDirectory()){  
            File[] files = file.listFiles();  
            for(int i = 0; i < files.length; ++i){  
                input = new FileInputStream(files[i]);  
                zipOut.putNextEntry(new ZipEntry(file.getName()  
                        + File.separator + files[i].getName()));  
                int temp = 0;  
                while((temp = input.read()) != -1){  
                    zipOut.write(temp);  
                }  
                input.close();  
            }  
        }  
        zipOut.close();  
    }  
}

【运行结果】

先看看要被压缩的文件吧：

接下来看看压缩之后的：

大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的

   
   import java.io.File;  
import java.io.IOException;  
import java.util.zip.ZipFile;  
 
/**  
 * ZipFile演示  
 * */ 
public class ZipFileDemo{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.zip");  
        ZipFile zipFile = new ZipFile(file);  
        System.out.println("压缩文件的名称为：" + zipFile.getName());  
    }  
}

【运行结果】：

压缩文件的名称为：d:\hello.zip

现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件(也就是压缩文件中只有一个文件的情况)，我们采用前面的例子产生的压缩文件hello.zip

   
   import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.zip.ZipEntry;  
import java.util.zip.ZipFile;  
 
/**  
 * 解压缩文件（压缩文件中只有一个文件的情况）  
 * */ 
public class ZipFileDemo2{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.zip");  
        File outFile = new File("d:" + File.separator + "unZipFile.txt");  
        ZipFile zipFile = new ZipFile(file);  
        ZipEntry entry = zipFile.getEntry("hello.txt");  
        InputStream input = zipFile.getInputStream(entry);  
        OutputStream output = new FileOutputStream(outFile);  
        int temp = 0;  
        while((temp = input.read()) != -1){  
            output.write(temp);  
        }  
        input.close();  
        output.close();  
    }  
}

【运行结果】：
解压缩之前：

这个压缩文件还是175字节
解压之后产生：

又回到了56字节，表示郁闷。

现在让我们来解压一个压缩文件中包含多个文件的情况吧
ZipInputStream类

当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类

   
   import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.OutputStream;  
import java.util.zip.ZipEntry;  
import java.util.zip.ZipFile;  
import java.util.zip.ZipInputStream;  
 
/**  
 * 解压缩一个压缩文件中包含多个文件的情况  
 * */ 
public class ZipFileDemo3{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "zipFile.zip");  
        File outFile = null;  
        ZipFile zipFile = new ZipFile(file);  
        ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));  
        ZipEntry entry = null;  
        InputStream input = null;  
        OutputStream output = null;  
        while((entry = zipInput.getNextEntry()) != null){  
            System.out.println("解压缩" + entry.getName() + "文件");  
            outFile = new File("d:" + File.separator + entry.getName());  
            if(!outFile.getParentFile().exists()){  
                outFile.getParentFile().mkdir();  
            }  
            if(!outFile.exists()){  
                outFile.createNewFile();  
            }  
            input = zipFile.getInputStream(entry);  
            output = new FileOutputStream(outFile);  
            int temp = 0;  
            while((temp = input.read()) != -1){  
                output.write(temp);  
            }  
            input.close();  
            output.close();  
        }  
    }  
}

【运行结果】：
被解压的文件：

解压之后再D盘下会出现一个temp文件夹，里面内容：

PushBackInputStream回退流

   
   import java.io.ByteArrayInputStream;  
import java.io.IOException;  
import java.io.PushbackInputStream;  
 
/**  
 * 回退流操作  
 * */ 
public class PushBackInputStreamDemo{  
    public static void main(String[] args) throws IOException{  
        String str = "hello,rollenholt";  
        PushbackInputStream push = null;  
        ByteArrayInputStream bat = null;  
        bat = new ByteArrayInputStream(str.getBytes());  
        push = new PushbackInputStream(bat);  
        int temp = 0;  
        while((temp = push.read()) != -1){  
            if(temp == ','){  
                push.unread(temp);  
                temp = push.read();  
                System.out.print("(回退" + (char) temp + ") ");  
            }else{  
                System.out.print((char) temp);  
            }  
        }  
    }  
}

【运行结果】：
hello(回退,) rollenholt

   
   /**  
 * 取得本地的默认编码  
 * */ 
public class CharSetDemo{  
    public static void main(String[] args){  
        System.out.println("系统默认编码为：" + System.getProperty("file.encoding"));  
    }  
}

【运行结果】：

系统默认编码为：GBK

乱码的产生：

   
   import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.OutputStream;  
 
/**  
 * 乱码的产生  
 * */ 
public class CharSetDemo2{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.txt");  
        OutputStream out = new FileOutputStream(file);  
        byte[] bytes = "你好".getBytes("ISO8859-1");  
        out.write(bytes);  
        out.close();  
    }  
}

【运行结果】：

一般情况下产生乱码，都是由于编码不一致的问题。

对象的序列化

对象序列化就是把一个对象变为二进制数据流的一种方法。

一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。

先让我们实现一个具有序列化能力的类吧：

   
   import java.io.*;  
/**  
 * 实现具有序列化能力的类  
 * */ 
public class SerializableDemo implements Serializable{  
    public SerializableDemo(){  
          
    }  
    public SerializableDemo(String name, int age){  
        this.name=name;  
        this.age=age;  
    }  
    @Override 
    public String toString(){  
        return "姓名："+name+"  年龄："+age;  
    }  
    private String name;  
    private int age;  
}

这个类就具有实现序列化能力，

在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类

先给一个ObjectOutputStream的例子吧：

   
   import java.io.Serializable;  
import java.io.File;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.ObjectOutputStream;  
 
/**  
 * 实现具有序列化能力的类  
 * */ 
public class Person implements Serializable{  
    public Person(){  
 
    }  
 
    public Person(String name, int age){  
        this.name = name;  
        this.age = age;  
    }  
 
    @Override 
    public String toString(){  
        return "姓名：" + name + "  年龄：" + age;  
    }  
 
    private String name;  
    private int age;  
}  
/**  
 * 示范ObjectOutputStream  
 * */ 
public class ObjectOutputStreamDemo{  
    public static void main(String[] args) throws IOException{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(  
                file));  
        oos.writeObject(new Person("rollen", 20));  
        oos.close();  
    }  
}

【运行结果】：

当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。

虽然我们不能直接查看里面的内容，但是我们可以使用ObjectInputStream类查看：

   
   import java.io.File;  
import java.io.FileInputStream;  
import java.io.ObjectInputStream;  
 
/**  
 * ObjectInputStream示范  
 * */ 
public class ObjectInputStreamDemo{  
    public static void main(String[] args) throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
                file));  
        Object obj = input.readObject();  
        input.close();  
        System.out.println(obj);  
    }  
}

【运行结果】

姓名：rollen 年龄：20

到底序列化什么内容呢?

其实只有属性会被序列化。

Externalizable接口

被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。

当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。

现在我们来演示一下序列化和反序列话：

   
   package IO;  
 
import java.io.Externalizable;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.io.ObjectInput;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutput;  
import java.io.ObjectOutputStream;  
 
/**  
 * 序列化和反序列化的操作  
 * */ 
public class ExternalizableDemo{  
    public static void main(String[] args) throws Exception{  
        ser(); // 序列化  
        dser(); // 反序列话  
    }  
 
    public static void ser() throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(  
                file));  
        out.writeObject(new Person("rollen", 20));  
        out.close();  
    }  
 
    public static void dser() throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
                file));  
        Object obj = input.readObject();  
        input.close();  
        System.out.println(obj);  
    }  
}  
 
class Person implements Externalizable{  
    public Person(){  
 
    }  
 
    public Person(String name, int age){  
        this.name = name;  
        this.age = age;  
    }  
 
    @Override 
    public String toString(){  
        return "姓名：" + name + "  年龄：" + age;  
    }  
 
    // 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用  
    @Override 
    public void writeExternal(ObjectOutput out) throws IOException{  
        out.writeObject(this.name);  
        out.writeInt(age);  
    }  
 
    // 复写这个方法，根据需要读取内容 反序列话的时候需要  
    @Override 
    public void readExternal(ObjectInput in) throws IOException,  
            ClassNotFoundException{  
        this.name = (String) in.readObject();  
        this.age = in.readInt();  
    }  
 
    private String name;  
    private int age;  
}

【运行结果】：

姓名：rollen 年龄：20

本例中，我们将全部的属性都保留了下来，

Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，

当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：

下面举一个例子：

   
   package IO;  
 
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.io.Serializable;  
 
/**  
 * 序列化和反序列化的操作  
 * */ 
public class serDemo{  
    public static void main(String[] args) throws Exception{  
        ser(); // 序列化  
        dser(); // 反序列话  
    }  
 
    public static void ser() throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(  
                file));  
        out.writeObject(new Person1("rollen", 20));  
        out.close();  
    }  
 
    public static void dser() throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
                file));  
        Object obj = input.readObject();  
        input.close();  
        System.out.println(obj);  
    }  
}  
 
class Person1 implements Serializable{  
    public Person1(){  
 
    }  
 
    public Person1(String name, int age){  
        this.name = name;  
        this.age = age;  
    }  
 
    @Override 
    public String toString(){  
        return "姓名：" + name + "  年龄：" + age;  
    }  
 
    // 注意这里  
    private transient String name;  
    private int age;  
}

【运行结果】：

姓名：null 年龄：20

最后在给一个序列化一组对象的例子吧：

   
   import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.io.Serializable;  
 
/**  
 * 序列化一组对象  
 * */ 
public class SerDemo1{  
    public static void main(String[] args) throws Exception{  
        Student[] stu = { new Student("hello", 20), new Student("world", 30),  
                new Student("rollen", 40) };  
        ser(stu);  
        Object[] obj = dser();  
        for(int i = 0; i < obj.length; ++i){  
            Student s = (Student) obj[i];  
            System.out.println(s);  
        }  
    }  
 
    // 序列化  
    public static void ser(Object[] obj) throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(  
                file));  
        out.writeObject(obj);  
        out.close();  
    }  
 
    // 反序列化  
    public static Object[] dser() throws Exception{  
        File file = new File("d:" + File.separator + "hello.txt");  
        ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
                file));  
        Object[] obj = (Object[]) input.readObject();  
        input.close();  
        return obj;  
    }  
}  
 
class Student implements Serializable{  
    public Student(){  
 
    }  
 
    public Student(String name, int age){  
        this.name = name;  
        this.age = age;  
    }  
 
    @Override 
    public String toString(){  
        return "姓名：  " + name + "  年龄：" + age;  
    }  
 
    private String name;  
    private int age;  
}