The method …………………., force writes whenever the data accumulates in the output stream.

In Java, a stream is a sequence of data composed of bytes. It’s synonymous to a stream because like a stream of water, it continues to flow. Based on the datatype that is transferred through the stream, they are classified as one of the following based on the byte:

1. Output stream

2. Input stream

Output stream

In order to write data to a destination, the Java application utilizes an output streammay be a peripheral device, socket, file, or an array.

The OutputStream class is an abstract class. It is the super-class of all classes denoting an output-stream of bytes. An output-stream takes in output bytes and sends them to some reservoir.

Important methods of OutputStream

1. public void write(int)throws IOException: This writes a byte to the most recent output stream.
2. public void write(byte[])throws IOException: This writes an array of bytes to the current output stream.
3. public void flush()throws IOException: This performs the function of flushing the current output stream.
4. public void close()throws IOException: This closes the current output stream.

Because of the scope of this shot, we are restricted to FileOutputStream and FileInputStream.

Java FileOutputStream is a type of output stream used for writing data to a destination file. When it is necessary to write primitive values into a file, use the FileOutputStream class. You can write byte-type as well as character-type data via FileOutputStream class, but FileWriter is preferred to FileOutputStream for character-type data.

FileOutputStream class declaration

The Java.io.FileOutputStream class is declared as: public class FileOutputStream extends OutputStream.

FileOutputStream class methods

1. protected void finalize(): This wraps up the connection with the file output stream.
2. void write(byte[] array): This writes array, length, and byte data from the byte array to the file output stream.
3. void write(byte[] array, int off, int size): This writes size bytes from the byte array beginning at offset position straight to the file output stream.
4. void write(int b): It is used to write the particular byte to the file output stream.
5. File-Channel get-Channel(): It is used to return the file channel object related to the file output stream.
6. void close(): This closes the file output stream.

import java.io.FileOutputStream; public class FileOutputStreamExample { public static void main(String args[]){ try{ FileOutputStream fileout=new FileOutputStream("D:\\testout.txt"); fout.write(65); fileout.close(); System.out.println("success..."); }catch(Exception e){System.out.println(e);} } } Output

Java FileOutputStream Example 1

The InputStream class is an abstract class. It is the parent-class of all classes that represents an input stream of bytes.

Important methods of InputStream

1. public abstract int read()throws IOException: This method reads the preceding byte of data from the input stream. It returns a negative one at the end of the file.
2. public int available()throws IOException: An estimated number of bytes is returned by this method so it can be read from the most recent input stream.
3. public void close()throws IOException: This method uses the close keyword to close the latest input stream.

The Java FileInputStream class acquires input bytes data from a file. It reads byte-associated dataraw bytes stream, such as image data, audio, video, etc., and can read character-stream data. Nonetheless, in order to read streams of characters, the FileReader class is recommended.

Java FileInputStream class declaration

The Java.io.FileInputStream class is declared as: public class FileInputStream extends InputStream.

Java FileInputStream class methods

1. int available(): This method returns an estimated number of bytes that is readable from the input stream.
2. int read(): This method reads the byte of data from the input stream.
3. int read(byte[] byt): This reads up to byte.length bytes of data from the input stream.
4. int read(byte[] byt, int off, int size): This method reads up to size bytes of data from the input stream.
5. long skip(long m): This performs the function of skipping over to discard m bytes of data from the input stream.
6. FileChannel getChannel(): This functions to return the special FileChannel object related to the file input stream.

import java.io.FileInputStream; public class DataStreamExample { public static void main(String args[]){ try{ FileInputStream fileinp=new FileInputStream("D:\\testout.txt"); int i=fileinp.read(); System.out.print((char)i); fin.close(); }catch(Exception e){System.out.println(e);} } }

Java FileInputStream example 1: to read a single character

I hope the content of this shot, despite its brevity, answers some of the burning questions you had before reading through it.

RELATED TAGS

• java.lang.Object

• All Implemented Interfaces: Closeable, Flushable, AutoCloseable Direct Known Subclasses: ByteArrayOutputStream, FileOutputStream, FilterOutputStream, ObjectOutputStream, OutputStream, PipedOutputStream
  public abstract class OutputStream extends Object implements Closeable, Flushable

  This abstract class is the superclass of all classes representing an output stream of bytes. An output stream accepts output bytes and sends them to some sink.

  Applications that need to define a subclass of OutputStream must always provide at least a method that writes one byte of output.

  Since: JDK1.0 See Also:BufferedOutputStream, ByteArrayOutputStream, DataOutputStream, FilterOutputStream, InputStream, write(int)

• • • clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

• • • public abstract void write(int b) throws IOException

      Writes the specified byte to this output stream. The general contract for write is that one byte is written to the output stream. The byte to be written is the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.

      Subclasses of OutputStream must provide an implementation for this method.

      Parameters:b - the byte. Throws: IOException - if an I/O error occurs. In particular, an IOException may be thrown if the output stream has been closed.
    • public void write(byte[] b) throws IOException

      Writes b.length bytes from the specified byte array to this output stream. The general contract for write(b) is that it should have exactly the same effect as the call write(b, 0, b.length).

      Parameters:b - the data. Throws: IOException - if an I/O error occurs.See Also:write(byte[], int, int)
    • public void write(byte[] b, int off, int len) throws IOException

      Writes len bytes from the specified byte array starting at offset off to this output stream. The general contract for write(b, off, len) is that some of the bytes in the array b are written to the output stream in order; element b[off] is the first byte written and b[off+len-1] is the last byte written by this operation.

      The write method of OutputStream calls the write method of one argument on each of the bytes to be written out. Subclasses are encouraged to override this method and provide a more efficient implementation.

      If b is null, a NullPointerException is thrown.

      If off is negative, or len is negative, or off+len is greater than the length of the array b, then an IndexOutOfBoundsException is thrown.

      Parameters:b - the data.off - the start offset in the data.len - the number of bytes to write. Throws: IOException - if an I/O error occurs. In particular, an IOException is thrown if the output stream is closed.
    • public void flush() throws IOException

      Flushes this output stream and forces any buffered output bytes to be written out. The general contract of flush is that calling it is an indication that, if any bytes previously written have been buffered by the implementation of the output stream, such bytes should immediately be written to their intended destination.

      If the intended destination of this stream is an abstraction provided by the underlying operating system, for example a file, then flushing the stream guarantees only that bytes previously written to the stream are passed to the operating system for writing; it does not guarantee that they are actually written to a physical device such as a disk drive.

      The flush method of OutputStream does nothing.

      Specified by: flush in interface Flushable Throws: IOException - if an I/O error occurs.
    • public void close() throws IOException

      Closes this output stream and releases any system resources associated with this stream. The general contract of close is that it closes the output stream. A closed stream cannot perform output operations and cannot be reopened.

      The close method of OutputStream does nothing.

      Specified by: close in interface Closeable Specified by: close in interface AutoCloseable Throws: IOException - if an I/O error occurs.

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2020, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.