EOFException - comment gérer?

Je suis un débutant programmeur java à la suite de la tutoriels java.

Je suis à l'aide d'un simple Programme Java à partir de la Tutoriels Java's Flux De Données De La Page, et au moment de l'exécution, il ne cesse de montrer EOFException. Je me demandais si cela était normal, que le lecteur doit venir à la fin du fichier par la suite.

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);
    }
}

Il compile bien, mais la sortie est:

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.

De la Tutoriels Java's Flux De Données De La Page, il dit:

Avis que les flux de données détecte une fin-de-fichier de l'état par la capture de EOFException, au lieu de tester pour une valeur invalide en retour. Toutes les implémentations de DataInput utilisation de méthodes EOFException au lieu des valeurs de retour.

Donc, est-ce à dire que la capture de EOFException est normal, donc il suffit de l'attraper et de la manipulation est très bien, ce qui signifie que la fin de fichier est atteinte?

Si cela signifie que je doit le manipuler, merci de me conseiller sur la façon de le faire.

MODIFIER

De la des suggestions, je l'ai résolu en utilisant in.available() > 0 pour la while condition de boucle.

Ou, je ne pouvais rien faire pour gérer l'exception, parce que c'est la fin.

Retrait de la e.printStackTrace(); dans le catch bloc de supprimer l'impression de l'exception de la trace de la pile. Au lieu de l'imprimer, vous devriez peut-être le journal.

OriginalL'auteur Jonathan Lam | 2013-08-26

  1. 20

    Lors de la lecture du fichier, vous n'êtes pas la fin de votre boucle. Donc sa lecture de toutes les valeurs et correctement jette EOFException sur la prochaine itération de la lire à la ligne ci-dessous:

     price = in.readDouble();

    Si vous lisez la documentation, il est dit:

    Jette:

    EOFException - si ce flux d'entrée atteint la fin avant de lire les huit octets.

    IOException - le flux a été fermé et le contenu du flux d'entrée ne prend pas en charge la lecture après la clôture, ou d'une autre I/O erreur se produit.

    Mettre un bon résiliation condition dans ta boucle while pour résoudre la question par exemple ci-dessous:

         while(in.available() > 0)  <--- if there are still bytes to read
    je l'ai juste essayé, et ça marche! merci
    Cette boucle de sortie quand il n'y a plus de données actuellement disponible pour la lecture, et pas juste à la fin du flux. InputStream.available() n'est pas un test pour la fin du flux. Voir la Javadoc.

    OriginalL'auteur Yogendra Singh

  2. 4

    La meilleure façon de gérer cela pourrait être de mettre fin à votre boucle infinie avec un bon état.

    Mais depuis que vous avez demandé pour la gestion des exceptions:

    Essayez d'utiliser deux prises. Votre EOFException est prévu, il semble donc y avoir aucun problème quand il se passe. Toute autre exception doivent être manipulés.

    ...
} catch (EOFException e) {
   //... this is fine
} catch(IOException e) {
    //handle exception which is not expected
    e.printStackTrace(); 
}
    c'est ce qu'ils ont fait dans le Flux de Données exemple. il travaille trop.

    OriginalL'auteur Martin Seeler

  3. 2

    Vous pouvez utiliser while(in.available() != 0) au lieu de while(true).

    hasNextLine() ne fait pas partie de DataInputStream. Cette réponse est fausse.
    Désolé! Je ne savais pas que l'. J'ai changé maintenant.
    Cette réponse est toujours mal. InputStream.available() n'est pas un test pour la fin du flux. Voir la Javadoc.

    OriginalL'auteur akaHuman

  4. 2

    Sinon, vous pouvez écrire le nombre d'éléments de la première (en-tête) à l'aide de:

    out.writeInt(prices.length);

    Lorsque vous lisez le fichier, vous devez d'abord lire l'en-tête (élément de comptage):

    int elementCount = in.readInt();

for (int i = 0; i < elementCount; i++) {
     //read elements
}
    oui, je pourrais l'utiliser, mais il serait plus pratique que @yogendra singh suggestion
    ouais, c'est pas sûr que ce soit (le fichier peut être vide, etc.), juste montré comme une alternative

    OriginalL'auteur Katona

  5. 0

    Vous attraper IOException qui attire aussi EOFException, parce que c'est héréditaire. Si vous regardez l'exemple de la tutoriel ils ont souligné que vous devez attraper EOFException - et c'est ce qu'ils font. Pour résoudre votre problème de capture EOFException avant IOException:

    try
{
    //...
}
catch(EOFException e) {
    //eof - no error in this case
}
catch(IOException e) {
    //something went wrong
    e.printStackTrace(); 
}

    À côté que je n'aime pas le contrôle du flux de données à l'aide d'exceptions - il n'est pas l'usage prévu des exceptions et donc (à mon avis) vraiment mauvais style.

    merci pour votre avis sur cette.
    C'est exactement la 'destination' pour son exception. Le problème avec votre "principe" est que les exceptions *sont " une forme de contrôle de flux.

    OriginalL'auteur Jost

  6. 0

    Mettre votre code à l'intérieur du bloc try catch:
    j'.e : 

    try{
  if(in.available()!=0){
    //------
  }
}catch(EOFException eof){
  //
}catch(Exception e){
  //
}
}

    OriginalL'auteur Sudarshan Nagre

  7. 0

    Vous pouvez trouver le code qui lit à partir d'un InputStream et utilise l'extrait de code
    while(in.available()>0) de vérifier pour la fin du flux, plutôt que de vérifier pour un
    EOFException (fin du fichier).

    Le problème avec cette technique, et la Javadoc fait écho à cela, c'est qu'il ne vous indique le nombre de blocs qui peuvent être lus sans bloquer l'appelant suivant. En d'autres termes, il peut return 0 même si il y a plus d'octets à lire. Par conséquent, la InputStream available() méthode ne doit jamais être utilisé pour vérifier la fin du flux.

    Vous devez utiliser while (true) et

    catch(EOFException e) {
//This isn't problem
} catch (Other e) {
//This is problem
}

    OriginalL'auteur Taleh Alqayev