refactoring mit stream

guguli

Bekanntes Mitglied
Hallo,

ich möchte gerne durch Anwendung von java8 stream meinen Code etwas refactorn.

So das ist mein Code jetzt:

Code:
List<BaumElementDTO> baum = new ArrayList<>();
ErklaerungList<?> elist = ErklaerungList.create(fall.getErklaerungenAlle());
for (Gruppe<ByArtPersG> groupArtPersG : elist.groupByJahr().erklaerungen(jahr).groupByStichtagArt()
               .erklaerungen(sa).groupByArtPersG()) {
        if (groupArtPersG.merkmal().isGesellschafter()) {
               BaumKnotenDTO letzteWurzel = new BaumKnotenDTO("Gesellschaft",
                       groupArtPersG.merkmal().getArtPersG());
               baum.add(letzteWurzel);
       }
}


das hier ist ein teil davon, und die die Methoden der Klassen "ErklaerungListund", "Gruppe" sollten durch Anwendung von Stream aus ihren Klassen verschwinden, sodass diese Klassen gelöscht werden können.

Kann mir einer dabei helfen?
Danke
 

mrBrown

Super-Moderator
Mitarbeiter
Wenn ich richtig verstehe, möchtest du z.B. diese Methodenaufrufe: elist.groupByJahr().erklaerungen(jahr).groupByStichtagArt().erklaerungen(sa).groupByArtPersG() durch sinnvolle Anwendung von Streams ersetzen?



Vielleicht ist es auch einfacher, wenn du einmal völlig unabhängig von Code erklärst, was der Algorithmus machen soll?
 

MoxxiManagarm

Top Contributor
Best guess

Java:
List<BaumElementDTO> baum = ErklaerungList.create(fall.getErklaerungenAlle()).stream()
.filter(element -> element.getJahr() == jahr)
.filter(element -> element.getStichArt().equals(sa))
.filter(element -> element.merkmal().isGesellschafter())
.sort(Comparator.comparing(Erklaerung::getArtPersG))
.map(element -> new BaumKnotenDTO("Gesellschaft", element.merkmal().getArtPersG()))
.collect(Collectors.toList());
 

guguli

Bekanntes Mitglied
Wenn ich richtig verstehe, möchtest du z.B. diese Methodenaufrufe: elist.groupByJahr().erklaerungen(jahr).groupByStichtagArt().erklaerungen(sa).groupByArtPersG() durch sinnvolle Anwendung von Streams ersetzen?

genau, und ich möchte durch die Anwendung geeignten stream methoden wie groupingby sowas wie
Code:
.groupByJahr().erklaerungen(jahr).groupByStichtagArt().erklaerungen(sa).groupByArtPersG()
auflösen.
 

guguli

Bekanntes Mitglied
Klassen wie GruppeList, ErklaerungList und Gruppe sind hilfsklassen, die wurden vor java 8 verwendet, die Hoffnung ist, diese mittels Stream Methoden aufzulösen.
 

mrBrown

Super-Moderator
Mitarbeiter
Du bist lustig - du musst die natürlich an die vorhandenen Methoden (die du uns ja nicht gezeigt hast) anpassen. Wenn man nach Jahr gruppieren kann, wird man ja irgendwie dran kommen
 

guguli

Bekanntes Mitglied
aso, in der Klasse ByJahr ist eine Methode "gruppiere": wie folgt implementiert:

Code:
public final class ByJahr {
   private ByJahr() {  
   }  
   public static SortedMap<Integer, List<Erklaerung>> gruppiere(List<Erklaerung> erklaerungen) {    
       List<Erklaerung> erklaerungenCpy = new ArrayList<>(erklaerungen);
       SortedMap<Integer, List<Erklaerung>> erklaerungenNachJahr = new TreeMap<>(Collections.reverseOrder());
       Collections.sort(erklaerungenCpy, Collections.reverseOrder(Erklaerung.SORT_BY_STICHDATUM_EINGANG));     
        for(Erklaerung erklaerung : erklaerungenCpy){
           int jahr = DateUtil.getJahr(erklaerung.getHeader().getStichdatum());
           List<Erklaerung> erklaerungenFuerEinJahr = erklaerungenNachJahr.get(jahr);
           if(erklaerungenFuerEinJahr==null){
               erklaerungenFuerEinJahr = new ArrayList<>();
               erklaerungenNachJahr.put(jahr, erklaerungenFuerEinJahr);
           }
           erklaerungenFuerEinJahr.add(erklaerung);
        }
       return erklaerungenNachJahr;
   }
}

wie kann ich .filter(element -> element.getJahr() == jahr) anpassen?
 

guguli

Bekanntes Mitglied
für "stichTagArt" gibt es in der Klasse "ErklaerungList<T>" folgende Methoden:
Java:
public GruppeList<ByStichtagArt> groupByStichtagArt() {
       SortedMap<ByStichtagArt, List<Erklaerung>> erklaerungenStichtagArt = ByStichtagArt.gruppiere(this);
       return new ErklaerungList<ByStichtagArt>(erklaerungenStichtagArt).groups();
   }

public GruppeList<T> groups() {
       GruppeList<T> result = new GruppeList<>();
       for (Entry<T,List<Erklaerung>> entry : groupByT.entrySet()) {
           result.add(new Gruppe<T>(entry.getKey(), new ErklaerungList<>(entry.getKey(), entry.getValue())));
       }
       return result;
   }


und in der Klasse "ByStichtagArt" folgende Methode
Java:
public static SortedMap<ByStichtagArt, List<Erklaerung>> gruppiere(List<Erklaerung> erklaerungenByJahr) {
       SortedMap<ByStichtagArt, List<Erklaerung>> result = new TreeMap<>();

       // group list elements
       for (Erklaerung erklaerung : erklaerungenByJahr) {
           // this is the grouping criteria
           ByStichtagArt key = new ByStichtagArt(erklaerung.getHeader().getStichdatumDisplay(),
                   erklaerung.getHeader().getBilanzart());

           // fetch elements of the group
           List<Erklaerung> bilsOfYear = result.get(key);

           if (bilsOfYear == null) {
               // no elements found
               // create new element for year and put it into result
               bilsOfYear = new ArrayList<>();
               result.put(key, bilsOfYear);
           }

           bilsOfYear.add(erklaerung);
       }

       return result;
   }


wie kann ich nun das für StichtagArt anpassen?
 
Zuletzt bearbeitet von einem Moderator:

Oneixee5

Top Contributor
Es sieht als würdest du mit JPA arbeiten und du versuchst neue Objekte per Liste zu erstellen und in die DB einzufügen. Warum machst du nicht einfach
Insert into ... Select... und lässt dieses ganze inperformate Objektkegelei sein?
 

mrBrown

Super-Moderator
Mitarbeiter
Es sieht als würdest du mit JPA arbeiten und du versuchst neue Objekte per Liste zu erstellen und in die DB einzufügen. Warum machst du nicht einfach
Insert into ... Select... und lässt dieses ganze inperformate Objektkegelei sein?
Wie kommst du da auf JPA? o_O
Das ist doch ein ganz einfacher Fall von "ich habe eine Liste und möchte bestimmte Elemente daraus"...
 

guguli

Bekanntes Mitglied
Es sieht als würdest du mit JPA arbeiten und du versuchst neue Objekte per Liste zu erstellen und in die DB einzufügen. Warum machst du nicht einfach
Insert into ... Select... und lässt dieses ganze inperformate Objektkegelei sein?
Nein das ist kein JPA. @mrBrown hat recht.
Ich möchte das ganze mittels stream umschreiben. Das finde ich aber nicht so einfach.
 

mrBrown

Super-Moderator
Mitarbeiter
Ich möchte das ganze mittels stream umschreiben. Das finde ich aber nicht so einfach.
Es geht, aber das ganze so häppchenweise zu sehen macht es für helfende etwas schwerer...


Möglicherweise ist es einfacher, die Anforderung einmal Normalsprachlich zu formulieren und dann neu mit Streams umzusetzen, ohne den alten Code zu refactoren.

Ansonsten: Zieh aus den Methoden die Bedingungen raus, damit ist dann schon mal ein vernünftiger Anfang gemacht.
 

guguli

Bekanntes Mitglied
Das GroupBy-Zeug wird anscheinend ja nur zum Filtern verwendet, d. h. Du kannst alles einfach durch filter() ersetzen. In dem Fall werden einfach zwei Werte benötigt:
erklaerung.getHeader().getStichdatumDisplay() und erklaerung.getHeader().getBilanzart().

Ich hab das so gemacht, bekomme aber eine fehlermeldung:
Code:
.filter(element -> new ByStichtagArt(element.getHeader().getStichdatumDisplay(), element.getHeader().getBilanzart()))

Type mismatch: cannot convert from ByStichtagArt to boolean

ich muss das irgendwie ohne die klasse ByStichtagArt machen oder ?!
 

mihe7

Top Contributor
Müssen tust Du gar nichts :)

Du hast zum Vergleich "sa" gegeben - von welchem Typ ist der und wie sieht der Typ aus?
 

MoxxiManagarm

Top Contributor
Was ich aus den Häppchen weiß...
Es gibt eine Klasse, die Beispielsweise Fall heißt, diese besitzt eine Liste an Erklaerungen.
Code:
------------------------------------------------
Fall
------------------------------------------------
- erklaerungen: List<Erklaerung>
------------------------------------------------
+ getErklaerungenAlle(): List<Erklaerung>
------------------------------------------------

Eine Erklaerung hat mindestens einen Header
Code:
------------------------------------------------
Erklaerung
------------------------------------------------
- header: Header
------------------------------------------------
+ getHeader(): Header
------------------------------------------------

Und der Header hat vermutlich mindestens das:
Code:
------------------------------------------------
Header
------------------------------------------------
- stichdatum: Date
- bilanzart: String
------------------------------------------------
+ getStichdatumDisplay(): String
+ getBilanzart(): String
------------------------------------------------

Wobei das Display vermutlich nur eine StringFormatierung des Datums ist und Bilanzart auch nochmal irgendeine andere Klasse oder Enum etc sein könnte.

Was noch nicht bekannt ist sind die Merkmale mit den Gesellschaftern.

Du möchtest die Liste der Erklärungen eines Falls...
1. Nach dem Jahr der Erklärung filtern
2. Nach Stichtagart filtern, was eine Verknüpfung aus dem Displaywert und der Bilanzart ist.
3. Nach dem Merkmal Gesellschafter filtern

Hier ein mein Best Guess ein bissl angepasst:
Java:
List<BaumElementDTO> baum = fall.getErklaerungenAlle().stream()
.filter(erklaerung -> DateUtil.getJahr(erklaerung.getHeader().getStichdatum()) == jahr)
.filter(erklaerung -> erklaerung.getHeader().getStichdatumDisplay.equals(display))
.filter(erklaerung -> erklaerung.getHeader().getBilanzart().equals(art))
.filter(erklaerung -> erklaerung.getMerkmal().isGellschaft())
.map(erklaerung -> new BaumKnotenDTO("Gesellschaft", erklaerung.merkmal().getArtPersG()))
.collect(Collectors.toList());

Und ganz nebenbei war die ganze Sache auch schon vor Java 8 umständlicher als nötig.
 

guguli

Bekanntes Mitglied
danke @MoxxiManagarm das geht glaube ich in richtigen Richtung, ich poste jetzt den kompletten Methode. Die For schleife muss sozusagen durch stream ersetzt werden.

Code:
public HoleBilanzResponseDTO run(HoleBilanzRequestDTO request) {
       Long erklId = request.getErklId();
       this.zusatzKnotenOptional = request.getKontext() == null ? null : request.getKontext().getZusatzKnoten();

       Fall fall = EBContext.get().getFall(erklId);

       Erklaerung erklaerung = fall.getHauptErklaerung();
       HoleBilanzResponseDTO result = new HoleBilanzResponseDTO();
       result.setErklId(erklId);

       // Bereite Vorjahrevorhandenmerker auf
       String vorjahre = "";
       for (Erklaerung vorjahr : erklaerung.getVorjahre()) {
           if (vorjahr == null) {
               vorjahre = vorjahre.concat("2");
           } else {
               vorjahre = vorjahre.concat("1");
           }
       }

       // Bereite WeitereStichtagemerker auf
       boolean hatWeitereStichtage = erklaerung.getHatWeitereStichtage();
       BaumDisplayer bilanzDisplayer = new BaumDisplayer(erklaerung, vorjahre, hatWeitereStichtage,
               zusatzKnotenOptional);

       List<BilanzElementDTO> bilanzElemente = bilanzDisplayer.display();

       if (fall.isVersionskonfliktErklaerungen()) {
           throw new EBException(fall.getVersionskonfliktErklaerungenFehlertext());
       }

       EBContext.get().setSelectedErklId(request.getErklId());
       if ("ab".equals(request.getReihenfolgeVJ())) {
           EBContext.get().setStichtagAbsteigendSortieren(true);
       }

       String stichtagString = erklaerung.getHeader().getStichdatumDisplay();

       String arbeitsbereich = erklaerung.getHeader().getArbeitsbereich();

       // Titel erstellen
       result.setName(erklaerung.getHeader().getName());
       result.setGesellschaftsform(fall.getGesellschaftsform().getName());
       // String stnr = EBContext.get().getSteuernummer();

       result.setSteuernummer(fall.getBezeichnerStnr());
       result.setFenstertitel(
               " " + ((arbeitsbereich == null || arbeitsbereich.isEmpty()) ? "" : ("/ " + arbeitsbereich + " "))
                       + erklaerung.getHeader().getName() + " - E-Bilanz " + stichtagString);

       BilanzartSteuerlich bilanzartSteuerlichEnum = erklaerung.getHeader().getBilanzartSteuerlich();
       if (bilanzartSteuerlichEnum != null) {
           result.setArtpersg(bilanzartSteuerlichEnum.getValue());
       }

       // Bei Personengesellschaften sind ggf. vorhandene Sonder-/
       // Ergänzungsbilanzen
       // (für Gesellschafter 1..n) anzuzeigen:
       List<BaumElementDTO> baumSonderErgaenzBil = new ArrayList<>();
       String stichtag = StichtagUtil.dateToAufbereitetString(erklaerung.getHeader().getStichdatum());
       Integer jahr = erklaerung.getHeader().getStichdatum().getYear() + 1900;
       ByStichtagArt sa = new ByStichtagArt(stichtag, erklaerung.getHeader().getBilanzart());

       ErklaerungList<?> elist = ErklaerungList.create(fall.getErklaerungenAlle());
       for (Gruppe<ByArtPersG> groupArtPersG : elist.groupByJahr().erklaerungen(jahr).groupByStichtagArt()
               .erklaerungen(sa).groupByArtPersG()) {
           // Nur wenn Sonder-/Ergänzungsbilanz :
           if (groupArtPersG.merkmal().isGesellschafterSonderErgaenzungsbilanz()) {
               BaumKnotenDTO letzteWurzel = new BaumKnotenDTO("Gesellschaftergruppe",
                       groupArtPersG.merkmal().getArtPersG());
               baumSonderErgaenzBil.add(letzteWurzel);
               // Gesellschafterschleife :
               for (Gruppe<ByGesellschafterUndArtPersG> groupGesellschafterArtPersG : groupArtPersG.erklaerungen()
                       .groupByGesellschafterUndArtPersG()) {
                   String gesLabel = groupGesellschafterArtPersG.merkmal().getLabel();
                   BaumKnotenDTO gesellschafterWurzel = new BaumKnotenDTO("Gesellschafternr", gesLabel);
                   letzteWurzel.addElement(gesellschafterWurzel);
                   // Bilanz-Schleife
                   for (Erklaerung e : groupGesellschafterArtPersG.erklaerungen().sortByEingangsdatum()) {
                       gesellschafterWurzel.addElement(new BaumBlattDTO(e));
                   }
               }
           }
       }

       BaumElementDTO root;
       if (erklaerung.getHeader().isGesamthandsbilanz()) {
           root = new BaumKnotenDTO("ArtPersG", BilanzartSteuerlich.GESAMTHANDSBILANZ.getValue());
           BaumBlattDTO bb = new BaumBlattDTO(erklaerung);
           ((BaumKnotenDTO) root).addElement(bb);
           bb.getChildren().addAll(bilanzElemente);
           result.getBaumelemente().add(root);
           result.getBaumelemente().addAll(baumSonderErgaenzBil);
       } else {
           root = new BaumBlattDTO(erklaerung);
           root.getChildren().addAll(bilanzElemente);

           result.getBaumelemente().add(root);
       }

       // Ist die Erkl von jmd. anders bereits in Bearbeitung?
       KontextDTO kontext = (KontextDTO) EBContext.get().getAufrufkontext();
       if (kontext != null && kontext.isBearbeitungEnabled() && kontext.getAufrufquelle() == Aufrufquelle.EBBearbeitung
               && kontext.isBearbeitungAbgelehnt(erklId)) {
           NachrichtDTO nachricht = new NachrichtDTO();
           SperreDTO s = kontext.getSperre(erklId);
           nachricht.setText("EBilanz nur lesende Anzeige möglich.\n" + (s == null ? "" : s.getHinweistext()));
           nachricht.setTyp(NachrichtTyp.HINWEIS);
           result.setNachricht(nachricht);
       }

       return result;
   }

getHeader ist in der klasse Erklearung und gibt ein Objekt der Klasse Heaser zurück.

Die kLasse Erklearung liste ist wie folgt:
Code:
public class ErklaerungList<T> extends ArrayList<Erklaerung> {

   private static final long serialVersionUID = 1L;
   private SortedMap<T, List<Erklaerung>> groupByT=  new TreeMap<>();
   
   public ErklaerungList(T gruppe, List<Erklaerung> erklaerungen) {
       super(Collections.unmodifiableList(new ArrayList<Erklaerung>(erklaerungen)));   
       groupByT.put(gruppe, erklaerungen);
   }
   
   private ErklaerungList(SortedMap<T, List<Erklaerung>> groupByT) {
       super(getErklaerungen(groupByT));
       this.groupByT = groupByT;
   }

   public List<Erklaerung> asList() {
       return getErklaerungen(groupByT);
   }
   
   private static <T> List<Erklaerung> getErklaerungen( Map<T, List<Erklaerung>> xxx) {
        List<Erklaerung> result = new ArrayList<>();
        for (List<Erklaerung> v : xxx.values()) {
            result.addAll(v);
        }
        return result;
   }
   
   public GruppeList<T> groups() {
       GruppeList<T> result = new GruppeList<>();
       for (Entry<T,List<Erklaerung>> entry : groupByT.entrySet()) {
           result.add(new Gruppe<T>(entry.getKey(), new ErklaerungList<>(entry.getKey(), entry.getValue())));
       }
       return result;
   }
   
   
   public static ErklaerungList<?> create(List<Erklaerung> erklaerungen) {
       return new ErklaerungList<>("NOGROUP", erklaerungen);
   }
   

   public GruppeList<Integer> groupByJahr() {
       SortedMap<Integer, List<Erklaerung>> erklaerungenNachJahr = ByJahr.gruppiere(this);       
       return new ErklaerungList<Integer>(erklaerungenNachJahr).groups();
   }

   public GruppeList<ByStichtagArt> groupByStichtagArt() {
       SortedMap<ByStichtagArt, List<Erklaerung>> erklaerungenStichtagArt = ByStichtagArt.gruppiere(this);
       return new ErklaerungList<ByStichtagArt>(erklaerungenStichtagArt).groups();
   }

   public GruppeList<ByArtPersG> groupByArtPersG() {
       return groupByArtPersG(ByArtPersG.GESELLSCHAFTER_GROUPSIZE, ByArtPersG.GESELLSCHAFTER_MAXGROUPS);
   }

   public GruppeList<ByArtPersG> groupByArtPersG(int groupSize, int maxGroups) {
       SortedMap<ByArtPersG, List<Erklaerung>> erklaerungenArtPersG = ByArtPersG.gruppiere(this, groupSize, maxGroups);
       return new ErklaerungList<ByArtPersG>(erklaerungenArtPersG).groups();
   }
   
   public GruppeList<ByGesellschafterUndArtPersG> groupByGesellschafterUndArtPersG() {
       SortedMap<ByGesellschafterUndArtPersG, List<Erklaerung>> erklaerungenGesellschafterUndArtPersG = ByGesellschafterUndArtPersG.gruppiere(this);
       return new ErklaerungList<ByGesellschafterUndArtPersG>(erklaerungenGesellschafterUndArtPersG).groups();
   }
   

   
   public ErklaerungList<T> sortByEingangsdatum() {
       Collections.sort(this, Erklaerung.SORT_BY_EINGANGSDATUM);
       return this;
   }   
   
}
 

MoxxiManagarm

Top Contributor
Mein Ansatz sollte aufzeigen, dass ich versucht habe die Anforderung neu zu formulieren. Gehe gedanklich von all den Helfermethoden und -klassen weg, welche du bedenkenlos raushauen kannst. Male dir deine wichtigen Komponenten als klassendiagramm auf. Dann hast du die Beziehungen und Struktur. Mit der Klarheit, welche du dir so schaffst wirst du den Stream bestimmt ohne Mühe selbst korrekt formulieren können. Die Helfer waren bereits vor java 8 umständlicher als nötig und verwirren jetzt nur noch umso mehr. Hau sie weg und machs neu.
 

guguli

Bekanntes Mitglied
I habe das soweit fertig:

Java:
baumSonderErgaenzBil = fall.getErklaerungenAlle2().stream()
               .filter(element -> DateUtil.getJahr(element.getHeader().getStichdatum()) == jahr)
               .filter(element -> element.getHeader().getStichdatumDisplay().equals(StichtagUtil.dateToAufbereitetString(erklaerung.getHeader().getStichdatum())))
               .filter(element -> element.getHeader().getBilanzart().equals(sa.getArt()))
               .filter(element -> element.getHeader().getBilanzartSteuerlich().equals(bilanzartSteuerlichEnum.getValue()))
               .collect(Collectors.toList());

nun will ich die if statement umschrieben. so wie oben beshrieben mit getMerkmal() kann ich nicht, denn getMerkmal() exitiert nirgendwo.

Java:
if (groupArtPersG.merkmal().isGesellschafterSonderErgaenzungsbilanz()) {
               BaumKnotenDTO letzteWurzel = new BaumKnotenDTO("Gesellschaftergruppe",
                       groupArtPersG.merkmal().getArtPersG());
               baumSonderErgaenzBil.add(letzteWurzel);
               // Gesellschafterschleife :
               for (Gruppe<ByGesellschafterUndArtPersG> groupGesellschafterArtPersG : groupArtPersG.erklaerungen()
                       .groupByGesellschafterUndArtPersG()) {
                   String gesLabel = groupGesellschafterArtPersG.merkmal().getLabel();
                   BaumKnotenDTO gesellschafterWurzel = new BaumKnotenDTO("Gesellschafternr", gesLabel);
                   letzteWurzel.addElement(gesellschafterWurzel);
                   // Bilanz-Schleife
                   for (Erklaerung e : groupGesellschafterArtPersG.erklaerungen().sortByEingangsdatum()) {
                       gesellschafterWurzel.addElement(new BaumBlattDTO(e));
                   }
               }
           }
 
Zuletzt bearbeitet von einem Moderator:

mihe7

Top Contributor
I habe das soweit fertig:
Hm... ich hätte jetzt etwas wie
Java:
Map<BilanzSteuerlich, List<Erklaerung>> erklaerungen = fall.getErklaerungenAlle().stream()
    .filter(erklaerung -> DateUtil.getJahr(erklaerung.getHeader().getStichdatum()) == jahr)
    .filter(erklaerung -> erklaerung.getHeader().getStichdatumDisplay.equals(display))
    .filter(erklaerung -> erklaerung.getHeader().getBilanzart().equals(art))
    .filter(erklaerung -> erklaerung.getMerkmal().isGellschaft())
    .collect(Collectors.groupingBy(erklaerung -> erklaerung.getMerkmal().getArtPersG()));
erwartet.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
L Best Practice Code Refactoring für Methoden mit fast gleicher Aufbau Java Basics - Anfänger-Themen 6
G Refactoring von mehreren identischen Klassen Java Basics - Anfänger-Themen 36
U Refactoring Java Basics - Anfänger-Themen 4
LimDul Suche Java Stream Tutorial Java Basics - Anfänger-Themen 2
W Stream und LocalDate Java Basics - Anfänger-Themen 15
M Stream mit den ersten n natürlichen Zahlen Java Basics - Anfänger-Themen 4
berserkerdq2 Wo ist der SInn, dass man den Stream, den ich zum Schreiben nutze, outputstream nenne? Java Basics - Anfänger-Themen 5
berserkerdq2 Wann soll ich den Stream schließen, wenn ich das in einer Methode habe? Java Basics - Anfänger-Themen 8
K Erste Schritte Stream-Aufruf vereinfachen Java Basics - Anfänger-Themen 3
I Datei als Stream aus Ressource laden? Java Basics - Anfänger-Themen 2
O Alternative zu Stream.forEach() Java Basics - Anfänger-Themen 6
Dimax stream in string[] speichern Java Basics - Anfänger-Themen 6
S Java Stream API Java Basics - Anfänger-Themen 6
A Stream Java Basics - Anfänger-Themen 14
N String N-Gramme mit Stream erstellen Java Basics - Anfänger-Themen 7
T Buffered Stream leert Txt File Java Basics - Anfänger-Themen 3
A Textdatei mit stream einlesen Java Basics - Anfänger-Themen 2
B Text-Datei nur in Stream speichern und dann ausgeben Java Basics - Anfänger-Themen 3
J Gefilterten Stream über die Konsole ausgeben Java Basics - Anfänger-Themen 1
J Count und Copy in Stream<Path> Java Basics - Anfänger-Themen 11
W for Schleife in allgemeingültiges Konstrukt aus Stream und Lambdas Java Basics - Anfänger-Themen 6
W Stream Array List - Frage Java Basics - Anfänger-Themen 5
P Java Verketten von Stream - Bedeutung der Anweisungen? Java Basics - Anfänger-Themen 3
nightsky_ Methoden (Stream) Collectors.toMap() Java Basics - Anfänger-Themen 2
W HTTP-Stream auf Ajax umbauen Java Basics - Anfänger-Themen 7
elischa Client-Server IO und Stream Steuerung ? Java Basics - Anfänger-Themen 2
N Eigene Stream Methoden implementieren Java Basics - Anfänger-Themen 3
M Panel erstellen, welches ein Control erhält. Ausgabe soll über einen Stream erfolgen. Java Basics - Anfänger-Themen 0
E Stream closed - Obwohl nicht manuell geschlossen! Java Basics - Anfänger-Themen 0
N Java.io.ioexception: Stream closed Java Basics - Anfänger-Themen 2
P Wann Byte-Stream und wann Character-Stream? Java Basics - Anfänger-Themen 11
S Input/Output nullpointerException beim schliessen von stream Java Basics - Anfänger-Themen 3
A Integer aus Stream to Double Java Basics - Anfänger-Themen 7
P Java Stream, wann welche Stream verwenden? Java Basics - Anfänger-Themen 3
M Java Stream?! Java Basics - Anfänger-Themen 8
S Input/Output Data-Input/Output-Stream Java Basics - Anfänger-Themen 2
V Jar-Datei von Byte-Array oder Stream laden? Java Basics - Anfänger-Themen 9
J Input/Output Auf effiziente Weise einen Stream auszulesen Java Basics - Anfänger-Themen 5
M Stream close Java Basics - Anfänger-Themen 6
A Prüfen ob Datei geöffnet ist bzw Stream finden Java Basics - Anfänger-Themen 2
H exception "java.io.IOException: Stream closed" Java Basics - Anfänger-Themen 10
Burny91 File.delete(file) geht nicht-Offener Stream aber WO? Java Basics - Anfänger-Themen 4
M Audio Stream läuft auf :connection abort: socket write error Java Basics - Anfänger-Themen 2
H Fehler-Stream grafisch umsetzen Java Basics - Anfänger-Themen 4
H Datentypen Byte-Array aus Stream lesen Java Basics - Anfänger-Themen 3
S Fehler beim Speichern von MP3-Stream Java Basics - Anfänger-Themen 6
bambi0815 Text Datei Stream to Char[][] Java Basics - Anfänger-Themen 7
D JSP: IOException: Stream closed nach dispatchter.forward(..) Java Basics - Anfänger-Themen 13
G Warum bei Stream close() aufrufen. Java Basics - Anfänger-Themen 12
G NoClassDefFoundError: javax/xml/stream/XMLStreamException Java Basics - Anfänger-Themen 23
P Stream Java Basics - Anfänger-Themen 4
alexpetri javax.xml.stream.* nicht gefunden Java Basics - Anfänger-Themen 3
M Stream unvollständig Java Basics - Anfänger-Themen 5
Zed Stream in Variable speichern. Java Basics - Anfänger-Themen 3
M Input/Output Stream aus einem String Java Basics - Anfänger-Themen 2
S Schreib Stream Java Basics - Anfänger-Themen 21
M Stream in String umwandeln Java Basics - Anfänger-Themen 5
K datei komplett als Stream oder ähnliches Java Basics - Anfänger-Themen 4
A Serialisierbarer Stream? - File per RMI versenden Java Basics - Anfänger-Themen 4
R Binary Stream in Bild umwandeln Java Basics - Anfänger-Themen 5
C Position im Objekt-Stream Java Basics - Anfänger-Themen 2
M Ausgabe in String anstatt auf Stream Java Basics - Anfänger-Themen 17
C Stream-Konzept Java Basics - Anfänger-Themen 2
A von Socket-Stream lesen Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben