Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/io/FileOutputStream.java
/* * Copyright (c) 1994, 2017, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.io; import java.nio.channels.FileChannel; import jdk.internal.misc.SharedSecrets; import jdk.internal.misc.JavaIOFileDescriptorAccess; import sun.nio.ch.FileChannelImpl; /** * A file output stream is an output stream for writing data to a * <code>File</code> or to a <code>FileDescriptor</code>. Whether or not * a file is available or may be created depends upon the underlying * platform. Some platforms, in particular, allow a file to be opened * for writing by only one {@code FileOutputStream} (or other * file-writing object) at a time. In such situations the constructors in * this class will fail if the file involved is already open. * * <p><code>FileOutputStream</code> is meant for writing streams of raw bytes * such as image data. For writing streams of characters, consider using * <code>FileWriter</code>. * * @apiNote * To release resources used by this stream {@link #close} should be called * directly or by try-with-resources. Subclasses are responsible for the cleanup * of resources acquired by the subclass. * Subclasses that override {@link #finalize} in order to perform cleanup * should be modified to use alternative cleanup mechanisms such as * {@link java.lang.ref.Cleaner} and remove the overriding {@code finalize} method. * * @implSpec * If this FileOutputStream has been subclassed and the {@link #close} * method has been overridden, the {@link #close} method will be * called when the FileInputStream is unreachable. * Otherwise, it is implementation specific how the resource cleanup described in * {@link #close} is performed. * * @author Arthur van Hoff * @see java.io.File * @see java.io.FileDescriptor * @see java.io.FileInputStream * @see java.nio.file.Files#newOutputStream * @since 1.0 */ public class FileOutputStream extends OutputStream { /** * Access to FileDescriptor internals. */ private static final JavaIOFileDescriptorAccess fdAccess = SharedSecrets.getJavaIOFileDescriptorAccess(); /** * The system dependent file descriptor. */ private final FileDescriptor fd; /** * The associated channel, initialized lazily. */ private volatile FileChannel channel; /** * The path of the referenced file * (null if the stream is created with a file descriptor) */ private final String path; private final Object closeLock = new Object(); private volatile boolean closed; private final Object altFinalizer; /** * Creates a file output stream to write to the file with the * specified name. A new <code>FileDescriptor</code> object is * created to represent this file connection. * <p> * First, if there is a security manager, its <code>checkWrite</code> * method is called with <code>name</code> as its argument. * <p> * If the file exists but is a directory rather than a regular file, does * not exist but cannot be created, or cannot be opened for any other * reason then a <code>FileNotFoundException</code> is thrown. * * @implSpec Invoking this constructor with the parameter {@code name} is * equivalent to invoking {@link #FileOutputStream(String,boolean) * new FileOutputStream(name, false)}. * * @param name the system-dependent filename * @exception FileNotFoundException if the file exists but is a directory * rather than a regular file, does not exist but cannot * be created, or cannot be opened for any other reason * @exception SecurityException if a security manager exists and its * <code>checkWrite</code> method denies write access * to the file. * @see java.lang.SecurityManager#checkWrite(java.lang.String) */ public FileOutputStream(String name) throws FileNotFoundException { this(name != null ? new File(name) : null, false); } /** * Creates a file output stream to write to the file with the specified * name. If the second argument is <code>true</code>, then * bytes will be written to the end of the file rather than the beginning. * A new <code>FileDescriptor</code> object is created to represent this * file connection. * <p> * First, if there is a security manager, its <code>checkWrite</code> * method is called with <code>name</code> as its argument. * <p> * If the file exists but is a directory rather than a regular file, does * not exist but cannot be created, or cannot be opened for any other * reason then a <code>FileNotFoundException</code> is thrown. * * @param name the system-dependent file name * @param append if <code>true</code>, then bytes will be written * to the end of the file rather than the beginning * @exception FileNotFoundException if the file exists but is a directory * rather than a regular file, does not exist but cannot * be created, or cannot be opened for any other reason. * @exception SecurityException if a security manager exists and its * <code>checkWrite</code> method denies write access * to the file. * @see java.lang.SecurityManager#checkWrite(java.lang.String) * @since 1.1 */ public FileOutputStream(String name, boolean append) throws FileNotFoundException { this(name != null ? new File(name) : null, append); } /** * Creates a file output stream to write to the file represented by * the specified <code>File</code> object. A new * <code>FileDescriptor</code> object is created to represent this * file connection. * <p> * First, if there is a security manager, its <code>checkWrite</code> * method is called with the path represented by the <code>file</code> * argument as its argument. * <p> * If the file exists but is a directory rather than a regular file, does * not exist but cannot be created, or cannot be opened for any other * reason then a <code>FileNotFoundException</code> is thrown. * * @param file the file to be opened for writing. * @exception FileNotFoundException if the file exists but is a directory * rather than a regular file, does not exist but cannot * be created, or cannot be opened for any other reason * @exception SecurityException if a security manager exists and its * <code>checkWrite</code> method denies write access * to the file. * @see java.io.File#getPath() * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkWrite(java.lang.String) */ public FileOutputStream(File file) throws FileNotFoundException { this(file, false); } /** * Creates a file output stream to write to the file represented by * the specified <code>File</code> object. If the second argument is * <code>true</code>, then bytes will be written to the end of the file * rather than the beginning. A new <code>FileDescriptor</code> object is * created to represent this file connection. * <p> * First, if there is a security manager, its <code>checkWrite</code> * method is called with the path represented by the <code>file</code> * argument as its argument. * <p> * If the file exists but is a directory rather than a regular file, does * not exist but cannot be created, or cannot be opened for any other * reason then a <code>FileNotFoundException</code> is thrown. * * @param file the file to be opened for writing. * @param append if <code>true</code>, then bytes will be written * to the end of the file rather than the beginning * @exception FileNotFoundException if the file exists but is a directory * rather than a regular file, does not exist but cannot * be created, or cannot be opened for any other reason * @exception SecurityException if a security manager exists and its * <code>checkWrite</code> method denies write access * to the file. * @see java.io.File#getPath() * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkWrite(java.lang.String) * @since 1.4 */ public FileOutputStream(File file, boolean append) throws FileNotFoundException { String name = (file != null ? file.getPath() : null); SecurityManager security = System.getSecurityManager(); if (security != null) { security.checkWrite(name); } if (name == null) { throw new NullPointerException(); } if (file.isInvalid()) { throw new FileNotFoundException("Invalid file path"); } this.fd = new FileDescriptor(); fd.attach(this); this.path = name; open(name, append); altFinalizer = getFinalizer(this); if (altFinalizer == null) { FileCleanable.register(fd); // open sets the fd, register the cleanup } } /** * Creates a file output stream to write to the specified file * descriptor, which represents an existing connection to an actual * file in the file system. * <p> * First, if there is a security manager, its <code>checkWrite</code> * method is called with the file descriptor <code>fdObj</code> * argument as its argument. * <p> * If <code>fdObj</code> is null then a <code>NullPointerException</code> * is thrown. * <p> * This constructor does not throw an exception if <code>fdObj</code> * is {@link java.io.FileDescriptor#valid() invalid}. * However, if the methods are invoked on the resulting stream to attempt * I/O on the stream, an <code>IOException</code> is thrown. * * @param fdObj the file descriptor to be opened for writing * @exception SecurityException if a security manager exists and its * <code>checkWrite</code> method denies * write access to the file descriptor * @see java.lang.SecurityManager#checkWrite(java.io.FileDescriptor) */ public FileOutputStream(FileDescriptor fdObj) { SecurityManager security = System.getSecurityManager(); if (fdObj == null) { throw new NullPointerException(); } if (security != null) { security.checkWrite(fdObj); } this.fd = fdObj; this.path = null; this.altFinalizer = null; fd.attach(this); } /** * Opens a file, with the specified name, for overwriting or appending. * @param name name of file to be opened * @param append whether the file is to be opened in append mode */ private native void open0(String name, boolean append) throws FileNotFoundException; // wrap native call to allow instrumentation /** * Opens a file, with the specified name, for overwriting or appending. * @param name name of file to be opened * @param append whether the file is to be opened in append mode */ private void open(String name, boolean append) throws FileNotFoundException { open0(name, append); } /** * Writes the specified byte to this file output stream. * * @param b the byte to be written. * @param append {@code true} if the write operation first * advances the position to the end of file */ private native void write(int b, boolean append) throws IOException; /** * Writes the specified byte to this file output stream. Implements * the <code>write</code> method of <code>OutputStream</code>. * * @param b the byte to be written. * @exception IOException if an I/O error occurs. */ public void write(int b) throws IOException { write(b, fdAccess.getAppend(fd)); } /** * Writes a sub array as a sequence of bytes. * @param b the data to be written * @param off the start offset in the data * @param len the number of bytes that are written * @param append {@code true} to first advance the position to the * end of file * @exception IOException If an I/O error has occurred. */ private native void writeBytes(byte b[], int off, int len, boolean append) throws IOException; /** * Writes <code>b.length</code> bytes from the specified byte array * to this file output stream. * * @param b the data. * @exception IOException if an I/O error occurs. */ public void write(byte b[]) throws IOException { writeBytes(b, 0, b.length, fdAccess.getAppend(fd)); } /** * Writes <code>len</code> bytes from the specified byte array * starting at offset <code>off</code> to this file output stream. * * @param b the data. * @param off the start offset in the data. * @param len the number of bytes to write. * @exception IOException if an I/O error occurs. */ public void write(byte b[], int off, int len) throws IOException { writeBytes(b, off, len, fdAccess.getAppend(fd)); } /** * Closes this file output stream and releases any system resources * associated with this stream. This file output stream may no longer * be used for writing bytes. * * <p> If this stream has an associated channel then the channel is closed * as well. * * @apiNote * Overriding {@link #close} to perform cleanup actions is reliable * only when called directly or when called by try-with-resources. * Do not depend on finalization to invoke {@code close}; * finalization is not reliable and is deprecated. * If cleanup of native resources is needed, other mechanisms such as * {@linkplain java.lang.ref.Cleaner} should be used. * * @exception IOException if an I/O error occurs. * * @revised 1.4 * @spec JSR-51 */ public void close() throws IOException { if (closed) { return; } synchronized (closeLock) { if (closed) { return; } closed = true; } FileChannel fc = channel; if (fc != null) { // possible race with getChannel(), benign since // FileChannel.close is final and idempotent fc.close(); } fd.closeAll(new Closeable() { public void close() throws IOException { fd.close(); } }); } /** * Returns the file descriptor associated with this stream. * * @return the <code>FileDescriptor</code> object that represents * the connection to the file in the file system being used * by this <code>FileOutputStream</code> object. * * @exception IOException if an I/O error occurs. * @see java.io.FileDescriptor */ public final FileDescriptor getFD() throws IOException { if (fd != null) { return fd; } throw new IOException(); } /** * Returns the unique {@link java.nio.channels.FileChannel FileChannel} * object associated with this file output stream. * * <p> The initial {@link java.nio.channels.FileChannel#position() * position} of the returned channel will be equal to the * number of bytes written to the file so far unless this stream is in * append mode, in which case it will be equal to the size of the file. * Writing bytes to this stream will increment the channel's position * accordingly. Changing the channel's position, either explicitly or by * writing, will change this stream's file position. * * @return the file channel associated with this file output stream * * @since 1.4 * @spec JSR-51 */ public FileChannel getChannel() { FileChannel fc = this.channel; if (fc == null) { synchronized (this) { fc = this.channel; if (fc == null) { this.channel = fc = FileChannelImpl.open(fd, path, false, true, false, this); if (closed) { try { // possible race with close(), benign since // FileChannel.close is final and idempotent fc.close(); } catch (IOException ioe) { throw new InternalError(ioe); // should not happen } } } } } return fc; } /** * Cleans up the connection to the file, and ensures that the * {@link #close} method of this file output stream is * called when there are no more references to this stream. * The {@link #finalize} method does not call {@link #close} directly. * * @apiNote * To release resources used by this stream {@link #close} should be called * directly or by try-with-resources. * * @implSpec * If this FileOutputStream has been subclassed and the {@link #close} * method has been overridden, the {@link #close} method will be * called when the FileOutputStream is unreachable. * Otherwise, it is implementation specific how the resource cleanup described in * {@link #close} is performed. * * @deprecated The {@code finalize} method has been deprecated and will be removed. * Subclasses that override {@code finalize} in order to perform cleanup * should be modified to use alternative cleanup mechanisms and * to remove the overriding {@code finalize} method. * When overriding the {@code finalize} method, its implementation must explicitly * ensure that {@code super.finalize()} is invoked as described in {@link Object#finalize}. * See the specification for {@link Object#finalize()} for further * information about migration options. * * @exception IOException if an I/O error occurs. * @see java.io.FileInputStream#close() */ @Deprecated(since="9", forRemoval = true) protected void finalize() throws IOException { } private static native void initIDs(); static { initIDs(); } /* * Returns a finalizer object if the FOS needs a finalizer; otherwise null. * If the FOS has a close method; it needs an AltFinalizer. */ private static Object getFinalizer(FileOutputStream fos) { Class<?> clazz = fos.getClass(); while (clazz != FileOutputStream.class) { try { clazz.getDeclaredMethod("close"); return new AltFinalizer(fos); } catch (NoSuchMethodException nsme) { // ignore } clazz = clazz.getSuperclass(); } return null; } /** * Class to call {@code FileOutputStream.close} when finalized. * If finalization of the stream is needed, an instance is created * in its constructor(s). When the set of instances * related to the stream is unreachable, the AltFinalizer performs * the needed call to the stream's {@code close} method. */ static class AltFinalizer { private final FileOutputStream fos; AltFinalizer(FileOutputStream fos) { this.fos = fos; } @Override @SuppressWarnings("deprecation") protected final void finalize() { try { if (fos.fd != null) { if (fos.fd == FileDescriptor.out || fos.fd == FileDescriptor.err) { // Subclass may override flush; otherwise it is no-op fos.flush(); } else { /* if fd is shared, the references in FileDescriptor * will ensure that finalizer is only called when * safe to do so. All references using the fd have * become unreachable. We can call close() */ fos.close(); } } } catch (IOException ioe) { // ignore } } } }
⏎ java/io/FileOutputStream.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 246215👍, 0💬
Popular Posts:
The Digester package lets you configure an XML -> Java object mapping module, which triggers certain...
Apache ZooKeeper is an open-source server which enables highly reliable distributed coordination. Ap...
How to show the XML parsing flow with sax\DocumentTracer.java provided in the Apache Xerces package?...
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module. JDK 11 Base module compiled class fil...
JDK 17 java.management.jmod is the JMOD file for JDK 17 Management module. JDK 17 Management module ...