|
* (byte)(b) * </pre> * <p> * This method blocks until the byte is read, the end of the stream * is detected, or an exception is thrown. * * @return the next byte of this file as a signed eight-bit * {@code byte}. * @exception EOFException if this file has reached the end. * @exception IOException if an I/O error occurs. */ public final byte readByte() throws IOException { int ch = this.read(); if (ch < 0) throw new EOFException(); return (byte)(ch); } /** * Reads an unsigned eight-bit number from this file. This method reads * a byte from this file, starting at the current file pointer, * and returns that byte. * <p> * This method blocks until the byte is read, the end of the stream * is detected, or an exception is thrown. * * @return the next byte of this file, interpreted as an unsigned * eight-bit number. * @exception EOFException if this file has reached the end. * @exception IOException if an I/O error occurs. */ public final int readUnsignedByte() throws IOException { int ch = this.read(); if (ch < 0) throw new EOFException(); return ch; } /** * Reads a signed 16-bit number from this file. The method reads two * bytes from this file, starting at the current file pointer. * If the two bytes read, in order, are * {@code b1} and {@code b2}, where each of the two values is * between {@code 0} and {@code 255}, inclusive, then the * result is equal to: * <blockquote>* (short)((b1 << 8) | b2) * </pre> * <p> * This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this file, interpreted as a signed * 16-bit number. * @exception EOFException if this file reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final short readShort() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) throw new EOFException(); return (short)((ch1 << 8) + (ch2 << 0)); } /** * Reads an unsigned 16-bit number from this file. This method reads * two bytes from the file, starting at the current file pointer. * If the bytes read, in order, are * {@code b1} and {@code b2}, where * <code>0 <= b1, b2 <= 255, * then the result is equal to: * <blockquote>* (b1 << 8) | b2 * </pre> * <p> * This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this file, interpreted as an unsigned * 16-bit integer. * @exception EOFException if this file reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final int readUnsignedShort() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) throw new EOFException(); return (ch1 << 8) + (ch2 << 0); } /** * Reads a character from this file. This method reads two * bytes from the file, starting at the current file pointer. * If the bytes read, in order, are * {@code b1} and {@code b2}, where * <code>0 <= b1, b2 <= 255, * then the result is equal to: * <blockquote>* (char)((b1 << 8) | b2) * </pre> * <p> * This method blocks until the two bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next two bytes of this file, interpreted as a * {@code char}. * @exception EOFException if this file reaches the end before reading * two bytes. * @exception IOException if an I/O error occurs. */ public final char readChar() throws IOException { int ch1 = this.read(); int ch2 = this.read(); if ((ch1 | ch2) < 0) throw new EOFException(); return (char)((ch1 << 8) + (ch2 << 0)); } /** * Reads a signed 32-bit integer from this file. This method reads 4 * bytes from the file, starting at the current file pointer. * If the bytes read, in order, are {@code b1}, * {@code b2}, {@code b3}, and {@code b4}, where * <code>0 <= b1, b2, b3, b4 <= 255, * then the result is equal to: * <blockquote>* (b1 << 24) | (b2 << 16) + (b3 << 8) + b4 * </pre> * <p> * This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this file, interpreted as an * {@code int}. * @exception EOFException if this file reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. */ public final int readInt() throws IOException { int ch1 = this.read(); int ch2 = this.read(); int ch3 = this.read(); int ch4 = this.read(); if ((ch1 | ch2 | ch3 | ch4) < 0) throw new EOFException(); return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)); } /** * Reads a signed 64-bit integer from this file. This method reads eight * bytes from the file, starting at the current file pointer. * If the bytes read, in order, are * {@code b1}, {@code b2}, {@code b3}, * {@code b4}, {@code b5}, {@code b6}, * {@code b7}, and {@code b8,} where: * <blockquote>* 0 <= b1, b2, b3, b4, b5, b6, b7, b8 <=255, * </pre> * <p> * then the result is equal to: * <blockquote>* ((long)b1 << 56) + ((long)b2 << 48) * + ((long)b3 << 40) + ((long)b4 << 32) * + ((long)b5 << 24) + ((long)b6 << 16) * + ((long)b7 << 8) + b8 * </pre> * <p> * This method blocks until the eight bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next eight bytes of this file, interpreted as a * {@code long}. * @exception EOFException if this file reaches the end before reading * eight bytes. * @exception IOException if an I/O error occurs. */ public final long readLong() throws IOException { return ((long)(readInt()) << 32) + (readInt() & 0xFFFFFFFFL); } /** * Reads a {@code float} from this file. This method reads an * {@code int} value, starting at the current file pointer, * as if by the {@code readInt} method * and then converts that {@code int} to a {@code float} * using the {@code intBitsToFloat} method in class * {@code Float}. * <p> * This method blocks until the four bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next four bytes of this file, interpreted as a * {@code float}. * @exception EOFException if this file reaches the end before reading * four bytes. * @exception IOException if an I/O error occurs. * @see java.io.RandomAccessFile#readInt() * @see java.lang.Float#intBitsToFloat(int) */ public final float readFloat() throws IOException { return Float.intBitsToFloat(readInt()); } /** * Reads a {@code double} from this file. This method reads a * {@code long} value, starting at the current file pointer, * as if by the {@code readLong} method * and then converts that {@code long} to a {@code double} * using the {@code longBitsToDouble} method in * class {@code Double}. * <p> * This method blocks until the eight bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return the next eight bytes of this file, interpreted as a * {@code double}. * @exception EOFException if this file reaches the end before reading * eight bytes. * @exception IOException if an I/O error occurs. * @see java.io.RandomAccessFile#readLong() * @see java.lang.Double#longBitsToDouble(long) */ public final double readDouble() throws IOException { return Double.longBitsToDouble(readLong()); } /** * Reads the next line of text from this file. This method successively * reads bytes from the file, starting at the current file pointer, * until it reaches a line terminator or the end * of the file. Each byte is converted into a character by taking the * byte's value for the lower eight bits of the character and setting the * high eight bits of the character to zero. This method does not, * therefore, support the full Unicode character set. * * <p> A line of text is terminated by a carriage-return character * ({@code '\u005Cr'}), a newline character ({@code '\u005Cn'}), a * carriage-return character immediately followed by a newline character, * or the end of the file. Line-terminating characters are discarded and * are not included as part of the string returned. * * <p> This method blocks until a newline character is read, a carriage * return and the byte following it are read (to see if it is a newline), * the end of the file is reached, or an exception is thrown. * * @return the next line of text from this file, or null if end * of file is encountered before even one byte is read. * @exception IOException if an I/O error occurs. */ public final String readLine() throws IOException { StringBuffer input = new StringBuffer(); int c = -1; boolean eol = false; while (!eol) { switch (c = read()) { case -1: case '\n': eol = true; break; case '\r': eol = true; long cur = getFilePointer(); if ((read()) != '\n') { seek(cur); } break; default: input.append((char)c); break; } } if ((c == -1) && (input.length() == 0)) { return null; } return input.toString(); } /** * Reads in a string from this file. The string has been encoded * using a * <a href="DataInput.html#modified-utf-8">modified UTF-8 * format. * <p> * The first two bytes are read, starting from the current file * pointer, as if by * {@code readUnsignedShort}. This value gives the number of * following bytes that are in the encoded string, not * the length of the resulting string. The following bytes are then * interpreted as bytes encoding characters in the modified UTF-8 format * and are converted into characters. * <p> * This method blocks until all the bytes are read, the end of the * stream is detected, or an exception is thrown. * * @return a Unicode string. * @exception EOFException if this file reaches the end before * reading all the bytes. * @exception IOException if an I/O error occurs. * @exception UTFDataFormatException if the bytes do not represent * valid modified UTF-8 encoding of a Unicode string. * @see java.io.RandomAccessFile#readUnsignedShort() */ public final String readUTF() throws IOException { return DataInputStream.readUTF(this); } /** * Writes a {@code boolean} to the file as a one-byte value. The * value {@code true} is written out as the value * {@code (byte)1}; the value {@code false} is written out * as the value {@code (byte)0}. The write starts at * the current position of the file pointer. * * @param v a {@code boolean} value to be written. * @exception IOException if an I/O error occurs. */ public final void writeBoolean(boolean v) throws IOException { write(v ? 1 : 0); //written++; } /** * Writes a {@code byte} to the file as a one-byte value. The * write starts at the current position of the file pointer. * * @param v a {@code byte} value to be written. * @exception IOException if an I/O error occurs. */ public final void writeByte(int v) throws IOException { write(v); //written++; } /** * Writes a {@code short} to the file as two bytes, high byte first. * The write starts at the current position of the file pointer. * * @param v a {@code short} to be written. * @exception IOException if an I/O error occurs. */ public final void writeShort(int v) throws IOException { write((v >>> 8) & 0xFF); write((v >>> 0) & 0xFF); //written += 2; } /** * Writes a {@code char} to the file as a two-byte value, high * byte first. The write starts at the current position of the * file pointer. * * @param v a {@code char} value to be written. * @exception IOException if an I/O error occurs. */ public final void writeChar(int v) throws IOException { write((v >>> 8) & 0xFF); write((v >>> 0) & 0xFF); //written += 2; } /** * Writes an {@code int} to the file as four bytes, high byte first. * The write starts at the current position of the file pointer. * * @param v an {@code int} to be written. * @exception IOException if an I/O error occurs. */ public final void writeInt(int v) throws IOException { write((v >>> 24) & 0xFF); write((v >>> 16) & 0xFF); write((v >>> 8) & 0xFF); write((v >>> 0) & 0xFF); //written += 4; } /** * Writes a {@code long} to the file as eight bytes, high byte first. * The write starts at the current position of the file pointer. * * @param v a {@code long} to be written. * @exception IOException if an I/O error occurs. */ public final void writeLong(long v) throws IOException { write((int)(v >>> 56) & 0xFF); write((int)(v >>> 48) & 0xFF); write((int)(v >>> 40) & 0xFF); write((int)(v >>> 32) & 0xFF); write((int)(v >>> 24) & 0xFF); write((int)(v >>> 16) & 0xFF); write((int)(v >>> 8) & 0xFF); write((int)(v >>> 0) & 0xFF); //written += 8; } /** * Converts the float argument to an {@code int} using the * {@code floatToIntBits} method in class {@code Float}, * and then writes that {@code int} value to the file as a * four-byte quantity, high byte first. The write starts at the * current position of the file pointer. * * @param v a {@code float} value to be written. * @exception IOException if an I/O error occurs. * @see java.lang.Float#floatToIntBits(float) */ public final void writeFloat(float v) throws IOException { writeInt(Float.floatToIntBits(v)); } /** * Converts the double argument to a {@code long} using the * {@code doubleToLongBits} method in class {@code Double}, * and then writes that {@code long} value to the file as an * eight-byte quantity, high byte first. The write starts at the current * position of the file pointer. * * @param v a {@code double} value to be written. * @exception IOException if an I/O error occurs. * @see java.lang.Double#doubleToLongBits(double) */ public final void writeDouble(double v) throws IOException { writeLong(Double.doubleToLongBits(v)); } /** * Writes the string to the file as a sequence of bytes. Each * character in the string is written out, in sequence, by discarding * its high eight bits. The write starts at the current position of * the file pointer. * * @param s a string of bytes to be written. * @exception IOException if an I/O error occurs. */ @SuppressWarnings("deprecation") public final void writeBytes(String s) throws IOException { int len = s.length(); byte[] b = new byte[len]; s.getBytes(0, len, b, 0); writeBytes(b, 0, len); } /** * Writes a string to the file as a sequence of characters. Each * character is written to the data output stream as if by the * {@code writeChar} method. The write starts at the current * position of the file pointer. * * @param s a {@code String} value to be written. * @exception IOException if an I/O error occurs. * @see java.io.RandomAccessFile#writeChar(int) */ public final void writeChars(String s) throws IOException { int clen = s.length(); int blen = 2*clen; byte[] b = new byte[blen]; char[] c = new char[clen]; s.getChars(0, clen, c, 0); for (int i = 0, j = 0; i < clen; i++) { b[j++] = (byte)(c[i] >>> 8); b[j++] = (byte)(c[i] >>> 0); } writeBytes(b, 0, blen); } /** * Writes a string to the file using * <a href="DataInput.html#modified-utf-8">modified UTF-8 * encoding in a machine-independent manner. * <p> * First, two bytes are written to the file, starting at the * current file pointer, as if by the * {@code writeShort} method giving the number of bytes to * follow. This value is the number of bytes actually written out, * not the length of the string. Following the length, each character * of the string is output, in sequence, using the modified UTF-8 encoding * for each character. * * @param str a string to be written. * @exception IOException if an I/O error occurs. */ public final void writeUTF(String str) throws IOException { DataOutputStream.writeUTF(str, this); } private static native void initIDs(); private native void close0() throws IOException; static { initIDs(); } }Other Java examples (source code examples)
Here is a short list of links related to this Java RandomAccessFile.java source code file:
Java example source code file (RandomAccessFile.java)
The RandomAccessFile.java Java example source code/* * Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code 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 * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.io; import java.nio.channels.FileChannel; import sun.nio.ch.FileChannelImpl; /** * Instances of this class support both reading and writing to a * random access file. A random access file behaves like a large * array of bytes stored in the file system. There is a kind of cursor, * or index into the implied array, called the <em>file pointer; * input operations read bytes starting at the file pointer and advance * the file pointer past the bytes read. If the random access file is * created in read/write mode, then output operations are also available; * output operations write bytes starting at the file pointer and advance * the file pointer past the bytes written. Output operations that write * past the current end of the implied array cause the array to be * extended. The file pointer can be read by the * {@code getFilePointer} method and set by the {@code seek} * method. * <p> * It is generally true of all the reading routines in this class that * if end-of-file is reached before the desired number of bytes has been * read, an {@code EOFException} (which is a kind of * {@code IOException}) is thrown. If any byte cannot be read for * any reason other than end-of-file, an {@code IOException} other * than {@code EOFException} is thrown. In particular, an * {@code IOException} may be thrown if the stream has been closed. * * @author unascribed * @since JDK1.0 */ public class RandomAccessFile implements DataOutput, DataInput, Closeable { private FileDescriptor fd; private FileChannel channel = null; private boolean rw; private Object closeLock = new Object(); private volatile boolean closed = false; private static final int O_RDONLY = 1; private static final int O_RDWR = 2; private static final int O_SYNC = 4; private static final int O_DSYNC = 8; /** * Creates a random access file stream to read from, and optionally * to write to, a file with the specified name. A new * {@link FileDescriptor} object is created to represent the * connection to the file. * * <p> The mode argument specifies the access mode with which the * file is to be opened. The permitted values and their meanings are as * specified for the <a * href="#mode"><tt>RandomAccessFile(File,String) constructor. * * <p> * If there is a security manager, its {@code checkRead} method * is called with the {@code name} argument * as its argument to see if read access to the file is allowed. * If the mode allows writing, the security manager's * {@code checkWrite} method * is also called with the {@code name} argument * as its argument to see if write access to the file is allowed. * * @param name the system-dependent filename * @param mode the access <a href="#mode">mode * @exception IllegalArgumentException if the mode argument is not equal * to one of <tt>"r", "rw", "rws", or * <tt>"rwd" * @exception FileNotFoundException * if the mode is <tt>"r" but the given string does not * denote an existing regular file, or if the mode begins with * <tt>"rw" but the given string does not denote an * existing, writable regular file and a new regular file of * that name cannot be created, or if some other error occurs * while opening or creating the file * @exception SecurityException if a security manager exists and its * {@code checkRead} method denies read access to the file * or the mode is "rw" and the security manager's * {@code checkWrite} method denies write access to the file * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkRead(java.lang.String) * @see java.lang.SecurityManager#checkWrite(java.lang.String) * @revised 1.4 * @spec JSR-51 */ public RandomAccessFile(String name, String mode) throws FileNotFoundException { this(name != null ? new File(name) : null, mode); } /** * Creates a random access file stream to read from, and optionally to * write to, the file specified by the {@link File} argument. A new {@link * FileDescriptor} object is created to represent this file connection. * * <p>The mode argument specifies the access mode * in which the file is to be opened. The permitted values and their * meanings are: * * <table summary="Access mode permitted values and meanings"> * <tr> | Value | Meaning | |
---|---|---|---|
"r" | |||
"rw" | |||
"rws" | |||
"rwd" |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.