Ошибка в лаунчере java io eofexception

The java.io.EOFException is a checked exception in Java that occurs when an end of file or end of stream is reached unexpectedly during input. This exception is mainly used by data input streams to signal end of stream.

Since EOFException is a checked exception, it must be explicitly handled in methods that can throw this exception — either by using a try-catch block or by throwing it using the throws clause.

What Causes EOFException

While reading the contents of a file or stream using DataInputStream objects, if the end of the file or stream is reached unexpectedly, an EOFException is thrown. Methods of the DataInputStream class that are used to read data such as readBoolean(), readByte() and readChar() can throw this exception.

Many other input operations return a special value on end of file or stream rather than throwing an exception.

EOFException Example

Here’s an example of a EOFException thrown when trying to read all characters from an input file:

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class EOFExceptionExample {
    public static void main(String[] args) {
        DataInputStream inputStream = null;

        try {
            inputStream = new DataInputStream(new FileInputStream("myfile.txt"));

            while (true) {
                inputStream.readChar();
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            try {
                inputStream.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }
}

In the above example, the contents of a file with the name myfile.txt are read in an infinite loop using the DataInputStream.readChar() method. When the readChar() method is called at the end of the file, an EOFException is thrown:

java.io.EOFException
    at java.base/java.io.DataInputStream.readChar(DataInputStream.java:369)
    at EOFExceptionExample.main(EOFExceptionExample.java:13)

How to Fix EOFException

Since EOFException is a checked exception, a try-catch block should be used to handle it. The try block should contain the lines of code that can throw the exception and the catch block should catch and handle the exception appropriately.

The above example can be updated to handle the EOFException in a try-catch block:

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.IOException;

public class EOFExceptionExample {
    public static void main(String[] args) {
        DataInputStream inputStream = null;

        try {
            inputStream = new DataInputStream(new FileInputStream("myfile.txt"));

            while (true) {
                try {
                    inputStream.readChar();
                } catch (EOFException eofe) {
                    System.out.println("End of file reached");
                    break;
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        } finally {
            try {
                inputStream.close();
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }
    }
}

Here, the inputStream.readChar() method call is placed in a try block and the EOFException is caught inside the catch block. When an EOFException occurs at the end of the file, it is handled and a break statement is used to break out of the loop.

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Java errors easier than ever. Sign Up Today!

I’m a beginner java programmer following the java tutorials.

I am using a simple Java Program from the Java tutorials’s Data Streams Page, and at runtime, it keeps on showing EOFException. I was wondering if this was normal, as the reader has to come to the end of the file eventually.

import java.io.*;

public class DataStreams {
    static final String dataFile = "F://Java//DataStreams//invoicedata.txt";

    static final double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 };
    static final int[] units = { 12, 8, 13, 29, 50 };
    static final String[] descs = {
        "Java T-shirt",
        "Java Mug",
        "Duke Juggling Dolls",
        "Java Pin",
        "Java Key Chain"
    };
    public static void main(String args[]) {
        try {
            DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(dataFile)));

            for (int i = 0; i < prices.length; i ++) {
                out.writeDouble(prices[i]);
                out.writeInt(units[i]);
                out.writeUTF(descs[i]);
            }

            out.close(); 

        } catch(IOException e){
            e.printStackTrace(); // used to be System.err.println();
        }

        double price;
        int unit;
        String desc;
        double total = 0.0;

        try {
            DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream(dataFile)));

            while (true) {
                price = in.readDouble();
                unit = in.readInt();
                desc = in.readUTF();
                System.out.format("You ordered %d" + " units of %s at $%.2f%n",
                unit, desc, price);
                total += unit * price;
            }
        } catch(IOException e) {
            e.printStackTrace(); 
        }

        System.out.format("Your total is %f.%n" , total);
    }
}

It compiles fine, but the output is:

You ordered 12 units of Java T-shirt at $19.99
You ordered 8 units of Java Mug at $9.99
You ordered 13 units of Duke Juggling Dolls at $15.99
You ordered 29 units of Java Pin at $3.99
You ordered 50 units of Java Key Chain at $4.99
java.io.EOFException
        at java.io.DataInputStream.readFully(Unknown Source)
        at java.io.DataInputStream.readLong(Unknown Source)
        at java.io.DataInputStream.readDouble(Unknown Source)
        at DataStreams.main(DataStreams.java:39)
Your total is 892.880000.

From the Java tutorials’s Data Streams Page, it says:

Notice that DataStreams detects an end-of-file condition by catching EOFException, instead of testing for an invalid return value. All implementations of DataInput methods use EOFException instead of return values.

So, does this mean that catching EOFException is normal, so just catching it and not handling it is fine, meaning that the end of file is reached?

If it means I should handle it, please advise me on how to do it.

EDIT

From the suggestions, I’ve fixed it by using in.available() > 0 for the while loop condition.

Or, I could do nothing to handle the exception, because it’s fine.

Contents of page >

• What is hierarchy of java.lang. EOFException?

• EOFException is Checked (compile time exceptions) and UnChecked (RuntimeExceptions) in java ?

• What is EOFException in java?

• Example/Programs/Scenarios where EOFException may be thrown in java>

• How to avoid EOFException in java?

• Solution 1) You may persist some count in file during serialization process to find out exactly how many object were actually serialized and simply use for loop in place of while loop in deserialization process.

• Solution 2) I’ll recommend you this solution, probably the best solution

• Create a class EofIndicatorClass which implements Serializable interface.

What is hierarchy of java.lang. EOFException?

-java.lang.Object

-java.lang.Throwable

   -java.lang.EOFException

EOFException is Checked (compile time exceptions) and UnChecked (RuntimeExceptions) in java ?

java.lang.EOFException is a Checked (compile time) Exception in java.

What is EOFException in java?

EOFException is the End of file Exception. Many input streams through EOFException to indicate end of file (Few Java Api doesn’t provide any elegant solution to signify end the file). EOFException could be thrown >

1. During DESERIALIZATION of object (when we are reading object using input stream).

2. During use of RandomAccessFile, by using seek method we can move to random position, if seek is set beyond the length the file and we try to read from there than java.io.EOFException is thrown.

Now let’s discuss above two points with program and examples.

Example/Programs/Scenarios where EOFException may be thrown in java>

SERIALIZATION>

Create object of ObjectOutput and give its reference variable name oout and call writeObject() method and pass our employee object as parameter [oout.writeObject(object1) ]

Program to Serialize Object>

DESERIALIZATION>

Create object of ObjectInput and give it’s reference variable name oin and call readObject() method [oin.readObject() ]

Program to DeSerialize object>

In the above program when file is read till end using readObject() in while loop then EOFException is thrown. Java Api doesn’t provide any elegant solution to signify end the file.

By using seek method we can move to random position, if seek is set beyond the length the file and we try to read from there than java.io.EOFException is thrown.

Program to read/write from file using RandomAccessFile >

Note : Before executing below program, remove everything from c:/myFile.txt for better understanding of program

Or preferably you may delete this file because if file doesn’t exist than RandomAccessFile will create new file.

After executing above program c:/myFile.txt will look like this >

How to avoid EOFException in java?

During deserialization process when file is read till end using readObject() in while loop then EOFException is thrown as we saw in DeSerialization program. Java Api doesn’t provide any elegant solution to signify end the file.

Generally what we could except at EOF(end of file) is null but that doesn’t happen.

So, we’ll try to address the problem because catching EOFException and interpreting it as EOF is not the elegant solution because sometimes you may fail to detect a normal EOF of a file that has been truncated.

So, let’s discuss best possible solution to address the EOFException >

• Solution 1) You may persist some count in file during serialization process to find out exactly how many object were actually serialized and simply use for loop in place of while loop in deserialization process.

Or,

• Solution 2) I’ll recommend you this solution, probably the best solution

• Create a class EofIndicatorClass which implements Serializable interface.

• During serialization >

• Write instance of EofIndicatorClass at EOF during serialization to indicate EOF during deSerialization process.

• During serialization >

• If oin.readObject() returns instanceof EofIndicatorClass that means it’s EOF, exit while loop and EOFException will not be thrown.

Now, let’s discuss solution 2 in detail.

Program to Serialize Object and persisting EofIndicatorClass at EOF >

Program to DeSerialize object and detecting EOF without throwing EOFException >

Avoid ObjectInputStream.readObject() from throwing EOFException at End Of File in java

If you note output of program EOFException wasn’t thrown, you may compare output of the program with DeSerialization done in this post where EOFException was thrown.

Summary >

So in this Exception handling java tutorial we learned what is hierarchy of java.lang. EOFException? java.lang.EOFException is a Checked (compile time) Exception in java. What is EOFException in java? Example/Programs/Scenarios where EOFException may be thrown in java. How to avoid EOFException in java?

Having any doubt? or you you liked the tutorial! Please comment in below section.

RELATED LINKS>

Most common and frequently occurring checked (compile time) and Errors in java >

• IOException and how to solve it in java

• EOFException in java

• SQLException in java

• What is java.lang.InterruptedException in java

• when java.lang.ClassNotFoundException occurs in java

Most common and frequently occurring unchecked (runtime) in java.

• What is java.lang.NullPointerException in java, when it occurs,how to handle, avoid and fix it

• NumberFormatException in java

• IndexOutOfBoundsException in java

• When java.lang.ArrayIndexOutOfBoundsException occurs in java

• When java.lang.StringIndexOutOfBoundsException occurs in java

• java.lang.ArithmeticException in java — Divide number by zero

• When dividing by zero does not throw ArithmeticException in java

• When java.lang.IllegalStateException occurs in java

• when java.lang.IllegalMonitorStateException is thrown in java

• Solve java.lang.UnsupportedOperationException in java

Most common and frequently occurring Errors in java >

• OutOfMemoryError in java

• When java.lang.StackOverflowError occurs in java

• Solve java.lang.ExceptionInInitializerError in java

• How to solve java.lang.NoClassDefFoundError in java

Few More >

• What is difference between ClassNotFoundException and NoClassDefFoundError in java

While reading the contents of a file in certain scenarios the end of the file will be reached in such scenarios a EOFException is thrown.

Especially, this exception is thrown while reading data using the Input stream objects. In other scenarios a specific value will be thrown when the end of file reached.

Example

Let us consider the DataInputStream class, it provides various methods such as readboolean(), readByte(), readChar() etc.. to read primitive values. While reading data from a file using these methods when the end of file is reached an EOFException is thrown.

import java.io.DataInputStream;
import java.io.FileInputStream;
public class EOFExample {
   public static void main(String[] args) throws Exception {
      //Reading from the above created file using readChar() method
      DataInputStream dis = new DataInputStream(new FileInputStream("D:data.txt"));
      while(true) {
         char ch;
         ch = dis.readChar();
         System.out.print(ch);
      }
   }
}

Runtime Exception

Hello how are youException in thread "main" java.io.EOFException
   at java.io.DataInputStream.readChar(Unknown Source)
   at SEPTEMBER.remaining.EOFExample.main(EOFExample.java:11)

Handling EOFException

You cannot read contents of a file without reaching end of the file using the DataInputStream class. If you want, you can use other sub classes of the InputStream interface.

Example

In the following example we have rewritten the above program using FileInputStream class instead of DataInputStream to read data from a file.

 Live Demo

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Scanner;
public class AIOBSample {
   public static void main(String[] args) throws Exception {
      //Reading data from user
      byte[] buf = " Hello how are you".getBytes();
      //Writing it to a file using the DataOutputStream
      DataOutputStream dos = new DataOutputStream(new FileOutputStream("D:data.txt"));
      for (byte b:buf) {
         dos.writeChar(b);
      }
      dos.flush();
      System.out.println("Data written successfully");
   }
}

Output

Data written successfully

Following is another way to handle EOFException in Java −

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.IOException;
public class HandlingEOF {
   public static void main(String[] args) throws Exception {
      DataInputStream dis = new DataInputStream(new FileInputStream("D:data.txt"));
      while(true) {
         char ch;
         try {
            ch = dis.readChar();
            System.out.print(ch);
         } catch (EOFException e) {
            System.out.println("");
            System.out.println("End of file reached");
            break;
         } catch (IOException e) {
         }
      }
   }
}

Output

Hello how are you
End of file reached

In this tutorial we will discuss about the EOFException in Java. This exception indicates the the end of file (EOF), or the end of stream has been reached unexpectedly. Also, this exception is mainly used by DataInputStreams, in order to signal the end of stream. However, notice that other input operations may return a special value upon the end of a stream, instead of throwing an EOFException.

The EOFException class extends the IOException class, which is the general class of exceptions produced by failed, or interrupted I/O operations. Moreover, it implements the Serializable interface. Also, it is defined as a checked exception and thus, it must be declared in a method, or a constructor’s throws clause.

Finally, the EOFException exists since the 1.0 version of Java.

The Structure of EOFException

Constructors

• EOFException()

Creates an instance of the EOFException class, setting null as its message.

• EOFException(String s)

Creates an instance of the EOFException class, using the specified string as message. The string argument indicates the name of the class that threw the error.

The EOFException in Java

DataInputStreams provide methods that can read primitive Java data types from an underlying input stream in a machine-independent way. An application writes data, by using the methods provided by the OutputStream class, or the DataOutputStream class.

Specifically, primitive types can be read by an application, using one of the following methods:

• readBoolean() – Reads one input byte and returns true if that byte is nonzero, false if that byte is zero.
• readByte() – Reads and returns one input byte.
• readChar() – Reads two input bytes and returns a char value.
• readDouble() – Reads eight input bytes and returns a double value.
• readFloat() – Reads four input bytes and returns a float value.
• readInt() – Reads four input bytes and returns an int value.
• readLong() – Reads eight input bytes and returns a long value.
• readShort() – Reads two input bytes and returns a short value.
• readUnsignedByte() – Reads one input byte and returns it as a zero-extended int value. The integer value resides in the range [0, 255].
• readUnsignedShort() – Reads two input bytes and returns them as an int value. The integer value resides in the range [0, 65535].

For a list of all available methods, take a closer look on the DataInputStream class.

The following example reads all characters from an input file:

EOFExceptionExample.java:

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class EOFExceptionExample {
	
	//The name of the input file.
	private final static String FILENAME = "input.txt";
	
	private static void writeToFile() throws IOException {
		DataOutputStream out = new DataOutputStream(new FileOutputStream(FILENAME));
		
		//Write a string to the stream.
		String str = "Hello from Java Code Geeks!";
		for(int i = 0; i < str.length(); ++i)
			out.writeChar(str.charAt(i));
		
		//Close the data stream.
		out.close();
		
		return;
	}
	
	public static void main(String[] args) {
		DataInputStream input = null;
		try {
			//Write some integers to the file.
			writeToFile();
			
			// Read all characters, until an EOFException is thrown.
			input = new DataInputStream(new FileInputStream(FILENAME));
			while(true) {
				char num;
				try {
					num = input.readChar();
					System.out.println("Reading from file: " + num);
				}
				catch (EOFException ex1) {
					break; //EOF reached.
				}
				catch (IOException ex2) {
					System.err.println("An IOException was caught: " + ex2.getMessage());
					ex2.printStackTrace();
				}
			}
		}
		catch (IOException ex) {
			System.err.println("An IOException was caught: " + ex.getMessage());
			ex.printStackTrace();
		}
		finally {
			try {
				// Close the input stream.
				input.close();
			}
			catch(IOException ex) {
				System.err.println("An IOException was caught: " + ex.getMessage());
				ex.printStackTrace();
			}
		}
	}
}

In this example we first, write a string to a file and then, use the readChar() method to read all written characters one-by-one.

A sample execution is shown below:

Reading from file: H
Reading from file: e
Reading from file: l
Reading from file: l
Reading from file: o
Reading from file:  
Reading from file: f
Reading from file: r
Reading from file: o
Reading from file: m
Reading from file:  
Reading from file: J
Reading from file: a
Reading from file: v
Reading from file: a
Reading from file:  
Reading from file: C
Reading from file: o
Reading from file: d
Reading from file: e
Reading from file:  
Reading from file: G
Reading from file: e
Reading from file: e
Reading from file: k
Reading from file: s
Reading from file: !

Once the EOFException is thrown, we only have to break from the reading loop and then, close the stream.

Download the Eclipse Project

This was a tutorial about the EOFException in Java.

Exception in thread «main» java.io.eofexception