Example #1
1
  static void serTest(Map s, int size) throws Exception {
    if (!(s instanceof Serializable)) return;
    System.out.print("Serialize              : ");

    for (int i = 0; i < size; i++) {
      s.put(new Integer(i), Boolean.TRUE);
    }

    long startTime = System.currentTimeMillis();

    FileOutputStream fs = new FileOutputStream("MapCheck.dat");
    ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(fs));
    out.writeObject(s);
    out.close();

    FileInputStream is = new FileInputStream("MapCheck.dat");
    ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(is));
    Map m = (Map) in.readObject();

    long endTime = System.currentTimeMillis();
    long time = endTime - startTime;

    System.out.print(time + "ms");

    if (s instanceof IdentityHashMap) return;
    reallyAssert(s.equals(m));
  }
Example #2
0
 public void testResultListSerializableComplex() throws Exception {
   // Create mutliple objects
   removeAll(Object.class);
   for (int i = 0; i < 20; i++) getStore().save(new Book("Learning Java 1." + i, "" + i));
   for (int i = 0; i < 20; i++) getStore().save(new Referrer(i));
   for (int i = 0; i < 20; i++) getStore().save(new User());
   for (int i = 0; i < 20; i++) getStore().save(new MapHolder());
   // Get the result list for all objects
   List result = getStore().find("find object");
   Assert.assertEquals(result.size(), 80);
   // Now serialize
   ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
   ObjectOutputStream objectOut = new ObjectOutputStream(byteOut);
   objectOut.writeObject(result);
   objectOut.close();
   // Close the store, let's pretend we're outside it
   tearDownStore();
   try {
     // Deserialize
     ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
     ObjectInputStream objectIn = new ObjectInputStream(byteIn);
     List deList = (List) objectIn.readObject();
     // Test object
     Assert.assertEquals(deList.size(), 80);
     Assert.assertEquals(getCount(deList, Book.class), 20);
     Assert.assertEquals(getCount(deList, Referrer.class), 20);
     Assert.assertEquals(getCount(deList, User.class), 20);
     Assert.assertEquals(getCount(deList, MapHolder.class), 20);
   } finally {
     // Setup store for next tests
     setUpStore();
   }
 }
 private TaskObjectsExecutionResults runObject(TaskObjectsExecutionRequest obj)
     throws IOException, PDBatchTaskExecutorException {
   Object res = null;
   try {
     setAvailability(false);
     _oos.writeObject(obj);
     _oos.flush();
     res = _ois.readObject();
     setAvailability(true);
   } catch (IOException e) { // worker closed connection
     processException(e);
     throw e;
   } catch (ClassNotFoundException e) {
     processException(e);
     throw new IOException("stream has failed");
   }
   if (res instanceof TaskObjectsExecutionResults) {
     _isPrevRunSuccess = true;
     return (TaskObjectsExecutionResults) res;
   } else {
     PDBatchTaskExecutorException e =
         new PDBatchTaskExecutorException("worker failed to run tasks");
     if (_isPrevRunSuccess == false && !sameAsPrevFailedJob(obj._tasks)) {
       processException(e); // twice a loser, kick worker out
     }
     _isPrevRunSuccess = false;
     _prevFailedBatch = obj._tasks;
     throw e;
   }
 }
 /**
  * Serialize an object to a byte array. (code by CB)
  *
  * @param object object to serialize
  * @return byte array that represents the object
  * @throws Exception
  */
 public static byte[] toByte(Object object) throws Exception {
   ByteArrayOutputStream os = new ByteArrayOutputStream();
   ObjectOutputStream oos = new ObjectOutputStream((OutputStream) os);
   oos.writeObject(object);
   oos.close();
   return os.toByteArray();
 }
Example #5
0
  public void writeIndex(String location) {

    System.out.println("Writing index at: " + location);

    ObjectOutputStream objectOutputStream = null;

    try {

      File outputFile = new File(location);
      if (!outputFile.exists()) {
        outputFile.getParentFile().mkdirs();
        outputFile.createNewFile();
      }

      OutputStream file = new FileOutputStream(outputFile);
      BufferedOutputStream buffer = new BufferedOutputStream(file);
      objectOutputStream = new ObjectOutputStream(buffer);
      objectOutputStream.writeObject(tokenCountMap);
      objectOutputStream.writeObject(references);
    } catch (IOException ex) {
      System.out.println(
          "\nError writing index for " + author.getName() + " at location " + location);
    } finally {
      if (objectOutputStream != null)
        try {
          objectOutputStream.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
    }
  }
Example #6
0
 /**
  * A getter for the high scores list. Reads it directly from file and throws an error if the file
  * is not found (!working on this!).
  *
  * @return Object[][] where [i][0] is the rank (String), [i][1] is the name (String) and [i][2] is
  *     the score (Integer).
  */
 public static Object[][] getHighScore() {
   if (!new File("HighScores.dat").exists()) {
     // This object matrix actually stores the information of the high scores list
     Object[][] highScores = new Object[10][3];
     // We fill the high scores list with blank entries:  #.    " "    0
     for (int i = 0; i < highScores.length; i++) {
       highScores[i][0] = (i + 1) + ".";
       highScores[i][1] = " ";
       highScores[i][2] = 0;
     }
     // This actually writes and makes the high scores file
     try {
       ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("HighScores.dat"));
       o.writeObject(highScores);
       o.close();
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
   try {
     // Read and return the read object matrix
     ObjectInputStream o = new ObjectInputStream(new FileInputStream("HighScores.dat"));
     Object[][] highScores = (Object[][]) o.readObject();
     o.close();
     return highScores;
   } catch (IOException | ClassNotFoundException e) {
     e.printStackTrace();
   }
   return null;
 }
Example #7
0
 public void serializeAndReplace(Object obj) throws IOException {
   FileOutputStream fOut = new FileOutputStream(this.getFilepath());
   ObjectOutputStream objOut = new ObjectOutputStream(fOut);
   objOut.writeObject(obj);
   objOut.close();
   fOut.close();
 }
Example #8
0
 public FileCollectionSnapshot snapshot(FileCollection files) {
   try {
     File snapshotFile = cache.get(files);
     if (snapshotFile == null) {
       assert cache.size() == 0;
       FileCollectionSnapshot snapshot = snapshotter.snapshot(files);
       snapshotFile = new File(tmpDir, String.valueOf(cache.size()));
       ObjectOutputStream outstr =
           new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(snapshotFile)));
       try {
         outstr.writeObject(snapshot);
       } finally {
         outstr.close();
       }
       cache.put(files, snapshotFile);
       return snapshot;
     } else {
       ObjectInputStream instr =
           new ObjectInputStream(new BufferedInputStream(new FileInputStream(snapshotFile)));
       try {
         return (FileCollectionSnapshot) instr.readObject();
       } finally {
         instr.close();
       }
     }
   } catch (Exception e) {
     throw new UncheckedIOException(e);
   }
 }
 /**
  * Serializes the passed object to a byte array, returning a zero byte array if the passed object
  * is null, or fails serialization
  *
  * @param arg The object to serialize
  * @return the serialized object
  */
 public static byte[] serializeNoCompress(Object arg) {
   if (arg == null) return new byte[] {};
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   ObjectOutputStream oos = null;
   try {
     oos = new ObjectOutputStream(baos);
     oos.writeObject(arg);
     oos.flush();
     baos.flush();
     return baos.toByteArray();
   } catch (Exception ex) {
     return new byte[] {};
   } finally {
     try {
       baos.close();
     } catch (Exception ex) {
       /* No Op */
     }
     if (oos != null)
       try {
         oos.close();
       } catch (Exception ex) {
         /* No Op */
       }
   }
 }
Example #10
0
  public void testSerial() {
    assertTrue(_nbhm.isEmpty());
    final String k1 = "k1";
    final String k2 = "k2";
    assertThat(_nbhm.put(k1, "v1"), nullValue());
    assertThat(_nbhm.put(k2, "v2"), nullValue());

    // Serialize it out
    try {
      FileOutputStream fos = new FileOutputStream("NBHM_test.txt");
      ObjectOutputStream out = new ObjectOutputStream(fos);
      out.writeObject(_nbhm);
      out.close();
    } catch (IOException ex) {
      ex.printStackTrace();
    }

    // Read it back
    try {
      File f = new File("NBHM_test.txt");
      FileInputStream fis = new FileInputStream(f);
      ObjectInputStream in = new ObjectInputStream(fis);
      NonBlockingIdentityHashMap nbhm = (NonBlockingIdentityHashMap) in.readObject();
      in.close();
      assertThat(
          "serialization works",
          nbhm.toString(),
          anyOf(is("{k1=v1, k2=v2}"), is("{k2=v2, k1=v1}")));
      if (!f.delete()) throw new IOException("delete failed");
    } catch (IOException ex) {
      ex.printStackTrace();
    } catch (ClassNotFoundException ex) {
      ex.printStackTrace();
    }
  }
Example #11
0
  // add the new user to the encrypted users file which has the detailed stats for all users
  // synchronize to make sure that only one thread can be inside this block at a time.
  public static synchronized String addUserAndIssueCode(UserStats stats)
      throws IOException, GeneralSecurityException, ClassNotFoundException, NoMoreCodesException {

    // ok, now we have a list of stats objects, representing all users.
    // add this user to the list.
    // the code assigned to this user will simply be codes.get(users.size())
    // but do an error check first to be sure we're not out of codes
    List<UserStats> users = readUsersFile();

    if (users.size() >= MemoryStudy.codes.size()) {
      log.warn("NOC WARNING: codes file exhausted!!!!");
      throw new NoMoreCodesException();
    }

    // ok, we have enough codes, just give out one
    String passkey = MemoryStudy.codes.get(users.size());
    int USERID_BASE =
        100; // userid numbering starts from USERID_BASE, new id is base + # existing codes
    stats.userid = Integer.toString(USERID_BASE + users.size());
    stats.code = passkey;
    users.add(stats);

    // encrypt and write the users file back
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    oos.writeObject(users);
    oos.close();
    CryptoUtils.writeEncryptedBytes(baos.toByteArray(), USERS_FILE);

    return passkey;
  }
Example #12
0
 public static void saveObjectToFile(String fileName, Object obj) throws Exception {
   FileOutputStream ostream = new FileOutputStream(fileName);
   ObjectOutputStream p = new ObjectOutputStream(ostream);
   p.writeObject(obj);
   p.flush();
   ostream.close();
 }
 public static void main(String[] args) {
   Random r = new Random();
   int n;
   if (args.length == 1) {
     n = Integer.parseInt(args[0]);
   } else {
     n = r.nextInt(10000) + 1;
   }
   try {
     OutputStream ofs = new FileOutputStream("scores.txt");
     ObjectOutputStream oos = new ObjectOutputStream(ofs);
     for (int i = 0; i < n; ++i) {
       int testNum = r.nextInt(21);
       String name = randString(r.nextInt(6) + 5);
       while (testNum-- > 0) {
         oos.writeUTF(name);
         oos.writeInt(r.nextInt(101));
       }
     }
     ofs.close();
   } catch (Exception e) {
     System.out.println("Error creating scores.txt: " + e.getMessage());
   }
   try {
     InputStream ifs = new FileInputStream("scores.txt");
     String name = findStudentWithTopThreeAverageScores(ifs);
     System.out.println("top student is " + name);
     ifs.close();
   } catch (Exception e) {
     System.out.println("Error reading scores.txt: " + e.getMessage());
   }
 }
  /** Method: readFromFile() */
  @Test
  public void testReadFromFile() throws Exception {
    GameNode testGameNode = new GameNode();
    testGameNode.setPlayer("rarry");
    testGameNode.setOpponent("lobertie");
    testGameNode.setGameName("raddle");
    testGameNode.setWinLose(true);
    testGameNode.setScore(29);
    LinkedList<GameNode> testLLGN = new LinkedList<GameNode>();
    testLLGN.add(testGameNode);
    try {
      FileOutputStream fileOut = new FileOutputStream("gameStats.ser");
      ObjectOutputStream out = new ObjectOutputStream(fileOut);
      out.writeObject(testLLGN);
      out.close();
      fileOut.close();
    } catch (IOException e) {

    }

    testScoreboard.readFromFile();

    assertTrue(
        "Is a public method that returns void and only alters a private variable with no getter. Should be made"
            + " a private method, should allow for ScoreInfo access or should not be tested",
        false);
  }
  public void InsertSupplier(Supplier supplier) {
    FileOutputStream fos = null;

    try {
      File file = new File("Suppliers.dat");

      if (file.exists()) {
        fos = new FileOutputStream(file, true);
        _aoos = new AppendableObjectOutputStream(fos);
        _aoos.writeObject(supplier);
        System.out.println("Fornecedor cadastrado com sucesso!");
      } else {
        fos = new FileOutputStream(file);
        _oos = new ObjectOutputStream(fos);
        _oos.writeObject(supplier);
        System.out.println("Fornecedor cadastrado com sucesso!");
      }

    } catch (IOException ex) {
      System.out.println("Falha ao cadastrar fornecedor!");
      ex.getStackTrace();
    } finally {
      try {
        if (_aoos != null) _aoos.close();
        if (_oos != null) _oos.close();
        if (fos != null) fos.close();
      } catch (IOException ex) {
        System.out.println("Falha ao cadastrar fornecedor!");
        ex.getStackTrace();
      }
    }
  }
  static boolean saveDat(String path) {
    try {
      //            DataOutputStream out = new DataOutputStream(new FileOutputStream(path));
      //            out.writeInt(start.length);
      //            for (int i : start)
      //            {
      //                out.writeInt(i);
      //            }
      //            out.writeInt(pair.length);
      //            for (int i : pair)
      //            {
      //                out.writeInt(i);
      //            }
      //            out.close();
      ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(path));
      out.writeObject(start);
      out.writeObject(pair);
      out.close();
    } catch (Exception e) {
      logger.log(Level.WARNING, "在缓存" + path + "时发生异常", e);
      return false;
    }

    return true;
  }
Example #17
0
 private void writeObject(ObjectOutputStream out) throws IOException {
   out.writeInt(CURRENT_SERIAL_VERSION);
   out.writeObject(prefix);
   out.writeInt(gramSizes.length);
   for (int i = 0; i < gramSizes.length; i++) out.writeInt(gramSizes[i]);
   out.writeBoolean(distinguishBorders);
 }
Example #18
0
  public void run() {
    try {
      System.out.println("socked");
      sock = new Socket(ii, pp);
      oout = new ObjectOutputStream(sock.getOutputStream());
      oout.flush();

      oin = new ObjectInputStream(sock.getInputStream());
      System.out.println("read ");
      rf.setLength(0);
      do {
        System.out.println("read ");
        file f = (file) oin.readObject();
        if (f.length <= 0) break;
        write(f);
      } while (true);
      oout.close();
      oin.close();
      rf.close();
      sock.close();
      xx.ConfirmPopup("Haua file namano shesh!!!");

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 /** Создаёт новый файл для хранения долговременной информации */
 public static void createNewData() throws IOException {
   if (ApplicationProperties.BUY_FILE.createNewFile()) {
     ObjectOutputStream os =
         new ObjectOutputStream(new FileOutputStream(ApplicationProperties.BUY_FILE));
     os.writeObject(new ApplicationService());
   }
 }
  @Override
  public void execute(JavaExecSpec javaExec) {
    configureReloadAgent(javaExec); // mutates the launch context

    OutputStream fileOut = null;
    ObjectOutputStream oos = null;
    try {
      fileOut = new FileOutputStream(contextDestination);
      oos = new ObjectOutputStream(fileOut);
      oos.writeObject(launchContext);

      javaExec.setWorkingDir(launchContext.getBaseDir());
      if (launchContext.getGrailsHome() != null) {
        javaExec.systemProperty("grails.home", launchContext.getGrailsHome().getAbsolutePath());
      }

      File launcherJar = findJarFile(ForkedGrailsLauncher.class);
      javaExec.classpath(launcherJar);
      javaExec.setMain(Main.class.getName());
      javaExec.args(contextDestination.getAbsolutePath());
    } catch (IOException e) {
      throw new RuntimeException(e);
    } finally {
      try {
        if (oos != null) {
          oos.close();
        }
        if (fileOut != null) {
          fileOut.close();
        }
      } catch (IOException ignore) {

      }
    }
  }
Example #21
0
 public static void main(String[] args) {
   String str;
   Socket sock = null;
   ObjectOutputStream writer = null;
   Scanner kb = new Scanner(System.in);
   try {
     sock = new Socket("127.0.0.1", 4445);
   } catch (IOException e) {
     System.out.println("Could not connect.");
     System.exit(-1);
   }
   try {
     writer = new ObjectOutputStream(sock.getOutputStream());
   } catch (IOException e) {
     System.out.println("Could not create write object.");
     System.exit(-1);
   }
   str = kb.nextLine();
   try {
     writer.writeObject(str);
     writer.flush();
   } catch (IOException e) {
     System.out.println("Could not write to buffer");
     System.exit(-1);
   }
   try {
     sock.close();
   } catch (IOException e) {
     System.out.println("Could not close connection.");
     System.exit(-1);
   }
   System.out.println("Wrote and exited successfully");
 }
Example #22
0
  public static void Ex() {
    System.out.println("-- do zapisu --");
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    DowodOsobisty z = new DowodOsobisty(br);
    z.info();

    try {
      ObjectOutputStream outp = new ObjectOutputStream(new FileOutputStream("plik.dat"));
      outp.writeObject(z);
      outp.close();
    } catch (Exception e) {
      System.out.println(e);
    }

    System.out.println("\n-- z pliku --");
    ObjectInputStream inp;

    try {
      inp = new ObjectInputStream(new FileInputStream("plik.dat"));
      Object o = inp.readObject();
      DowodOsobisty x = (DowodOsobisty) o;
      inp.close();
      x.info();
    } catch (Exception e) {
      System.out.println(e);
    }
  }
Example #23
0
  public void run() {
    try {
      ObjectOutputStream outputStream = new ObjectOutputStream(_clientSocket.getOutputStream());
      outputStream.flush();

      DataInputStream inputStream = new DataInputStream(_clientSocket.getInputStream());

      while (true) {
        String request = inputStream.readUTF();

        Trace.info("Received request: " + request);

        RMResult response = processIfComposite(request);
        if (response == null) {
          response = processIfCIDRequired(request);
          if (response == null) {
            response = processAtomicRequest(request);
          }
        }

        outputStream.writeObject(response);
        outputStream.flush();
      }
    } catch (EOFException eof) {
      Trace.info("A client closed a connection.");
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
  public static void main1(String[] args) throws IOException, ClassNotFoundException {
    Employee harry = new Employee("Harry Hacker", 50000, 1989, 10, 1);
    Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
    carl.setSecretary(harry);
    Manager tony = new Manager("Tony Tester", 40000, 1990, 3, 15);
    tony.setSecretary(harry);

    Employee[] staff = new Employee[3];
    staff[0] = carl;
    staff[1] = harry;
    staff[2] = tony;

    // save all employee records to the file employee.dat
    try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("employee.dat"))) {
      out.writeObject(staff);
    }
    try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("employee.dat"))) {
      // retrieve all records into a new array
      Employee[] newStaff = (Employee[]) in.readObject();
      //          raise secretary's salary
      newStaff[1].raiseSalary(10);
      // print the newly read employee records
      for (Employee e : newStaff) System.out.println(e);
    }
  }
Example #25
0
  public void updateFile() {
    ArrayList<Product> products = new ArrayList<Product>();
    try {
      // products.clear();
      Statement s = connection.createStatement();
      // ((org.postgresql.jdbc3.AbstractJdbc3Statement)s).setQueryTimeout(1);

      String sql = "select * from stock";
      // ResultSet
      // resultset=((org.postgresql.jdbc3.AbstractJdbc3Statement)s).executeQuery(sql);
      ResultSet resultset = s.executeQuery(sql);
      // searchResult.clear();
      while (resultset.next()) {
        int id = resultset.getInt(1);
        String pname = resultset.getString(2);
        int amount = resultset.getInt(3);
        double price = resultset.getDouble(4);
        String feature = resultset.getString(5);
        products.add(new Product(id, pname, amount, price, feature));
      }
      System.out.println(products.size() + "beforewrite");
      oout = new ObjectOutputStream(new FileOutputStream(file));
      oout.writeObject(products);
      oout.close();
      System.out.println("all written");
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
 private void createDB() throws IOException {
   File db = new File(dbLocation);
   ObjectOutputStream w = new ObjectOutputStream(new FileOutputStream(dbLocation));
   w.writeObject(digestDB);
   w.flush();
   w.close();
 }
 private void handleKeepAlive() {
   Connection c = null;
   try {
     netCode = ois.readInt();
     c = checkConnectionNetCode();
     if (c != null && c.getState() == Connection.STATE_CONNECTED) {
       oos.writeInt(ACK_KEEP_ALIVE);
       oos.flush();
       System.out.println("->ACK_KEEP_ALIVE"); // $NON-NLS-1$
     } else {
       System.out.println("->NOT_CONNECTED"); // $NON-NLS-1$
       oos.writeInt(NOT_CONNECTED);
       oos.flush();
     }
   } catch (IOException e) {
     System.out.println("handleKeepAlive: " + e.getMessage()); // $NON-NLS-1$
     if (c != null) {
       c.setState(Connection.STATE_DISCONNECTED);
       System.out.println(
           "Connection closed with "
               + c.getRemoteAddress()
               + //$NON-NLS-1$
               ":"
               + c.getRemotePort()); // $NON-NLS-1$
     }
   }
 }
  /**
   * Clone a <code>Serializable</code> object; for use when a <code>clone()</code> method is not
   * available.
   *
   * @param obj object to clone
   * @return clone object
   * @throws RuntimeException
   */
  public static Object cloneSerializable(Object obj) {
    Object ret = null;

    try {
      ByteArrayOutputStream baos = new ByteArrayOutputStream(StreamUtils.DEFAULT_BUFFER_SIZE);
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(obj);
      oos.close();

      ByteArrayInputStream bis = new ByteArrayInputStream(baos.toByteArray());
      ObjectInputStream ois = new ObjectInputStream(bis);

      try {
        ret = ois.readObject();
      } catch (ClassNotFoundException cnfe) {
        assert false;
      }

      ois.close();
    } catch (IOException ioex) {
      throw new RuntimeException("Unable to clone object: " + obj);
    }

    return ret;
  }
Example #29
0
  public byte[] serialize(Object data) throws SharedMemorySerializationException {
    try {
      if (data == null) {
        return new byte[0];
      }
      int type = getType(data);
      switch (type) {
        case JAVA_OBJECT:
          {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(data);
            return byteArrayOutputStream.toByteArray();
          }
        case STRING:
          {
            return ((String) data).getBytes(DBProperties.getCharset());
          }
        case INTEGER:
          {
            byte[] array = new byte[SIZE_OF_INT];
            SerializationUtils.intByteArrayFiller((Integer) data, array, 0);
            return array;
          }
        default:
          throw new SharedMemorySerializationException(
              CommandStatus.unExpectedException, "Fail to serialize object : " + data);
      }

    } catch (IOException e) {
      throw new SharedMemorySerializationException(
          CommandStatus.unExpectedException, "Fail to serialize object : " + data);
    }
  }
 public void windowClosing(WindowEvent e) // write file on finish
     {
   FileOutputStream out = null;
   ObjectOutputStream data = null;
   try {
     // open file for output
     out = new FileOutputStream(DB);
     data = new ObjectOutputStream(out);
     // write Person objects to file using iterator class
     Iterator<Person> itr = persons.iterator();
     while (itr.hasNext()) {
       data.writeObject((Person) itr.next());
     }
     data.flush();
     data.close();
   } catch (Exception ex) {
     JOptionPane.showMessageDialog(
         objUpdate.this,
         "Error processing output file" + "\n" + ex.toString(),
         "Output Error",
         JOptionPane.ERROR_MESSAGE);
   } finally {
     System.exit(0);
   }
 }