`

ObjectInputStream流 持久化

阅读更多


  ObjectInputStream流 持久化
  vo类:
                          package javabean;

                        import java.io.Serializable;

                        public class Student implements Serializable {
                        /**
                                 *
                                 */
                                private static final long serialVersionUID = 1L;
                                private static  int count=1;
                        private int id;
                        private String name;
                        private int classid;
                        public Student(){
                                id=count;
                                count++;
                        }
                        public int getId() {
                                return id;
                        }
                        public String getName() {
                                return name;
                        }
                        public void setName(String name) {
                                this.name = name;
                        }
                        public int getClassid() {
                                return classid;
                        }
                        public void setClassid(int classid) {
                                this.classid = classid;
                        }
                        public String toString(){
                                return name;
                        }
                        public boolean equals(Object obj){
                                if(obj instanceof Student){
                                        Student stu=(Student)obj;
                                        if(this.id==stu.id){
                                                return true;
                                        }
                                }
                                   return false;
                        }
                        }
   执行类

                        package test;
                        import java.io.File;
                        import java.io.FileInputStream;
                        import java.io.FileOutputStream;
                        import java.io.IOException;
                        import java.io.InputStream;
                        import java.io.ObjectInputStream;
                        import java.io.ObjectOutputStream;
                        import java.util.ArrayList;
                        import java.util.List;
                        import javabean.Student;
                        public class DataSave {
                        public static void main(String[] args){
                         List<Student> list=getData();
                         for(int i=0;i<list.size();i++){
                                 System.out.println(list.get(i));
                         }
                        }

                        private static File getFile(){
                                File file=new File("src\\file\\datasave.txt");
                                return file;
                        }
                        //获取文档数据
                        private static List<Student> getData(){
                                File file=getFile();
                                List<Student> list=null;
                                FileInputStream fis=null;
                                ObjectInputStream ois=null;
                                try {
                                         fis=new FileInputStream(file);
                                         if(fis.available()!=0){
                                         ois=new ObjectInputStream(fis);
                                         Object obj=ois.readObject();
                                     list=(ArrayList<Student>)obj;
                                     System.out.println(list.get(1));
                                         }
                                         else
                                         {
                                         list=new ArrayList<Student>();
                                         }
                                }catch(Exception e){
                                        e.printStackTrace();
                                }finally{
                                        fis=null;
                                        ois=null;
                                }
                                return list;
                        }
                        //更改数据
                        private static void setData(List<Student> list){
                                 File file=getFile();
                                FileOutputStream fos=null;
                            ObjectOutputStream oos=null;
                                try{
                            fos=new FileOutputStream(file);
                                oos=new ObjectOutputStream(fos);
                                oos.writeObject(list);
                                oos.flush();
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }finally{
                                        oos=null;
                                        fos=null;
                        }
                        }
                        //插入数据
                        public static void insert(Student stu){
                                    List<Student> list=getData();
                                    list.add(stu);
                                    setData(list);
                                   
                        }
                        //修改数据
                        public static void update(int i,Student stu){
                                List<Student> list=getData();
                            list.remove(i);
                            list.add(i, stu);
                            setData(list);
                        }
                        //删除数据
                        public static void delete(int i){
                                List<Student> list=getData();
                            list.remove(i);
                            setData(list);
                        }
                        public static void close(InputStream stream){
                                try {
                                        stream.close();
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }
                        }

分享到:
评论

相关推荐

    ObjectInputStream

    ObjectInputStream序列化实例,简单就学会,JAVA原来so easy

    ObjectInputStream的用法---马克-to-win java视频

    ObjectInputStream的用法---马克-to-win java视频的介绍对象输入字节流

    object文件流

    objectInputStream

    ObjectInputStream 和 ObjectOutputStream 介绍_动力节点Java学院整理

    ObjectInputStream 和 ObjectOutputStream 的作用是,对基本数据和对象进行序列化操作支持。本文给大家详细介绍了ObjectInputStream 和 ObjectOutputStream的相关知识,感兴趣的朋友一起学习吧

    java序列化与ObjectOutputStream和ObjectInputStream的实例详解

    主要介绍了java序列化与ObjectOutputStream和ObjectInputStream的实例详解的相关资料,希望通过本文能帮助到大家,需要的朋友可以参考下

    IO体系.java

    用于操作对象的流,将一个具体的对象进行持久化写入到硬盘上。 | |--PipedInputStream/:管道流。管道读取流可以读取管道写入流的数据。注意:需要加多线程技术,否则会发生死锁。read方法是阻塞式的。 | |--...

    Java之IO流学习总结

    ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。 2.输出字节流OutputStream IO 中输出字节流的继承图可见上图,可以看出: OutputStream 是所有的输出字节流的父类,它是一个...

    JDK_API_1_6

    ObjectInputStream.GetField 提供对从输入流读取的持久字段的访问权限。 ObjectOutputStream ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。 ObjectOutputStream.PutField 提供对要写入...

    使用流套接字建立客户机

    使用流套接字建立客户机 运用ObjectOutputStream,ObjectInputStream,ServerSocket,Socket;

    序列化

    把字节序列化保存到文件中,就可以做到持久化保存数据内容。 从文件中读取字节序列化数据,可以直接得到对应的对象。 2 ObjectOutputStream类 将对象数据序列化,保存到文件中 构造方法 Constructor ...

    java输入输出流 流式输入与输出

    要串行化一个对象,必须与一定的对象输入/输出流联系起来,通过对象输出流将对象状态保存下来,再通过对象输入流将对象状态恢复。 java.io包中,提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可...

    DVD项目功能实现

    ObjectInputStream ois = null; List&lt;T&gt; list = new ArrayList(); try { if(!file.exists()){ file.createNewFile&#40;&#41;;// 首次运行,文件不存在,需要自动创建 } fis = new FileInputStream(file); ...

    JAVA_ObjectInputStream

    拿点积分啊,不然不给下东西. Java Object的一个学习源码.

    Java序列化

    把字节序列化保存到文件中,就可以做到持久化==保存数据内容。 从文件中读取字节序列化数据,可以直接得到对应的对象。 1.2 ObjectOutputStream类 将对象数据序列化,保存到文件中 构造方法 Constructor ...

    JavaIOObjectStreams:FileInputStream 与 ObjectInputStream 和 ObjectOutputStream 的组合

    JavaIO对象流 FileInputStream 与 ObjectInputStream 和 ObjectOutputStream 的组合 奥利弗·缪尔

    WEBSphere反序列化漏扫.rar

    序列化是让Java对象脱离Java运行环境的一种手段,可以有效的实现多平台之间的通信、对象持久化存储。 Java 序列化是指把 Java 对象转换为字节序列的过程,便于保存在内存、文件、数据库中,ObjectOutputStream类的...

    Java高级程序设计实战教程第五章-Java序列化机制.pptx

    序列化可以将对象的状态写在流里进行网络传输,或者保存到文件、数据库等系统中,并在需要时把该流读取出来重新构造一个相同的对象。 Java高级程序设计实战教程第五章-Java序列化机制全文共15页,当前为第2页。 5.2 ...

    IO流各个类的使用方法

    ObjectInputStream ObjectOutputStream ByteArrayInputStream ByteArrayOutputStream 【字符流】 Reader Writer InputStreamReader OutputStreamWriter BufferedReader BufferedWriter /PrintWriter FileReader ...

    序列化与反序列化

    反序列化:ObjectInputStream ObjectOutputStream介绍 (序列化) 构造: ObjectOutputStream(OutputStream out) 参数可以传入这两个:FileOutputStream,BufferedOutputStream 关键方法: writeObject(Object obj) 将...

    java72-java-advance.rar

    JavaAdvance复习题汇总 1.java语言提供处理不同类型流的类的包是(D) ...5.下列字节输入流中,哪一个不能够被实例化B A.FileInputStream B.FilterInputStream C.ByteArrayInputStream D.ObjectInputStream

Global site tag (gtag.js) - Google Analytics