Alle Zeichen, die in der Console sind in Textdatei

[chris009]

Hallo,

Ich habe folgende beiden Methoden, die Strings per Syszem.out.print() in die Console schreiben:

public void schreibetage(int monatsanzahl, int tagesanzahl)
	{
		gc.set(2007, monatsanzahl, 1);
		int bDayOfWeek = gc.get(Calendar.DAY_OF_WEEK);
		if (bDayOfWeek == 1) {
			System.out.print(" ");
		} else {
			System.out.print(" ");
			for (int b = 1; b < bDayOfWeek; b++) {
				System.out.print("        ");
			}
		}

		for (int i = 1; i <= tagesanzahl; i++) {
			gc.set(2007, monatsanzahl, i);
			int iDayOfWeek = gc.get(Calendar.DAY_OF_WEEK);

			if (i < 10) {
				System.out.print("0" + i + "      ");
			} else {
				System.out.print(i + "      ");
			}
			if (iDayOfWeek == 7) {
				System.out.print("\n" + " ");

			}
		}
	}

	public void schreibefeiertage(int monatsanzahl, int tagesanzahl)
	{
		System.out.println("\n");
		for (int e = 0; e <= tagesanzahl; e++) {
			int tagesnummer = kalenderfunktionen.tagesnummer(e, monatsanzahl,
					jahresanzahl);
			String feier = kalenderfunktionen.istFeiertag(jahresanzahl,
					tagesnummer);
			if (feier == null) {
				System.out.print("");
			} else {
				System.out.println(e + ". " + feier);
			}

		}

	}

Ich habe bereits eine Klasse erstellt, die Streams in eine Textdatein speichern kann. Dazu muss allerdings die gesamte Konsolenausgabe in EINEM String zusammengefasst werden.

Wisst ihr, wie ich die ausgebebenen Werte in einen String bekommen. ( Habe das bis jetzt noch nicht geschafft )

Vielen Dank im Voraus

 

[SlaterB]

wenn sie erstmal in System.out sind, dann würde ich sie als 'weg' bezeichen, egal obs noch zu retten ist oder nicht,

merke dir die Strings dagegen lieber bevor bzw. parallel während wie weggeschrieben werden,

jeden Aufruf
System.out.print(xy);
ersetzt du durch
MyClass.merkeUndOute(xy);

in dieser statischen Operation kannst du dann neben System.out noch anderes mit dem String machen (z.B. merken),

elegante Version davon:
erstelle dir eine PrintStream-Unterklasse, die übergebene Strings merkt und weiterreicht und setze diesen eigenen Stream in die Variablen out der Klasse System,
dann musst du sonst nix weiter ändern

 

[Guest]

Das Problem ist, dass ich auch in meiner Main-Klasse viel mit system.outprint() arbeite. Ich liste mal alle Klassen auf.

Für mich ist wichtig, dass ich einen String bekomme, der dann von der Klasse STREAMS eingelesen und abgespeichert werden kann.

package kalender;

import java.io.IOException;

public class Main {
	static Monat monat = new Monat();
	static int menuauswahl;

	public static void main(String[] args) throws IOException
	{

		boolean wiederholen = true;
		do {
			System.out.println("\n" + "1 - Kalender für das ganze Jahr");
			System.out.println("2 - Ausgabe Monatsblatt");
			System.out.println("3 - Kalender mit Feiertagen Jahr");
			System.out.println("4 - Kalender mit Feiertagen Monat");
			System.out.println("0 - Ende");
			System.out.println("Bitte Menüauswahl treffen:");
			menuauswahl = MeineEingabe.erfasseInt();
			if (menuauswahl == 1) {
				for (int i = 1; i <= 12; i++) {
					monatdeckblatt(i);
					monat.schreibetage(i, monat.lieferetagesanzahl(i));
					System.out.println("");
					System.out.println("");
				}

			} else if (menuauswahl == 2) {
				monat.erfasseMonatsanzahl();
				monat.erfasseJahrenanzahl();
				monatdeckblatt(monat.getMonatsanzahl());
				monat.lieferetagesanzahl(monat.getMonatsanzahl());
				monat.schreibetage(monat.getMonatsanzahl(), monat
						.getTagesanzahl());
			} else if (menuauswahl == 3) {
				for (int i = 1; i <= 12; i++) {
					monatdeckblatt(i);
					monat.schreibetage(i, monat.lieferetagesanzahl(i));
					monat.schreibefeiertage(i, monat.lieferetagesanzahl(i));
				}
			}

			else if (menuauswahl == 4) {
				monat.erfasseMonatsanzahl();
				monat.erfasseJahrenanzahl();
				monatdeckblatt(monat.getMonatsanzahl());
				monat.lieferetagesanzahl(monat.getMonatsanzahl());
				monat.schreibetage(monat.getMonatsanzahl(), monat
						.getTagesanzahl());
				monat.schreibefeiertage(monat.getMonatsanzahl(), monat
						.getTagesanzahl());
			} else if (menuauswahl == 0) {
				System.out.println("Und Tschüss!");
				wiederholen = false;
			} else {
				System.out
						.println("Bitte nur die im Menü angegebenen Werte angeben!");
				wiederholen = true;

			}
		} while (wiederholen);

	}

	public int getMenuauswahl()
	{
		return menuauswahl;
	}

	public void setMenuauswahl(int menuauswahl)
	{
		this.menuauswahl = menuauswahl;
	}

	public static void monatdeckblatt(int a)
	{
		KalenderFunktionen kalle = new KalenderFunktionen();
		final String[] b = kalle.monatsname;
		System.out.print("                    " + b[a]);
		System.out
				.println("\n----------------------------------------------------");
		System.out.println(" " + "So" + "      " + "Mo" + "      " + "Di"
				+ "      " + "Mi" + "      " + "Do" + "      " + "Fr"
				+ "      " + "Sa" + " ");
	}

}

package kalender;

import java.text.SimpleDateFormat;
import java.util.*;

public class Monat {
	GregorianCalendar gc = new GregorianCalendar();
	SimpleDateFormat sdf = new SimpleDateFormat("EEEE");
	KalenderFunktionen kalenderfunktionen = new KalenderFunktionen();

	private int monatsanzahl = 0;
	private int jahresanzahl = 0;
	private int tagesanzahl;

	public Monat() {
		this.monatsanzahl = monatsanzahl;
		this.tagesanzahl = tagesanzahl;
	}

	public int getJahresanzahl()
	{
		return monatsanzahl;
	}

	public void setJahresanzahl(int jahresanzahl)
	{
		this.monatsanzahl = monatsanzahl;
	}

	public void erfasseJahrenanzahl()
	{
		System.out.println("Bitte Jahr eingeben:");
		jahresanzahl = MeineEingabe.erfasseInt();
	}

	public int getMonatsanzahl()
	{
		return monatsanzahl;
	}

	public void setMonatsanzahl(int monatsanzahl)
	{
		this.monatsanzahl = monatsanzahl;
	}

	public void erfasseMonatsanzahl()
	{
		boolean wiederholen = true;
		do {
			System.out.println("Bitte Monat von 1-12 wählen:");
			monatsanzahl = MeineEingabe.erfasseInt();
			if (monatsanzahl == 0 || monatsanzahl > 13) {
				System.out.println("Bitte nur Monat von 1-12 wählen!");
				wiederholen = true;
			} else {
				wiederholen = false;
			}

		} while (wiederholen);
	}

	public int getTagesanzahl()
	{
		return tagesanzahl;
	}

	public void setTagesanzahl(int tagesanzahl)
	{
		this.tagesanzahl = tagesanzahl;
	}

	public int lieferetagesanzahl(int monatsnummer)
	{
		tagesanzahl = kalenderfunktionen.tage_im_monat(monatsnummer, 2007);
		return tagesanzahl;
	}

	public void schreibetage(int monatsanzahl, int tagesanzahl)
	{
		gc.set(2007, monatsanzahl, 1);
		int bDayOfWeek = gc.get(Calendar.DAY_OF_WEEK);
		if (bDayOfWeek == 1) {
			System.out.print(" ");
		} else {
			System.out.print(" ");
			for (int b = 1; b < bDayOfWeek; b++) {
				System.out.print("        ");
			}
		}

		for (int i = 1; i <= tagesanzahl; i++) {
			gc.set(2007, monatsanzahl, i);
			int iDayOfWeek = gc.get(Calendar.DAY_OF_WEEK);

			if (i < 10) {
				System.out.print("0" + i + "      ");
			} else {
				System.out.print(i + "      ");
			}
			if (iDayOfWeek == 7) {
				System.out.print("\n" + " ");

			}
		}
	}

	public void schreibefeiertage(int monatsanzahl, int tagesanzahl)
	{
		System.out.println("\n");
		for (int e = 0; e <= tagesanzahl; e++) {
			int tagesnummer = kalenderfunktionen.tagesnummer(e, monatsanzahl,
					jahresanzahl);
			String feier = kalenderfunktionen.istFeiertag(jahresanzahl,
					tagesnummer);
			if (feier == null) {
				System.out.print("");
			} else {
				System.out.println(e + ". " + feier);
			}

		}

	}
}

package kalender;
/**
 * Klasse:  MeineAusgabe
 * 
 * @author  ChristianKirrmann
 * 
 */

/**
 * Enthaelt die Methoden die zur Ausgabe auf den Monitor erforderlich ist.
 */


public class MeineAusgabe {
	/**
	 * Dient der Ausgabe von Text in der Konsole
	 */
	public static void schreibe(String text) {
		System.out.print(text);
	}
}

package kalender;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.text.*;
import java.util.*;

public class MeineEingabe {
	private static BufferedReader eingabe = new BufferedReader(
			new InputStreamReader(System.in));

	public static String erfasseText()
	{
		String var = "";
		try {
			var = eingabe.readLine();
			if (var.equals(""))
			{
				var = null;
			}
		} catch (IOException e) {
			System.out.println("Fehler bei der Eingabe!");
		}
		return var;
	}

	public static String leseText() 
	{
		String var = "";
		boolean wiederholen = true;;
		do {
			try {
				var = eingabe.readLine();
				if (!var.equals("")) {
					wiederholen = false;
				}
				else {
					System.out.print("Das ist ein Pflichteingabefeld!\n");
					System.out.print("Bitte Eingabe wiederholen:");
					wiederholen = true;
				}
			} catch (IOException e) {
				System.out.println("Fehler bei der Eingabe!");
			}
		} while (wiederholen);
		return var;
	}

	public static int erfasseInt() 
	{
		int var = 0;
		boolean wiederholen = true;
		do {
			try {
				var = Integer.parseInt(erfasseText());
				if (var >= 0)
				{
				wiederholen = false;
				}
				else {
					System.out.print("Das ist ein Pflichteingabefeld!\n");
					wiederholen = false;
				}
			} catch (NumberFormatException e) {
				System.out.println("Keine gültige Zahl!");
			}
		} while (wiederholen);
		return var;
	}

	public static int leseInt() 
	{
		int var = 0;
		boolean wiederholen = true;
		do {
			try {
				var = Integer.parseInt(erfasseText());
				if (var != 0) {
					wiederholen = false;
				}
			} catch (NumberFormatException e) {
				System.out.println("Keine gültige Zahl!");
			}
		} while (wiederholen);
		return var;
	}

	public static double erfasseDouble() throws IOException
	{
		double var = 0;
		boolean wiederholen = true;
		do {
			try {
				return Double.parseDouble(erfasseText());
			} catch (NumberFormatException e) {
				System.out.println("Keine gültige Gleitkommazahl!");
			}
		} while (wiederholen);
		return var;
	}
	
	public static Date erfasseDatum()
	{
		String teingabe= "";
		boolean wiederholen = true;
		SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy");
		Date datum = new Date();
		do {
			try {
				teingabe = eingabe.readLine();
				datum = df.parse(teingabe);
				wiederholen = false;
			} catch (Exception e) {
				System.out.println("Bitte gültiges Datumsformat ( 'DD'.'MM'.'YYYY' ) eingeben!");
				wiederholen = true;
			}
		} while (wiederholen);
		return datum;
	}
}

package kalender;



public class KalenderFunktionen
{
static final  int MaxAnzahlTageImJahr = 365;/* ohne Schalttag */
static final  int TageProWoche = 7;

static final String[] monatsname =
	{null,"Januar","Februar","Maerz","April","Mai","Juni","Juli",
   "August","September","Oktober","November","Dezember"};

static final int[] monatslaenge = {0,31,28,31,30,31,30,31,31,30,31,30,31};

static final String[] wochentag =
	{"Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"};

static final String[] wochentagkurz = {"So","Mo","Di","Mi","Do","Fr","Sa"};



/* --------- Feiertage mit festem Datum ----------- */
static final String  Neujahr = new String("01.01");
static final String  HlgDreiKoenige = new String("06.01");
static final String  Valentinstag = new String("14.02");
static final String  Maifeiertag = new String("01.05");
static final String  MariaHimmelfahrt = new String("15.08");
static final String  TagDerEinheit = new String("03.10");
static final String  Allerheiligen = new String("01.11");
static final String  Nikolaus = new String("06.12");
static final String  Heiligabend = new String("24.12");
static final String  ErsterWeihnachtstag = new String("25.12");
static final String  ZweiteWeihnachtstag = new String("26.12");
static final String  Silvester = new String("31.12");

/* --------- von OSTERN abhaengige Feiertage ------------- */
 int Rosenmontag( int jahr )
 { return ostersonntag(jahr) - 48; }

 int Aschermittwoch( int jahr )
 { return ostersonntag(jahr) - 46; }

 int Gruendonnerstag( int jahr )
 { return ostersonntag(jahr) - 3; }

 int Karfreitag( int jahr )
 { return ostersonntag(jahr) - 2; }

 int Ostermontag( int jahr )
 { return ostersonntag(jahr) + 1; }

 int ChristiHimmelfahrt( int jahr )
 {	return ostersonntag(jahr) + 39; }

 int Pfingstsonntag( int jahr )
 { return ostersonntag(jahr) + 49; }

 int Pfingstmontag( int jahr )
 { return ostersonntag(jahr) + 50;}

 int Fronleichnam( int jahr )
 { return ostersonntag(jahr) + 60; }

/* --------- Feiertage mit festem Wochentag ------------
 * VierteAdvent		1.te Sonntag vor ErsterWeihnachtstag
 * DritteAdvent		2.te Sonntag vor ErsterWeihnachtstag
 * ZweiteAdvent		3.te Sonntag vor ErsterWeihnachtstag
 * ErsteAdvent		4.te Sonntag vor ErsterWeihnachtstag
 * Totensonntag		5.te Sonntag vor ErsterWeihnachtstag
 * Volkstrauertag	6.te Sonntag vor ErsterWeihnachtstag
 * BussBetTag		Mittwoch vor 5.te Sonntag vor ErsterWeihnachtstag
 */

/* --------- Sommer- / Winterzeit ------------
 * Sommerzeit		1.te Sonntag vor dem 01.04
 * Winterzeit		1.te Sonntag vor dem 01.11
 */



/**
 =========================================================================
 * Funktion:	istSchaltjahr( int jahr )
 * Parameter:	jahr (int)	:	das Jahr, das auf Schaltjahr ueberprueft wird
 * Rueckgabe:	(boolean) 	: 	true, wenn das Jahr ein Schaltjahr ist
 *				: 	false,  wenn das Jahr nicht Schaltjahr ist
 * Beschreibung: jedes 4.te Jahr ist Schaltjahr,
 * (wenn sich das Jahr durch 4 ohne Rest teilen laesst, ist es Schaltjahr )
 * Ausnahme davon jedes 100.te Jahr ist kein Schaltjahr
 * (wenn sich das Jahr durch 100 ohne Rest teilen laesst, ist es kein Schaltjahr)
 * Ausnahme davon jedes 400.ter Jahr	ist wieder Schaltjahr
 * (wenn sich das Jahr durch 400 ohne Rest teilen laesst, ist es Schaltjahr)
 * =========================================================================
 */
 boolean istSchaltjahr(int jahr)
 {

	return ((jahr%4 == 0 )&&((jahr%100 != 0 )||( jahr%400 == 0 )));
 }


/**
 =========================================================================
 * Funktion:	schaltjahr(int jahr)
 * Parameter:	jahr (int)	:	das Jahr, das auf Schaltjahr ueberprueft wird
 * Rueckgabe:	(int) 	: 	1 = true, wenn das Jahr ein Schaltjahr ist
 *			: 	0 = false,  wenn das Jahr nicht Schaltjahr ist
 * Beschreibung: siehe --> istSchaltjahr(long jahr)
 * =========================================================================
 */
 int schaltjahr(int jahr)
 {
	if(istSchaltjahr(jahr)) return 1;
	else return 0;
 }

/**
 =========================================================================
 * Funktion:	tage_seit_begin( int tag, int monat, int jahr)
 * Parameter:	tag (int)		: Tag
 *				monat (int) 	: Monat
 *				jahr (int)		: Jahr
 * Rueckgabe:	(long) 			: Anzahl der Tage seit Begin (das Jahr 1)
 * Beschreibung: die Berechnung der Anzahl der Tage seit dem Jahr 1 nach dem
 * gregorianischen Kalender,
 * was historisch nicht korrekt ist, da der gregor. Kalender erst
 * seit 1582 in Kraft trat.
 * =========================================================================
 */

 long tage_seit_begin( int tag, int monat, int jahr)
 {
	int		summe,
				i;

	summe = MaxAnzahlTageImJahr * (jahr -1); /* Anzahl der Tage aller vergangenen Jahre */
	summe += ( (jahr -1) / 4 ); 	/* plus alle vergangenen Schalttage */
	summe -= ( (jahr -1) / 100);	/* minus alle Schalttage, die zuviel berechnet wurden */
	summe += ( (jahr -1) / 400); 	/* plus alle Schalttage, die alle 400 Jahr anfallen */

//	if( monat != 1 )
		for(i = 1;i<monat;i++)
			summe += tage_im_monat( i, jahr );	/* plus alle Tage vergangener Monate */

	summe += tag;	/* plus alle restlichen Tage des Monats */

	return ( summe );
 }


/**
 =========================================================================
 * Funktion:	tage_im_monat( int monat, int jahr)
 * Parameter:	monat (int) 	: Monat
 *				jahr (int)		: Jahr
 * Rueckgabe:	(int) 			: Anzahl der Tage in einem Monat
 * Beschreibung: gibt die Anzahl der Tage im Monat zurueck
 * =========================================================================
 */

 int tage_im_monat( int monat, int jahr)
 {
	if( (monat != 2)||((monat == 2)&&(!istSchaltjahr(jahr)) ) )
		return monatslaenge[monat];
	else return ( monatslaenge[monat] + 1 ); /* Schalttag beruecksichtigen */
 }


/**
 =========================================================================
 * Funktion:	julian_date (int jahr, int monat, int tag)
 * Parameter:	tag (int)		: Tag
 *				monat (int) 	: Monat
 *				jahr (int)		: Jahr
 * Rueckgabe:	(long) 			: Anzahl der Tage seit dem 1.1.4713 vor Christus
 * Beschreibung: Das Julianische Datum  gibt die Anzahl der Tage
 * seit dem 1.1.4713 vor Christus an.
 * Algorithmus von R. G. Tantzen
 * =========================================================================
 */
 long julian_date(int tag, int monat, int jahr)
 {
	long 	c, y;

	if (monat>2)
		monat = monat - 3;
	else
	{
		monat = monat + 9;
		jahr--;
	}
	tag = tag + (153*monat+2) / 5;
	c = (146097L * (jahr / 100L))/4L;
	y = (1461L * (jahr % 100L))/4L;
	return c+y+tag+1721119L;
 }

/**
 =========================================================================
 * Funktion:	tagesnummer(int tag, int monat, int jahr)
 * Parameter:	tag (long)		: Tag
 *				monat (long) 	: Monat
 *				jahr (long)		: Jahr
 * Rueckgabe:	n (int)	   : Tagesnummer rel. zum Jahresanfang
 *	  					     (1=1.1.,2=2.1.,...365/366=31.12)
 * Beschreibung: Algorithmus von Robertson
 * =========================================================================
 */
 int tagesnummer(int tag, int monat, int jahr)
 {
   int d, e;
   d = (monat+10)/13;
   e = tag + (611*(monat+2))/20 - 2*d - 91;
   return (e + schaltjahr (jahr) * d );
 }

/**
 =========================================================================
 * Funktion:	monat_im_jahr(int jahr, int n)
 * Parameter:	jahr (long)	: Jahr
 *				n (int)	: Tagesnummer rel. zum Jahresanfang
 *						  (1=1.1.,2=2.1.,...365/366=31.12)
 * Rueckgabe:	(int) 	: Monat (1=Jan, 2=Feb, ... 12 = Dec)
 * Beschreibung: 	Algorithmus von  R. A. Stone
 * =========================================================================
 */
 int monat_im_jahr(int jahr, int n)
 {
   int a;
   a = schaltjahr(jahr);
   if ( n > 59+a )
	  n += 2-a;
   n += 91;
   return (20*n)/611 - 2;
 }

/**
 =========================================================================
 * Funktion:	tag_im_jahr(int jahr, int n)
 * Parameter:	jahr (long)	: Jahr
 *				n (int)		: Tagesnummer rel. zum Jahresanfang
 *							  (1=1.1.,2=2.1.,...365/366=31.12)
 * Rueckgabe:	(int) 		: Ausgabe: Tag (1..31)
 * Beschreibung: Algorithmus von  R. A. Stone
 * =========================================================================
 */
int tag_im_jahr(int jahr, int n)
{
   int a, m;
   a = schaltjahr(jahr);
   if ( n > 59+a )
	  n += 2-a;
   n += 91;
   m = (20*n)/611;
   return n - (611*m)/20;
}

/**
 =========================================================================
 * Funktion:	wochentag_im_jahr(int jahr, int n)
 * Parameter:	jahr (long)	: Jahr
 *				n (int)		: Tagesnummer rel. zum Jahresanfang
 *							  (1=1.1.,2=2.1.,...365/366=31.12)
 * Rueckgabe:	(int) : Wochentag (0=So, 1=Mo,..., 6=Sa)
 * Beschreibung: Algorithmus von Zeller
 * =========================================================================
 */
 int wochentag_im_jahr(int jahr, int n)
 {
   int j, c;
   j = (jahr-1) % 100;
   c = (jahr-1) / 100;
   return (28+j+n+(j/4)+(c/4)+5*c) % 7;
 }

/**
 =========================================================================
 * Funktion:	ostersonntag(int jahr)
 * Parameter:	jahr (long)	: Jahr
 * Rueckgabe:	(int) 		: Tagesnummer des Ostersonntag rel. zum Jahresanfang
 * Beschreibung: Algorithmus "Computus ecclesiasticus"
 * 325 n.Chr. wurde Ostern auf den Sonntag nach
 * dem ersten Fruehlingsvollmond festgelegt. Damit
 * liegt Ostern zwischen dem 22. Maerz und dem 25. April.
 * =========================================================================
 */
 int ostersonntag(int jahr)
 {
   int gz, jhd, ksj, korr, so, epakte, n;

   gz = (jahr%19)+1;
   jhd = jahr/100+1;
   ksj = (3*jhd)/4-12;
   korr = (8*jhd+5)/25-5;
   so = (5*jahr)/4-ksj-10;
   epakte = (11*gz+20+korr-ksj) % 30;
   if ( (epakte == 25 && gz > 11) || epakte == 24 )
	  epakte++;
   n = 44-epakte;
   if ( n < 21 )
	  n = n + 30;
   n = n + 7 - (so+n) % 7;
   n += schaltjahr(jahr);
   return n+59;
 }

// Ergänzungen aus dateFunktionen.c
/**
 * =========================================================================
 * Funktion:	istFeiertag( long jahr, int tagNr  )
 * Parameter: 	jahr (long)	: Jahr
 *					tagNr (int) : Tagesnummer
// * Rueckgabe:	(BOOL)		: True (= Feiertag), False (= kein Feiretag)
 * Rueckgabe:	(String)	: Text des Feiertages oder <code>null</code>
 * Beschreibung: gibt True zurueck, wenn Datum ein Feiertag ist
 *				 	  andernfalls False
 *	 Allerdings werden die Feiertage nicht unterschieden in gesetzliche,
 *	 regional abhängige, kommerzielle (Valentinstag), Winter- und Sommerzeit
 *  oder sonstige Ereignisse.
 * =========================================================================
 */
String istFeiertag (int jahr, int tagNr )
{
	int 	i;
   // long 	monat, tag;
   // monat = monat_im_jahr( jahr, tagNr );
   // tag 	= tag_im_jahr( jahr, tagNr );

	/* alle Feiertage, die vom Ostersonntsg abhaengen */
	if( tagNr == ostersonntag( jahr )) return "Ostersonntag";			/* Ostersonntag */
	else if ( tagNr == Ostermontag(jahr) ) return "Ostermontag";
	else if ( tagNr == ChristiHimmelfahrt( jahr ) ) return "Christi Himmelfahrt";
	else if ( tagNr == Pfingstsonntag( jahr ) ) return "Pfingstsonntag";
	else if ( tagNr == Pfingstmontag( jahr ) ) return "Pfingstmontag";
	else if ( tagNr == Fronleichnam( jahr ) ) return "Fronleichnam";
	else if ( tagNr == Karfreitag( jahr ) ) return "Karfreitag";
	else if ( tagNr == Gruendonnerstag( jahr ) ) return "Gruendonnerstag";
	else if ( tagNr == Rosenmontag( jahr ) ) return "Rosenmontag";
	else if ( tagNr == Aschermittwoch( jahr ) ) return "Aschermittwoch";
	 
	//+++ ACHTUNG! Korrektur 17.1.02 ++++++++++
	int tagnrf;		
	for( i = 0;i<6;i++)
	{	/* alle Feiertage mit festem Wochentag: 1.2.3.4.Advent,
		Totensonntag, Volkstrauertag */
		
		if( wochentag_im_jahr( jahr, tagesnummer( 25, 12, jahr) ) != 0)
		{	// wenn der 25.12. kein Sonntag ist, liegen 
			// die Feiertage i Sonntage vor dem 25.12.
			tagnrf =  getFeiertag_festWotag(jahr, i); 
		}
		else{
			// wenn 25.12. ein Sonntag ist, dann darf der 4.Advent nicht auf 
			// denselben Sonntag fallen, sondern muss noch 1 Sonntag davor liegen! 
			tagnrf =  getFeiertag_festWotag(jahr, i+1); 
		}
		
		if (tagnrf == tagNr){
			if(i < 4 )	return 4-i + ". Advent";
			else if (i == 4 ) return "Totensonntag";
			else return "Volktrauertag"; 	
		}
	}
	//+++ ACHTUNG! Korrektur 17.1.02 ++++++++++

	tagnrf =  getFeiertag_muttertag(jahr); /* Muttertag - Blumen schenken! */
	if(tagnrf == tagNr) return "Muttertag - Blumen schenken";

	tagnrf =  getFeiertag_bussbettag(jahr);		/* Buss und Bettag */
	if(tagnrf == tagNr) return "Buss und Bettag";

	tagnrf =  getFeiertag_fest( Neujahr, jahr); 	/* Neujahr */
	if(tagnrf == tagNr) return "Neujahr";

	tagnrf =  getFeiertag_fest( HlgDreiKoenige, jahr); /* Heiligen drei Koenige*/
	if(tagnrf == tagNr) return "Heiligen drei Koenige";

	tagnrf =  getFeiertag_fest( Valentinstag, jahr);	 /* Valentinstag */
	if(tagnrf == tagNr) return "Valentinstag";

	tagnrf =  getFeiertag_fest( Maifeiertag, jahr);		/* 1.ter Mai */
	if(tagnrf == tagNr) return "1.ter Mai";

	tagnrf =  getFeiertag_fest( MariaHimmelfahrt, jahr);  /* Maria Himmelfahrt */
	if(tagnrf == tagNr) return "Maria Himmelfahrt";

	tagnrf =  getFeiertag_fest( TagDerEinheit, jahr);  /* Tag d. deut. Einheit */
	if(tagnrf == tagNr) return "Tag d. deut. Einheit";

	tagnrf =  getFeiertag_fest( Allerheiligen, jahr);	/* Allerheiligen */
	if(tagnrf == tagNr) return "Allerheiligen";

	tagnrf =  getFeiertag_fest( Nikolaus, jahr);			/* Nikolaus */
	if(tagnrf == tagNr) return "Nikolaus";

	tagnrf =  getFeiertag_fest( Heiligabend, jahr); /* Heilig Abend */
	if(tagnrf == tagNr) return "Heilig Abend";

	tagnrf =  getFeiertag_fest( ErsterWeihnachtstag, jahr);	/* Weihnachten */
	if(tagnrf == tagNr) return "1. Weihnachten";

	tagnrf =  getFeiertag_fest( ZweiteWeihnachtstag, jahr);	/* Weihnachten */
	if(tagnrf == tagNr) return "2. Weihnachten";

	tagnrf =  getFeiertag_fest( Silvester, jahr);			/* Sylvester */
	if(tagnrf == tagNr) return "Sylvester";

	tagnrf =  getWinterzeit( jahr);						/* Beginn der Winterzeit */
	if(tagnrf == tagNr) return "Beginn der Winterzeit";

	tagnrf =  getSommerzeit( jahr);						/* Beginn der Sommerzeit */
	if(tagnrf == tagNr) return "Beginn der Sommerzeit";

	return null;
} // Ende istFeiertag

/**
 * =========================================================================
 * Funktion:	getFeiertag_festWotag(int jahr, int anz_so)
 * Parameter:	jahr (int)    : Datum (25.12.jjjj), ab dem gerechnet wird
 *				anz_so ( int) : der x.te Sonntag vor dem Datum
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung: 	Hilfsfunktion, gibt den Sonntag zurueck, der vor dem
 *					uebergebenen Datum liegt
 * 					-> fuer Feiertage mit festem Wochentag <-
 * =========================================================================
 */
int getFeiertag_festWotag(int jahr, int anz_so)
{

	int  wotag, tagNr1, tagNr2;

	tagNr1 = tagesnummer(25, 12, jahr);
	wotag =  wochentag_im_jahr( jahr, tagNr1);

	tagNr2 = tagNr1 - wotag - (anz_so * 7);

	return tagNr2;
} // Ende getFeiertag_festWotag

/**
 * =========================================================================
 * Funktion:	getFeiertag_fest(char *str, int jahr)
 * Parameter:	str (char *): Zeichenkette, die Tag/Monat
 *							  im Format "tt.mm" enthaelt
 *				jahr ( int) : Jahr
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung: Hilfsfunktion, wandelt das Format "tt.mm" in Datumsstruktur um
 * 				->fuer Feiertage mit festem Datum <-
 * =========================================================================
 */
int getFeiertag_fest(String str, int jahr)
{
	int datumT, datumM;
	String buffer_tag;
	String buffer_monat;

	/*
	strncpy( buffer_tag, str, 2); buffer_tag[2]=StringEndekennung;
	strncpy( buffer_monat, &str[3], 2 ); buffer_monat[2]=StringEndekennung;
	datum.tag = atoi( buffer_tag );
	datum.monat = atoi( buffer_monat );
	datum.jahr = jahr;
	return datum;
	*/
	buffer_tag = str.substring(0,2);
	buffer_monat = str.substring(3,5);
	datumT = Integer.parseInt(buffer_tag);
	datumM = Integer.parseInt(buffer_monat);
	return tagesnummer(datumT, datumM, jahr);

} // getFeiertag_fest

/**
 * =========================================================================
 * Funktion:	getFeiertag_bussbettag(int jahr)
 * Parameter:	jahr (int)	: Datum (25.12.jjjj), ab dem gerechnet wird
// * Rueckgabe:	(Date) : Struktur, die Tag, Monat, Jahr als Integer enthaelt
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung: gibt das Datum vom Buss- und Bettag zurueck (als Struktur Date)
 *		 Buss-und Bettag ist immer 32 Tage vor dem letzten Sonntag vor dem 25.12.
 * 	 32 Tage = (4 Sonntage * 7 Tage) + 4 Tage
 * =========================================================================
 */
int getFeiertag_bussbettag(int jahr)
{
	// Date datum_back;
	int  wotag, tagNr1, tagNr2;
	int  anz_so = 4; /* Anzahl der Sonntage */

	tagNr1 = tagesnummer(25, 12, jahr);
	wotag =  wochentag_im_jahr( jahr, tagNr1);

	tagNr2 = tagNr1 - wotag - (anz_so * 7) - 4;

	// datum_back.tag = tag_im_jahr( jahr, tagNr2);
	// datum_back.monat = monat_im_jahr( jahr, tagNr2);
	// datum_back.jahr = jahr;
	// return datum_back;

	return tagNr2;
} // Ende getFeiertag_bussbettag

/**
 * =========================================================================
 * Funktion:	getFeiertag_muttertag(int jahr)
 * Parameter:	jahr (int): Datum (30.04.jjjj), ab dem gerechnet wird
// * Rueckgabe:	(Date) 	 : Struktur, die Tag, Monat, Jahr als Integer enthaelt
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung: gibt das Datum vom Muttertag zurueck (als Struktur Date)
 * Muttertag ist immer 14 Tage nach dem letzten Sonntag im April. Falls dieser
 * Tag Pfingstsonntag ist, wird der Muttertag eine Woche vorverlegt.
 * =========================================================================
 */
int getFeiertag_muttertag(int jahr)
{
	// Date datum_back;
	int  wotag, tagNr1, tagNr2;
	int  anz_so = 4;

	tagNr1 = tagesnummer(30, 4, jahr);
	wotag =  wochentag_im_jahr( jahr, tagNr1);
	tagNr2 = tagNr1 - wotag +14;

	if( tagNr2 == Pfingstsonntag( jahr ) )
		tagNr2 = tagNr2 - 7;

	// datum_back.tag = tag_im_jahr( jahr, tagNr2);
	// datum_back.monat = monat_im_jahr( jahr, tagNr2);
	// datum_back.jahr = jahr;

	// return datum_back;
	return tagNr2;
} // Ende getFeiertag_muttertag

/**
 * =========================================================================
 * Funktion:	getSommerzeit(long jahr)
 * Parameter:	jahr (int)	: Jahr
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung: 	gibt die Sommerzeit (1.te Sonntag vor dem 1.4.)
						fuer das Jahr zurueck
 * =========================================================================
 */
int getSommerzeit(int jahr)
{
	return get_SW_Zeit(jahr, 4);
}

/**
 * =========================================================================
 * Funktion:	getWinterzeit(long jahr)
 * Parameter:	jahr (int)	: Jahr
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung:  gibt die Winterzeit (1.te Sonntag vor dem 1.11.)
						fuer das Jahr zurueck
 * =========================================================================
 */
int getWinterzeit(int jahr)
{
	return get_SW_Zeit(jahr, 11);
}

/**
 * =========================================================================
 * Funktion:	get_SW_Zeit(long jahr, int monat)
 * Parameter:	jahr (long)	: Jahr
 *					monat (int) : Monat ( 4 = Sommerzeit, 11 = Winterzeit )
 * Rueckgabe:	(int) : Tagesnummer im Jahr
 * Beschreibung: Hilfsfunktion zur Berechnung der Winter-/Sommerzeit
 * =========================================================================
 */
int get_SW_Zeit(int jahr, int monat)
{

	int  wotag, tagNr1, tagNr2;

	tagNr1 = tagesnummer(1, monat, jahr);
	wotag =  wochentag_im_jahr( jahr, tagNr1);
	tagNr2 = tagNr1 - wotag;

	return tagNr2;
} // Ende get_SW_Zeit



} // end of class KalFunk

Die wichtigsten Klasse sind eben MONAT UND MAIN, da die gesamten Werte, die in die Konsole geschrieben werden auch in die Textdatei ( aus Klasse Streams ) müssen.

 

[SlaterB]

ich könnte jetzt meine Antwort noch mal wiederholen,
aber ob damit wem geholfen ist?

hast du meins gelesen/ willst du darauf eingehen/ hast du andere Fragen/
wartest du auf anderen Antworten?

 

[Murray]

Auch wenn du noch mehr Code postest - am Problem ändert das nicht; du solltest Daten, die du später nochmal brauchst, nicht einfach per System.out auf die Konsole schreiben, sondern lieber direkt dann einsammeln, wenn sie anfallen.

Notfalls kannst du mit Output-Redirection arbeiten und - bevor die ganzen Ausgaben auf die Konsole geschrieben werden - mit System#setOut einen eigenen PrintWriter setzen, der sich die Ausgaben irgendwo merkt, Dann wirdt du aber natürlich auch deine Auswahlmenüs mit in dieser Ausgabe finden.

 

[Guest]

Du hast mir vorgeschlagen eine Methode merkeUndOute(xy) anstatt System.out.print() zu verwenden.

Wie könnte in diesem Fall diese Methde aussehen? Ich weiß wirklich nicht, wie ich das alles in einen String bekomme. :?

 

[SlaterB]

public static void merkeUndOute(String xy) {
System.out.println(xy);

// merke xy
}

wenn du grundsätzlich nicht weißt, wie man sich Strings merkt,
dann solltest du erstmal im kleinen Rahmen anfangen,
nicht das Problem auf System.out usw lenken,

das geht z.B. mit einer Liste, ArrayList,
list.add(xy);

 

[Guest]

@Murray

Notfalls kannst du mit Output-Redirection arbeiten und - bevor die ganzen Ausgaben auf die Konsole geschrieben werden - mit System#setOut einen eigenen PrintWriter setzen, der sich die Ausgaben irgendwo merkt, Dann wirdt du aber natürlich auch deine Auswahlmenüs mit in dieser Ausgabe finden.

Die gesamte Konsolenausgabe in einen String zu speichern wäre bei dieser Problematik doch am besten. Wie müsste ich die Methode genau definieren bzw. in welche Klasse, damit die gesamte Konsolenausgabe in einen String gepackt wird?

 

[Murray]

Die gesamte Konsolenausgabe in einen String zu speichern wäre bei dieser Problematik doch am besten.

Finde ich weiterhin nicht, aber dem Menschen Wille ist sein Himmelreich...

Wie müsste ich die Methode genau definieren bzw. in welche Klasse, damit die gesamte Konsolenausgabe in einen String gepackt wird?

Kleines Beispiel für Output-Redirection:

import java.io.*;

public class Redirect {

 static class PW extends PrintStream {
 
   //--- Puffer zum Zwischenspeichern der Daten
   private ByteArrayOutputStream baos = new ByteArrayOutputStream();
   
   
   public PW( OutputStream dest) {
     super( dest);
   }
   
   public void write( byte[] b, int offset, int length) {
   
     //--- Superklasse delegiert den write-Befehl an den Zieldatenstrom
     super.write( b, offset,length);
     
     //--- zus. Daten im Puffer ablegen
     baos.write( b, offset, length);
   }
   
   public String getStr() throws IOException {
   
     //--- evtl. gepufferte Daten in Puffer uebernehem
     flush();
     baos.flush();
     
     //--- String-Repraesentation erzeugen
     return new String( baos.toByteArray());
   }
   
 }

public static void main( String[] args) throws IOException {


  //--- Standard-Ausgabestrom merken
	final PrintStream out = System.out;
	
	System.out.println( "Vorher");
	
	//--- eigenen Ausgabestrom setzen
	PW pw = new PW( out);
	System.setOut( pw);
	
	
  System.out.println( "Mittendrin");

  for ( int i=0; i<10; i++) {
    for ( int j=0; j<10; j++) {
      System.out.print( j);
      System.out.print( " ");
    }
    System.out.println();
  }
	
	//--- Standard-Ausgabestrom wiederherstellen
	System.setOut( out);

	System.out.println( "Nacher");
	
	System.out.println( "=== <Konsolenausgabe> ===========================");
  System.out.print( pw.getStr());
	System.out.println( "=== </Konsolenausgabe> ==========================");

}
}

 

[Guest]

@Murray


Danke für das Beispiel. Allerdings programmiere ich noch nicht so lange und da steig ich überhaupt nicht durch.

Wie könnte man den nun mithilfe deiner Methoden das beispielsweise alle System.out.print() - Prozesse in meinen Klassen MONAT und MAIN ersetzen/anpassen, damit die Konsolenausgaben als ein String zusammengefasst werden und dann in eine Texdatei ( mithilfe der Klasse Streams ) gespeichert werden kann. Ich wäre dir dankbar, wenn du mir das ggf in meine Klassen einbauen könntest.

Sollte das ganze nicht funktionieren, muss ich mich eben damit abfinden das Problem nicht mehr lösen zu können. :bloed:

 

[Gast]

Wenn du grundsätzlich keine Abneigung dagegen hast, kannst du ein Loggingsystem verwenden. Entweder log4j oder den in Java integrierten Logger.

Da würdest du dann nicht mehr System.out verwenden, sondern die Ausgaben an den Logger übergeben.

In einer properties Datei kannst du dann konfigurieren wohin du deine Loggingnachrichten überall ausgegeben haben willst. (Console, Textdatei, Rollierende Textdatei, Datenbank, JMS, Mail, ...).

Und wie, was alles geloggt werden soll(z.B Uhrzeit der Ausgabe, Loglevel, und natürlich die Nachricht)

 

[André Uhres]

Vielleicht hilft dies: http://www.java-forum.org/de/topic57807_console.html
Die gesamte Konsole wird in eine JTextPane geschrieben.
Die kannst du dann mit JTextComponent#write direkt in eine Datei schreiben :wink:
console.txt
Kalender.jar (Quellcode im jar)

 

[Murray]

Wie könnte man den nun mithilfe deiner Methoden das beispielsweise alle System.out.print() - Prozesse in meinen Klassen MONAT und MAIN ersetzen/anpassen, damit die Konsolenausgaben als ein String zusammengefasst werden und dann in eine Texdatei ( mithilfe der Klasse Streams ) gespeichert werden kann. Ich wäre dir dankbar, wenn du mir das ggf in meine Klassen einbauen könntest.

Das Beispiel war eher für den Fall gedacht, dass du die Aufrufe von System.out.print/println eben nicht durch irgendetwas ersetzen musst. Dazu einfach die Defintion der statischen Klasse PW in deine KLasse mit der Main-Methode kopieren, dann diesen Abschnitt

  //--- Standard-Ausgabestrom merken
   final PrintStream out = System.out;
   
   //--- eigenen Ausgabestrom setzen
   PW pw = new PW( out);
   System.setOut( pw);

an den Anfang der main-Methode setzen und diesen

   //--- Standard-Ausgabestrom wiederherstellen
   System.setOut( out);
   String ausgabe = pw.getStr();

ans Ende.

Dann enthält die Variable ausgabe am Ende die vollständige Konsolenausgabe (eigentlich nur das, was nach System.out geschrieben wurde; System.err its nicht umgeleitet).

Aber grundsätzlich würde ich dir eher dazu raten, System.out.print/println wirklich durch etwas anders zu ersetzen - diese Umleitung ist eher dann das Mittel der Wahl,wenn man das entsprechende Programm nicht modifizieren kann/darf.