ObjectInputStream (2)

  1 package Aug14.IO;
  2
  3 import java.io.*;
  4 import java.util.*;
  5 import java.util.Map.Entry;
  6
  7 public class TestCurrentAccount {
  8
  9     private void objectWriter(Map<Integer, CurrentAccount> m, File f) {
 10         try {
 11             // File f = new File("D:\\Account.txt");
 12             ObjectOutputStream oos = new ObjectOutputStream(
 13                     new FileOutputStream(f));
 14             oos.writeObject(m);
 15             oos.flush();
 16             oos.close();
 17             System.out.println("File Writing Success");
 18         } catch (Exception e) {
 19             e.printStackTrace();
 20         }
 21     }
 22
 23     @SuppressWarnings("unchecked")
 24     private void objectReader(File f) {
 25         try {
 26
 27             ObjectInputStream ois = new ObjectInputStream(
 28                     new FileInputStream(f));
 29
 30             Map<Integer, CurrentAccount> m = (Map<Integer, CurrentAccount>) ois
 31                     .readObject();
 32
 33             Set view = m.entrySet();
 34             Iterator it = view.iterator();
 35             while (it.hasNext()) {
 36                 Entry<Integer, CurrentAccount> ca = (Entry<Integer, CurrentAccount>) it
 37                         .next();
 38                 CurrentAccount cur = ca.getValue();
 39                 System.out.println("Key:- " + ca.getKey() + "\tValues:- "
 40                         + cur.getAccountId() + "  " + cur.getName() + "  "
 41                         + cur.getBalanceAmount());
 42
 43             }
 44             ois.close();
 45         } catch (Exception e) {
 46             e.printStackTrace();
 47         }
 48         System.out.println("File Reading Success");
 49     }
 50
 51     @SuppressWarnings("unchecked")
 52     public static void main(String[] args) {
 53         Scanner reader = new Scanner(System.in);
 54         CurrentAccount cu;
 55         // Map map=new HashMap();
 56         Map<Integer, CurrentAccount> map = new HashMap<Integer, CurrentAccount>();
 57         for (int i = 0; i < 1; i++) {
 58             cu = new CurrentAccount();
 59
 60             System.out.println("Enter AccountId");
 61             cu.setAccountId(reader.nextInt());
 62             System.out.println("Enter name");
 63             cu.setName(reader.next());
 64             System.out.println("Enter balanceAmount");
 65             cu.setBalanceAmount(reader.nextDouble());
 66             map.put(10000 + i, cu);
 67         }
 68
 69         String answer = "No";
 70
 71         while (answer.equals("No") || !answer.equals("Yes")) {
 72             System.out.println("Enter the path to store the data:");
 73             // File f = new File("D:\\Account.txt");
 74             String path = reader.next();
 75             File file = new File(path);
 76
 77             if (file.exists()) {
 78                 System.out
 79                         .println("The file already exists ,do you want it being overwritten?(Yes/No)");
 80                 answer = reader.next();
 81
 82                 if (answer.equals("Yes")) {
 83                     TestCurrentAccount ta = new TestCurrentAccount();
 84                     ta.objectWriter(map, file);
 85                     ta.objectReader(file);
 86                     break;
 87                 } else if (answer.equals("No")) {
 88                     System.out
 89                             .println("Enter the new  path to store the data:");
 90
 91                 } else {
 92                     System.out
 93                             .println("Please enter the right answer,try again:");
 94                 }
 95             } else {
 96                 TestCurrentAccount ta = new TestCurrentAccount();
 97                 ta.objectWriter(map, file);
 98                 ta.objectReader(file);
 99                 break;
100
101             }
102
103         }
104     }
105 }
106
107 class CurrentAccount implements Serializable {
108     int AccountId;
109     String name;
110     double balanceAmount;
111
112     public int getAccountId() {
113         return AccountId;
114     }
115
116     public void setAccountId(int accountId) {
117         AccountId = accountId;
118     }
119
120     public String getName() {
121         return name;
122     }
123
124     public void setName(String name) {
125         this.name = name;
126     }
127
128     public double getBalanceAmount() {
129         return balanceAmount;
130     }
131
132     public void setBalanceAmount(double balanceAmount) {
133         this.balanceAmount = balanceAmount;
134     }
135
136 }

ObjectInputStream (2)

时间: 2024-09-29 10:44:12

ObjectInputStream (2)的相关文章

JAVA笔记(十三)

package cn.itcast.dao.impl; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import cn.itcast.da

JAVA对象序列化(Serializable、ObjectOutputStream、ObjectInputStream、 transient)

1)对象序列化是把一个对象变为二进制的数据流的一种方法.对象序列化后可以方便的实现对象的传输或存储. 2)如果一个类的对象想被序列化,则对象所在的类必须实现Serialilzable接口.此接口中没有定义任何方法,所以此借口是一个标识接口,表示一个类具备被序列化的能力. 3)对象被序列化后变为二进制,可以经过二进制数据流进行传输.此时必须依靠对象输出流(ObjectOutputStream)和对象输入流(ObjectInputStream). 4)在序列化中,只有属性被序列化.因为每个对象都具有

Java笔记(七)

File类: 1 import java.io.File; 2 import java.io.IOException; 3 4 public class Demo{ 5 public static void main(String[] args){ 6 //将a.txt封装成file对象.可以将已有的和未出现的文件或者文件夹封装成对象 7 File f1 = new File("a.txt"); 8 9 //左边参数是父目录,右边是文件名 10 File f2 = new File(&

java_设计模式_装饰者模式_Decorator Pattern(2016-07-28)

装饰模式又名包装(Wrapper)模式.装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案. 装饰模式的结构 装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任.换言之,客户端并不会觉得对象在装饰前和装饰后有什么不同.装饰模式可以在不使用创造更多子类的情况下,将对象的功能加以扩展. 装饰模式的类图如下: 在装饰模式中的角色有: ● 抽象构件(Component)角色:给出一个抽象接口,以规范准备接收附加责任的对象. ● 具体构件(ConcreteComponent)角色

Java输入输出(二)——具体操作

文本输入输出 进行文本输出的类是PrintWriter,这个类提供格式化输出字符的功能,它是Writer的子类.类似于System.out的使用,PrintWriter的实例提供了很多类似的输出功能.System.out是PrintStream的实例,PrintStream是OutputStream的子类,因此System.out与PrintWriter的实例处于同等位置,因此具有类似的操作.所不同的是System.out负责字节流输出,而PrintWriter负责字符流输出. PrintWri

java面试核心基础(1)

1.以下代码的执行结果 String s1 = "helloworld"; String s2 = "hello" + new Stirng("world"); System.out.println(s1 == s2); 分析:false,s1 == s2这比較的是两个对象的地址,而不是值.s2中存在new Stirng("world"),该语句会新开辟一块内存来存放world字符串,因此,s1与s2的地址不同 2.以下说法正

Java序列化(Serialization)

关于Java的序列化的文章在网上已经够多了,在这里写关于Java序列化的文章是对自己关于这方面的的一种总结,结合以前的开发经验与网上的资料,写了这篇文章,对自己是有着巩固记忆的作用,也希望能够对大家有一定帮助. 一.什么是序列化(Serialization)? 序列化是Java提供的一种机制,将对象转化成字节序列,在字节序列中保存了对象的数据.对象的类型的信息与存储在对象中的数据的类型.序列化实际上就是将保存对象的"状态",可以方便以后的程序使用或者通过网络传输到另一台主机使用.一般来

java--IO流(2)--黑马程序员

------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- IO流(2) 主要内容:<FileInputStream类.带缓冲的字节流.String类中的编码和解码.转换流.字符流类.带缓冲的字符流.数据输入输出流.byte数组缓冲流.打印流.随机访问流.序列化流和反序列化流.Properties  > 1.FileInputStream类 字节流:  输出流:OutputStream  |--FileOutputStream:  输入流:Input

疯狂Java学习笔记(56)------------对象序列化

所谓对象序列化就是将对象的状态转换成字节流,以后可以通过这些值再生成相同状态的对象! 对象序列化是对象持久化的一种实现方法,它是将一个对象的属性和方法转化为一种序列化的格式以用于存储和传输,反序列化就是根据这些保存的信息重建对象的过程. java对象序列化机制一般来讲有两种用途: 1.需要将对象的状态保存到文件中(存储),而后能够通过读入对象状态来重新构造对象,恢复程序状态 2.使用套接字在网络上传送对象的程序来说,是很有用的(传输). 我们通过让类实现java.io.Serializable