Frage zur Effizienz von read und read(byte[])

[b1zarRe]

Hi,

ich habe eine grundlegende Frage zu der Methode read() bzw. read(byte[]) eines
FileInputStreams.

Verstehe ich es richtig, dass eine read(byte[]) Methode deshalb effizienter
ist, weil man mit dieser (und sinnvoller Puffergröße) weniger Zugriffe aus
den InputStream hat als mit einer read() Methode, welche
quasi immer Stück für Stück, also byte für byte, ausliest?


Ich hätte zudem noch eine andere Frage.... Eventuell ist
es Zeit schlafen zu gehen oder ein Bierchen zu trinken, aber ich verstehe folgendes nicht:

public class Bruch {
  private int zaehler;
  private int nenner;
  private final String BRUCHSTRICH = "/";

  public Bruch(int zaehler, int nenner) {
     if(nenner==0) {
       throw new IllegalArgumentException("Division durch 0 nicht erlaubt.");
     } else {
        //(...)
     }
  }
  //(...) Andere Methoden
}

Ich verstehe nun nicht, warum ich nicht gezwungen bin,
im Konstruktorkopf nach den Parametern ein "throws IllegalArgumentException" hinzuschreiben,
oder das ganze gleiche mit try und catch zu machen?
Liegt das daran, weil IllegalArgumentException eine UncheckedException ist und es
quasi eine Fehlerart ist, die man verhindern kann aus Programmiersicht? Und falls ja, wie?
Einfach prüfen ob nenner==0 und dann...?Falls ja, dann eine Meldung an den Benutzer geben?

Also doch mit try und catch? und im Catch fall eine Antwort an den Benutzer, korrekt?

 

[Gast2]

Zur ersten Frage:
Ja kann man so sagen. Wenn du 100 Kisten Bananen in die Nachbarstadt bringen müsstest, dann würdest du auch nicht jede Kiste einzeln rüber fahren, sondern gleich 20 Stück in dein Auto packen und nen paar mal weniger fahren

Zur zweiten Frage:
IllegalArgumentException erbt von RuntimeException, und die müssen nicht zwingend per try-catch behandelt werden.

 

[Firephoenix]

Die eine read-Methode scheint aber die andere zu verwenden (ist allerdings wirklich etwas spät )
java.io: InputStream.java

Gruß

 

[b1zarRe]

Das ist ja nicht schlimm und auch nicht die Frage gewesen - Aber danke.
danke @ EikeB

Noch eine Frage:
Ich soll zeigen(ja das geht mehr in Richtung Hausaufgaben Board... aber ist nunmal jetzt hier und passt
zu der 2. Frage), dass wenn eine Exception im Konstruktor auftritt, eine Klasse nicht erzeugt werden muss.

import java.util.ArrayList;

/**
 */
public class eineException {
    private int zahl;
    
    public eineException(int zahl) {
        
        try {
        if(zahl==1) {
            throw new IllegalArgumentException("Diese Zahl bitte nicht.");
        } else {
            this.zahl = zahl;
        }
        } catch(IllegalArgumentException e) {}
    }
    
    public static void main(String[] args) {
        eineException a = new eineException(1);
        eineException b = new eineException(1);
        
        System.out.println(null==a);
        System.out.println(a==b);
        System.out.println(a.equals(b));
}
}

Ich hatte nun gehofft, dass einfach als Ausgabe mit a==null oder
a==b false herauskommt, mit der Begründung, dass ein Fehler geworfen wird
und somit die Instanz nicht erzeugt wird...
Kann man das überhaupt zeigen meines Erachtes nicht:

/**
 */
public class eineBessereException {
    
    public eineBessereException(String pfad) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(pfad);
    }
    
    public static void main(String[] args) throws FileNotFoundException {
        eineBessereException a = new eineBessereException("C:\\123.txt");
        System.out.println(a==null);
    }
}

Der letzte SOUT wird ja auch nichtmehr ausgegeben, sprich: Ich habe keine Chance
mehr zu schauen, ob die Variable a eine Instanz referenziert... oder fällt euch noch was ein?

 

[Gast2]

Ich soll zeigen [...], dass wenn eine Exception im Konstruktor auftritt, eine Klasse nicht erzeugt werden muss.

Höö ???:L Was meinst du damit, der Satz ist für mich unverständlich.

Der Code macht ebenfalls keinen Sinn. Das try-catch Konstrukt mit der Exception drin sorgt nur dafür dass die Instanzvariable zahl nicht gesetzt wird (, und damit den Standardwert 0 behält).

 

[b1zarRe]

Siehe 2. Beispiel.

Ich soll halt zeigen bzw. "mir selbst klar machen", dass wenn im Konstruktor eine Ausnahme auftritt,
welche nicht gefangen wird(deshalb 2. Beispiel), dass kein Objekt erzeugt wurde.

 

[Firephoenix]

...welche nicht gefangen wird...

public eineException(int zahl) {
        
        try {
        if(zahl==1) {
            throw new IllegalArgumentException("Diese Zahl bitte nicht.");
        } else {
            this.zahl = zahl;
        }
        } catch(IllegalArgumentException e) {}
    }

du fängst sie doch im Konstruktor ???:L

Ich denke mal gemeint ist folgender Fall: wird im Konstruktor eine Exception geworfen wird kein neues Objekt erzeugt (dann darf man die Exception aber nicht im Konstruktor fangen)

Gruß

 

[b1zarRe]

Jau ich habs jetzt, danke euch:

public class eineBessereException {
    
    public eineBessereException(String pfad) throws FileNotFoundException {
        FileInputStream fis = new FileInputStream(pfad);
    }
    
    public static void main(String[] args)  {
        eineBessereException a = null;
        try {
        a = new eineBessereException("C:\\123.txt");
        } catch(Exception e) {
            System.out.println(a==null);
        }
        
    }
}

Nee, stimmt ja nicht... das ergibt nur true weil ich vorher
als null initialisiert hab.... mhh irgendwie muss ich das doch zeigen
können.

 

[Gast2]

Wenn eine Exception auftritt und die nicht gefangen wird, dann läuft der Code nicht weiter. Die Exception wird soweit nach oben gereicht bis entweder nen try-catch kommt oder die JVM die Exception sieht, dann wird das Programm gestoppt und die Meldung ausgegeben.
Deine Ausgabe wird im Fall einer Exception also nie ausgeführt.

Dein Problem wird mit dadurch aber auch nicht klarer. Bei nem Konstruktoraufruf kann nur folgendes passieren: Entweder es wird eine Instanz erstellt oder es fliegt eine Exception. Aber das plötzlich null oder ähnliches zurückgegeben wird kann nicht sein.

 

[b1zarRe]

@EikeB
Nunja, ich dachte, wenn ich eine Exception in dem Konstruktor werfe, und
diese erst "später" abfange und dann eine Instanz prüfe ob sie ==null ist, dann
hätte ich gezeigt, dass die Variable der Klasse auf nichts referenziert und somit
keine neue Instanz erzeugt wurde.

 

[Firephoenix]

@EikeB
Nunja, ich dachte, wenn ich eine Exception in dem Konstruktor werfe, und
diese erst "später" abfange und dann eine Instanz prüfe ob sie ==null ist, dann
hätte ich gezeigt, dass die Variable der Klasse auf nichts referenziert und somit
keine neue Instanz erzeugt wurde.

Sollte so eigentlich auch passen

 

[Spacerat]

Wenn innerhalb eines Konstruktors eine Exception auftritt, resultiert diese meist (evtl. immer?) aus übergebenen Parametern. Diese Exception kann man abfangen und stattdessen eine IllegalArgumentException werfen. Die Instanz wird dann nicht erzeugt.
Dein Code macht deswegen, wie EikeB schon sagt, auch keinen Sinn. Du fängst die geworfene Exception ja gleich wieder ab. Erstens, wieso wirfst du sie dann und zweitens wird das Objekt dadurch trotzdem instanziert (wg. mit std. 0).
[EDIT]...und zu langsam... doch schon so spät ja?[/EDIT]
[EDIT]Aber da fehlt noch 'ne Ergänzung zum InputStream. Afaik ist das implementationsabhängig. Das Lesen einzelner Bytes würde auf Dateien tatsachlich ja nicht den geringsten Sinn ergeben. Eben wegen dem Beispiel mit den "kühlen Blonden" (oder waren's doch Bananen?).[/EDIT]

 

[b1zarRe]

@SpaceRat
" Diese Exception kann man abfangen und stattdessen eine IllegalArgumentException werfen. Die Instanz wird dann nicht erzeugt."
- Ich glaube Du meintest, diese NICHT abfangen und dann wird keine Instanz erzeugt, korrekt? Sonst wären
deine nächsten Sätze unschlüssig....?

@Firephoenix
Nur wie kann ich das hinbekommen?
Also ich versuchs nochmal zu erläutern: Ich möchte einen Fehler im Konstruktor erzeugen, welcher zur Folge
hat, dass ein Objekt der Klasse nicht erzeugt wird. (Und somit müsste die Variable in dem das Objekt
gelandet wäre, ja "null" beinhalten... => die Variable == null müsste dann true ergeben).

Nur wie kann ich das umsetzen? Geht das überhaupt?

 

[Gast2]

public class Test {
  public Test() {
    throw new IllegalArgumentException();
  }
  
  public static void main(String[] args) {
    Test test = null;
    try {
      test = new Test();
    } catch (IllegalArgumentException e) {}
    System.out.println(test);
  }
}

 

[F.S.WhiTeY]

Moin,


lass dich doch nicht kirre machen. Dein letztes Code-Snipped ist doch richtig!
Du kannst da fünf mal vorher a mit null refferenzieren das macht überhaupnichts!

Probier mal folgendes aus, nur zum Verständniss:

 public static void main(String[] args) {

     String a = null;
     System.out.println(a);
     String a = "1";
     System.out.println(a);
     String a = null;
     System.out.println(a);
     String a = "2";
     System.out.println(a);
     String a = null;
     System.out.println(a);


}

Was ist da die Ausgabe?

Ich sag es dir, ohne kompiliert zu haben:
null
1
null
2
null

Also macht deine vorheriges a = null mal garnix

Das hier wäre allerdings die methode wie ich es machen würde um sicher zu gehen

public class eineBessereException {
    
    public eineBessereException(boolean testException) throws NullPointerException {
        if(testException){
         throw new NullPointerException("Exception wurde geworfen!");
        }else{
        System.out.println("Instanz wurde erstellt!")
        }
    }
    
    public static void main(String[] args)  {
        eineBessereException a = null;

        try {
        a = new eineBessereException(true);
        } catch(Exception e) {
               e.printStackTrace();
        }finally{
           System.out.println(null==a);
        }
        
        try {
        a = new eineBessereException(false);
        } catch(Exception e) {
               e.printStackTrace();
        }finally{
           System.out.println(null==a);
        }
        
    }
}

[WR]
Ich habe den ganzen Code aus dem kopf und ohne IDE geschrieben, also könnte er nicht kompilierbar sein. Er sollte es aber eigentlich sein!
[/WR]

Edit: Er hätte doch nicht kompiliert, ich habe da mal ein paar ; und } hinzugefügt

 

[Spacerat]

Wieso unschlüssig?
Mir ging es im Prinzip nur darum, dass, sofern sie im Konstruktor auftreten, man aus checked Expeptions eine unchecked Exception macht.

class Test {
  Test() {
    try {
      //...Code which throws an Exception
    } catch(Exception e) {
      throw new RuntimeException("test couldn' t be initialised");
    }
  }
}

Sowas tut man, um den Aufrufer nicht mit der Notwendigkeit zu traktieren, eine checked Exception fangen oder weiterreichen zu müssen. Die Alternative wäre

class Test {
  Test() throws Exception {
    // code which throws an Exception
  }
}

Die IllegalArgumentException ist bereits eine unchecked Exception. An Stellen, wo man selber eine solche wirft, macht es keinen Sinn, sie gleich wieder abzufangen.

 

[F.S.WhiTeY]

spacerat ich glaube der sinn einer geworfenen exception ist dem to bewusst, jedoch nicht deine logik. das was du sagst ist natürlich schlüssig, ich glaube nur der to ist derzeit nochj damit überfordert.

lass ihn noch ein wenig rumspielen und auch mal seine eigenen exceptions implementiert haben, dann kommt er auch dahinter was du meinst

[OT]
und sonst so ? was lässt dich um diese Uhrzeit noch im java-forum rumtoben ?
[/OT]

 

[Spacerat]

[OT]

und sonst so ? was lässt dich um diese Uhrzeit noch im java-forum rumtoben ?

Mal überlegen... Koffeinmangel ist's jedenfalls nicht. Evtl. Schlaflosigkeit oder Wochenende?[/OT]

 

[b1zarRe]

@F.S.WhiTeY
Jau, deine Methodik kommt meiner Nahe. ABER ich gehe davon aus,
dass wenn ich etwas mit null initialisiere und dann ein try versuche,
wo eine Exception geworden wird, quasi genau diese Zeile nichtmehr weiter
bearbeitet wird. Somit "a = new eineBessereException(false);" (wg. Exception)
korrekt ausgeführt wird und somit immernoch "a=null" zählt und nur deswegen
null==a //true ausgeben wird.... :/

Dein Beispiel mit den Strings hat keine Exceptions und somit auch nicht diese Problemstellung.

- Und bin noch hier... weil ich für ne Prüfung in 2 Wochen lerne


@EikeB
das is doch wie mein Code nur umgeformt, oder?

 

[F.S.WhiTeY]

[OT]
naja wochenende ist ja keine begründung mit pattköppen wie mir hier um 3am ot zu erzeugen. schlaflosigkeit hingen ist scho ein besserer grund
[/OT]

 

[F.S.WhiTeY]

@F.S.WhiTeY
Jau, deine Methodik kommt meiner Nahe. ABER ich gehe davon aus,
dass wenn ich etwas mit null initialisiere und dann ein try versuche,
wo eine Exception geworden wird, quasi genau diese Zeile nichtmehr weiter
bearbeitet wird. Somit "a = new eineBessereException(false);" (wg. Exception)
korrekt ausgeführt wird und somit immernoch "a=null" zählt und nur deswegen
null==a //true ausgeben wird.... :/

Dein Beispiel mit den Strings hat keine Exceptions und somit auch nicht diese Problemstellung.

- Und bin noch hier... weil ich für ne Prüfung in 2 Wochen lerne


@EikeB
das is doch wie mein Code nur umgeformt, oder?

sry wenn ich nun deutlich werde aber hast du genau so viel sangria intus wie ich?
nun verstehe ich nämlich garnichtmehr was du willst

zur erklärung: eine variable ist immer dann null, wenn sie mit null initialisiert wird oder einfach nur deklariert wurde.
da sie in deinem try nicht initialisiertt werden kann, im falle der exc, bleibt sie null. danach ist sie es nicht mehr, weil keine exc.

edit: das war nun wirklich nicht patzig gemeint nur um missverständniss zu vermeiden

edit edit: also eigentlich ist a=null oder einfach nur datebtyp a; fast das selbe, auf jeden fall beides null.

 

[Spacerat]

Also eigentlich steht das einzig Richtige ja schon im Eingangspost des TO:

public class Bruch {
  private final int zaehler, nenner;

  Bruch(int zaehler, int nenner) {
    if(nenner == 0) {
      throw new IllegalArgumentException("nenner darf nicht 0 sein");
    }
    this.zaehler = zaehler;
    this.nenner = nenner;
  }

  double toDecimal() {
    return zaehler / (double) nenner;
  }

  public static void main(String[] args) {
    Bruch b;
    try {
      b = new Bruch(1, 2);
      System.out.println(b.toDecimal());
      b = new Bruch(1, 5);
      System.out.println(b.toDecimal());
      b = new Bruch(1, 0); // wirft Exception, b bleibt unveraendert
      System.out.println(b.toDecimal()); // wird nicht ausgegeben, weil eine Exception geworfen wird.
    } catch(Exception e) { // alle Exceptions (inkl. IllegalArgumentException) werden abgefangen.
      e.printStackTrace(); // wenn man schon rigoros alles abfaengt, sollte man den Fehler zumindest ausgeben.
      // Zeigt das b durch die Exception nicht verändert wurde.
      System.out.println(b.toDecimal()); 
    }
//  System.out.println(b.toDecimal()); // ergaebe einen Compilerfehler weil b nicht initialisiert wurde.
    // auskommentiert, damit KSKB funktioniert.
  }
}

@F.S.Whitey: Wenn ein Objekt nur deklariert wurde ist es nicht null sondern uninitialised, das hat dann immer einen Compilerfehler zur Folge. Bevor ein Objekt verwendet werden kann muss zwangsläufig ein Wert zugewiesen werden, dieser Wert darf auch null sein.
[EDIT]Ach ja... Schluss mit aus der Rolle fallen, lieber in die Falle rollen. [/EDIT]

 

[F.S.WhiTeY]

@F.S.Whitey: Wenn ein Objekt nur deklariert wurde ist es nicht null sondern uninitialised, das hat dann immer einen Compilerfehler zur Folge. Bevor ein Objekt verwendet werden kann muss zwangsläufig ein Wert zugewiesen werden, dieser Wert darf auch null sein.

Nicht ganz richtig, das gilt nur wenn du die variable innerhalb der methode deklarierst. Klassenvariablen werden vorinitialisiert. Das macht der Compiler für uns, wenn wir zu faul sind es selber zu machen

Innerhalb der Methode hast du allerdings recht, das würde nicht kompiliert werden.

folgender code ist KSKB

public class eineBessereException {
    
    static eineBessereException a;

    public eineBessereException(boolean testException) throws NullPointerException {
        if(testException){
         throw new NullPointerException("Exception wurde geworfen!");
        }else{
        System.out.println("Instanz wurde erstellt!")
        }
    }
    
    public static void main(String[] args)  {
        
            System.out.println(null==a);
           System.out.println(a);
        
    }
}

[EDIT]
Ich kann nicht mehr rollen, trägst du mich ?
[/EDIT]

 

[Firephoenix]

...
@EikeB
das is doch wie mein Code nur umgeformt, oder?

Der einzige Unterschied sollte sein, das deine Ausgabe true ergibt ( a == null) und Eikes variante "null" ausgibt ( a direkt ausgegeben).
Wie schon gesagt wurde, dein Code ist völlig in Ordnung und du zeigst damit genau das was du willst: nämlich das eine Exception die aus dem Konstruktor fliegt dazu führt, dass kein neues Objekt erzeugt wird (weil der Methodendurchlauf im Konstruktor durch die Exception abgebrochen wird). Dadurch ist die Objektreferenz die du initialisieren wolltest auch noch null und genau darauf prüft deine Ausgabe - also alles ok so.

Wie man dabei mit checked oder unchecked-Exceptions umgeht sollte hier eh erstmal egal sein, das ist eher eine Stilfrage, der Effekt bleibt aber identisch.
Gruß