Java tutorial
//package com.java2s; /* * This file is part of OpenVPN-Settings. * * Copyright 2009-2012 Friedrich Schuffelhut * * OpenVPN-Settings is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * OpenVPN-Settings is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with OpenVPN-Settings. If not, see <http://www.gnu.org/licenses/>. * * Report bugs or new features at: http://code.google.com/p/android-openvpn-settings/ * Contact the author at: android.openvpn@schaeuffelhut.de */ import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.io.Reader; public class Main { /** * The default buffer size to use for the skip() methods. */ private static final int SKIP_BUFFER_SIZE = 2048; private static char[] SKIP_CHAR_BUFFER; private static byte[] SKIP_BYTE_BUFFER; /** * Skip the requested number of bytes or fail if there are not enough left. * <p> * This allows for the possibility that {@link InputStream#skip(long)} may * not skip as many bytes as requested (most likely because of reaching EOF). * * @param input stream to skip * @param toSkip the number of bytes to skip * @see InputStream#skip(long) * * @throws IOException if there is a problem reading the file * @throws IllegalArgumentException if toSkip is negative * @throws EOFException if the number of bytes skipped was incorrect * @since Commons IO 2.0 */ public static void skipFully(InputStream input, long toSkip) throws IOException { if (toSkip < 0) { throw new IllegalArgumentException("Bytes to skip must not be negative: " + toSkip); } long skipped = skip(input, toSkip); if (skipped != toSkip) { throw new EOFException("Bytes to skip: " + toSkip + " actual: " + skipped); } } /** * Skip the requested number of characters or fail if there are not enough left. * <p> * This allows for the possibility that {@link Reader#skip(long)} may * not skip as many characters as requested (most likely because of reaching EOF). * * @param input stream to skip * @param toSkip the number of characters to skip * @see Reader#skip(long) * * @throws IOException if there is a problem reading the file * @throws IllegalArgumentException if toSkip is negative * @throws EOFException if the number of characters skipped was incorrect * @since Commons IO 2.0 */ public static void skipFully(Reader input, long toSkip) throws IOException { long skipped = skip(input, toSkip); if (skipped != toSkip) { throw new EOFException("Chars to skip: " + toSkip + " actual: " + skipped); } } /** * Skip bytes from an input byte stream. * This implementation guarantees that it will read as many bytes * as possible before giving up; this may not always be the case for * subclasses of {@link Reader}. * * @param input byte stream to skip * @param toSkip number of bytes to skip. * @return number of bytes actually skipped. * * @see InputStream#skip(long) * * @throws IOException if there is a problem reading the file * @throws IllegalArgumentException if toSkip is negative * @since Commons IO 2.0 */ public static long skip(InputStream input, long toSkip) throws IOException { if (toSkip < 0) { throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip); } /* * N.B. no need to synchronize this because: * - we don't care if the buffer is created multiple times (the data is ignored) * - we always use the same size buffer, so if it it is recreated it will still be OK * (if the buffer size were variable, we would need to synch. to ensure some other thread * did not create a smaller one) */ if (SKIP_BYTE_BUFFER == null) { SKIP_BYTE_BUFFER = new byte[SKIP_BUFFER_SIZE]; } long remain = toSkip; while (remain > 0) { long n = input.read(SKIP_BYTE_BUFFER, 0, (int) Math.min(remain, SKIP_BUFFER_SIZE)); if (n < 0) { // EOF break; } remain -= n; } return toSkip - remain; } /** * Skip characters from an input character stream. * This implementation guarantees that it will read as many characters * as possible before giving up; this may not always be the case for * subclasses of {@link Reader}. * * @param input character stream to skip * @param toSkip number of characters to skip. * @return number of characters actually skipped. * * @see Reader#skip(long) * * @throws IOException if there is a problem reading the file * @throws IllegalArgumentException if toSkip is negative * @since Commons IO 2.0 */ public static long skip(Reader input, long toSkip) throws IOException { if (toSkip < 0) { throw new IllegalArgumentException("Skip count must be non-negative, actual: " + toSkip); } /* * N.B. no need to synchronize this because: * - we don't care if the buffer is created multiple times (the data is ignored) * - we always use the same size buffer, so if it it is recreated it will still be OK * (if the buffer size were variable, we would need to synch. to ensure some other thread * did not create a smaller one) */ if (SKIP_CHAR_BUFFER == null) { SKIP_CHAR_BUFFER = new char[SKIP_BUFFER_SIZE]; } long remain = toSkip; while (remain > 0) { long n = input.read(SKIP_CHAR_BUFFER, 0, (int) Math.min(remain, SKIP_BUFFER_SIZE)); if (n < 0) { // EOF break; } remain -= n; } return toSkip - remain; } /** * Read characters from an input character stream. * This implementation guarantees that it will read as many characters * as possible before giving up; this may not always be the case for * subclasses of {@link Reader}. * * @param input where to read input from * @param buffer destination * @param offset inital offset into buffer * @param length length to read, must be >= 0 * @return actual length read; may be less than requested if EOF was reached * @throws IOException if a read error occurs */ public static int read(Reader input, char[] buffer, int offset, int length) throws IOException { if (length < 0) { throw new IllegalArgumentException("Length must not be negative: " + length); } int remaining = length; while (remaining > 0) { int location = (length - remaining); int count = input.read(buffer, location, remaining); if (-1 == count) { // EOF break; } remaining -= count; } return length - remaining; } /** * Read characters from an input character stream. * This implementation guarantees that it will read as many characters * as possible before giving up; this may not always be the case for * subclasses of {@link Reader}. * * @param input where to read input from * @param buffer destination * @return actual length read; may be less than requested if EOF was reached * @throws IOException if a read error occurs */ public static int read(Reader input, char[] buffer) throws IOException { return read(input, buffer, 0, buffer.length); } /** * Read bytes from an input stream. * This implementation guarantees that it will read as many bytes * as possible before giving up; this may not always be the case for * subclasses of {@link InputStream}. * * @param input where to read input from * @param buffer destination * @param offset inital offset into buffer * @param length length to read, must be >= 0 * @return actual length read; may be less than requested if EOF was reached * @throws IOException if a read error occurs */ public static int read(InputStream input, byte[] buffer, int offset, int length) throws IOException { if (length < 0) { throw new IllegalArgumentException("Length must not be negative: " + length); } int remaining = length; while (remaining > 0) { int location = (length - remaining); int count = input.read(buffer, location, remaining); if (-1 == count) { // EOF break; } remaining -= count; } return length - remaining; } /** * Read bytes from an input stream. * This implementation guarantees that it will read as many bytes * as possible before giving up; this may not always be the case for * subclasses of {@link InputStream}. * * @param input where to read input from * @param buffer destination * @return actual length read; may be less than requested if EOF was reached * @throws IOException if a read error occurs */ public static int read(InputStream input, byte[] buffer) throws IOException { return read(input, buffer, 0, buffer.length); } }