`

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();
                                }
                        }
                        }

分享到:
评论

相关推荐

    java持久化的解决方案

    当一个对象实现了`Serializable`接口,便可以通过`ObjectOutputStream`和`ObjectInputStream`流进行序列化与反序列化操作,从而将对象的状态转化为字节流存储至磁盘或其他长期存储介质。这种方法的优势在于简单易用...

    序列化与持久化相同点跟不同点

    ### 序列化与持久化的相同点与不同点 #### 一、持久化定义与应用场景 **持久化**是指将程序中的数据(如内存中的对象)保存到可长期存储的设备上,比如硬盘或者固态硬盘等。持久化的主要目的是确保即使在程序结束...

    图书管理系统数据持久化

    本系统采用Java技术进行开发,利用了集合、序列化以及IO流等核心概念,确保数据的持久化存储和高效访问。以下是对这些关键知识点的详细阐述。 首先,**Java集合框架**是Java编程中的基石之一,它提供了多种数据结构...

    字节流,字符流,对象流,序列化,持久化

    总的来说,字节流、字符流和对象流是Java I/O操作的基础,而序列化和持久化是高级话题,涉及对象的状态保存和恢复。理解并熟练掌握这些概念对于编写高效的Java程序至关重要。在实际开发中,我们应根据具体需求选择...

    缓存List并写入文件持久化.zip

    在IT行业中,数据持久化是一项重要的任务,它指的是将数据保存到非易失性存储设备,以便在系统重启或关闭后仍然能够恢复。本案例中,“缓存List并写入文件持久化”的主题聚焦于如何将内存中的数据,特别是列表(List...

    基于Java的实例开发源码-JActor的文件持久化组件 JFile.zip

    【标题】"基于Java的实例开发源码-JActor的文件持久化组件 JFile.zip" 提供了一个关于如何在Java环境中实现文件持久化的实例。JActor的JFile组件是专为处理文件存储和检索设计的一个模块,它使得数据能够在程序运行...

    IO流与序列化

    在Java编程语言中,`IO流`(Input/Output Stream)和`序列化`是两个重要的概念,它们在处理数据传输、持久化存储以及对象状态的保存等方面发挥着关键作用。 **IO流**: IO流是Java提供的用于处理输入输出操作的机制...

    java持久化工具类:JavaBean与XML

    JavaBean持久化通常通过序列化实现,序列化是将Java对象转换为字节流的过程,以便可以存储或在网络上传输。要使一个Java类成为可序列化的,只需在类定义上添加`java.io.Serializable`接口。序列化后,可以使用`...

    探索Java序列化与反序列化的奥秘:数据持久化的桥梁

    Java序列化是一项核心功能,它允许程序员将对象的状态转化为字节流的形式,从而实现对象的持久化存储或者在网络之间进行传递。这对于诸如远程方法调用(RMI)、分布式计算、对象存储以及缓存管理等场景至关重要。下面...

    day21_缓冲流、转换流、序列化流、Commons IO.pdf

    序列化流允许我们将Java对象持久化到磁盘或在网络中传输。`ObjectOutputStream` 和 `ObjectInputStream` 分别用于序列化和反序列化对象。通过这两个类,我们可以将对象的状态保存到文件,或者从文件中恢复对象的...

    io_输入输出流_序列化反序列化_04.zip

    在Java中,序列化是将对象的状态转换为字节流的过程,以便可以存储到磁盘、在网络上传输或持久化到数据库中。要实现一个对象的序列化,该对象的类需要实现java.io.Serializable接口。序列化的主要方法是...

    对象流(序列化)

    在Java编程语言中,对象流(也称为序列化)...总的来说,对象流和序列化是Java中不可或缺的一部分,它们为数据持久化、网络通信等提供了便利。然而,同时也需要对序列化的潜在风险有充分的认识,并采取相应的安全措施。

    IO流学习(字节流 字符流 文本流)!

    **对象流**如ObjectInputStream和ObjectOutputStream则用于序列化和反序列化Java对象,实现对象的持久化存储。 在实际编程中,我们还需要理解**异常处理**在IO流中的重要性。由于IO操作可能失败,如文件不存在、...

    21.【缓冲流、转换流、序列化流、打印流】(1)_缓冲流_源码

    序列化流(`ObjectInputStream`和`ObjectOutputStream`)主要用于对象的序列化和反序列化,即将对象的状态保存到文件或网络中,或者从这些地方恢复。序列化是Java提供的一种持久化机制,通过实现`Serializable`接口...

    object文件流

    总的来说,ObjectInputStream和ObjectOutputStream是Java中实现对象持久化和跨进程通信的关键工具。它们允许我们保存和恢复对象的状态,同时也支持在不同JVM之间传递对象,这对于分布式系统和网络编程尤其重要。在...

    java 对象流 的用法

    3. **序列化流的安全性**:序列化可能会暴露对象的内部状态,因此在设计可序列化类时,要考虑安全性问题,避免敏感信息的泄露。 4. **工具类**:Java提供了一些工具类,如`ObjectStreamClass`和`...

    IOstream_javaIOl流_

    - 对象序列化:ObjectInputStream和ObjectOutputStream允许将Java对象转换为字节流进行持久化存储或网络传输。 - 数据操作:DataInputStream和DataOutputStream提供方法读写基本数据类型,如int、float等。 - 复用流...

    java之io流实例

    - ObjectInputStream和ObjectOutputStream允许我们将Java对象序列化和反序列化,从而实现对象的持久化存储或网络传输。 5. 复用流: - PipedInputStream和PipedOutputStream用于线程间通信,一个线程写入数据,另...

    java数据流的概述

    这在持久化对象、网络通信等方面非常有用。 除此之外,Java NIO(New IO)提供了一种新的数据流模型,它引入了通道(Channel)和缓冲区(Buffer)的概念,提高了I/O操作的性能和并发性。例如,FileChannel可以从...

Global site tag (gtag.js) - Google Analytics