Example usage for java.io RandomAccessFile close

List of usage examples for java.io RandomAccessFile close

  1. HOME
  2. Java
  3. java
  4. java.io.*
  5. RandomAccessFile
  6. close

Introduction

In this page you can find the example usage for java.io RandomAccessFile close.

Prototype

public void close() throws IOException

Source Link

Document

Closes this random access file stream and releases any system resources associated with the stream.

Usage

From source file:au.org.ala.layers.intersect.Grid.java

public void writeGrid(String newfilename, float[] dfiltered, double xmin, double ymin, double xmax, double ymax,
        double xres, double yres, int nrows, int ncols) {
    int size, i, length = dfiltered.length;
    double maxvalue = Double.MAX_VALUE * -1;
    double minvalue = Double.MAX_VALUE;

    //write data as whole file
    RandomAccessFile afile = null;
    try { //read of random access file can throw an exception
        afile = new RandomAccessFile(newfilename + ".gri", "rw");

        size = 4;/*from  w  w w . java 2 s . com*/
        byte[] b = new byte[size * length];
        ByteBuffer bb = ByteBuffer.wrap(b);

        if (byteorderLSB) {
            bb.order(ByteOrder.LITTLE_ENDIAN);
        } else {
            bb.order(ByteOrder.BIG_ENDIAN);
        }
        for (i = 0; i < length; i++) {
            if (Double.isNaN(dfiltered[i])) {
                bb.putFloat((float) noDataValueDefault);
            } else {
                if (minvalue > dfiltered[i]) {
                    minvalue = dfiltered[i];
                }
                if (maxvalue < dfiltered[i]) {
                    maxvalue = dfiltered[i];
                }
                bb.putFloat((float) dfiltered[i]);
            }
        }

        afile.write(b);
    } catch (Exception e) {
        logger.error("error writing grid file", e);
    } finally {
        if (afile != null) {
            try {
                afile.close();
            } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
        }
    }

    writeHeader(newfilename, xmin, ymin, xmin + xres * ncols, ymin + yres * nrows, xres, yres, nrows, ncols,
            minvalue, maxvalue, "FLT4BYTES", String.valueOf(noDataValueDefault));

}

From source file:com.flexoodb.common.FlexUtils.java

static public byte[] getFileInBytes(String f) throws Exception {
    boolean haserror = false;
    Throwable t = null;/*from  w w  w.  java  2 s  .c  o m*/
    byte[] data = null;
    RandomAccessFile rf = null;
    try {
        rf = new RandomAccessFile(f, "r");
        int size = (int) rf.length();
        data = new byte[size];
        rf.readFully(data);
    } catch (Exception e) {
        t = e;
        haserror = true;
    } finally {
        if (rf != null) {
            rf.close();
        }

        if (haserror) {
            throw new Exception(t);
        }

    }
    return data;
}

From source file:org.archive.crawler.fetcher.OptimizeFetchHTTP.java

/**
 * Load cookies from a file before the first fetch.
 * <p>/*from w  ww  .  j a v  a2 s .  com*/
 * The file is a text file in the Netscape's 'cookies.txt' file format.<br>
 * Example entry of cookies.txt file:<br>
 * <br>
 * www.archive.org FALSE / FALSE 1074567117 details-visit texts-cralond<br>
 * <br>
 * Each line has 7 tab-separated fields:<br>
 * <li>1. DOMAIN: The domain that created and have access to the cookie
 * value.
 * <li>2. FLAG: A TRUE or FALSE value indicating if hosts within the given
 * domain can access the cookie value.
 * <li>3. PATH: The path within the domain that the cookie value is valid
 * for.
 * <li>4. SECURE: A TRUE or FALSE value indicating if to use a secure
 * connection to access the cookie value.
 * <li>5. EXPIRATION: The expiration time of the cookie value (unix style.)
 * <li>6. NAME: The name of the cookie value
 * <li>7. VALUE: The cookie value
 *
 * @param cookiesFile file in the Netscape's 'cookies.txt' format.
 */
public void loadCookies(String cookiesFile) {
    // Do nothing if cookiesFile is not specified.
    if (cookiesFile == null || cookiesFile.length() <= 0) {
        return;
    }
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(cookiesFile, "r");
        String[] cookieParts;
        String line;
        Cookie cookie = null;
        while ((line = raf.readLine()) != null) {
            // Line that starts with # is commented line, therefore skip it.
            if (!line.startsWith("#")) {
                cookieParts = line.split("\\t");
                if (cookieParts.length == 7) {
                    // Create cookie with not expiration date (-1 value).
                    // TODO: add this as an option.
                    cookie = new Cookie(cookieParts[0], cookieParts[5], cookieParts[6], cookieParts[2], -1,
                            Boolean.valueOf(cookieParts[3]).booleanValue());

                    if (cookieParts[1].toLowerCase().equals("true")) {
                        cookie.setDomainAttributeSpecified(true);
                    } else {
                        cookie.setDomainAttributeSpecified(false);
                    }
                    HttpClient http = this.getClient();
                    http.getState().addCookie(cookie);
                    logger.debug("Adding cookie: " + cookie.toExternalForm());
                }
            }
        }
    } catch (FileNotFoundException e) {
        // We should probably throw FatalConfigurationException.
        System.out.println("Could not find file: " + cookiesFile + " (Element: " + ATTR_LOAD_COOKIES + ")");

    } catch (IOException e) {
        // We should probably throw FatalConfigurationException.
        e.printStackTrace();
    } finally {
        try {
            if (raf != null) {
                raf.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

From source file:com.av.remusic.service.MediaService.java

private void saveQueue(final boolean full) {
    if (!mQueueIsSaveable) {
        return;/* w  ww . j  a v a 2  s .c o m*/
    }

    final SharedPreferences.Editor editor = mPreferences.edit();
    if (full) {
        mPlaybackStateStore.saveState(mPlaylist, mShuffleMode != SHUFFLE_NONE ? mHistory : null);
        if (mPlaylistInfo.size() > 0) {
            String temp = MainApplication.gsonInstance().toJson(mPlaylistInfo);
            try {
                File file = new File(getCacheDir().getAbsolutePath() + "playlist");
                RandomAccessFile ra = new RandomAccessFile(file, "rws");
                ra.write(temp.getBytes());
                ra.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        editor.putInt("cardid", mCardId);

    }
    editor.putInt("curpos", mPlayPos);
    if (mPlayer.isInitialized()) {
        editor.putLong("seekpos", mPlayer.position());
    }
    editor.putInt("repeatmode", mRepeatMode);
    editor.putInt("shufflemode", mShuffleMode);
    editor.apply();
}

From source file:com.cerema.cloud2.lib.resources.files.ChunkedUploadRemoteFileOperation.java

@Override
protected int uploadFile(OwnCloudClient client) throws IOException {
    int status = -1;

    FileChannel channel = null;/*from ww  w  . jav a2 s  . co m*/
    RandomAccessFile raf = null;
    try {
        File file = new File(mLocalPath);
        raf = new RandomAccessFile(file, "r");
        channel = raf.getChannel();
        mEntity = new ChunkFromFileChannelRequestEntity(channel, mMimeType, CHUNK_SIZE, file);
        synchronized (mDataTransferListeners) {
            ((ProgressiveDataTransferer) mEntity).addDatatransferProgressListeners(mDataTransferListeners);
        }

        long offset = 0;
        String uriPrefix = client.getWebdavUri() + WebdavUtils.encodePath(mRemotePath) + "-chunking-"
                + Math.abs((new Random()).nextInt(9000) + 1000) + "-";
        long totalLength = file.length();
        long chunkCount = (long) Math.ceil((double) totalLength / CHUNK_SIZE);
        String chunkSizeStr = String.valueOf(CHUNK_SIZE);
        String totalLengthStr = String.valueOf(file.length());
        for (int chunkIndex = 0; chunkIndex < chunkCount; chunkIndex++, offset += CHUNK_SIZE) {
            if (chunkIndex == chunkCount - 1) {
                chunkSizeStr = String.valueOf(CHUNK_SIZE * chunkCount - totalLength);
            }
            if (mPutMethod != null) {
                mPutMethod.releaseConnection(); // let the connection available
                                                // for other methods
            }
            mPutMethod = new PutMethod(uriPrefix + chunkCount + "-" + chunkIndex);
            if (mRequiredEtag != null && mRequiredEtag.length() > 0) {
                mPutMethod.addRequestHeader(IF_MATCH_HEADER, "\"" + mRequiredEtag + "\"");
            }
            mPutMethod.addRequestHeader(OC_CHUNKED_HEADER, OC_CHUNKED_HEADER);
            mPutMethod.addRequestHeader(OC_CHUNK_SIZE_HEADER, chunkSizeStr);
            mPutMethod.addRequestHeader(OC_TOTAL_LENGTH_HEADER, totalLengthStr);
            ((ChunkFromFileChannelRequestEntity) mEntity).setOffset(offset);
            mPutMethod.setRequestEntity(mEntity);
            if (mCancellationRequested.get()) {
                mPutMethod.abort();
                // next method will throw an exception
            }
            status = client.executeMethod(mPutMethod);

            if (status == 400) {
                InvalidCharacterExceptionParser xmlParser = new InvalidCharacterExceptionParser();
                InputStream is = new ByteArrayInputStream(mPutMethod.getResponseBodyAsString().getBytes());
                try {
                    mForbiddenCharsInServer = xmlParser.parseXMLResponse(is);

                } catch (Exception e) {
                    mForbiddenCharsInServer = false;
                    Log_OC.e(TAG, "Exception reading exception from server", e);
                }
            }

            client.exhaustResponse(mPutMethod.getResponseBodyAsStream());
            Log_OC.d(TAG, "Upload of " + mLocalPath + " to " + mRemotePath + ", chunk index " + chunkIndex
                    + ", count " + chunkCount + ", HTTP result status " + status);

            if (!isSuccess(status))
                break;
        }

    } finally {
        if (channel != null)
            channel.close();
        if (raf != null)
            raf.close();
        if (mPutMethod != null)
            mPutMethod.releaseConnection(); // let the connection available for other methods
    }
    return status;
}

From source file:it.drwolf.ridire.session.CrawlerManager.java

private long getURICount(Job job, String whichCount, User currentUser)
        throws IOException, HeritrixException, DocumentException, XPathExpressionException, SAXException {
    // this.updateJobsList(currentUser);
    Pattern pURICount = Pattern.compile(
            "\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z\\s+(\\d+)\\s+(\\d+)\\s+(\\d+)", Pattern.MULTILINE);
    String jobName = job.getName();
    Job j = this.getPersistedJob(jobName);
    if (j == null) {
        return 0L;
    }//from w  w w  .  ja va2s . co  m
    if (job.getChildJobName() != null && job.getChildJobName().length() > 0) {
        jobName = job.getChildJobName();
    }
    String dir = this.entityManager.find(Parameter.class, Parameter.JOBS_DIR.getKey()).getValue();
    long uriCountFromCrawlReport = 0L;
    long queuedURICount = 0L;
    long discoveredURICount = 0L;
    HttpMethod method = null;
    String jobStatus = this.getJobStatus(jobName);
    // jobName = jobName.replaceAll(" ", "\\\\ ");
    try {
        while (true) {
            if (jobStatus.equals(CrawlStatus.RUNNING.toString())) {
                RandomAccessFile progressStatistics = null;
                try {
                    progressStatistics = new RandomAccessFile(this.jobsDir + CrawlerManager.FILE_SEPARATOR
                            + jobName + CrawlerManager.FILE_SEPARATOR + "logs" + CrawlerManager.FILE_SEPARATOR
                            + "progress-statistics.log", "r");
                    if (progressStatistics != null) {
                        progressStatistics.seek(Math.max(0, progressStatistics.length() - 3000));
                        String line = progressStatistics.readLine();
                        StringBuffer buffer = new StringBuffer();
                        while (line != null) {
                            buffer.append(line + "\n");
                            line = progressStatistics.readLine();
                        }
                        String progressStatisticsContent = buffer.toString();
                        Matcher m = pURICount.matcher(progressStatisticsContent);
                        int start = 0;
                        long queuedURICountTemp = 0L;
                        long discoveredURICountTemp = 0L;
                        long uriCountFromCrawlReportTemp = 0L;
                        while (m.find(start)) {
                            start = m.end();
                            queuedURICountTemp = Long.parseLong(m.group(2));
                            discoveredURICountTemp = Long.parseLong(m.group(1));
                            uriCountFromCrawlReportTemp = Long.parseLong(m.group(3));
                        }
                        queuedURICount += queuedURICountTemp;
                        discoveredURICount = discoveredURICountTemp;
                        uriCountFromCrawlReport = uriCountFromCrawlReportTemp;
                    }
                } catch (FileNotFoundException e) {
                    // TODO: handle exception
                } finally {
                    if (progressStatistics != null) {
                        progressStatistics.close();
                    }
                }
                break;
            } else if (whichCount.equalsIgnoreCase("finishedURICount")) {
                File reportFile = new File(
                        dir + CrawlerManager.FILE_SEPARATOR + jobName + CrawlerManager.FILE_SEPARATOR
                                + "reports" + CrawlerManager.FILE_SEPARATOR + "crawl-report.txt");
                if (reportFile.exists() && reportFile.canRead()) {
                    String content = FileUtils.readFileToString(reportFile);
                    Matcher m = CrawlerManager.pFinishedURICount.matcher(content);
                    if (m.find()) {
                        String bytes = m.group(1);
                        uriCountFromCrawlReport += Long.parseLong(bytes);
                    }
                }
                Matcher m = CrawlerManager.childJobPattern.matcher(jobName);
                if (m.matches()) {
                    Integer count = Integer.parseInt(m.group(1));
                    if (count > 1) {
                        count--;
                        jobName = jobName.substring(0, jobName.indexOf("__")) + "__" + count;
                    } else if (count == 1) {
                        jobName = jobName.substring(0, jobName.indexOf("__"));
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            } else {
                return 0L;
            }
        }
    } finally {
        if (method != null) {
            method.releaseConnection();
        }
    }
    if (whichCount.equals("discoveredUriCount")) {
        return discoveredURICount;
    }
    if (whichCount.equals("queuedUriCount")) {
        return queuedURICount;
    }
    return uriCountFromCrawlReport;
}

From source file:cc.arduino.utils.network.FileDownloader.java

private void downloadFile(boolean noResume) throws InterruptedException {
    RandomAccessFile file = null;

    try {//w ww  .  j a va  2s . c o m
        // Open file and seek to the end of it
        file = new RandomAccessFile(outputFile, "rw");
        initialSize = file.length();

        if (noResume && initialSize > 0) {
            // delete file and restart downloading
            Files.delete(outputFile.toPath());
            initialSize = 0;
        }

        file.seek(initialSize);

        setStatus(Status.CONNECTING);

        Proxy proxy = new CustomProxySelector(PreferencesData.getMap()).getProxyFor(downloadUrl.toURI());
        if ("true".equals(System.getProperty("DEBUG"))) {
            System.err.println("Using proxy " + proxy);
        }

        HttpURLConnection connection = (HttpURLConnection) downloadUrl.openConnection(proxy);
        connection.setRequestProperty("User-agent", userAgent);
        if (downloadUrl.getUserInfo() != null) {
            String auth = "Basic " + new String(new Base64().encode(downloadUrl.getUserInfo().getBytes()));
            connection.setRequestProperty("Authorization", auth);
        }

        connection.setRequestProperty("Range", "bytes=" + initialSize + "-");
        connection.setConnectTimeout(5000);
        setDownloaded(0);

        // Connect
        connection.connect();
        int resp = connection.getResponseCode();

        if (resp == HttpURLConnection.HTTP_MOVED_PERM || resp == HttpURLConnection.HTTP_MOVED_TEMP) {
            URL newUrl = new URL(connection.getHeaderField("Location"));

            proxy = new CustomProxySelector(PreferencesData.getMap()).getProxyFor(newUrl.toURI());

            // open the new connnection again
            connection = (HttpURLConnection) newUrl.openConnection(proxy);
            connection.setRequestProperty("User-agent", userAgent);
            if (downloadUrl.getUserInfo() != null) {
                String auth = "Basic " + new String(new Base64().encode(downloadUrl.getUserInfo().getBytes()));
                connection.setRequestProperty("Authorization", auth);
            }

            connection.setRequestProperty("Range", "bytes=" + initialSize + "-");
            connection.setConnectTimeout(5000);

            connection.connect();
            resp = connection.getResponseCode();
        }

        if (resp < 200 || resp >= 300) {
            throw new IOException("Received invalid http status code from server: " + resp);
        }

        // Check for valid content length.
        long len = connection.getContentLength();
        if (len >= 0) {
            setDownloadSize(len);
        }
        setStatus(Status.DOWNLOADING);

        synchronized (this) {
            stream = connection.getInputStream();
        }
        byte buffer[] = new byte[10240];
        while (status == Status.DOWNLOADING) {
            int read = stream.read(buffer);
            if (read == -1)
                break;

            file.write(buffer, 0, read);
            setDownloaded(getDownloaded() + read);

            if (Thread.interrupted()) {
                file.close();
                throw new InterruptedException();
            }
        }

        if (getDownloadSize() != null) {
            if (getDownloaded() < getDownloadSize())
                throw new Exception("Incomplete download");
        }
        setStatus(Status.COMPLETE);
    } catch (InterruptedException e) {
        setStatus(Status.CANCELLED);
        // lets InterruptedException go up to the caller
        throw e;

    } catch (SocketTimeoutException e) {
        setStatus(Status.CONNECTION_TIMEOUT_ERROR);
        setError(e);

    } catch (Exception e) {
        setStatus(Status.ERROR);
        setError(e);

    } finally {
        IOUtils.closeQuietly(file);

        synchronized (this) {
            IOUtils.closeQuietly(stream);
        }
    }
}

From source file:gate.util.reporting.PRTimeReporter.java

/**
 * Stores GATE processing elements and the time taken by them in an in-memory
 * data structure for report generation.
 *
 * @param inputFile/* www  . j  ava 2 s.  c  om*/
 *          A File handle of the input log file.
 *
 * @return An Object of type LinkedHashMap<String, Object> containing the
 *         processing elements (with time in milliseconds) in hierarchical
 *         structure. Null if there was an error.
 */
@Override
public Object store(File inputFile) throws BenchmarkReportInputFileFormatException {
    LinkedHashMap<String, Object> globalStore = new LinkedHashMap<String, Object>();
    long fromPos = 0;
    RandomAccessFile in = null;
    try {
        if (getLogicalStart() != null) {
            fromPos = tail(inputFile, FILE_CHUNK_SIZE);
        }
        in = new RandomAccessFile(inputFile, "r");
        if (getLogicalStart() != null) {
            in.seek(fromPos);
        }
        ArrayList<String> startTokens = new ArrayList<String>();
        String logEntry;
        String docName = null;
        Pattern pattern = Pattern.compile("(\\d+) (\\d+) (.*) (.*) \\{(.*)\\}");
        while ((logEntry = in.readLine()) != null) {
            Matcher matcher = pattern.matcher(logEntry);
            // Skip the statistics for the event documentLoaded
            if (logEntry.matches(".*documentLoaded.*"))
                continue;
            if (logEntry.matches(".*START.*")) {
                String[] splittedStartEntry = logEntry.split("\\s");
                String startToken = (splittedStartEntry.length > 2) ? splittedStartEntry[2] : null;
                if (startToken == null) {
                    throw new BenchmarkReportInputFileFormatException(
                            getBenchmarkFile().getAbsolutePath() + " is invalid.");
                }
                startTokens.add(startToken);
                if (startToken.endsWith("Start"))
                    continue;
                organizeEntries(globalStore, startToken.split("\\."), "0");
            }

            if (matcher != null) {
                if (matcher.matches()) {
                    if (validateLogEntry(matcher.group(3), startTokens)) {
                        String[] splittedBIDs = matcher.group(3).split("\\.");
                        if (splittedBIDs.length > 1) {
                            docName = splittedBIDs[1];
                            pipelineNames.add(splittedBIDs[0]);
                        }
                        organizeEntries(globalStore,
                                (matcher.group(3).replaceFirst(Pattern.quote(docName) + ".", "")).split("\\."),
                                matcher.group(2));
                    }
                }
            }
        }

    } catch (IOException e) {
        e.printStackTrace();
        globalStore = null;

    } finally {
        try {
            if (in != null) {
                in.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
            globalStore = null;
        }
    }

    if (validEntries == 0) {
        if (logicalStart != null) {
            throw new BenchmarkReportInputFileFormatException(
                    "No valid log entries present in " + getBenchmarkFile().getAbsolutePath()
                            + " does not contain a marker named " + logicalStart + ".");
        } else {
            throw new BenchmarkReportInputFileFormatException(
                    "No valid log entries present in " + getBenchmarkFile().getAbsolutePath());
        }
    }
    return globalStore;
}

From source file:org.commoncrawl.service.crawler.CrawlList.java

private static void appendTargetsToLogFile(File logFileName, IntrusiveList<CrawlTarget> list)
        throws IOException {

    LogFileHeader header = new LogFileHeader();

    boolean preExistingHeader = logFileName.exists();

    RandomAccessFile file = new RandomAccessFile(logFileName, "rw");

    try {/*from w  w  w  .  j  a v  a 2s  .c  om*/
        long headerOffset = 0;

        if (preExistingHeader) {

            headerOffset = readLogFileHeader(file, header);

            if (header._writePos == 0) {
                file.seek(headerOffset);
            } else {
                // seelk to appropriate write position 
                file.seek(header._writePos);
            }
        } else {
            headerOffset = writeLogFileHeader(file, header);
        }

        CustomByteArrayOutputStream bufferOutputStream = new CustomByteArrayOutputStream(1 << 17);
        DataOutputStream dataOutputStream = new DataOutputStream(bufferOutputStream);
        CRC32 crc = new CRC32();

        for (CrawlTarget target : list) {

            PersistentCrawlTarget persistentTarget = target.createPersistentTarget();

            bufferOutputStream.reset();
            // write to intermediate stream ... 
            persistentTarget.write(dataOutputStream);
            // and crc the data ... 
            crc.reset();
            crc.update(bufferOutputStream.getBuffer(), 0, bufferOutputStream.size());
            // write out length first 
            file.writeInt(bufferOutputStream.size());
            //crc next
            long computedValue = crc.getValue();
            //TODO: waste of space - write 32 bit values as long because having problems with java sign promotion rules during read...
            file.writeLong(computedValue);
            // and then the data 
            file.write(bufferOutputStream.getBuffer(), 0, bufferOutputStream.size());
        }

        // now update header ... 
        header._itemCount += list.size();
        header._writePos = file.getFilePointer();

        // now write out header anew ... 
        writeLogFileHeader(file, header);

    } finally {
        if (file != null) {
            file.close();
        }
    }
}

From source file:big.BigZip.java

/**
 * Version 2 that permits to extract the text from a compressed file without
 * creating any file on the disk./*w ww.jav  a2 s  .  co  m*/
 * @param filePosition
 * @return      The source code of the compressed file
 */
public String extractBytesToRAM(final long filePosition) {

    String result = null;

    try {

        // add the signature bytes to our start position
        long startPosition = filePosition + magicSignature.length();

        // enable random access to the BIG file (fast as heck)
        RandomAccessFile dataBIG = new RandomAccessFile(fileMainBIG, "r");
        // jump directly to the position where the file is positioned
        dataBIG.seek(startPosition);
        // create a byte array
        ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();

        // get the end of this file entry (by brute-force)
        char test = 0;
        long endPosition = -1;
        while (test != -1) {
            test = dataBIG.readChar();
            // if the magic devil number was found..
            if (test == 66) {
                // read the next value for confirmation
                byte value = dataBIG.readByte();
                if (value != 73) {
                    continue;
                }
                // we found the next entry
                endPosition = dataBIG.getFilePointer() - 1;
                break;
            }
        }

        // rewind back to the start position
        dataBIG.seek(startPosition);

        // now we start reading bytes during the mentioned interval
        while (dataBIG.getFilePointer() < endPosition) {
            // read a byte from our BIG archive
            int data = dataBIG.read();
            byteOutput.write(data);
        }
        // flush data at this point
        byteOutput.flush();
        // now convert the stream from input into an output (to feed the zip stream)
        ByteArrayInputStream byteInput = new ByteArrayInputStream(byteOutput.toByteArray());
        // where we place the decompressed bytes
        ByteArrayOutputStream textOutput = new ByteArrayOutputStream();
        // create the zip streamer
        final ArchiveInputStream archiveStream;
        archiveStream = new ArchiveStreamFactory().createArchiveInputStream("zip", byteInput);
        final ZipArchiveEntry entry = (ZipArchiveEntry) archiveStream.getNextEntry();
        // copy all bytes from one location to the other (and decompress the data)
        IOUtils.copy(archiveStream, textOutput);
        // flush the results
        textOutput.flush();
        // we've got the result right here!
        result = textOutput.toString();
        // now close all the streams that we have open
        dataBIG.close();
        byteOutput.close();
        byteInput.close();
        textOutput.close();
        archiveStream.close();

    } catch (FileNotFoundException ex) {
        Logger.getLogger(BigZip.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    } catch (IOException ex) {
        Logger.getLogger(BigZip.class.getName()).log(Level.SEVERE, null, ex);
        return null;
    } catch (ArchiveException ex) {
        Logger.getLogger(BigZip.class.getName()).log(Level.SEVERE, null, ex);
    }

    return result;
}