标签: objectinputstream

是不是可以附加到ObjectOutputStream？

我试图附加到对象列表.以下代码段是一个在作业完成时调用的函数.

FileOutputStream fos = new FileOutputStream
           (preferences.getAppDataLocation() + "history" , true);
ObjectOutputStream out = new ObjectOutputStream(fos);

out.writeObject( new Stuff(stuff) );
out.close();

但是当我尝试阅读它时,我只得到文件中的第一个.然后我明白了java.io.StreamCorruptedException.

阅读我正在使用

FileInputStream fis = new FileInputStream
        ( preferences.getAppDataLocation() + "history");
ObjectInputStream in = new ObjectInputStream(fis);    

try{
    while(true)
        history.add((Stuff) in.readObject());
}catch( Exception e ) { 
    System.out.println( e.toString() );
}

我不知道会有多少个物品存在,所以我在读书时没有例外.从谷歌所说的这是不可能的.我想知道是否有人知道方法？

我疯了,我创建了一个文件对象,所以可以用ObjectInputStream读取它,然后放置了assets文件夹.该方法适用于小于1M的文件,并且对较大的文件给出错误.我读到这是Android平台的限制,但我也知道可以"轻松"避免.例如,那些已经下载游戏Reging Thunder的人可以很容易地看到他们的资产文件夹中的文件大小是18.9M.这是我从ObjecInputStream读取1个对象的代码

File f = File.createTempFile("mytempfile", "dat");
FileOutputStream fos = new FileOutputStream(f);

InputStream is = mc.getAssets().open(path,3);

ObjectInputStream ois=new ObjectInputStream(is);
byte[] data = (byte[]) ois.readObject();
fos.write(data);

fos.flush();
fos.close();
ois.close();
is.close();

现在我有一个未压缩的文件,我可以使用它而不用担心错误"这个文件不能作为文件描述符打开;它可能是压缩的"

此函数适用于小于1M的文件,较大的文件在"ObjectInputStream ois = new ObjectInputStream(is);"行返回java.io.IOException.

为什么？？

我已经下载了Eclipse并试图创建一个示例servlet程序,但是我遇到了以下错误

无法解析java.io.ObjectInputStream类型.它是从所需的.class文件间接引用的

我已正确配置构建路径.我正在使用Java 8和Apache Tomcat 7,并且正确引用了两者的库.

问题仅适用于Java EE.通常Java SE项目运行正常.

我编写了以下代码,将4000字节的0写入文件test.txt.然后,我一次以1000字节的块读取相同的文件.

FileOutputStream output = new FileOutputStream("test.txt");
ObjectOutputStream stream = new ObjectOutputStream(output);

byte[] bytes = new byte[4000];

stream.write(bytes);
stream.close();

FileInputStream input = new FileInputStream("test.txt");
ObjectInputStream s = new ObjectInputStream(input);


byte[] buffer = new byte[1000];
int read = s.read(buffer);

while (read > 0) {
    System.out.println("Read " + read);
    read = s.read(buffer);
}

s.close();

我期望发生的是四次读取1000个字节.

Read 1000
Read 1000
Read 1000
Read 1000

然而,实际发生的事情是,我似乎每1024字节"暂停"(因为缺少一个更好的词).

Read 1000
Read 24
Read 1000
Read 24
Read 1000
Read 24
Read 928

如果我尝试读取超过1024个字节,那么我的上限为1024字节.如果我尝试读取少于1024个字节,我仍然需要暂停1024字节标记.

在输出文件的检查test.txt …

我试图使用readObject读取二进制文件中的行数,但我得到IOException EOF.我这样做是对的吗？

    FileInputStream istream = new FileInputStream(fileName);
    ObjectInputStream ois = new ObjectInputStream(istream);

    /** calculate number of items **/
    int line_count = 0;
    while( (String)ois.readObject() != null){            
        line_count++;
    }

我有一些非常标准的代码,它从流中获取一个序列化对象,基本上看起来像这样:

  Object getObjectFromStream(InputStream is) {
    ObjectInputStream ois = new ObjectInputStream(is);
    return ois.readObject();
  }

然后我在我的资源文件夹中有一个文件,所以在我的开发机器上,我可以将它作为文件引用,或者作为JarResource引用:

  InputStream is = new FileInputStream("/home/.../src/main/resources/serializedObjects/testObject");
  InputStream is = this.getClass().getResourceAsStream("/serializedObjects/testObject");

在我的脑海中,两者都应该做同样的事情.然而,当它发生时,两者都解析为有效(非空)流,但FileInputStream正确地从我的getObjectFromStream(InputStream)方法返回一个Object,而getResourceAsStream版本抛出此异常:

  java.io.StreamCorruptedException: invalid stream header: EFBFBDEF
    at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:800)
    at java.io.ObjectInputStream.(ObjectInputStream.java:297)

大多数情况下,我想知道如何解决这个问题,但我也很欣赏理解两个InputStream之间的区别......

当我从一个ObjectInputStreamwith中读取大量对象时,我遇到了一个OOM readUnshared.MAT指向其内部句柄表作为罪魁祸首,OOM堆栈跟踪(在本文末尾)也是如此.从各方面来看,这不应该发生.此外,OOM是否发生似乎取决于先前如何写入对象.

据有关该主题的写了,readUnshared要解决这个问题(而不是readObject通过读期间不创建句柄表条目)(即写了我是如何发现writeUnshared和readUnshared,这是我以前没有注意到).

但是,从我自己的观察看来,readObject和readUnshared相同的行为,以及OOM是否发生,如果对象被取决于写有reset()每个写操作后(它并没有,如果没关系writeObjectVS writeUnshared使用了,因为我以前认为的-我是我第一次参加考试时就累了.那是:

              writeObject   writeObject+reset   writeUnshared   writeUnshared+reset
readObject       OOM               OK               OOM                 OK
readUnshared     OOM               OK               OOM                 OK

因此,实际上是否readUnshared有任何影响似乎完全取决于对象的编写方式.这对我来说是令人惊讶和意想不到的.我确实花了一些时间来追踪代码路径但是,并且授予它已经很晚了我累了,我不清楚为什么它仍然会使用句柄空间以及为什么它将取决于对象的编写方式(但是,我现在有一个初步的怀疑,虽然我还没有确认,如下所述).readUnshared

从我所有的课题研究,到目前为止,它似乎writeObject与readUnshared 应工作.

这是我一直在测试的程序:

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import …

至于现在,java.io.StreamCorruptedException当我尝试追加一个Object时,我会得到.我已经在互联网上搜索了一种克服这种情况的方法.到目前为止我找到的答案是无法完成的.解决此问题的方法是将对象写入列表,然后将列表写入文件.

但是每次添加新对象时我都要覆盖该文件.它似乎不是加班的最佳解决方案.

有没有办法将对象附加到现有的对象流？

我正在尝试使用Java中的套接字和对象流来进行本地IPC但是我看到性能不佳.

我正在测试通过ObjectOutputStream发送对象的ping时间,以通过Socket上的ObjectInputStream接收回复.

这是请求者:

public SocketTest(){

    int iterations = 100;
    try {
        Socket socket = new Socket("localhost", 1212);

        ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream()); 
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream()); 

        double start = System.currentTimeMillis();
        for (int i = 0; i < iterations; ++i) {

            Request request = new Request();
            objectOutputStream.writeObject(request);

            Response response = (Response)objectInputStream.readObject();
        }
        double finish = System.currentTimeMillis();
        System.out.println("Per ping: " + (finish - start) / iterations );

    } catch (Exception e) {
        e.printStackTrace();
    }
}

这是响应者:

public ServerSocketTest(){

    try {

        ServerSocket …

我想为我的项目维护一个Bank用户的数据库.我能够将用户数保存在一个可序列化文件中.但是当我尝试将用户保存到数据库时,它只将最新的一个添加到数据库中.

下面是写入对象的代码的潜行高峰:

if(e.getSource()==submit) {
            if(uFName != null && uLName != null && uInitialDeposit !=0) {
                if(uAccountType=="Savings") {
                    Random randomGenerator = new Random();
                    //Gets the number of users from file if file exists
                    File f = new File(fileNameAdmin);
                    if(f.exists() && !f.isDirectory()) {
                        admin=db.readFromAdminDatabase();
                    }
                    u[admin.numberOfUsers]= new User();
                    u[admin.numberOfUsers].fName=uFName;
                    u[admin.numberOfUsers].lName=uLName;
                    u[admin.numberOfUsers].initalDeposit=uInitialDeposit;
                    u[admin.numberOfUsers].interestRate=uInterestRate;
                    u[admin.numberOfUsers].accountType="Saving";
                    u[admin.numberOfUsers].accountNumber=690000+admin.numberOfSavingsAccount;

                    //Generates a 4 digit random number which will be used as ATM pin
                    u[admin.numberOfUsers].atmPin=randomGenerator.nextInt(9999-1000)+1000;

                    //A savings account will be created 
                    sa[admin.numberOfSavingsAccount]=new SavingsAccount(u[admin.numberOfUsers].accountNumber,u[admin.numberOfUsers].fName,u[admin.numberOfUsers].lName,
                            u[admin.numberOfUsers].initalDeposit,
                            u[admin.numberOfUsers].interestRate);
                    u[admin.numberOfUsers].sa=sa[admin.numberOfSavingsAccount];
                    System.out.println(u[admin.numberOfUsers].sa.balance);
                    JOptionPane.showMessageDialog(submit,"Congratulations! You …