Example #1
1
 /**
  * Construct a frequency table from an InputStream. This will create a temporary file to copy the
  * InputStream in.
  *
  * @param source the Input Stream
  * @return an InputStream which is a copy of the source Stream, provided to re-Read the same Bytes
  *     for the actual compression process.
  */
 public InputStream constructTable(InputStream source, boolean copy) {
   freq = new int[TABLESIZE];
   try {
     File file = null;
     FileOutputStream fos = null;
     if (copy == true) {
       file = File.createTempFile("huf", "tmp");
       file.deleteOnExit();
       fos = new FileOutputStream(file);
     }
     while (source.available() != 0) {
       int c = source.read();
       freq[c]++;
       if (copy) fos.write(c);
     }
     source.close();
     if (copy) {
       fos.close();
       return new FileInputStream(file);
     }
     return null;
   } catch (Exception ex) {
     ExHandler.handle(ex);
     return null;
   }
 }
  private static void testSysOut(String fs, String exp, Object... args) {
    FileOutputStream fos = null;
    FileInputStream fis = null;
    try {
      PrintStream saveOut = System.out;
      fos = new FileOutputStream("testSysOut");
      System.setOut(new PrintStream(fos));
      System.out.format(Locale.US, fs, args);
      fos.close();

      fis = new FileInputStream("testSysOut");
      byte[] ba = new byte[exp.length()];
      int len = fis.read(ba);
      String got = new String(ba);
      if (len != ba.length) fail(fs, exp, got);
      ck(fs, exp, got);

      System.setOut(saveOut);
    } catch (FileNotFoundException ex) {
      fail(fs, ex.getClass());
    } catch (IOException ex) {
      fail(fs, ex.getClass());
    } finally {
      try {
        if (fos != null) fos.close();
        if (fis != null) fis.close();
      } catch (IOException ex) {
        fail(fs, ex.getClass());
      }
    }
  }
Example #3
0
  /**
   * @param in the InputStream, i.e. the source, closes the passed input stream
   * @param fn where to output the file (numbers are ok)
   */
  protected final void fileForShow(InputStream in, String fn) {
    File f = (((fn == null) || fn.equals("")) ? DEF_FILE : getFile(fn));
    boolean fout = "true".equals(System.getProperty("file.echo"));

    try {
      FileOutputStream out = new FileOutputStream(f);
      int b = 0;

      while ((b = in.read()) != -1) {
        if (fout) {
          Console.out.write(b);
        }

        out.write(b);
      }

      out.flush();
      out.close();
      Console.out.flush();
      in.close();
      s_showFile = f;
    } catch (Exception exp) {
      System.err.println("FAILED TO WRITE TO OUTPUT FILE " + f.getAbsolutePath());
      exp.printStackTrace();
    }
  }
Example #4
0
  /**
   * This method will read the standard input and save the content to a temporary. source file since
   * the source file will be parsed mutiple times. The HTML source file is parsed and checked for
   * Charset in HTML tags at first time, then source file is parsed again for the converting The
   * temporary file is read from standard input and saved in current directory and will be deleted
   * after the conversion has completed.
   *
   * @return the vector of the converted temporary source file name
   */
  public Vector getStandardInput() throws FileAccessException {
    byte[] buf = new byte[2048];
    int len = 0;
    FileInputStream fis = null;
    FileOutputStream fos = null;
    File tempSourceFile;
    String tmpSourceName = ".tmpSource_stdin";

    File outFile = new File(tmpSourceName);

    tempSourceFile = new File(System.getProperty("user.dir") + sep + tmpSourceName);
    if (!tempSourceFile.exists()) {
      try {
        fis = new FileInputStream(FileDescriptor.in);
        fos = new FileOutputStream(outFile);
        while ((len = fis.read(buf, 0, 2048)) != -1) fos.write(buf, 0, len);
      } catch (IOException e) {
        System.out.println(ResourceHandler.getMessage("plugin_converter.write_permission"));
        return null;
      }
    } else {
      throw new FileAccessException(ResourceHandler.getMessage("plugin_converter.overwrite"));
    }
    tempSourceFile = new File(System.getProperty("user.dir") + sep + tmpSourceName);
    if (tempSourceFile.exists()) {
      fileSpecs.add(tmpSourceName);
      return fileSpecs;
    } else {
      throw new FileAccessException(
          ResourceHandler.getMessage("plugin_converter.write_permission"));
    }
  }
Example #5
0
 /**
  * @param guid
  * @param data
  * @throws IOException
  */
 public void write(int guid, byte[] data) throws IOException {
   File file = new File(Integer.toString(guid));
   FileOutputStream fos = null;
   fos = new FileOutputStream(file);
   // Writes bytes from the specified byte array to this file output stream
   fos.write(data);
 }
Example #6
0
  /**
   * Créer le fichier complet correspondant Copie et réassemble les données Supprime le fichier
   * temporaire et renvoi le nouveau fichier
   */
  public synchronized FileShared tmpToComplete() {
    String name = this.getName();
    name = name.substring(0, name.length() - ((String) App.config.get("tmpExtension")).length());

    File complete = new File(App.config.get("downloadDir") + File.separator + name);
    if (complete.exists()) {
      throw new IllegalArgumentException();
    }

    try {
      FileOutputStream writer_tmp = new FileOutputStream(complete, true);
      FileChannel writer = writer_tmp.getChannel();

      int i;
      for (i = 0; i < this.nbPieces(); i++) {
        byte[] piece = this.readPieceTmpFile(i);
        Tools.write(writer, 0, piece);
      }

      writer.force(true);
      writer_tmp.close();
    } catch (Exception e) {
      System.out.println("Unable to write complete file");
      e.printStackTrace();
    }

    this.delete();

    return new FileShared(name);
  }
Example #7
0
  /** Initialise le header du fichier temporaire */
  private void initHeaderTmpFile() {
    try {
      FileOutputStream writer_tmp = new FileOutputStream(this);
      FileChannel writer = writer_tmp.getChannel();

      int offset = 0;

      // Taille de la clef
      Tools.write(writer, offset, _key.length());
      offset += 4;
      // Clef
      Tools.write(writer, offset, _key);
      offset += _key.length();
      // Size
      Tools.write(writer, offset, _size);
      offset += 4;
      // piecesize
      Tools.write(writer, offset, _piecesize);
      offset += 4;
      // Buffermap
      int i;
      for (i = 0; i < this.nbPieces(); i++) {
        Tools.write(writer, offset, -1);
        offset += 4;
      }

      writer.force(true);
      writer_tmp.close();
    } catch (Exception e) {
      System.out.println("Unable to create a new tmp file");
      e.printStackTrace();
    }
  }
  public static void saveJPG(Image img, String s) {
    BufferedImage bi =
        new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_RGB);
    Graphics2D g2 = bi.createGraphics();
    g2.drawImage(img, null, null);

    FileOutputStream out = null;
    try {
      out = new FileOutputStream(s);
    } catch (java.io.FileNotFoundException io) {
      System.out.println("File Not Found");
    }

    JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
    JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
    param.setQuality(0.5f, false);
    encoder.setJPEGEncodeParam(param);

    try {
      encoder.encode(bi);
      out.close();
    } catch (java.io.IOException io) {
      System.out.println("IOException");
    }
  }
  // Merge the availableChunks to build the original file
  void MergeChunks(File[] chunks) throws IOException {

    // Safety check
    if (chunks == null) {
      System.err.println("ERROR: No chunks to merge!");
      return;
    }

    FileOutputStream fos = new FileOutputStream("complete/" + filename);

    try {
      FileInputStream fis;
      byte[] fileBytes;
      int bytesRead;
      for (File f : chunks) {
        fis = new FileInputStream(f);
        fileBytes = new byte[(int) f.length()];
        bytesRead = fis.read(fileBytes, 0, (int) f.length());
        assert (bytesRead == fileBytes.length);
        assert (bytesRead == (int) f.length());
        fos.write(fileBytes);
        fos.flush();
        fileBytes = null;
        fis.close();
        fis = null;
      }
    } catch (Exception exception) {
      exception.printStackTrace();
    } finally {
      fos.close();
      fos = null;
    }
  }
Example #10
0
 protected void add(Object value) {
   File f = null;
   FileOutputStream fos = null;
   try {
     f = createTempFile("S", dir);
     fos = new FileOutputStream(f);
     ObjectOutputStream fout = new ObjectOutputStream(new BufferedOutputStream(fos));
     fout.writeObject(value);
     fout.flush();
     fos.getFD().sync();
   } catch (Exception e) {
     throw new SpaceError(e);
   } finally {
     if (fos != null) {
       try {
         fos.close();
       } catch (Exception e) {
         throw new SpaceError(e);
       }
     }
   }
   stored.add(f.getAbsolutePath());
   /* fill cache */
   if (cacheSize > data.size()) if ((data.size() + 1) == stored.size()) data.add(value);
 }
  static void eliminarLugarFicheroLOC(Lugar lugar) {
    String fichero = lugar.getFicheroLOC();

    try {
      FileReader fr = new FileReader(fichero);
      BufferedReader br = new BufferedReader(fr);

      String linea;
      ArrayList lineas = new ArrayList();

      do {
        linea = br.readLine();
        if (linea != null) {
          if (!linea.substring(0, lugar.nombre.length()).equals(lugar.nombre)) lineas.add(linea);
        } else break;
      } while (true);
      br.close();
      fr.close();

      FileOutputStream fos = new FileOutputStream(fichero);
      PrintWriter pw = new PrintWriter(fos);

      for (int i = 0; i < lineas.size(); i++) pw.println((String) lineas.get(i));
      pw.flush();
      pw.close();
      fos.close();

    } catch (FileNotFoundException e) {
      System.err.println("error: eliminando " + e);

    } catch (IOException e) {
      System.err.println("error: eliminando 2 : " + e);
    }
  }
 public static void writeLogFile(String descript, String filename) {
   File file;
   FileOutputStream outstream;
   // BufferedWriter outstream;
   Date time = new Date();
   long bytes = 30000000;
   try {
     // Get log file
     String logfile = "C:\\" + filename + ".txt";
     file = new File(logfile);
     boolean exists = file.exists();
     if (!exists) {
       // create a new, empty node file
       try {
         file = new File(logfile);
         boolean success = file.createNewFile();
       } catch (IOException e) {
         System.out.println("Create Event Log file failed!");
       }
     }
     try {
       descript = descript + "\n";
       outstream = new FileOutputStream(file, true);
       for (int i = 0; i < descript.length(); ++i) {
         outstream.write((byte) descript.charAt(i));
       }
       outstream.close();
     } catch (IOException e) {
     }
   } catch (java.lang.Exception e) {
   }
 }
Example #13
0
  void ReceiveFile() throws Exception {
    String fileName;

    fileName = din.readUTF();

    if (fileName != null && !fileName.equals("NOFILE")) {
      System.out.println("Receiving File");
      File f =
          new File(
              System.getProperty("user.home")
                  + "/Desktop"
                  + "/"
                  + fileName.substring(fileName.lastIndexOf("/") + 1));
      System.out.println(f.toString());
      f.createNewFile();
      FileOutputStream fout = new FileOutputStream(f);
      int ch;
      String temp;
      do {
        temp = din.readUTF();
        ch = Integer.parseInt(temp);
        if (ch != -1) {
          fout.write(ch);
        }
      } while (ch != -1);
      System.out.println("Received File : " + fileName);
      fout.close();
    } else {
    }
  }
Example #14
0
  public void flush() throws IOException {
    if (!dirty) return;

    FileOutputStream fos = null;
    OutputStreamWriter osw = null;
    try {
      fos = new FileOutputStream(filePath);
      osw = new OutputStreamWriter(fos, charset);

      // 全局数据
      for (Line l : globalLines) {
        osw.write(l.toString());
        osw.write('\n');
      }

      // 各个块
      for (Sector s : sectors) {
        osw.write(s.toString());
      }

      dirty = false;
    } finally {
      // XXX 因为stream之间有一定的依赖顺序,必须按照一定的顺序关闭流
      if (osw != null) osw.close();
      if (fos != null) fos.close();
    }
  }
  /**
   * Save the downloaded files into the corresponding directories
   *
   * @deprecated
   */
  public synchronized void save() {
    synchronized (this) {
      synchronized (this.isComplete) {
        byte[] data = new byte[0];
        for (int i = 0; i < this.nbPieces; i++) {
          if (this.pieceList[i] == null) {

          } else {
            data = Utils.concat(data, this.pieceList[i].data());
          }
        }
        String saveAs = Constants.SAVEPATH;
        int offset = 0;
        if (this.nbOfFiles > 1) saveAs += this.torrent.saveAs + "/";
        for (int i = 0; i < this.nbOfFiles; i++) {
          try {
            new File(saveAs).mkdirs();
            FileOutputStream fos =
                new FileOutputStream(saveAs + ((String) (this.torrent.name.get(i))));
            fos.write(
                Utils.subArray(data, offset, ((Integer) (this.torrent.length.get(i))).intValue()));
            fos.flush();
            fos.close();
            offset += ((Integer) (this.torrent.length.get(i))).intValue();
          } catch (IOException ioe) {
            ioe.printStackTrace();
            System.err.println(
                "Error when saving the file " + ((String) (this.torrent.name.get(i))));
          }
        }
      }
    }
  }
  private synchronized void save() {
    myDir.mkdirs();

    Properties props = new Properties();

    props.setProperty(KIND_KEY, myKind.toString());
    props.setProperty(ID_KEY, myRepositoryId);
    props.setProperty(PATH_OR_URL_KEY, myRepositoryPathOrUrl);
    props.setProperty(INDEX_VERSION_KEY, CURRENT_VERSION);
    if (myUpdateTimestamp != null)
      props.setProperty(TIMESTAMP_KEY, String.valueOf(myUpdateTimestamp));
    if (myDataDirName != null) props.setProperty(DATA_DIR_NAME_KEY, myDataDirName);
    if (myFailureMessage != null) props.setProperty(FAILURE_MESSAGE_KEY, myFailureMessage);

    try {
      FileOutputStream s = new FileOutputStream(new File(myDir, INDEX_INFO_FILE));
      try {
        props.store(s, null);
      } finally {
        s.close();
      }
    } catch (IOException e) {
      MavenLog.LOG.warn(e);
    }
  }
Example #17
0
 public void saveCache(
     JMXInstrumentedCache<K, V> cache, File savedCachePath, Function<K, byte[]> converter)
     throws IOException {
   long start = System.currentTimeMillis();
   String msgSuffix = " " + savedCachePath.getName() + " for " + cfname + " of " + ksname;
   logger.debug("saving" + msgSuffix);
   int count = 0;
   File tmpFile =
       File.createTempFile(savedCachePath.getName(), null, savedCachePath.getParentFile());
   FileOutputStream fout = new FileOutputStream(tmpFile);
   ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(fout));
   FileDescriptor fd = fout.getFD();
   for (K key : cache.getKeySet()) {
     byte[] bytes = converter.apply(key);
     out.writeInt(bytes.length);
     out.write(bytes);
     ++count;
   }
   out.flush();
   fd.sync();
   out.close();
   if (!tmpFile.renameTo(savedCachePath))
     throw new IOException("Unable to rename cache to " + savedCachePath);
   if (logger.isDebugEnabled())
     logger.debug(
         "saved "
             + count
             + " keys in "
             + (System.currentTimeMillis() - start)
             + " ms from"
             + msgSuffix);
 }
Example #18
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();
 }
Example #19
0
  public void get() throws Exception {
    byte[] b = new byte[8192];
    int n = 0, t = 0; // t == total amount of downloaded bytes
    long length = smbFile.length(), initialTime, currentTime;
    float percentage;

    out = new FileOutputStream(downloadDir + "/" + smbFile.getName());

    Date date = new Date();
    initialTime = date.getTime();

    while ((n = in.read(b)) > 0) {
      t += n;
      percentage = ((float) t / (float) length) * 100;
      currentTime = new Date().getTime();

      float iets = (float) t;
      float tijd = (float) ((currentTime - initialTime) + 1);
      float speed = iets / tijd;

      System.out.printf("%3.2f   %f KB/s\r", percentage, speed);
      System.out.flush();
      out.write(b);
    }

    out.close();
    System.out.println();
  }
 /** Saves the authorization database to disk. */
 public void save() throws CoreException {
   if (!needsSaving || file == null) return;
   try {
     file.delete();
     if ((!file.getParentFile().exists() && !file.getParentFile().mkdirs())
         || !canWrite(file.getParentFile()))
       throw new CoreException(
           new Status(
               IStatus.ERROR,
               Platform.PI_RUNTIME,
               Platform.FAILED_WRITE_METADATA,
               NLS.bind(Messages.meta_unableToWriteAuthorization, file),
               null));
     file.createNewFile();
     FileOutputStream out = new FileOutputStream(file);
     try {
       save(out);
     } finally {
       out.close();
     }
   } catch (IOException e) {
     throw new CoreException(
         new Status(
             IStatus.ERROR,
             Platform.PI_RUNTIME,
             Platform.FAILED_WRITE_METADATA,
             NLS.bind(Messages.meta_unableToWriteAuthorization, file),
             e));
   }
   needsSaving = false;
 }
 public synchronized void saveProperties() {
   if (ownLock()) {
     try {
       FileOutputStream out = new FileOutputStream(propertyFile);
       try {
         fontProps.store(out, "-- ICEpf Font properties --");
       } finally {
         out.close();
       }
       recordMofifTime();
     } catch (IOException ex) {
       // check to make sure the storage relate dialogs can be shown
       if (getBoolean("application.showLocalStorageDialogs", true)) {
         Resources.showMessageDialog(
             null,
             JOptionPane.ERROR_MESSAGE,
             messageBundle,
             "fontManager.properties.title",
             "manager.properties.saveError",
             ex);
       }
       // log the error
       if (logger.isLoggable(Level.WARNING)) {
         logger.log(Level.WARNING, "Error saving font properties cache", ex);
       }
     }
   }
 }
Example #22
0
 void saveJar(File f, byte[] data) {
   try {
     FileOutputStream out = new FileOutputStream(f);
     out.write(data, 0, data.length);
     out.close();
   } catch (IOException e) {
   }
 }
Example #23
0
 public static void writeURLtoFile(URL url, String filename) throws IOException {
   // FileWriter writer = new FileWriter(filename);
   // saveURL(url, writer);
   // writer.close();
   FileOutputStream os = new FileOutputStream(filename);
   saveURL(url, os);
   os.close();
 }
Example #24
0
  /**
   * This is a special version of the routine which knows the FileSystemProvider default format.
   *
   * @param dir
   * @param outFile
   * @throws IOException
   */
  public static void exportWithDir(String dir, String outFile) throws IOException {
    FileOutputStream out = new FileOutputStream(new File(outFile));
    Exporter x = new Exporter(out, true);

    x.export(dir);

    out.close();
  }
Example #25
0
  public ParseDoc(Object xmlFile, String rootId, TreeMap prevIdMap) {

    SAXBuilder saxBuilder = new SAXBuilder();

    try {
      if (xmlFile instanceof String) {
        document = saxBuilder.build((String) xmlFile);
      } else if (xmlFile instanceof URL) {
        document = saxBuilder.build((URL) xmlFile);
      }
      root = ParseUtils.parseRoot(document, rootId);
      objects = new TreeMap();

      // Build description string (but not for the snippets.xml file)
      if (xmlFile instanceof String) {
        List authorL = root.getChildren("author");
        String author = "<unknown>";
        if (root.getAttributeValue("name") != null) {
          author = root.getAttributeValue("name");
        } else if (authorL.size() > 0) {
          author = ((Element) authorL.get(0)).getValue();
        }
        String description =
            "from file "
                + xmlFile.toString()
                + " (author: "
                + author
                + ") on "
                + new Date().toString();
        HasIdentifiers.addGlobalIdentifier("_description_", description);
      }

      // Get all macro definitions, and remove them from document
      TreeMap macroMap = ParseUtils.getMacroDefs(root);

      // Process all macro expansions; replace macro expansion request with result
      ParseUtils.expandMacros(root, macroMap);

      // Get all elements in document, and assign identifiers to them;
      idMap = ParseUtils.parseId(root, prevIdMap);

      // Rewriting done; output debug XML code
      if (root.getAttributeValue("debug") != null) {
        XMLOutputter outputter = new XMLOutputter();
        FileOutputStream fos = new FileOutputStream(xmlFile + ".debug");
        outputter.output(document, fos);
        fos.close();
      }

    } catch (JDOMException e) { // indicates a well-formedness or other error

      throw new Error("JDOMException: " + e.getMessage());

    } catch (IOException e) { // indicates an IO problem

      throw new Error("IOException: " + e.getMessage());
    }
  }
 private void write(File f, byte[] bs) {
   try {
     FileOutputStream o = new FileOutputStream(f);
     o.write(bs, 0, bs.length);
     o.close();
   } catch (Exception e) {
     e.printStackTrace();
   }
 }
Example #27
0
  /**
   * Crea el fichero de indices con la informacion inicial necesaria para un archivo concreto.
   *
   * @param fichero es el fichero de indices que tendra toda la informacion.
   * @param archivo es el objeto que representa el archivo en concreto.
   * @param fragmentos es la lista de fragmentos que faltan de dicho archivo.
   */
  public void crearFicheroIndices(File fichero, Archivo archivo, Vector<Fragmento> fragmentos) {
    Vector<Fragmento> fragTengo = new Vector<Fragmento>(), fragFaltan = fragmentos;
    Indices indices = new Indices(archivo, fragTengo, fragFaltan);
    ByteArrayOutputStream bs = new ByteArrayOutputStream();
    try {
      ObjectOutputStream os = new ObjectOutputStream(bs);
      os.writeObject(indices);
      os.close();

    } catch (IOException e) {
      /*System.out.println("Error -> posibles causas: ");
      System.out.println( "\tProblemas al crear un flujo de bytes serializable" );
      System.out.println( "\tProblemas al serializar el objeto indice" );
      System.out.println( "\tProblemas al cerrar el flujo serializable" );*/
      ControlDeErrores.getInstancia()
          .registrarError(
              ErrorEGorilla.ERROR_DISCO,
              "Error -> posibles causas: "
                  + "\tProblemas al crear un flujo de bytes serializable"
                  + "\tProblemas al serializar el objeto indice"
                  + "\tProblemas al cerrar el flujo serializable");
      // e.printStackTrace();
    }

    byte[] bytes = bs.toByteArray(); // devuelve byte[]

    try {
      if (fichero.exists() == true) {
        String nombreNuevoFichero = fichero.getName();
        nombreNuevoFichero += "_" + archivo.getHash();
        fichero = new File(nombreNuevoFichero);
      }
      FileOutputStream ficheroIndices = new FileOutputStream(fichero);
      BufferedOutputStream bufferedOutput = new BufferedOutputStream(ficheroIndices);
      bufferedOutput.write(bytes, 0, bytes.length);
      bufferedOutput.close();
      // creo que tambien hace falta cerrar el otro
      ficheroIndices.close();
    } catch (FileNotFoundException e) {
      System.out.println("No existe el fichero <" + fichero.getName() + ">");
    } catch (IOException e) {
      /*System.out.println("Error -> posibles causas: ");
      System.out.println( "\tProblemas al escribir en el fichero <"+fichero.getName()+">" );
      System.out.println( "\tProblemas al cerrar el flujo o el fichero <"+fichero.getName()+">" );*/
      ControlDeErrores.getInstancia()
          .registrarError(
              ErrorEGorilla.ERROR_DISCO,
              "Error -> posibles causas: "
                  + "\tProblemas al escribir en el fichero <"
                  + fichero.getName()
                  + ">"
                  + "\tProblemas al cerrar el flujo o el fichero <"
                  + fichero.getName()
                  + ">");
      // e.printStackTrace();
    }
  }
Example #28
0
 protected void saveGlyphFile(File a_file) throws FileNotFoundException {
   FileOutputStream output = new FileOutputStream(a_file);
   saveGlyphFile(output);
   try {
     output.close(); // JPEXS
   } catch (IOException ex) {
     Logger.getLogger(GlyphFile.class.getName()).log(Level.SEVERE, null, ex);
   }
 }
Example #29
0
 /**
  * @param args, arg[0] should be passed as the file path & name to be encrypted.
  * @throws Exception
  */
 public static void main(String[] args) throws Exception {
   getBytes(
       args[
           0]); // calls get bytes method for converting file to bytes, need some way to remember
                // the file type.
   cipherText = doEncrypt();
   FileOutputStream FOS = new FileOutputStream(new File("test.txt"));
   FOS.write(cipherText); // pri8nts the file of cipherText
   FOS.close();
 }
Example #30
0
  /** Metodo que escreve os clientes num ficheiro */
  public void escreveobjLocalidades(String fileLocalidades)
      throws FileNotFoundException, IOException {
    FileOutputStream fosloc = new FileOutputStream(fileLocalidades);
    ObjectOutputStream oosloc = new ObjectOutputStream(fosloc);

    oosloc.writeObject(this.localidades);

    oosloc.close();
    fosloc.close();
  }