BufferedReader - Startwert

  • Java

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • BufferedReader - Startwert

    Also ich wollte ein kleines Suchsystem mit Java bastellen, dass eine Textdatei nach einem Begriff durchsucht und die Zeile, in der der Begriff vorkommt ausgibt. Nun stehe ich vor folgendem Problem:
    Wenn ich meinen Code kompilieren will kommen diese Fehler:

    Quellcode

    1. ch = datei.read ();
    2. variable datei might not been initialized

    Quellcode

    1. datei.close ();
    2. variable datei might not been initialized

    Quellcode

    1. datei.close ();
    2. variable datei might not been initialized


    (datei ist meine Variable vom Typ Buffered Reader)

    Hier ist mein Code:

    Spoiler anzeigen

    Java-Quellcode

    1. import java.io.*;
    3. class InputTest
    4. {
    5. public static void main (String args[])
    6. {
    7. BufferedReader datei;
    8. FileReader fr;
    9. String zeile;
    10. int ch;
    11. String str = "";
    12. BufferedReader br = new BufferedReader (new InputStreamReader (System.in));
    13. System.out.print ("Bitte Suchbegriff eingeben: ");
    14. try
    15. {
    16. str = br.readLine();
    17. }
    18. catch (IOException exc)
    19. {
    20. System.out.println ("Fehler beim einlesen der Konsole!");
    21. }
    23. try
    24. {
    25. fr = new FileReader ("test.txt");
    26. datei = new BufferedReader (fr);
    27. }
    28. catch (FileNotFoundException exc)
    29. {
    30. System.out.println ("Datei konnte nicht gefunden werden!");
    31. }
    32. catch (IOException exc)
    33. {
    34. System.out.println ("Datei konnte nicht geöffnet werden!");
    35. }
    37. try
    38. {
    39. do
    40. {
    41. ch = datei.read ();
    42. zeile = datei.readLine ();
    43. if (zeile.indexOf (str) >0)
    44. {
    45. System.out.println (zeile);
    46. }
    47. }
    48. while (ch != -1);
    49. }
    50. catch (IOException exc)
    51. {
    52. System.out.println ("Dateifehler!");
    53. try
    54. {
    55. datei.close ();
    56. }
    57. catch (IOException exc2)
    58. {
    59. System.out.println ("Fehler. Datei wird geschlossen");
    60. }
    61. }
    63. try
    64. {
    65. datei.close ();
    66. }
    67. catch (IOException exc2)
    68. {
    69. System.out.println ("Fehler. Datei wird geschlossen");
    70. }
    71. }
    72. }
    Alles anzeigen


    Ich weiß, dass ich die Variable mit einem Startwert 'füllen muss', aber das habe ich doch in Zeile 26 getan!
    Was mache ich Falsch?
    Ich würde mich über eine schnelle Hilfe freuen!
    Viele Grüße, maxda

  • Du initialisierst 'datei' in einem try-Block, d.h. es kann vorkommen, dass die Datei niemals initialisiert wird, deshalb wird dir dein Compiler auch nen Fehler melden. Damit du kompilieren kannst musst du datei mit null initialisieren.
    Aber generell macht es wenig Sinn eine FileNotFoundException abzufangen und dann trotzdem mit der Datei weiter arbeiten zu wollen...
    Du solltest erst die Datei öffnen und dann abhängig davon ob datei == null ist weiter arbeiten oder eben nicht.

    Ausserdem kannst du die meisten catch-Klauseln noch zusammen fassen. Und das close() sollte unbedingt in die finally-Klausel.

  • Danke erstmal für die Antwort! Wenn ich das so mache:

    Spoiler anzeigen

    Java-Quellcode

    1. import java.io.*;
    3. class InputTest
    4. {
    5. public static void main (String args[])
    6. {
    7. //BufferedReader datei;
    8. BufferedReader datei=null;
    9. FileReader fr;
    10. String zeile;
    11. int ch;
    12. String str = "";
    13. BufferedReader br = new BufferedReader (new InputStreamReader (System.in));
    14. System.out.print ("Bitte Suchbegriff eingeben: ");
    15. try
    16. {
    17. str = br.readLine();
    18. }
    19. catch (IOException exc)
    20. {
    21. System.out.println ("Fehler beim einlesen der Konsole!");
    22. }
    24. try
    25. {
    26. fr = new FileReader ("test.txt");
    27. datei = new BufferedReader (fr);
    28. }
    29. catch (FileNotFoundException exc)
    30. {
    31. System.out.println ("Datei konnte nicht gefunden werden!");
    32. }
    33. catch (IOException exc)
    34. {
    35. System.out.println ("Datei konnte nicht geöffnet werden!");
    36. }
    38. if (datei!=null)
    39. {
    40. try
    41. {
    42. do
    43. {
    44. ch = datei.read ();
    45. zeile = datei.readLine ();
    46. if (zeile.indexOf (str) >0)
    47. {
    48. System.out.println (zeile);
    49. }
    50. }
    51. while (ch != -1);
    52. }
    53. catch (IOException exc)
    54. {
    55. System.out.println ("Dateifehler!");
    56. try
    57. {
    58. datei.close ();
    59. }
    60. catch (IOException exc2)
    61. {
    62. System.out.println ("Fehler. Datei wird geschlossen");
    63. }
    64. }
    66. try
    67. {
    68. datei.close ();
    69. }
    70. catch (IOException exc)
    71. {
    72. System.out.println ("Fehler. Datei wird geschlossen");
    73. }
    74. }
    75. }
    76. }
    Alles anzeigen
    dann gibt es 'ne NullPointerException, obwohl ich ja überprüft habe, ob datei den Wert null hat!

    Edit: Also die NullPointerException kommt in Zeile 46. ?(

  • Das liegt daran, dass die Methode readLine vom BufferedReader null zurückgibt wenn der Stream leer ist.
    Du müsstest also bevor du irgendwas mit 'zeile' machst nochmal prüfen ob zeile != null ist.
    Wenn ich deinen Code richtig verstehe versuchst du sowas mit 'ch' zuverhindern, problem ist nur, dass die Schleifen-Bedingung erst geprüft wird denn du schon mit dem gelesenen String arbeiten willst.

    Ich hab deinen Code mal etwas aufgeräumt, ist zwar immer noch nicht toll aber vll. hilft dir das:
    Spoiler anzeigen

    Java-Quellcode

    1. import java.io.*;
    2. import java.util.Scanner;
    4. class InputTest
    5. {
    6. public static void main (String args[]) throws IOException {
    8. //Scanner zum lesen von der Konsole, mag ich lieber als nen InputStream
    9. Scanner cin = new Scanner(System.in);
    11. String zeile = null;
    12. BufferedReader lesestrom = null;
    14. //Dateipfad einlesen
    15. System.out.println("Bitte Dateipfad eingeben:");
    16. String dateipfad = cin.nextLine();
    17. File datei = new File(dateipfad);
    19. try{
    20. //Lesestrom initialisieren, kann ne FileNotFoundException werfen
    21. lesestrom = new BufferedReader(new FileReader(datei));
    23. //Suchbegriff einlesen
    24. System.out.println("Bitte Suchbegriff eingeben:");
    25. String suchbegriff = cin.nextLine();
    27. //Den Stream durcharbeiten, kann eine IOException werfen
    28. while((zeile = lesestrom.readLine()) != null ){
    30. if (zeile.indexOf(suchbegriff) > 0){
    31. System.out.println(zeile);
    32. }
    34. }
    36. }catch(FileNotFoundException fnfe){
    37. System.out.println("Datei nicht gefunden.");
    38. fnfe.printStackTrace();
    40. }finally{
    41. lesestrom.close();
    43. }
    45. }
    46. }
    Alles anzeigen



    Die IOExceptions kannste abfangen, hab das aber der Bequemlichkeit wegen sein gelassen, sonst musst man noch zusätzlich nen try-Block um das close machen und sowas nervt.