精华内容
下载资源
问答
  • 思路:把已经序列化的对象存入容器(如LinkedList)中,然后用ObjectInputStream和ObjectOutputStream对这实例化的LinkedList对象进行读写。 测试主程序: ...* @Description: 文件、...读写是使用对象流实现

    思路:把已经序列化的对象存入容器(如LinkedList<?>)中,然后用ObjectInputStream和ObjectOutputStream对这个实例化的LinkedList<?>对象进行读写。


    测试主程序:

    /**   
    * @Title: FileRW.java
    * @Package com.file
    * @Description: 文件、文件夹的创建、写入练习。读写是使用对象流实现。
    * @author 慢跑学Android
    * @date 2011-11-19 下午03:53:01
    * @version V1.0   
    */
    package com.file;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.util.LinkedList;
    
    
    public class FileRW {
    	private String dirPath;
    	private String filename;
    	
    	public static void main(String[] args) {
    		String path = "C:\\晓声";
    		String fileName = "test.txt";
    		FileRW fileRW = new FileRW(path, fileName);
    		LinkedList<TestMessage> msgOut = new LinkedList<TestMessage>();
    		LinkedList<TestMessage> msgIn = null;
    		
    		msgOut.add(new TestMessage("柯南", "偶像"));
    		msgOut.add(new TestMessage("卡卡西", "好样的"));
    		msgOut.add(new TestMessage("Android", "Android"));
    		msgOut.add(new TestMessage("哈哈", "测试下喔"));
    		fileRW.writeObject(path, fileName, msgOut);
    		
    		msgIn = fileRW.readObject(path,fileName);
    		
    		for(TestMessage temp:msgIn)	{
    			System.out.println(temp.getName() + temp.getData());
    		}
    		
    	}
    	
    	public FileRW(String dirPath, String filename) {
    		this.dirPath = dirPath;
    		this.filename = filename;
    		if (creatDir()) {			
    			creatFile();
    		}
    	}
    
    	
    	private boolean creatDir() {
    		if (null != dirPath) {
    			File path = new File(dirPath);
    			if (path.exists()) {
    				return true;
    			}
    			if (true == path.mkdirs() ) {
    				return true;
    			}
    		}
    		return false;
    	}
    
    	private void creatFile() {
    		if (null != filename) {
    			File file = new File(dirPath, filename);
    			if (false == file.exists()) {
    				try {
    					file.createNewFile();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    	
    
    	/**
    	* @Title: writeObject
    	* @Description: Write a object to a file.
    	* @param path the directory of the target file
    	* @param filename the name of the target file
    	* @param msg the type of the object
    	* @return void
    	* @throws
    	*/
    	private void writeObject(String path, String filename, LinkedList<TestMessage> msg) {
    		File file = new File(path, filename);
    		if (false == file.isFile()) {
    			return ;
    		}
    		
    		try {
    			// The value "false" for FileOutputStream means that overwrite this file,
    			// if it is "true",append the new data to this file.
    			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file,false));
    			oos.writeObject(msg);
    			oos.flush();
    			oos.close();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	* @Title: readObject
    	* @Description: Read a object from a file.
    	* @param path the directory of the target file
    	* @param filename the name of the target file
    	* @return LinkedList<TestMessage>
    	* @throws
    	*/
    	@SuppressWarnings("unchecked")
    	private LinkedList<TestMessage> readObject(String path, String filename) {
    		File file = new File(path, filename);
    		ObjectInputStream ois = null;
    		LinkedList<TestMessage> msgAll = null;
    		
    		try {
    			ois = new ObjectInputStream(new FileInputStream(file));
    			try {
    				msgAll = (LinkedList<TestMessage>)ois.readObject();
    				
    			} catch (ClassNotFoundException e) {
    				e.printStackTrace();
    			}
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				ois.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    		
    		return msgAll;
    	}
    }
    



    测试程序中的消息包定义:

    /**   
    * @Title: TestMessage.java
    * @Package com.file
    * @Description: FileRW的消息流
    * @author 慢跑学Android
    * @date 2011-11-19 下午04:35:11
    * @version V1.0   
    */
    package com.file;
    
    
    public class TestMessage implements java.io.Serializable {
    	private String name;
    	private String data;
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getData() {
    		return data;
    	}
    	public void setData(String data) {
    		this.data = data;
    	}
    	public TestMessage(String name, String msg) {
    		this.name = name;
    		data = msg;
    	}
    }
    

    程序运行结果:


    参考资料:ObjectInputStream类和ObjectOutputStream类的使用


    展开全文
  • 思路:把已经序列化的对象存入容器(如LinkedList)中,然后用ObjectInputStream和ObjectOutputStream对这实例化的LinkedList对象进行读写 测试主程序: package com.file; import java.io.File; import ...

    思路:把已经序列化的对象存入容器(如LinkedList< ? >)中,然后用ObjectInputStream和ObjectOutputStream对这个实例化的LinkedList< ? >对象进行读写

    测试主程序:

    package com.file;  
    
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileNotFoundException;  
    import java.io.FileOutputStream;  
    import java.io.IOException;  
    import java.io.ObjectInputStream;  
    import java.io.ObjectOutputStream;  
    import java.util.LinkedList;  
    
    
    public class FileRW {  
        private String dirPath;  
        private String filename;  
    
        public static void main(String[] args) {  
            String path = "C:\\晓声";  
            String fileName = "test.txt";  
            FileRW fileRW = new FileRW(path, fileName);  
            LinkedList<TestMessage> msgOut = new LinkedList<TestMessage>();  
            LinkedList<TestMessage> msgIn = null;  
    
            msgOut.add(new TestMessage("柯南", "偶像"));  
            msgOut.add(new TestMessage("卡卡西", "好样的"));  
            msgOut.add(new TestMessage("Android", "Android"));  
            msgOut.add(new TestMessage("哈哈", "测试下喔"));  
            fileRW.writeObject(path, fileName, msgOut);  
    
            msgIn = fileRW.readObject(path,fileName);  
    
            for(TestMessage temp:msgIn) {  
                System.out.println(temp.getName() + temp.getData());  
            }  
    
        }  
    
        public FileRW(String dirPath, String filename) {  
            this.dirPath = dirPath;  
            this.filename = filename;  
            if (creatDir()) {             
                creatFile();  
            }  
        }  
    
    
        private boolean creatDir() {  
            if (null != dirPath) {  
                File path = new File(dirPath);  
                if (path.exists()) {  
                    return true;  
                }  
                if (true == path.mkdirs() ) {  
                    return true;  
                }  
            }  
            return false;  
        }  
    
        private void creatFile() {  
            if (null != filename) {  
                File file = new File(dirPath, filename);  
                if (false == file.exists()) {  
                    try {  
                        file.createNewFile();  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        }  
    
    
        /** 
        * @Title: writeObject 
        * @Description: Write a object to a file. 
        * @param path the directory of the target file 
        * @param filename the name of the target file 
        * @param msg the type of the object 
        * @return void 
        * @throws 
        */  
        private void writeObject(String path, String filename, LinkedList<TestMessage> msg) {  
            File file = new File(path, filename);  
            if (false == file.isFile()) {  
                return ;  
            }  
    
            try {  
                // The value "false" for FileOutputStream means that overwrite this file,  
                // if it is "true",append the new data to this file.  
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file,false));  
                oos.writeObject(msg);  
                oos.flush();  
                oos.close();  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    
        /** 
        * @Title: readObject 
        * @Description: Read a object from a file. 
        * @param path the directory of the target file 
        * @param filename the name of the target file 
        * @return LinkedList<TestMessage> 
        * @throws 
        */  
        @SuppressWarnings("unchecked")  
        private LinkedList<TestMessage> readObject(String path, String filename) {  
            File file = new File(path, filename);  
            ObjectInputStream ois = null;  
            LinkedList<TestMessage> msgAll = null;  
    
            try {  
                ois = new ObjectInputStream(new FileInputStream(file));  
                try {  
                    msgAll = (LinkedList<TestMessage>)ois.readObject();  
    
                } catch (ClassNotFoundException e) {  
                    e.printStackTrace();  
                }  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    ois.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
    
            return msgAll;  
        }  
    }  

    测试程序中的消息包定义:

    
    package com.file;  
    
    
    public class TestMessage implements java.io.Serializable {  
        private String name;  
        private String data;  
    
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
        public String getData() {  
            return data;  
        }  
        public void setData(String data) {  
            this.data = data;  
        }  
        public TestMessage(String name, String msg) {  
            this.name = name;  
            data = msg;  
        }  
    }  
    

    转载地址:

    http://blog.csdn.net/u010355144/article/details/47951429

    展开全文
  • //调用Object.defineProperties(对象名,要添加的属性)方法,为对象一次定义多个属性(1.数据属性)(2.访问器属性) Object.defineProperties(book,{ //添加的两个数据属性(_year,edition) _year:{//(_year)前面的
    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <title>Document</title>
    <script type="text/javascript">
    //用面向字面量的方式创建一个book对象
    var book={};
    //调用Object.defineProperties(对象名,要添加的属性)方法,为对象一次定义多个属性(1.数据属性)(2.访问器属性)
    Object.defineProperties(book,{
    //添加的两个数据属性(_year,edition)
    _year:{//(_year)前面的下划线表示只能通过对象方法访问的属性
    value:2004
    },
    edition:{
    value:1
    },
    //添加了访问器属性(year)
    year:{
    //调用get方法读取属性
    get:function(){
    return this._year;
    },
    //调用set方法写入属性
    set:function(newValue){
    if (newValue>2004) {
    this._year=newValue;
    this.edition+=newValue-2004;
    }
    }
    }
    });
    //测试

    book.year=2005;//访问器属性常见方式,设置一个属性的值会导致其他属性发生变化

    alert(book.edition);
    </script>
    </head>
    <body>

    </body>
    </html>
    展开全文
  • 但是当我们追加写入一个文件时,这些头部信息也会写入文件中,读取的时候只会把文件第一次出现的头部信息过滤掉,并不会把文件中间的头部信息也过滤掉,所以追加多个对象后,读取对象时会出现问题。 怎么解决呢?...

    import java.io.*;

    class Person implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;

    private int age;

    public Person() {

    }

    public Person(String name, int age) {

    this.name = name;

    this.age = age;

    }

    public String toString() {

    return "姓名:" + name + ";年龄:" + age;

    }

    }

    public class Text{

    static int geshu = 0;

    public static void main(String[] args) throws Exception {

    String path = "d:" + File.separator + "test.txt";

    File f = new File(path);

    Person p1 = new Person("张三", 23);

    write(f, p1);

    read(f, geshu);

    Person p2 = new Person("李四", 32);

    write(f, p2);

    read(f, geshu);

    }

    public static void write(File f, Object p) throws Exception {

    OutputStream out = new FileOutputStream(f, true);

    //true表示追加

    MyObjectOutputStream oos = MyObjectOutputStream.newInstance(f, out);

    oos.writeObject(p);

    geshu++;

    oos.close();

    System.out.println("-----Oject写入成功....");

    }

    public static void read(File f, int geshu) throws Exception {

    FileInputStream in = new FileInputStream(f);

    ObjectInputStream ois = new ObjectInputStream(in);

    for (int i = 0; i < geshu; i++) {

    System.out.println((Person) ois.readObject());

    }

    ois.close();

    }

    }

    new一个ObjectOutputStream的时候,这个ObjectOutputStream的构造方法就会调用writeStreamHeader()方法, 这样流中就会被写入了一些信息,这些信息也会写入到我们的文件中。在第一次写入文件时,这些头部信息是需要的。因为ObjectInputStream读的时候会帮我们过滤掉。但是当我们追加写入一个文件时,这些头部信息也会写入文件中,读取的时候只会把文件第一次出现的头部信息过滤掉,并不会把文件中间的头部信息也过滤掉,所以追加多个对象后,读取对象时会出现问题。

    怎么解决呢?

    一、不用追加,可以在每次写入的时候把文件中所有对象读出来,再将这些对象和要写入的对象一起重新写入。

    二、如果不是第一次写入文件,在写入时去掉头部信息,怎么去掉呢?头部信息是在writeStreamHeader();方法中写入的,所以我们可以通过继承ObjectOutputStream来覆盖这个方法,如果不是第一次写入文件,这个方法什么也不做。

    class MyObjectOutputStream extends ObjectOutputStream {

    private static File f;

    writeStreamHeader()方法是在ObjectOutputStream的构造方法里调用的 由于覆盖后的writeStreamHeader()方法用到了f。如果直接用构造方法创建 一个MyObjectOutputStream对象,那么writeStreamHeader()中的f是空指针 因为f还没有初始化。所以这里采用单态模式 (将构造方法定义为私有的,然后通过方法获取对象,可以保证某个类只能存在一个对象示例)

    public static MyObjectOutputStream newInstance(File file, OutputStream out)

    throws IOException {

    f = file;

    return new MyObjectOutputStream(out);

    }//通过方法初始化f,获取对象。

    private MyObjectOutputStream(OutputStream out) throws IOException {

    super(out);//会调用重写的writeStreamHeader()方法

    }//不能在类的外部使用new,但在类的内部可以

    @Override

    protected void writeStreamHeader() throws IOException {

    if (!f.exists() || (f.exists() && f.length() == 0)) {

    super.writeStreamHeader();

    } else {

    super.reset();

    }

    }

    }

    展开全文
  • 一、利用对象数组进行读写: 学生类: public class Student implements Serializable{ int age; String name; public Student(){} public Student(int age,String name){ this.age=age; this.name=...
  • 使用缺省的serializetion的实现时,一个ObjectOutputStream的构造和一个ObjectInputStream的构造必须一一对应。... 因此,多次以追加方式向一个文件中写入object时,该文件将会包含多个标识头。所以用ObjectInputSt
  • readObject返回值为Object对象,从表面看我们只能读取一个序列化对象,但是数组也是Object对象,所以我们可以把序列化对象数组读取出来(List等集合框架也是好的选择),这样就可以实现读取多个对象。import java.io...
  • 使用ObjectOutputStream,如果以追加的方式,在一文件中末尾追加写入object,那每次都会在写入时增加特定的文件头信息,而这些头信息如果每次都写入到文件中,在使用ObjectInputStream读取这文件object时就会出现异常...
  • 使用 ScriptableObject 存数据对象

    万次阅读 2017-03-30 13:55:53
    直译过来就是“脚本化对象”,换言之这类作为存储结构化的数据来使用,并写入Unity的资源.asset文件去存储一组数据,取用的时候直接作为一数据对象拿来用,很方便。 ScriptableObject 有什么好处? Unity用于...
  • 数据持久化的本质 - 数据保存成文件,存储到...沙盒机制(Sand box):是安全机制  - 这就是ios和Mac系统安全的原因,就是因为它采用了沙盒机制 越狱之后沙盒机制被损坏了,应用程序之间可能会相互盗取信息 沙盒其实
  • 昨天在群里一个同学问了这样一个问题,Flink怎么根据数据里面的某个字段动态把数据写入多个kafka的topic.其实这个问题非常简单,你肯定会想到说写多个sink就可以了,Flink确...
  •  前段时间公司的WebService接口需要处理xml数据,主要就是和对象之间的互相转换,传输的时候用xml,后台使用的时候转换成对象,所以就有了xml和object之间经常的互相转换。  因为我们的项目使用的JDK是1.5,所以...
  • SharedObject 共享对象

    千次阅读 2009-01-16 14:04:00
    介绍 出于安全性能的考虑,flash player客户端...SharedObject对象为常驻在本地计算机或远程服务器上的多个客户端SWF文件或对象提供实时数据共享。本地共享对象类似于浏览器的cookie,远程数据共享对象类似于实时数据
  • 将Java对象写入文件中

    万次阅读 多人点赞 2018-06-05 00:01:39
    Java对象序列化 ...对象的序列化指将一Java对象写入IO中,与此对应的反是,对象的反序列化则指从IO中恢复该Java对象。 如果需要需要让某个对象支持序列化机制,则必须让它的类是可序列化的(serializa...
  • flash.net.SharedObject共享对象

    千次阅读 2010-09-08 15:54:00
    Flex应用程序可以存储简单数据类型如String、Array等,或者用户自定义的对象类型到一指定的位置。共享对象:本地共享对象(local SharedObject)和远端共享对象(Remote SharedObject) 本地共享对象(local ...
  • Java序列化读写多个对象的方法

    千次阅读 2018-03-21 16:19:51
    方法一:存入文件时,将几个对象放入一个Object[] 数组中,然后再读取。  private static void read() throws ClassNotFoundException, IOException { //创建序列化对象 ObjectInputStream ois = new ...
  • Flash本地共享对象 SharedObject

    千次阅读 2012-10-10 20:08:59
    SharedObject 介绍 以下内容是对网上一些资料的总结 Flex SharedObject 介绍(转自http://www.eb163.com/club/thread-3235-1-1.html): Flash的本地共享对象是在用户机器上实现持久化存储的...使用SharedObject对象
  • 如何在Node.js中读取和写入JSON对象到文件 本文翻译自How to read and write a JSON object to a file in Node.js
  • Java学习之IO下(转换,数据 ,print ,object简单使用) 一.转换 Reader  |--InputStreamReader  |--FileReader:专门用于处理文件的字符读取流对象。 Writer  |--OutputStreamWriter  |-
  • DAO(Data Access Object) 数据访问对象

    千次阅读 2016-02-22 19:23:42
    DAO(Data Access Object) 数据访问对象是第一面向对象的数据库接口,它显露了 Microsoft Jet 数据库引擎(由 Microsoft Access 所使用),并允许 Visual Basic 开发者通过 ODBC 像直接连接到其他数据库一样,...
  • Java中的高级I/O流-缓冲流、数据流以及对象流 前言:通过前面的学习,已经学完了Java中的基本流;Java中的流有字节流和字符流两大类,而每一种流都有对应的输入和输出流; 1、字节流 1.1字节输入流-主要是:...
  • python 线程写入文件

    万次阅读 2018-04-27 17:04:24
    python 线程写入文件 在python中,对文件的操作时很简洁的,一般是通过打开文件,获取文件对象,然后对文件对象进行写入。 这是file 的一些常用方法: class file(object): def close(self): # real ...
  • 怎么判断对象流已经读取到末尾

    千次阅读 2018-06-15 09:36:48
    对于有用过对象流的人来说,都很清楚,对象流操作的是对象,存入一的对象,也只能读一的对象,但是存在一问题就是写入多少就只能读多少,没有读取到结尾的判断方法,如果读取超过了则会抛出异常java.io....
  • java中将对象写入文件

    千次阅读 2009-09-21 19:20:27
    前两天无意中发现java中可以把对象写入文件(因为平时没太注意,所以没有发现,其实这也是team leader叫我们翻译C#代码的时候发现的)。正好今天晚上闲着无聊,就来看看这是怎么回事了。  java的IO包当中提供了...
  • 使用原因 我们在进行数据库查询的时候,查询出来的结果是ResultSet对象,我们需要一行一行的遍历,用...我们可以让查询的RestultSet对象一行数据和数据库表对象的实体类Object一起传入一类中进行“加工”,把Re...
  • 1. pycharm中运行scrapy ...pycharm中打开scrapy项目所在文件夹,任意创建一.py文件,写入如下代码 from scrapy import cmdline cmdline.execute('scrapy crawl mycsdn'.split()) 修改Run…...
  • ObjectOutputStream in Java can be used to convert an object to OutputStream. The process of converting object to stream is called ... Java中的ObjectOutputStream可用于将对象转换为OutputStream。 ...
  • 实例讲解Flex3的SharedObject对象用法

    千次阅读 2008-07-03 21:29:00
    实例讲解Flex3的SharedObject对象用法 Flex中的SharedObject对象可以实现web开发中的Cookie的功能,本例用到以下方法: 1.Shared... 2.SharedObject.flush() 立即把共享对象数据写入本地文件; 3.SharedObject.clear
  • Java笔记(7)-输入、输出流 字节流 字符流 文件字节流 文件字符流 缓冲流 随机流 数组流 数据流 对象流 序列化和对象克隆 文件锁 Scanner解析文件 Console就读取密码 InputStream、Reader、FileInputStream、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 240,104
精华内容 96,041
关键字:

object流写入多个对象