[Stiller Leser]

Wer kennt nicht das Problem? Man zahlt monatlich auf sein Depot ein, manchmal auch einen Extrabetrag. Ab und an verkauft man auch mal ein paar Aktien, kauft davon neue Aktien und/oder gönnt sich was schönes. Zwischendurch kommen hier und da auch noch Dividende rein, oder irgendwelche Gebühren, die abgezogen werden.
Man schaut sein Depot an, sieht unten oder oben rechts irgendeinen Betrag und fragt sich,
wieviel Zinsen sind denn eigentlich tatsächlich erzielt worden?
Eine ganz schön aufwendige Rechnerei. Und dann bleibt es dabei. Aber da ich es mal wissen wollte, habe ich das Programm hier geschrieben. Kann man sicher sehr viel schöner machen.
Nur zu. Aber für das Ergebnis reicht es.

Das Programm (Java) rechnet monatsweise.
Ausgezahltes Geld, also nicht wieder in Aktien angelegt, sondern vom Depot und Verrechnungskonto entferntes Geld, wird genauso verzinst, wie der sich ergebene Jahreszins, abgezogen.

Vorbereitung in einer Tabellenkalkulation:
Drei Spalten: in der ersten das Datum oder einfach fortlaufende Nummerierung. Mit Datum hat man eine einigermaßen gute Übersicht, dass kein Monat vergessen wird.
In der zweiten Spalte den Einzahlungsbetrag. In der dritten Spalte den Auszahlungsbetrag. Gibt es keine Ein- und/oder Auszahlung, muss jeweils eine 0.0 rein.
Der Auszahlungsbetrag wird ebenso als positive Zahl in die Spalte eingetragen.

Beispielsweise:
01.05.2010 ...................100,00............... 50,00
01.06.2010 ................... 75,00 ...............0,0
.
.
.
Die Monate müssen ohne Unterbrechung fortlaufend sein, sonst wird das Programm sicher Blödsinn rechnen oder abstürzen.

Die drei Spalten bis zum letzten Beitrag markieren und in einer Textdatei kopieren. Die Textdatei unter text.txt speichern und im Worpspace unter dem Pfad, wo ihr das Programm speichert, kopieren.

Als letzter Schritt in der Main in der Variable endbetrag (Stelle ist kommentiert) den Wert des Depots plus Verrechnungskonto eintragen und Programm starten.
Dann hat man den Jahreszinssatz und noch eine Alternativberechnung, wenn man monatlich den immer gleichen Betrag eingezahlt hätte, ohne was abfließen zu lassen.

Viel Spaß.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;


public class Depot_Jahreszins
{
    
    public static double potenz(double basis, int potenz)
    {
        
        double ergebnis=basis;
        
        for (int i=1;i<potenz;i++)
        {
            ergebnis=ergebnis*basis;
        }
        
        return ergebnis;
    }
    
     private static String[] ladeDatei(String datName) {


            File file = new File(datName);
            ArrayList<String> zeilen = new ArrayList<String>();


            if (!file.canRead() || !file.isFile())
                System.exit(0);


                BufferedReader in = null;
            try {
                in = new BufferedReader(new FileReader(datName));
                String zeile = null;
                while ((zeile = in.readLine()) != null) {
                    zeilen.add(zeile);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (in != null)
                    try {
                        in.close();
                    } catch (IOException e) {
               }
                
            }
            
            String rueckgabe[]=new String [zeilen.size()];
            for(int i=0;i<zeilen.size();i++)
            {
                rueckgabe[i]=zeilen.get(i);
            }
            
            return rueckgabe;
     }
    
public static double abs(double wert) {
    if(wert<0)return (wert*(-1.0));
    return wert;
}


public static double runden(double wert, int stellen) {
    
    long hilfswert = 0;
    int teiler=1;
    
    for(int i=1;i<stellen+1;i++) {
        teiler=teiler*10;
    }
    
    wert=wert*teiler+0.5;
    hilfswert=(long)wert;
    wert=(double)hilfswert;
    
    wert=wert/teiler;
    
    return wert;
}
            
    
   public static void main( String[] args )
   {
int monate=0;
double endbetrag=123456.78;  // <-----Hier tatsächlichen Endbetrag eingegeben.
double eingezahlt=0.00;
double ausgezahlt=0.00;


final double ABWEICHUNG=0.00001;
final double STARTSCHRITTGROESSE=0.1;
double schritt=STARTSCHRITTGROESSE;
int durchlaeufe=0;


double monatssparbetrag=0.0;
double monatszins=0.0;  
double betrag=0;
String hilfstring="";
String dateiName = "test.txt";
String[] textdatei= ladeDatei(dateiName);


System.out.println("Mal sehen ...");
monate=textdatei.length;


double[] plus = new double[monate];
double[] minus = new double[monate];


for (int i=0;i<monate;i++) {
    textdatei[i]=textdatei[i].replace(".", "");
    textdatei[i]=textdatei[i].replace(",", ".");
    int j=textdatei[i].lastIndexOf('.');
    j--;
    while(textdatei[i].charAt(j)>'/'&&textdatei[i].charAt(j)<':') {
        j--;
    }
    
    hilfstring=textdatei[i].substring(j, textdatei[i].length());
    minus[i]=Double.valueOf(hilfstring);
    textdatei[i]=textdatei[i].substring(0, j);
    
    j=textdatei[i].lastIndexOf('.');
    int k=j+2;
    j--;
    while(textdatei[i].charAt(j)>'/'&&textdatei[i].charAt(j)<':') {
        j--;
    }
    hilfstring=textdatei[i].substring(j, k);
    plus[i]=Double.valueOf(hilfstring);
    textdatei[i]=textdatei[i].substring(0, j);
    
    eingezahlt=eingezahlt+plus[i]-minus[i];
    if(minus[i]>plus[i]) {
        eingezahlt=eingezahlt-plus[i];
        minus[i]=minus[i]-plus[i];
        plus[i]=0.0;
    }
    
    ausgezahlt=ausgezahlt+minus[i];
}


System.out.format("Eingezahlt wurde: %.2f  Anzahl Monate: %d %n",runden(eingezahlt,2),monate);
System.out.format("Ausgezahlt wurde: %.2f %n",runden(ausgezahlt,2));
System.out.format("Eingezahlt ohne Berücksichtung der Abhebungen: %.2f %n",(eingezahlt+ausgezahlt));


while(abs(betrag-endbetrag)>ABWEICHUNG)
{
    betrag=0.0;
    monatszins=monatszins+schritt;
    durchlaeufe++;
    
    for (int i=0;i<monate;i++)
    {
        if(plus[i]!=0) {
            betrag=betrag+plus[i]*potenz(1.0+monatszins/100.0,monate-i);
        }
        if(minus[i]!=0) {
            betrag=betrag-minus[i]*potenz(1.0+monatszins/100.0,monate-i);
        }
    }
    if(betrag-endbetrag>ABWEICHUNG) {
        monatszins=monatszins-schritt;
        schritt=schritt/10;
    }
    
    
}


System.out.format("Tatsächlicher Endbetrag = %.2f  angenährter Betrag = %.2f  Abweichung in Euro  %.2f  € %n",runden(endbetrag,2),runden(betrag,2),runden(endbetrag-betrag,2));
System.out.format("Jahreszins= %.2f Prozent %n",runden(monatszins*12.0,2));
System.out.println("Durchläufe= "+durchlaeufe);


monatssparbetrag=eingezahlt/monate;


betrag=0.0;
monatszins=0.0;
durchlaeufe=0;


for(int i=0;i<monate;i++) {
    plus[i]=monatssparbetrag;
}


schritt=STARTSCHRITTGROESSE;
while(abs(betrag-endbetrag)>ABWEICHUNG)
{
    betrag=0.0;
    monatszins=monatszins+schritt;
    durchlaeufe++;
    
    for (int i=0;i<monate;i++)
    {
        betrag=betrag+plus[i]*potenz(1.0+monatszins/100.0,monate-i);
    }
    if(betrag-endbetrag>ABWEICHUNG) {
        monatszins=monatszins-schritt;
        schritt=schritt/10;
    }
    
}


System.out.println();
System.out.println("Zinssatz bei angenommener gleicher Einzahlung ohne zwischenzeitliche Abhebung:");
System.out.format("Eingezahlt wurde pro Monat: %.2f  Gesamt: %.2f %n",runden(monatssparbetrag,2),runden(monatssparbetrag*monate,2));
System.out.format("Tatsächlicher Endbetrag = %.2f  angenährter Betrag = %.2f  Abweichung in Euro %.2f  € %n",runden(endbetrag,2),runden(betrag,2),(runden(endbetrag-betrag,2)));
System.out.format("Jahreszins= %.2f Prozent %n",runden(monatszins*12.0,2));
System.out.println("Durchläufe= "+durchlaeufe);




   }
}

[Stiller Leser]

Jetzt habe ich doch das Programm noch ein wenig aufgehübscht.
Kam ich auch gleich wieder ein wenig in Java Swing rein.

Viel Spaß

Spoiler:(zum lesen bitte Text markieren)

[Bild: aufrechner.jpg]

Klasse Aufrechner

import javax.swing.SwingUtilities;




public class Aufrechner {
    
    final double ABWEICHUNG=0.0001;
    
    private double startschrittgroesse=0.1;
    
    private double eingezahlt=0;
    private double eingezahlt_a=0;
    private double ausgezahlt=0;
    private double ausgezahlt_a=0;
    
    private double monatszins;
    private double endbetrag;
    private double ca_endbetrag=0;




    private int monate=0;
    private int durchlaeufe=0;




    private double[] plus=null;
    private double[] plus_a=null;
    private double[] minus=null;
    private double[] minus_a=null;
    private String[] datum=null;
    
    private boolean bereinigt=false;
    private boolean fehler_daten=false; 




    public Aufrechner(String [] aufrechnen){




        setMonate(aufrechnen.length);
        this.plus=new double[this.getMonate()];
        this.plus_a=new double[this.getMonate()];
        this.minus=new double[this.getMonate()];
        this.minus_a=new double[this.getMonate()];
        this.datum=new String[this.getMonate()];




        initialisieren(aufrechnen);
    }




    private double getStartschrittgroesse(){
        return this.startschrittgroesse;
    }     




    private void initialisieren(String [] aufrechnen){
        String hilfstring="";
        
        this.fehler_daten=false;




        for(int i=0;i<getMonate();i++){
               this.datum[i]=aufrechnen[i].substring(0, 8);
               aufrechnen[i]=aufrechnen[i].replace(".", "");
               aufrechnen[i]=aufrechnen[i].replace(",", ".");
            int j=aufrechnen[i].lastIndexOf('.');
            j--;




            while(aufrechnen[i].charAt(j)>'/'&&aufrechnen[i].charAt(j)<':') {
                    j--;
            }
                    
              hilfstring=aufrechnen[i].substring(j, aufrechnen[i].length());
               try {
                   this.minus[i]=Double.valueOf(hilfstring);
            } catch (Exception e) {
                this.minus[i]=0;
                this.fehler_daten=true;
            }
              
               this.minus_a[i]=this.minus[i];
               aufrechnen[i]=aufrechnen[i].substring(0, j);
               j=aufrechnen[i].lastIndexOf('.');
               int k=j+2;
               j--;




               while(aufrechnen[i].charAt(j)>'/'&&aufrechnen[i].charAt(j)<':') {
                    j--;
            }




               hilfstring=aufrechnen[i].substring(j, k);
               
               try {
                   this.plus[i]=Double.valueOf(hilfstring);
            } catch (Exception e) {
                this.plus[i]=0;
                this.fehler_daten=true;
            }
            
            this.plus_a[i]=this.plus[i];
            aufrechnen[i]=aufrechnen[i].substring(0, j);
                    
            this.eingezahlt=this.eingezahlt+plus[i];
            this.eingezahlt_a=this.eingezahlt;
                    
            this.ausgezahlt=this.ausgezahlt+this.minus[i];
            this.ausgezahlt_a=this.ausgezahlt;
        }
        
        this.tauschen();
        this.bereinigt();
        this.tauschen();
    }
    
    private void bereinigt() {
        this.eingezahlt=0;
        this.ausgezahlt=0;
        
        for(int i=0;i<getMonate();i++) {
            if(this.minus[i]>=this.plus[i]) {
                this.minus[i]=this.minus[i]-this.plus[i];
                this.plus[i]=0.0;
            }
            else {
                this.plus[i]=this.plus[i]-this.minus[i];
                this.minus[i]=0;
            }
            
            this.eingezahlt=this.eingezahlt+this.plus[i];
            this.ausgezahlt=this.ausgezahlt+this.minus[i];
        }
    }
    
    public void tauschen() {
        double hilf=0;
        
        hilf=this.eingezahlt;
        this.eingezahlt=this.eingezahlt_a;
        this.eingezahlt_a=hilf;
        
        hilf=this.ausgezahlt;
        this.ausgezahlt=this.ausgezahlt_a;
        this.ausgezahlt_a=hilf;
        
        for(int i=0;i<this.getMonate();i++) {
            hilf=this.plus[i];
            this.plus[i]=this.plus_a[i];
            this.plus_a[i]=hilf;
            
            hilf=this.minus[i];
            this.minus[i]=this.minus_a[i];
            this.minus_a[i]=hilf;
        }
        
        if(this.bereinigt) {
            this.bereinigt=false;
        }
        else this.bereinigt=true;
    }
    
    public boolean getBereinigt() {
        return this.bereinigt;
    }
    
    public boolean getFehler_Daten() {
        return this.fehler_daten;
    }








    public double rechne_Jahreszins(){
        double betrag=0;
        double schritt=this.getStartschrittgroesse();
        this.setDurchlaeufe(0);
        this.setMonatszins(0);
        
        while(abs(betrag-this.endbetrag)>this.ABWEICHUNG){
            betrag=0.0;
            this.monatszins=this.monatszins+schritt;
            durchlaeufe++;
            
            for (int i=0;i<this.monate;i++)    {
                if(plus[i]!=0) {
                    betrag=betrag+this.plus[i]*potenz(1.0+this.monatszins/100.0,this.monate-i);
                }
                if(this.minus[i]!=0) {
                    betrag=betrag-this.minus[i]*potenz(1.0+this.monatszins/100.0,this.monate-i);
                }
            }
            if(betrag-this.endbetrag>this.ABWEICHUNG) {
                this.monatszins=this.monatszins-schritt;
                schritt=schritt/10;
            }
        }
        
        this.ca_endbetrag=betrag;
        return this.monatszins*12;
    }




    public double rechne_Jahreszins_gleichmaessige_Einzahlung(){
        double betrag=0;
        double monatssparbetrag=getMonatsrate();
        double schritt=this.getStartschrittgroesse();
        this.setDurchlaeufe(0);
        this.setMonatszins(0);
        
        while(abs(betrag-this.endbetrag)>this.ABWEICHUNG){
            betrag=0.0;
            this.monatszins=this.monatszins+schritt;
            durchlaeufe++;
            
            for (int i=0;i<this.monate;i++){
                betrag=betrag+monatssparbetrag*potenz(1.0+this.monatszins/100.0,this.monate-i);
            }
            if(betrag-this.endbetrag>this.ABWEICHUNG) {
                this.monatszins=this.monatszins-schritt;
                schritt=schritt/10;
            }
        }        




      this.ca_endbetrag=betrag;        
      return this.monatszins*12;    
    }




    public void setMonate(int monate){
        this.monate=monate;
    }




    public int getMonate(){
                   return this.monate;
    }




    public void setDurchlaeufe(int durchlaeufe){
        this.durchlaeufe=durchlaeufe;
    }




    public int getDurchlaeufe(){
        return this.durchlaeufe;
    }    




    public void setDatum(String datum, int i){
        this.datum[i]=datum;
    }




    public String getDatum(int i){
         return this.datum[i];
    }




    public void setEingezahlt(double eingezahlt){
         this.eingezahlt=eingezahlt;
    }




    public double getEingezahlt(){
         return this.eingezahlt;
    }
    
    public void setEndbetrag(double eingezahlt){
        this.endbetrag=eingezahlt;
    }
    
    public double getEndbetrag(){
        return this.endbetrag;
    }




    public double getCaEndbetrag(){
        return this.ca_endbetrag;
    }
     
    public void setAusgezahlt(double ausgezahlt){
        this.ausgezahlt=ausgezahlt;
    }




    public double getAusgezahlt(){
        return this.ausgezahlt;
    }




    public void setMonatszins(double monatszins){
        this.monatszins=monatszins;
    }




    public double getMonatszins(){
        return this.monatszins;
    }




    public void setPlus(double plus,int i){
        this.plus[i]=plus;
    }




    public double getPlus(int i){
        return this.plus[i];
    }




    public void setMinus(double minus,int i){
        this.minus[i]=minus;
    }




    public double getMinus(int i){
         return this.minus[i];
    }




    public double getMonatsrate(){
         return (this.getEingezahlt()-this.getAusgezahlt())/this.getMonate();
    }
    
    public static double potenz(double basis, int potenz){
        double ergebnis=basis;
        
        for (int i=1;i<potenz;i++){
            ergebnis=ergebnis*basis;
        }
        
        return ergebnis;
    }
     
    public static double abs(double wert) {
        if(wert<0)return (wert*(-1.0));
        return wert;
    }




            
    
    public static void main( String[] args ) {
    
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new Fenster();
            }
        });
   }
}

Klasse Fenster

import java.awt.event.ActionEvent;import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;




import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.JTable;
import javax.swing.ScrollPaneConstants;




public class Fenster implements ActionListener {
private JFrame frame;




private JMenuBar menubar;
private JMenu jm_datei;
private JMenuItem datei_laden;
private JMenuItem beenden;




private JMenu jm_eingabe;
private JMenuItem eingabe_endbetrag;




private JPanel panel;




private JPanel links;
private JPanel jp_information;
private JLabel [] jl_information;




private JPanel rechts;
private JPanel jp_grundwerte;
private JLabel [] jl_grundwerte;




private JPanel jp_jahreszinssatz;
private JLabel [] jl_jahreszinssatz;




private JPanel jp_jahreszinssatz_alt;
private JLabel [] jl_jahreszinssatz_alt;




private JPanel jp_bereinigt;
private JRadioButton jrb_bereinigt;
private JLabel [] jl_bereinigt;
private JRadioButton jrb_unbereinigt;
private ButtonGroup bg_bereinigt;








private boolean formen_ergebnisse_erstellt=false;




private JTable table;




private String dateiname="";




private int rand=10;
private int FENSTERBREITE=1024;
private int FENSTERHOEHE=768;




Aufrechner aufrechner;
    
    
public Fenster() {
    
    frame=new JFrame("Aufrechner",null);
    frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
    
    menubar=new JMenuBar();
    
    jm_datei=new JMenu("Datei");
    datei_laden= new JMenuItem("Datei laden");
    datei_laden.addActionListener(this);
    
    JSeparator sep= new JSeparator();
    
    beenden=new JMenuItem("Beenden");
    beenden.addActionListener(this);




    jm_datei.add(datei_laden);
    jm_datei.add(sep);
    jm_datei.add(beenden);
    
    jm_eingabe=new JMenu("Eingabe");
    eingabe_endbetrag=new JMenuItem("Endbetrag eingeben");
    eingabe_endbetrag.setEnabled(false);
    eingabe_endbetrag.addActionListener(this);
    
    jm_eingabe.add(eingabe_endbetrag);
    
    menubar.add(jm_datei);
    menubar.add(jm_eingabe);
    
    panel=new JPanel(null);
    panel.setBounds(0, 0, FENSTERBREITE, FENSTERHOEHE);
    
    links=new JPanel(null);
    links.setBounds(10, 10, FENSTERBREITE/2-10+100, FENSTERHOEHE-40);
    links.setBorder(BorderFactory.createTitledBorder
            (BorderFactory.createEtchedBorder(), "Datenbereich: Noch keine Daten vorhanden"));
    
    jp_information=new JPanel(null);
    jp_information.setBounds(290, 30, 300, 150);
    jp_information.setBorder(BorderFactory.createTitledBorder
            (BorderFactory.createEtchedBorder(), "Daten müssen wie folgt vorliegen:"));
    jl_information=new JLabel[8];
    jl_information[0]=new JLabel("Spalte 1: Datum monatsweise");
    jl_information[0].setBounds(rand, 15, 350, 25);
    jl_information[1]=new JLabel("Spalte 2: Einzahlung");
    jl_information[1].setBounds(rand, 30, 350, 25);
    jl_information[2]=new JLabel("Spalte 3: Auszahlung");
    jl_information[2].setBounds(rand, 45, 350, 25);
    jl_information[3]=new JLabel("Beispiel:");
    jl_information[3].setBounds(rand, 65, 350, 25);
    jl_information[4]=new JLabel("01.01.10    300,75    0,00");
    jl_information[4].setBounds(rand, 80, 350, 25);
    jl_information[5]=new JLabel("01.02.10    753,25    150,00");
    jl_information[5].setBounds(rand, 95, 350, 25);
    jl_information[6]=new JLabel("Monate fortlaufend ohne Unterbrechung.");
    jl_information[6].setBounds(rand, 110, 350, 25);
    
    for(int i=0;i<7;i++) jp_information.add(jl_information[i]);
    
    links.add(jp_information);
    




    
    rechts=new JPanel(null);
    rechts.setBounds(FENSTERBREITE/2+20+100, 10, FENSTERBREITE/2-10+200, FENSTERHOEHE-40);
    rechts.setBorder(BorderFactory.createTitledBorder
            (BorderFactory.createEtchedBorder(), "Noch keine Daten für Berechnung des effektiven Jahreszins vorhanden"));
    
    
    
    panel.add(links);
    panel.add(rechts);
    
    
    frame.setJMenuBar(menubar);
    frame.add(panel);
    
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setVisible(true);




}




private void erstelle_Bereinigtauswahl() {
    
    this.jp_bereinigt= new JPanel(null);
    this.jp_bereinigt.setBounds(290, 200, 300, 200);
    this.jp_bereinigt.setBorder(BorderFactory.createTitledBorder
            (BorderFactory.createEtchedBorder(), "Auswahl Bereinigt/Unbereinigt"));




    this.jrb_bereinigt=new JRadioButton("Bereinigte Tabellendaten");
    this.jrb_bereinigt.setBounds(5, 20, 250, 15);
    this.jrb_bereinigt.addActionListener(this);
    
    this.jrb_unbereinigt=new JRadioButton("Unbereinigte Tabellendaten");
    this.jrb_unbereinigt.setBounds(5, 40, 250, 15);
    this.jrb_unbereinigt.setSelected(true);
    this.jrb_unbereinigt.addActionListener(this);




    this.jl_bereinigt=new JLabel[8];
    
    this.jl_bereinigt[0]=new JLabel("unbereinigt:");
    this.jl_bereinigt[0].setBounds(rand, 60, 300, 25);
    this.jl_bereinigt[1]=new JLabel("01.01.10    300,75    0,00");
    this.jl_bereinigt[1].setBounds(rand, 75, 300, 25);
    this.jl_bereinigt[2]=new JLabel("01.02.10    753,25    150,00");
    this.jl_bereinigt[2].setBounds(rand, 90, 300, 25);
    this.jl_bereinigt[3]=new JLabel("01.03.10    200,00    500,00");
    this.jl_bereinigt[3].setBounds(rand, 105, 300, 25);




    this.jl_bereinigt[4]=new JLabel("bereinigt:");
    this.jl_bereinigt[4].setBounds(rand, 125, 300, 25);
    this.jl_bereinigt[5]=new JLabel("01.01.10    300,75    0,00");
    this.jl_bereinigt[5].setBounds(rand, 140, 300, 25);
    this.jl_bereinigt[6]=new JLabel("01.02.10    603,25    0,00");
    this.jl_bereinigt[6].setBounds(rand, 155, 300, 25);
    this.jl_bereinigt[7]=new JLabel("01.03.10    0,00    300,00");
    this.jl_bereinigt[7].setBounds(rand, 170, 300, 25);




    
    this.bg_bereinigt =new ButtonGroup();
    this.bg_bereinigt.add(jrb_bereinigt);
    this.bg_bereinigt.add(jrb_unbereinigt);
    
    this.jp_bereinigt.add(jrb_bereinigt);
    this.jp_bereinigt.add(jrb_unbereinigt);
    this.jp_bereinigt.add(jl_bereinigt[0]);
    this.jp_bereinigt.add(jl_bereinigt[1]);
    this.jp_bereinigt.add(jl_bereinigt[2]);
    this.jp_bereinigt.add(jl_bereinigt[3]);
    this.jp_bereinigt.add(jl_bereinigt[4]);
    this.jp_bereinigt.add(jl_bereinigt[5]);
    this.jp_bereinigt.add(jl_bereinigt[6]);
    this.jp_bereinigt.add(jl_bereinigt[7]);
    this.links.add(jp_bereinigt);
    
    this.links.repaint();
}




private void aktualisiereTabelle() {
    
    for(int i=0;i<aufrechner.getMonate();i++) {
        this.table.setValueAt(aufrechner.getDatum(i), i, 0);
        this.table.setValueAt(runden(aufrechner.getPlus(i),2), i, 1);
        this.table.setValueAt(runden(aufrechner.getMinus(i),2), i, 2);
    }




this.links.repaint();
}




public static double runden(double wert, int stellen) {
    long hilfswert = 0;
    int teiler=1;




    for(int i=1;i<stellen+1;i++) {
        teiler=teiler*10;
    }




    wert=wert*teiler+0.5;
    hilfswert=(long)wert;
    wert=(double)hilfswert;




    wert=wert/teiler;




    return wert;
}




private String formatiereDouble(double zahl) {
    
    long hilfswert=(long)zahl;
    int komma=(int)((zahl-(double)(hilfswert))*100);
    String vorne=String.valueOf(hilfswert);
    String hinten=String.valueOf(komma);
    
    if(hinten.isEmpty())hinten=hinten.concat("00");
    if(hinten.length()==1)hinten=hinten.concat("0");
    




    ArrayList<Character>liste=new ArrayList<>();
    ArrayList<Character>hilfsliste=new ArrayList<>();
    char[] chararray=vorne.toCharArray();
    
    int j=0;
    liste.add(',');
    for(int i=chararray.length-1;i>-1;i--) {
        liste.add(Character.valueOf(chararray[i]));
        j++;
        if(j%3==0 &&i>0)liste.add('.');
    }
    
    StringBuilder formatierteZahl=new StringBuilder(hilfsliste.size());
    
    for(int i=liste.size()-1;i>-1;i--) {
        hilfsliste.add(liste.get(i));
    }
    
    for(Character c: hilfsliste) {
        formatierteZahl.append(c);
    }
    
    return formatierteZahl.toString().concat(hinten);
}




private void aktualisiereBerechnungen() {
    String hilfstring="Eingezahlt wurden "+this.formatiereDouble(runden(aufrechner.getEingezahlt(),2))+" € in "+aufrechner.getMonate()+" Monaten";
    this.jl_grundwerte[0].setText(hilfstring);
    
    hilfstring="Ausgezahlt wurden "+this.formatiereDouble(runden(aufrechner.getAusgezahlt(),2))+" €.";
    this.jl_grundwerte[1].setText(hilfstring);        




    hilfstring="Eingezahlt mit Berücksichtung der Abhebungen wurden "+this.formatiereDouble(runden(aufrechner.getEingezahlt()-aufrechner.getAusgezahlt(),2))+" €.";
    this.jl_grundwerte[2].setText(hilfstring);
    
    double jahreszinssatz=runden(aufrechner.rechne_Jahreszins(),2);
    hilfstring="Tatsächlicher Endbetrag: "+this.formatiereDouble(runden(aufrechner.getEndbetrag(),2))+" €    Annährerung: "+this.formatiereDouble(runden(aufrechner.getCaEndbetrag(),2))+" €" +
                "    Abweichung: "+(runden(aufrechner.getEndbetrag()-aufrechner.getCaEndbetrag(),2)+" €");
    this.jl_jahreszinssatz[0].setText(hilfstring);
    hilfstring="Ermittelter effektiver Jahreszins: "+jahreszinssatz+" Prozent.";
    this.jl_jahreszinssatz[1].setText(hilfstring);
    hilfstring="Annäherung ereicht in  "+aufrechner.getDurchlaeufe()+" Durchgängen.";
    this.jl_jahreszinssatz[2].setText(hilfstring);




    jahreszinssatz=runden(aufrechner.rechne_Jahreszins_gleichmaessige_Einzahlung(),2);
    hilfstring="Sparbetrag pro Monat: "+this.formatiereDouble(runden(aufrechner.getEingezahlt()-aufrechner.getAusgezahlt(),2))+"€ / "+aufrechner.getMonate()+" Monate = "
                                        +this.formatiereDouble(runden(aufrechner.getMonatsrate(),2))+" €/Monat.";
    this.jl_jahreszinssatz_alt[0].setText(hilfstring);
    hilfstring="Tatsächlicher Endbetrag: "+this.formatiereDouble(runden(aufrechner.getEndbetrag(),2))+" €    Annährerung: "+this.formatiereDouble(runden(aufrechner.getCaEndbetrag(),2))+" €" +
                "    Abweichung: "+runden(aufrechner.getEndbetrag()-aufrechner.getCaEndbetrag(),2)+" €";
    this.jl_jahreszinssatz_alt[1].setText(hilfstring);
    hilfstring="Ermittelter effektiver Jahreszins: "+jahreszinssatz+" Prozent.";
    this.jl_jahreszinssatz_alt[2].setText(hilfstring);
    hilfstring="Annäherung ereicht in  "+aufrechner.getDurchlaeufe()+" Durchgängen.";
    this.jl_jahreszinssatz_alt[3].setText(hilfstring);        
    




    this.rechts.repaint();
}




private String[] ladeDatei(String datName) {




    File file = new File(datName);
    ArrayList<String> zeilen = new ArrayList<String>();




    if (!file.canRead() || !file.isFile())
        System.exit(0);




        BufferedReader in = null;
    try {
        in = new BufferedReader(new FileReader(datName));
        String zeile = null;
        while ((zeile = in.readLine()) != null) {
            zeilen.add(zeile);
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (in != null)
            try {
                in.close();
            } catch (IOException e) {
       }
        
    }
    
    String rueckgabe[]=new String [zeilen.size()];
    for(int i=0;i<zeilen.size();i++)
    {
        rueckgabe[i]=zeilen.get(i);
    }
    
    return rueckgabe;
}
@Override
public void actionPerformed(ActionEvent e) {
    // TODO Auto-generated method stub
    String [] textdatei=null;
    if (e.getSource()==this.datei_laden){
    
    JFileChooser chooser=new JFileChooser("D:/Daten/eclipse_workspace/Aufrechner");
    int auswahl=chooser.showOpenDialog(null);
    
    if(auswahl==JFileChooser.APPROVE_OPTION) {
        dateiname=chooser.getSelectedFile().getName();
        textdatei=ladeDatei(dateiname);
        
        aufrechner=new Aufrechner(textdatei);
        
        if(!aufrechner.getFehler_Daten()) {
            Object [][] komplett= new Object [aufrechner.getMonate()][3];
            for(int i=0;i<aufrechner.getMonate();i++) {
                komplett[i][0]=aufrechner.getDatum(i);
                komplett[i][1]=aufrechner.getPlus(i);
                komplett[i][2]=aufrechner.getMinus(i);
            }
        
            String[] titel={"Datum      ","Eingezahlt ","Ausgezahlt "};
        
            this.table=new JTable(komplett,titel);
        
            JScrollPane scrollbar=new JScrollPane(table,ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
            scrollbar.setBounds(30, 30, 250, 600);
            
            links.add(scrollbar);
            links.setBorder(BorderFactory.createTitledBorder
                    (BorderFactory.createEtchedBorder(), "Gelesene Daten aus Datei: ->"+dateiname + " -> Daten unbereinigt"));
            
            rechts.setBorder(BorderFactory.createTitledBorder
                    (BorderFactory.createEtchedBorder(), "Unter Eingabe Menüpunkt <Endbetrag eingeben> auswählen"));








            eingabe_endbetrag.setEnabled(true);
        }
        else 
            JOptionPane.showMessageDialog(null, "Fehler beim Laden der Datei","Error",
                    JOptionPane.ERROR_MESSAGE);
    }//ende von if(auswahl==JFileChooser.APPROVE_OPTION
    
    }//ende von datei laden
    
    if (e.getSource()==this.eingabe_endbetrag) {
        
        boolean korrekt=false;
        String hilfstring="";
        
        while(!korrekt) {
            korrekt=true;
            hilfstring= JOptionPane.showInputDialog(null, "Bitte Endbetrag eingeben:");
        
            try {
                aufrechner.setEndbetrag(Double.valueOf(hilfstring));
            } catch (NumberFormatException e2) {
            // TODO: handle exception
            korrekt=false;
            JOptionPane.showMessageDialog(null, "Es wurde keine Zahl eingegeben");
            }
        }
        
        this.rechts.setBorder(BorderFactory.createTitledBorder
                (BorderFactory.createEtchedBorder(), "Berechungen aus den vorhandenen Daten:"));
    if(!this.formen_ergebnisse_erstellt) {    
        this.jl_grundwerte=new JLabel[3];
        this.jp_grundwerte=new JPanel(null);
        this.jp_grundwerte.setBounds(20, 30, 550, 150);
        this.jp_grundwerte.setBorder(BorderFactory.createTitledBorder
                (BorderFactory.createEtchedBorder(), "Grundergebnisse:"));
        this.jl_grundwerte[0]=new JLabel();
        this.jl_grundwerte[0].setBounds(10, 25, 540, 30);
        this.jl_grundwerte[1]=new JLabel();
        this.jl_grundwerte[1].setBounds(10, 65, 540, 30);
        this.jl_grundwerte[2]=new JLabel();
        this.jl_grundwerte[2].setBounds(10, 105, 540, 30);




        this.jp_grundwerte.add(jl_grundwerte[0]);
        this.jp_grundwerte.add(jl_grundwerte[1]);
        this.jp_grundwerte.add(jl_grundwerte[2]);




        this.jl_jahreszinssatz=new JLabel[3];
        this.jp_jahreszinssatz=new JPanel(null);
        this.jp_jahreszinssatz.setBounds(20, 200, 550, 150);
        this.jp_jahreszinssatz.setBorder(BorderFactory.createTitledBorder
                (BorderFactory.createEtchedBorder(), "effektiver Jahreszins:"));
        this.jl_jahreszinssatz[0]=new JLabel(hilfstring);
        this.jl_jahreszinssatz[0].setBounds(10, 25, 540, 30);
        this.jl_jahreszinssatz[1]=new JLabel(hilfstring);
        this.jl_jahreszinssatz[1].setBounds(10, 65, 540, 30);
        this.jl_jahreszinssatz[2]=new JLabel(hilfstring);
        this.jl_jahreszinssatz[2].setBounds(10, 105, 540, 30);




        this.jp_jahreszinssatz.add(jl_jahreszinssatz[0]);
        this.jp_jahreszinssatz.add(jl_jahreszinssatz[1]);
        this.jp_jahreszinssatz.add(jl_jahreszinssatz[2]);
        
        this.jl_jahreszinssatz_alt=new JLabel[4];
        this.jp_jahreszinssatz_alt=new JPanel(null);
        this.jp_jahreszinssatz_alt.setBounds(20, 370, 550, 200);
        this.jp_jahreszinssatz_alt.setBorder(BorderFactory.createTitledBorder
                (BorderFactory.createEtchedBorder(), "Alternativer effektiver Jahreszins berechnet mit gleichmässiger Einzahlung:"));
        this.jl_jahreszinssatz_alt[0]=new JLabel(hilfstring);
        this.jl_jahreszinssatz_alt[0].setBounds(10, 25, 540, 30);
        this.jl_jahreszinssatz_alt[1]=new JLabel(hilfstring);
        this.jl_jahreszinssatz_alt[1].setBounds(10, 65, 540, 30);
        this.jl_jahreszinssatz_alt[2]=new JLabel(hilfstring);
        this.jl_jahreszinssatz_alt[2].setBounds(10, 105, 540, 30);
        this.jl_jahreszinssatz_alt[3]=new JLabel(hilfstring);
        this.jl_jahreszinssatz_alt[3].setBounds(10, 145, 540, 30);




        this.jp_jahreszinssatz_alt.add(jl_jahreszinssatz_alt[0]);
        this.jp_jahreszinssatz_alt.add(jl_jahreszinssatz_alt[1]);
        this.jp_jahreszinssatz_alt.add(jl_jahreszinssatz_alt[2]);
        this.jp_jahreszinssatz_alt.add(jl_jahreszinssatz_alt[3]);        




        this.rechts.add(this.jp_grundwerte);
        this.rechts.add(this.jp_jahreszinssatz);
        this.rechts.add(this.jp_jahreszinssatz_alt);
    }
        
        this.aktualisiereBerechnungen();
        
        if(!this.formen_ergebnisse_erstellt)this.formen_ergebnisse_erstellt=true;
        
        this.erstelle_Bereinigtauswahl();
        
        
    }
    
    if (e.getSource()==this.jrb_bereinigt) {
        this.aufrechner.tauschen();
        this.aktualisiereTabelle();
        this.aktualisiereBerechnungen();
        
        links.setBorder(BorderFactory.createTitledBorder
                (BorderFactory.createEtchedBorder(), "Gelesene Daten aus Datei: ->"+dateiname + " -> Daten bereinigt"));
    }
    
    if (e.getSource()==this.jrb_unbereinigt) {
        this.aufrechner.tauschen();
        this.aktualisiereTabelle();
        this.aktualisiereBerechnungen();
        
        links.setBorder(BorderFactory.createTitledBorder
                (BorderFactory.createEtchedBorder(), "Gelesene Daten aus Datei: ->"+dateiname + " -> Daten unbereinigt"));
    }




        
    if (e.getSource()==this.beenden) {
        frame.setVisible(false);
        frame.dispose();
        
        System.exit(0);
    }
}
}