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

最新推荐文章于 2024-04-23 19:50:58 发布
最新推荐文章于 2024-04-23 19:50:58 发布
阅读量304 收藏
点赞数
分类专栏： java 文章标签： java io string file null input

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.     }  
  21. } 

运行结果：

请输入内容

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.     }  
  18. } 

其实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.     }  
  21. } 

【运行结果】：

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

数据操作流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.     }  
  17. } 

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.     }  
  18. } 

【运行结果】：

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.     }  
  31. } 

【运行结果】

结果会在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.     }  
  26. } 

【运行结果】

运行结果之前，我创建了一个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.     }  
  36. } 

【运行结果】

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

接下来看看压缩之后的：

大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个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.     }  
  14. } 

【运行结果】：

压缩文件的名称为：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.     }  
  27. } 

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

这个压缩文件还是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.     }  
  42. } 

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

解压之后再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.     }  
  26. } 

【运行结果】：
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.     }  
  8. } 

【运行结果】：

系统默认编码为：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.     }  
  17. } 

【运行结果】：

??

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

对象的序列化

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

一个类要想被序列化，就行必须实现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;  
  19. } 

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

在继续将序列化之前，先将一下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.     }  
  39. } 

【运行结果】：

当我们查看产生的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.     }  
  17. } 

【运行结果】

姓名：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;  
  72. } 

【运行结果】：

姓名：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;  
  55. } 

【运行结果】：

姓名：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;  
  60. } 

【运行结果】：

姓名： hello 年龄：20

姓名： world 年龄：30

姓名： rollen 年龄：40


编程是一门艺术
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中的IO整理完整版
04-14
java中的IO整理完整版
JAVA基础------IO操作（三）
海大哥
10-09 1591
Scanner类 其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧 import java.util.Scanner;   /**   * Scanner的小例子，从键盘读数据   * */ public class Scanne
JAVA二进制文件读写
iteye_3986的博客
11-03 369
JAVA二进制文件读写 /** * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; impor...
java的二进制_Java 二进制I/O处理
weixin_31889705的博客
02-12 164
在Java中如何处理文本I/O使用Scanner类读取文本数据，使用PrintWriter类写文本数据例子：public classIO {public static void main(String [] args) throwsFileNotFoundException {//PrintWriter printWriter = new PrintWriter("123.txt"); 输出文本...
java的inputstream_java通过InputStream读取和写入文件操作实例代码
weixin_35606595的博客
02-12 723
1. File to InputStreamFile file = new File("file.xml");InputStream inputStream = new FileInputStream(file);2.InputStream to FileInputStream inputStream = new FileInputStream("file.xml");OutputStream ...
Java中的IO整理完整版
11-07
Java中的IO整理完整版
java从入门到精通视频教程(全94讲)学习笔记整理(齐全).docx
04-13
-二进制、位运算、位移运算 -集合 -集合 -集合 -集合补充 -异常 -面试题评讲 -布局管理器 -常用组件 -swing编程实战 -绘图技术.坦克大战2 -事件处理.坦克大战3 -事件监听.坦克大战4 -事件总结.坦克大战5 -线程.坦克...
Java常见面试题208道.docx
05-17
15.java 中 IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和 Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21....
2019java亲生经历面试题答案解析准备.zip
04-20
春节跳槽最新Java面试题及答案整理.txt 分享18道Java基础面试笔试题（面试实拍）.docx 去BAT面试完的Mysql面试题总结（55道，带完整答案）.docx 。。。。。。。还有很多就不在一一的说明了，希望对大家有很大的帮助...
string模拟实现
m0_73969414的博客
04-23 758
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 172
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1024
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
Web前端 Javascript笔记5
cycyzh的博客
04-18 930
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
2.8 构建gradle环境
蚊者逆袭的博客
04-18 2220
Gradle是一种现代化的构建工具，用于自动化地构建、测试和部署软件项目。它是一种基于JVM（Java虚拟机）的构建工具，最初是为了解决Apache Ant和Apache Maven等传统构建工具的一些限制而开发的。
迭代器模式
最新发布
LuckFairyLuckBaby的博客
04-23 342
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
JUC(java.util.concurrent) 的常见类
weixin_43497876的博客
04-20 1206
Callable 是一个 interface（类似之前的 Runnable，用来描述一个任务，但是没有返回值）也是描述一个任务的，有返回值。方便程序猿借助多线程的方式计算结果.创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable。
Java中如何实现minio文件上传
Keep__Me的博客
04-19 1205
前面已经在docker中部署了minio服务，那么该如何在Java代码中使用？这篇说下minio在Java中的配置跟使用。
数据库配置加密(自定义加密方式)
banyoyo的博客
04-18 513
解密后的urlstr字符串为jdbc:mysql://localhost:3306/ep?加密后的usernamestr字符串为c9fd389f247df4eacaff9693735ac1c5。解密后的usernamestr字符串为root。
Maven基础篇1
m0_52474839的博客
04-22 156
项目2需要用到项目3需要将项目三作为资源配置到项目二也就是dependecy中加入项目三的gav两点注意事项：使用项目三，直接将其gav添加到依赖中，使用项目三，项目三不能感知到，自己有相关资源依赖传递：就是自己使用的资源如果是jar包，那么jar资源使用的依赖自己也可以使用就像上图那样一层一层的传递下去；依赖传递分为：直接依 赖，间接依赖。
java基础中IO知识点的整理
06-01
好的，关于Java IO的知识点整理如下： 一、IO流的分类 1.按数据流向：输入流、输出流 2.按操作单元：字节流、字符流 3.按角色：节点流、处理流 二、字节流和字符流的区别 1.字节流操作的是8位字节，适用于二进制文件，如图片、音频、视频等； 2.字符流操作的是16位字符，适用于文本文件，如txt、html、xml等； 三、节点流和处理流的区别 1.节点流直接与数据源相连，读写数据源； 2.处理流不直接与数据源相连，通过节点流读写数据源，对读写过程进行包装，提供更高层次的操作。 四、File类 1.可以用来表示文件或目录 2.常用方法：创建文件、创建目录、删除文件、删除目录、判断是否存在、获取文件名、获取绝对路径等。 五、InputStream和OutputStream 1.InputStream是字节输入流的抽象类，常用方法：read()、available()、close()； 2.OutputStream是字节输出流的抽象类，常用方法：write()、flush()、close()； 六、Reader和Writer 1.Reader是字符输入流的抽象类，常用方法：read()、ready()、close()； 2.Writer是字符输出流的抽象类，常用方法：write()、flush()、close()； 七、字节流与字符流的转换 1.InputStreamReader：将字节流转换成字符流； 2.OutputStreamWriter：将字符流转换成字节流。 以上是Java IO的基础知识点，希望能对您有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值