`
zys08
  • 浏览: 141712 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

java中IO操作整理 2

阅读更多

BufferedReader的小例子

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

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

下面给一个实例:

  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStreamReader;  
  4.  
  5. /**  
  6.  * 使用缓冲区从键盘上读入内容  
  7.  * */ 
  8. public class BufferedReaderDemo{  
  9.     public static void main(String[] args){  
  10.         BufferedReader buf = new BufferedReader(  
  11.                 new InputStreamReader(System.in));  
  12.         String str = null;  
  13.         System.out.println("请输入内容");  
  14.         try{  
  15.             str = buf.readLine();  
  16.         }catch(IOException e){  
  17.             e.printStackTrace();  
  18.         }  
  19.         System.out.println("你输入的内容是:" + str);  
  20.     }  

运行结果:

请输入内容

dasdas

你输入的内容是:dasdas

Scanner类

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

  1. import java.util.Scanner;  
  2.  
  3. /**  
  4.  * Scanner的小例子,从键盘读数据  
  5.  * */ 
  6. public class ScannerDemo{  
  7.     public static void main(String[] args){  
  8.         Scanner sca = new Scanner(System.in);  
  9.         // 读一个整数  
  10.         int temp = sca.nextInt();  
  11.         System.out.println(temp);  
  12.         //读取浮点数  
  13.         float flo=sca.nextFloat();  
  14.         System.out.println(flo);  
  15.         //读取字符  
  16.         //...等等的,都是一些太基础的,就不师范了。  
  17.     }  

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

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

  1. import java.io.File;  
  2. import java.io.FileNotFoundException;  
  3. import java.util.Scanner;  
  4.  
  5. /**  
  6.  * Scanner的小例子,从文件中读内容  
  7.  * */ 
  8. public class ScannerDemo{  
  9.     public static void main(String[] args){  
  10.  
  11.         File file = new File("d:" + File.separator + "hello.txt");  
  12.         Scanner sca = null;  
  13.         try{  
  14.             sca = new Scanner(file);  
  15.         }catch(FileNotFoundException e){  
  16.             e.printStackTrace();  
  17.         }  
  18.         String str = sca.next();  
  19.         System.out.println("从文件中读取的内容是:" + str);  
  20.     }  

【运行结果】:

从文件中读取的内容是:这些文件中的内容哦!

数据操作流DataOutputStream、DataInputStream类

  1. import java.io.DataOutputStream;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5.  
  6. public class DataOutputStreamDemo{  
  7.     public static void main(String[] args) throws IOException{  
  8.         File file = new File("d:" + File.separator + "hello.txt");  
  9.         char[] ch = { 'A''B''C' };  
  10.         DataOutputStream out = null;  
  11.         out = new DataOutputStream(new FileOutputStream(file));  
  12.         for(char temp : ch){  
  13.             out.writeChar(temp);  
  14.         }  
  15.         out.close();  
  16.     }  

A B C

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

  1. import java.io.DataInputStream;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.IOException;  
  5.  
  6. public class DataOutputStreamDemo{  
  7.     public static void main(String[] args) throws IOException{  
  8.         File file = new File("d:" + File.separator + "hello.txt");  
  9.         DataInputStream input = new DataInputStream(new FileInputStream(file));  
  10.         char[] ch = new char[10];  
  11.         int count = 0;  
  12.         char temp;  
  13.         while((temp = input.readChar()) != 'C'){  
  14.             ch[count++] = temp;  
  15.         }  
  16.         System.out.println(ch);  
  17.     }  

【运行结果】:

AB

合并流 SequenceInputStream

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

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.io.SequenceInputStream;  
  8.  
  9. /**  
  10.  * 将两个文本文件合并为另外一个文本文件  
  11.  * */ 
  12. public class SequenceInputStreamDemo{  
  13.     public static void main(String[] args) throws IOException{  
  14.         File file1 = new File("d:" + File.separator + "hello1.txt");  
  15.         File file2 = new File("d:" + File.separator + "hello2.txt");  
  16.         File file3 = new File("d:" + File.separator + "hello.txt");  
  17.         InputStream input1 = new FileInputStream(file1);  
  18.         InputStream input2 = new FileInputStream(file2);  
  19.         OutputStream output = new FileOutputStream(file3);  
  20.         // 合并流  
  21.         SequenceInputStream sis = new SequenceInputStream(input1, input2);  
  22.         int temp = 0;  
  23.         while((temp = sis.read()) != -1){  
  24.             output.write(temp);  
  25.         }  
  26.         input1.close();  
  27.         input2.close();  
  28.         output.close();  
  29.         sis.close();  
  30.     }  

【运行结果】

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

文件压缩 ZipOutputStream类

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

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.util.zip.ZipEntry;  
  7. import java.util.zip.ZipOutputStream;  
  8.  
  9. public class ZipOutputStreamDemo1{  
  10.     public static void main(String[] args) throws IOException{  
  11.         File file = new File("d:" + File.separator + "hello.txt");  
  12.         File zipFile = new File("d:" + File.separator + "hello.zip");  
  13.         InputStream input = new FileInputStream(file);  
  14.         ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(  
  15.                 zipFile));  
  16.         zipOut.putNextEntry(new ZipEntry(file.getName()));  
  17.         // 设置注释  
  18.         zipOut.setComment("hello");  
  19.         int temp = 0;  
  20.         while((temp = input.read()) != -1){  
  21.             zipOut.write(temp);  
  22.         }  
  23.         input.close();  
  24.         zipOut.close();  
  25.     }  

【运行结果】

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

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

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.util.zip.ZipEntry;  
  7. import java.util.zip.ZipOutputStream;  
  8.  
  9. /**  
  10.  * 一次性压缩多个文件  
  11.  * */ 
  12. public class ZipOutputStreamDemo2{  
  13.     public static void main(String[] args) throws IOException{  
  14.         // 要被压缩的文件夹  
  15.         File file = new File("d:" + File.separator + "temp");  
  16.         File zipFile = new File("d:" + File.separator + "zipFile.zip");  
  17.         InputStream input = null;  
  18.         ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(  
  19.                 zipFile));  
  20.         zipOut.setComment("hello");  
  21.         if(file.isDirectory()){  
  22.             File[] files = file.listFiles();  
  23.             for(int i = 0; i < files.length; ++i){  
  24.                 input = new FileInputStream(files[i]);  
  25.                 zipOut.putNextEntry(new ZipEntry(file.getName()  
  26.                         + File.separator + files[i].getName()));  
  27.                 int temp = 0;  
  28.                 while((temp = input.read()) != -1){  
  29.                     zipOut.write(temp);  
  30.                 }  
  31.                 input.close();  
  32.             }  
  33.         }  
  34.         zipOut.close();  
  35.     }  

【运行结果】

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

接下来看看压缩之后的:

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

  1. import java.io.File;  
  2. import java.io.IOException;  
  3. import java.util.zip.ZipFile;  
  4.  
  5. /**  
  6.  * ZipFile演示  
  7.  * */ 
  8. public class ZipFileDemo{  
  9.     public static void main(String[] args) throws IOException{  
  10.         File file = new File("d:" + File.separator + "hello.zip");  
  11.         ZipFile zipFile = new ZipFile(file);  
  12.         System.out.println("压缩文件的名称为:" + zipFile.getName());  
  13.     }  

【运行结果】:

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

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

  1. import java.io.File;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.OutputStream;  
  6. import java.util.zip.ZipEntry;  
  7. import java.util.zip.ZipFile;  
  8.  
  9. /**  
  10.  * 解压缩文件(压缩文件中只有一个文件的情况)  
  11.  * */ 
  12. public class ZipFileDemo2{  
  13.     public static void main(String[] args) throws IOException{  
  14.         File file = new File("d:" + File.separator + "hello.zip");  
  15.         File outFile = new File("d:" + File.separator + "unZipFile.txt");  
  16.         ZipFile zipFile = new ZipFile(file);  
  17.         ZipEntry entry = zipFile.getEntry("hello.txt");  
  18.         InputStream input = zipFile.getInputStream(entry);  
  19.         OutputStream output = new FileOutputStream(outFile);  
  20.         int temp = 0;  
  21.         while((temp = input.read()) != -1){  
  22.             output.write(temp);  
  23.         }  
  24.         input.close();  
  25.         output.close();  
  26.     }  

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

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

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

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

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

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.util.zip.ZipEntry;  
  8. import java.util.zip.ZipFile;  
  9. import java.util.zip.ZipInputStream;  
  10.  
  11. /**  
  12.  * 解压缩一个压缩文件中包含多个文件的情况  
  13.  * */ 
  14. public class ZipFileDemo3{  
  15.     public static void main(String[] args) throws IOException{  
  16.         File file = new File("d:" + File.separator + "zipFile.zip");  
  17.         File outFile = null;  
  18.         ZipFile zipFile = new ZipFile(file);  
  19.         ZipInputStream zipInput = new ZipInputStream(new FileInputStream(file));  
  20.         ZipEntry entry = null;  
  21.         InputStream input = null;  
  22.         OutputStream output = null;  
  23.         while((entry = zipInput.getNextEntry()) != null){  
  24.             System.out.println("解压缩" + entry.getName() + "文件");  
  25.             outFile = new File("d:" + File.separator + entry.getName());  
  26.             if(!outFile.getParentFile().exists()){  
  27.                 outFile.getParentFile().mkdir();  
  28.             }  
  29.             if(!outFile.exists()){  
  30.                 outFile.createNewFile();  
  31.             }  
  32.             input = zipFile.getInputStream(entry);  
  33.             output = new FileOutputStream(outFile);  
  34.             int temp = 0;  
  35.             while((temp = input.read()) != -1){  
  36.                 output.write(temp);  
  37.             }  
  38.             input.close();  
  39.             output.close();  
  40.         }  
  41.     }  

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

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

PushBackInputStream回退流

  1. import java.io.ByteArrayInputStream;  
  2. import java.io.IOException;  
  3. import java.io.PushbackInputStream;  
  4.  
  5. /**  
  6.  * 回退流操作  
  7.  * */ 
  8. public class PushBackInputStreamDemo{  
  9.     public static void main(String[] args) throws IOException{  
  10.         String str = "hello,rollenholt";  
  11.         PushbackInputStream push = null;  
  12.         ByteArrayInputStream bat = null;  
  13.         bat = new ByteArrayInputStream(str.getBytes());  
  14.         push = new PushbackInputStream(bat);  
  15.         int temp = 0;  
  16.         while((temp = push.read()) != -1){  
  17.             if(temp == ','){  
  18.                 push.unread(temp);  
  19.                 temp = push.read();  
  20.                 System.out.print("(回退" + (char) temp + ") ");  
  21.             }else{  
  22.                 System.out.print((char) temp);  
  23.             }  
  24.         }  
  25.     }  

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

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

【运行结果】:

系统默认编码为:GBK

乱码的产生:

  1. import java.io.File;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.OutputStream;  
  5.  
  6. /**  
  7.  * 乱码的产生  
  8.  * */ 
  9. public class CharSetDemo2{  
  10.     public static void main(String[] args) throws IOException{  
  11.         File file = new File("d:" + File.separator + "hello.txt");  
  12.         OutputStream out = new FileOutputStream(file);  
  13.         byte[] bytes = "你好".getBytes("ISO8859-1");  
  14.         out.write(bytes);  
  15.         out.close();  
  16.     }  

【运行结果】:

??

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

对象的序列化

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

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

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

  1. import java.io.*;  
  2. /**  
  3.  * 实现具有序列化能力的类  
  4.  * */ 
  5. public class SerializableDemo implements Serializable{  
  6.     public SerializableDemo(){  
  7.           
  8.     }  
  9.     public SerializableDemo(String name, int age){  
  10.         this.name=name;  
  11.         this.age=age;  
  12.     }  
  13.     @Override 
  14.     public String toString(){  
  15.         return "姓名:"+name+"  年龄:"+age;  
  16.     }  
  17.     private String name;  
  18.     private int age;  

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

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

先给一个ObjectOutputStream的例子吧:

  1. import java.io.Serializable;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.ObjectOutputStream;  
  6.  
  7. /**  
  8.  * 实现具有序列化能力的类  
  9.  * */ 
  10. public class Person implements Serializable{  
  11.     public Person(){  
  12.  
  13.     }  
  14.  
  15.     public Person(String name, int age){  
  16.         this.name = name;  
  17.         this.age = age;  
  18.     }  
  19.  
  20.     @Override 
  21.     public String toString(){  
  22.         return "姓名:" + name + "  年龄:" + age;  
  23.     }  
  24.  
  25.     private String name;  
  26.     private int age;  
  27. }  
  28. /**  
  29.  * 示范ObjectOutputStream  
  30.  * */ 
  31. public class ObjectOutputStreamDemo{  
  32.     public static void main(String[] args) throws IOException{  
  33.         File file = new File("d:" + File.separator + "hello.txt");  
  34.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(  
  35.                 file));  
  36.         oos.writeObject(new Person("rollen"20));  
  37.         oos.close();  
  38.     }  

【运行结果】:

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

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

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.ObjectInputStream;  
  4.  
  5. /**  
  6.  * ObjectInputStream示范  
  7.  * */ 
  8. public class ObjectInputStreamDemo{  
  9.     public static void main(String[] args) throws Exception{  
  10.         File file = new File("d:" + File.separator + "hello.txt");  
  11.         ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
  12.                 file));  
  13.         Object obj = input.readObject();  
  14.         input.close();  
  15.         System.out.println(obj);  
  16.     }  

【运行结果】

姓名:rollen 年龄:20

到底序列化什么内容呢?

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

Externalizable接口

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

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

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

  1. package IO;  
  2.  
  3. import java.io.Externalizable;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8. import java.io.ObjectInput;  
  9. import java.io.ObjectInputStream;  
  10. import java.io.ObjectOutput;  
  11. import java.io.ObjectOutputStream;  
  12.  
  13. /**  
  14.  * 序列化和反序列化的操作  
  15.  * */ 
  16. public class ExternalizableDemo{  
  17.     public static void main(String[] args) throws Exception{  
  18.         ser(); // 序列化  
  19.         dser(); // 反序列话  
  20.     }  
  21.  
  22.     public static void ser() throws Exception{  
  23.         File file = new File("d:" + File.separator + "hello.txt");  
  24.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(  
  25.                 file));  
  26.         out.writeObject(new Person("rollen"20));  
  27.         out.close();  
  28.     }  
  29.  
  30.     public static void dser() throws Exception{  
  31.         File file = new File("d:" + File.separator + "hello.txt");  
  32.         ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
  33.                 file));  
  34.         Object obj = input.readObject();  
  35.         input.close();  
  36.         System.out.println(obj);  
  37.     }  
  38. }  
  39.  
  40. class Person implements Externalizable{  
  41.     public Person(){  
  42.  
  43.     }  
  44.  
  45.     public Person(String name, int age){  
  46.         this.name = name;  
  47.         this.age = age;  
  48.     }  
  49.  
  50.     @Override 
  51.     public String toString(){  
  52.         return "姓名:" + name + "  年龄:" + age;  
  53.     }  
  54.  
  55.     // 复写这个方法,根据需要可以保存的属性或者具体内容,在序列化的时候使用  
  56.     @Override 
  57.     public void writeExternal(ObjectOutput out) throws IOException{  
  58.         out.writeObject(this.name);  
  59.         out.writeInt(age);  
  60.     }  
  61.  
  62.     // 复写这个方法,根据需要读取内容 反序列话的时候需要  
  63.     @Override 
  64.     public void readExternal(ObjectInput in) throws IOException,  
  65.             ClassNotFoundException{  
  66.         this.name = (String) in.readObject();  
  67.         this.age = in.readInt();  
  68.     }  
  69.  
  70.     private String name;  
  71.     private int age;  

【运行结果】:

姓名:rollen 年龄:20

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

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

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

下面举一个例子:

  1. package IO;  
  2.  
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.ObjectInputStream;  
  7. import java.io.ObjectOutputStream;  
  8. import java.io.Serializable;  
  9.  
  10. /**  
  11.  * 序列化和反序列化的操作  
  12.  * */ 
  13. public class serDemo{  
  14.     public static void main(String[] args) throws Exception{  
  15.         ser(); // 序列化  
  16.         dser(); // 反序列话  
  17.     }  
  18.  
  19.     public static void ser() throws Exception{  
  20.         File file = new File("d:" + File.separator + "hello.txt");  
  21.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(  
  22.                 file));  
  23.         out.writeObject(new Person1("rollen"20));  
  24.         out.close();  
  25.     }  
  26.  
  27.     public static void dser() throws Exception{  
  28.         File file = new File("d:" + File.separator + "hello.txt");  
  29.         ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
  30.                 file));  
  31.         Object obj = input.readObject();  
  32.         input.close();  
  33.         System.out.println(obj);  
  34.     }  
  35. }  
  36.  
  37. class Person1 implements Serializable{  
  38.     public Person1(){  
  39.  
  40.     }  
  41.  
  42.     public Person1(String name, int age){  
  43.         this.name = name;  
  44.         this.age = age;  
  45.     }  
  46.  
  47.     @Override 
  48.     public String toString(){  
  49.         return "姓名:" + name + "  年龄:" + age;  
  50.     }  
  51.  
  52.     // 注意这里  
  53.     private transient String name;  
  54.     private int age;  

【运行结果】:

姓名:null 年龄:20

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

  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileOutputStream;  
  4. import java.io.ObjectInputStream;  
  5. import java.io.ObjectOutputStream;  
  6. import java.io.Serializable;  
  7.  
  8. /**  
  9.  * 序列化一组对象  
  10.  * */ 
  11. public class SerDemo1{  
  12.     public static void main(String[] args) throws Exception{  
  13.         Student[] stu = { new Student("hello"20), new Student("world"30),  
  14.                 new Student("rollen"40) };  
  15.         ser(stu);  
  16.         Object[] obj = dser();  
  17.         for(int i = 0; i < obj.length; ++i){  
  18.             Student s = (Student) obj[i];  
  19.             System.out.println(s);  
  20.         }  
  21.     }  
  22.  
  23.     // 序列化  
  24.     public static void ser(Object[] obj) throws Exception{  
  25.         File file = new File("d:" + File.separator + "hello.txt");  
  26.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(  
  27.                 file));  
  28.         out.writeObject(obj);  
  29.         out.close();  
  30.     }  
  31.  
  32.     // 反序列化  
  33.     public static Object[] dser() throws Exception{  
  34.         File file = new File("d:" + File.separator + "hello.txt");  
  35.         ObjectInputStream input = new ObjectInputStream(new FileInputStream(  
  36.                 file));  
  37.         Object[] obj = (Object[]) input.readObject();  
  38.         input.close();  
  39.         return obj;  
  40.     }  
  41. }  
  42.  
  43. class Student implements Serializable{  
  44.     public Student(){  
  45.  
  46.     }  
  47.  
  48.     public Student(String name, int age){  
  49.         this.name = name;  
  50.         this.age = age;  
  51.     }  
  52.  
  53.     @Override 
  54.     public String toString(){  
  55.         return "姓名:  " + name + "  年龄:" + age;  
  56.     }  
  57.  
  58.     private String name;  
  59.     private int age;  

【运行结果】:

姓名: hello 年龄:20

姓名: world 年龄:30

姓名: rollen 年龄:40

分享到:
评论

相关推荐

    java IO全面整理

    java IO全面整理,整理了一下关于java 的IO操作,我是直接在测试的时候将关键的测试代码放上去了,并配以简洁的注解,适合有一定基础的朋友!

    Java中IO流简介_动力节点Java学院整理

    Java io系统的设计初衷,就是为了实现“文件、控制台、网络设备”这些io设置的通信。例如,对于一个文件,我们...而到了java 1.1,为了与国际化进行接轨,在java io中添加了许多以字符(Unicode)为单位进行操作的类。

    java nio操作

    java nio操作基础 java IO整理

    java核心知识点整理.pdf

    25 JAVA8 与元数据.................................................................................................................................25 2.4. 垃圾回收与算法 .................................

    Android代码-一个集Gank.Io,Rxjava示例,操作符,MD控件使用,各种好玩Ap示例的学习App。

    2.增加了来自GeniusVJR整理的安卓面试笔记. 3.优化了一些界面UI效果,以及修复了一些Bug. v2.2 1.UI风格修改,更适合阅读. 2.去除了无用代码,代码进行重构工作,持续中. 3.增加了搜索功能,快速查询需要的干货. v2.1 ...

    JAVA_Thinking in Java(中文版 由yyc,spirit整理).chm

    JAVA_Thinking in Java(中文版 由yyc,spirit整理).chm ------------------------------------------------- 本教程由yyc,spirit整理 ------------------------------------------------- “Thinking in Java...

    Java学习教程,本人整理,适合初学者

    适合初学者的Java学习教程,包括变量、操作符、流程控制、继承、修饰符、接口、异常、类的生命周期、对象的生命周期、数组、线程、集合、IO系统、Java中常用类

    Java 常用API的运用,效率及技巧

    Java 常用API的运用,效率及技巧 Java面向对象基本概念 2. System 3. String, StringBuffer ...6. Java IO系统 7. Java集合类 8. ResourceBundle, Properties 9. Exceptions 10. JDBC类库 11. 常用设计模式

    Java常见面试题208道.docx

    7.java 中操作字符串都有哪些类?它们之间有什么区别? 8.String str="i"与 String str=new String(“i”)一样吗? 9.如何将字符串反转? 10.String 类的常用方法都有那些? 11.抽象类必须要有抽象方法吗? 12.普通...

    java 面试 百度入职老哥整理 全是干货

    包括但不限于: 多线程、集合、io、JVM、设计模式、网络原理、操作系统、Linux、安全加密、数据结构和算法等等,都有答案,并且很详细,263页的干货,可以作为查漏补缺之用。

    JAVA核心知识点整理(有效)

    标记整理算法(Mark-Compact).................................................................................................. 28 分代收集算法 ..............................................................

    java多线程tcpsocketserver源码-Java-Book:Java学习资料整理

    Java学习资料整理 框架 / dubbo监控 / / / / / / / / / / / / / / / / / / / / 收藏 / 技术社区 书籍推荐 计算机基础 计算机科学导论 --(如果不是计算机科班的,应先看看计算机基础,了解一些基本概念,有助于之后的...

    java基础笔记

    java基础笔记详细介绍了IO流的读取操作及集合概念

    Java基础知识代码

    这是一个Java基础知识的整理,里面包含常用的开发用到的用法,如数据库存连接,io操作, 集合操作等。对于看书无聊而又想快速入门的学生来说,是一种好的选择!

    张孝祥Java就业培训教程.pdf

    读者从本书中不仅可以学习到Java本身方面的知识,还能学到了许多编程思想和实际操作手法,仿佛老手就在你面前进行现场演示一样。本书不仅全面的介绍了Java语言本身,最重要还交会读者去掌握编程思想,找到编程感觉,...

    Thinking in Java(中文版 由yyc,spirit整理).chm

    2. Java的学习 3. 目标 4. 联机文档 5. 章节 6. 练习 7. 多媒体CD-ROM 8. 源代码 9. 编码样式 10. Java版本 11. 课程和培训 12. 错误 13. 封面设计 14. 致谢 第1章 对象入门 1.1 抽象的进步 1.2 对象的接口 1.3 ...

    Java学习笔记-个人整理的

    {2.8}框架中移动的小球}{59}{section.2.8} {2.9}抽象与接口}{59}{section.2.9} {2.10}访问控制}{60}{section.2.10} {2.10.1}类的属性}{60}{subsection.2.10.1} {2.10.2}类的方法}{61}{subsection.2.10.2} {...

    java-interview:java面试整理,包含数据结构与算法,java基础,多线程,IO,锁,jvm,spring,redis,mysql,操作系统,linux,网络,分布式,设计模式等

    java-com.fanmk.interview java面试整理,包含java基础,多线程,IO,锁,com.fanmk.jvm,spring,redis,mysql,操作系统,linux,网络,分布式,设计模式等官方网站常用博客 梁飞大大去做服务注册与发现 zookeeper...

    Java知识训练营高级视频教程汇总,附带教学源码课件

    共5章,其中第一章介绍了JavaAPI、第二章介绍了IO输入与输出、第三章介绍了图形用户界面GUI、第四章介绍了Applet、第五章介绍了网络编程。 老师从事了多年的软件开发和培训教学,非常清楚那些容易使新手困惑的问题,...

Global site tag (gtag.js) - Google Analytics