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 17 java.base.jmod - Base Module
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module.
JDK 17 Base module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.base.jmod.
JDK 17 Base module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Base module source code files are stored in \fyicenter\jdk-17.0.5\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, 2021, 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.access.SharedSecrets; import jdk.internal.access.JavaIOFileDescriptorAccess; import sun.nio.ch.FileChannelImpl; /** * A file output stream is an output stream for writing data to a * {@code File} or to a {@code FileDescriptor}. 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} is meant for writing streams of raw bytes * such as image data. For writing streams of characters, consider using * {@code FileWriter}. * * @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; /** * Creates a file output stream to write to the file with the * specified name. A new {@code FileDescriptor} object is * created to represent this file connection. * <p> * First, if there is a security manager, its {@code checkWrite} * method is called with {@code name} 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} 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 * @throws 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 * @throws SecurityException if a security manager exists and its * {@code checkWrite} 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}, then * bytes will be written to the end of the file rather than the beginning. * A new {@code FileDescriptor} object is created to represent this * file connection. * <p> * First, if there is a security manager, its {@code checkWrite} * method is called with {@code name} 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} is thrown. * * @param name the system-dependent file name * @param append if {@code true}, then bytes will be written * to the end of the file rather than the beginning * @throws 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. * @throws SecurityException if a security manager exists and its * {@code checkWrite} 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} object. A new * {@code FileDescriptor} object is created to represent this * file connection. * <p> * First, if there is a security manager, its {@code checkWrite} * method is called with the path represented by the {@code file} * 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} is thrown. * * @param file the file to be opened for writing. * @throws 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 * @throws SecurityException if a security manager exists and its * {@code checkWrite} 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} object. If the second argument is * {@code true}, then bytes will be written to the end of the file * rather than the beginning. A new {@code FileDescriptor} object is * created to represent this file connection. * <p> * First, if there is a security manager, its {@code checkWrite} * method is called with the path represented by the {@code file} * 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} is thrown. * * @param file the file to be opened for writing. * @param append if {@code true}, then bytes will be written * to the end of the file rather than the beginning * @throws 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 * @throws SecurityException if a security manager exists and its * {@code checkWrite} 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); @SuppressWarnings("removal") 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); 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} * method is called with the file descriptor {@code fdObj} * argument as its argument. * <p> * If {@code fdObj} is null then a {@code NullPointerException} * is thrown. * <p> * This constructor does not throw an exception if {@code fdObj} * 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} is thrown. * * @param fdObj the file descriptor to be opened for writing * @throws SecurityException if a security manager exists and its * {@code checkWrite} method denies * write access to the file descriptor * @see java.lang.SecurityManager#checkWrite(java.io.FileDescriptor) */ public FileOutputStream(FileDescriptor fdObj) { @SuppressWarnings("removal") SecurityManager security = System.getSecurityManager(); if (fdObj == null) { throw new NullPointerException(); } if (security != null) { security.checkWrite(fdObj); } this.fd = fdObj; this.path = 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} method of {@code OutputStream}. * * @param b the byte to be written. * @throws 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 * @throws 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} bytes from the specified byte array * to this file output stream. * * @param b the data. * @throws 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} bytes from the specified byte array * starting at offset {@code off} 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. * @throws 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. * * @throws IOException if an I/O error occurs. * * @revised 1.4 */ 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} object that represents * the connection to the file in the file system being used * by this {@code FileOutputStream} object. * * @throws 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 */ 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; } private static native void initIDs(); static { initIDs(); } }
⏎ java/io/FileOutputStream.java
Or download all of them as a single archive file:
File name: java.base-17.0.5-src.zip File size: 8883851 bytes Release date: 2022-09-13 Download
2023-09-26, 44385👍, 1💬
Popular Posts:
What Is javaws.jar in JRE (Java Runtime Environment) 8? javaws.jar in JRE (Java Runtime Environment)...
How to download and install ojdbc6.jar for Oracle 11g R2? ojdbc6.jar for Oracle 11g R2 is a Java 6, ...
JasperReports, the world's most popular open source business intelligence and reporting engine and J...
This package is the backport of java.util.concurrent API, introduced in Java 5.0 and further refined...
The Jakarta-ORO Java classes are a set of text-processing Java classes that provide Perl5 compatible...