# String mit Nullen auffüllen!



## LYBD (9. Nov 2009)

Ich muss einen String mit Nullen Auffüllen es geht mal wieder um Timestamps 
welche folgendermaßen aussehen: 
2008-12-30-18.08.55.906000

Meine sehen zur Zeit aber so aus:
2009-04-06-12.14.04.875
oder so:
2009-09-06-16.52.07.25
also einfach alle Möglichkeiten von:
.0 bis .123456

Wie kann ich dies machen das das ganze quasi Variabel ist ???:L???:L???:L

Hier mal mein CODE:


```
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

public class Abholprozess
{
//	Vor dem Ausführen UserID ändern und Fehlgeschlagen.txt auf dem Dekstop anlegen!
	//final static String VERZEICHNIS = ("C:/Workspaces/stdRAD/doc/Abholprozess.log");
	final static String VERZEICHNIS = ("C:/Workspaces/stdRAD/doc/Test.txt");
	final static String FEHLERHAFT ="C:/Dokumente und Einstellungen/Desktop/Fehler.txt";
	final static String ERFOLG ="C:/Dokumente und Einstellungen/dpadsp/Desktop/OK.txt";
	final static String DPOOLP ="C:/Workspaces/stdRAD/doc/DPOOLP.txt";
	final static String FEHLER = "Fehlerhaft";
	final static String OK = "Erfolgreich";
	
	private List m_alleFehlerhaften;
	private List m_alleErfolgreichen;
	
	public static void main(String[] args)
	{
		Abholprozess test = new Abholprozess();
		test.liesAbholLog();
		test.gibErgebnisseAus();
	}
	
	private void gibErgebnisseAus() 
	{
		try 
		{
			ausgabeListe(FEHLERHAFT, m_alleFehlerhaften);
			ausgabeListe(ERFOLG, m_alleErfolgreichen);
		} 
		catch (Exception e) 
		{
			System.out.println("Fehler bei der Ausgabe der Ergebnisse: " + e);
		}
	}
	
	private void ausgabeListe(String sDateiPfad, List liste)throws IOException
	{
		PrintWriter fehlerwriter = new PrintWriter(new FileOutputStream(new File (sDateiPfad)));
		Iterator i = liste.iterator();
		while (i.hasNext())
		{
			fehlerwriter.println(i.next());
		}
		fehlerwriter.close();
	}
	
	/**
	 * Liest die Logdatei ein und ermittelt die beiden Listen 
	 * mit den fehlerhaften und den erfolgreichen Aufträgen.
	 */
	private void liesAbholLog()
	{
		m_alleErfolgreichen = new ArrayList();
		m_alleFehlerhaften = new ArrayList();
		
		Map hmAlleAuftraege = new HashMap();
		
		String sTeil = null;
		String sValueAusZeile = null; 
		String sTimestampAlt = null;
		String sTimestampNeu = null;
		String sText = null;
		String sKey = null;
		String sGesamt = null;
		
		int iAuftrag;
		int iWurde;
		// Datei öffen, für jede erfolgreich bzw. fehlerhaft-Zeile 
		String sZeile;
		boolean bZeileRelevant;
		try
		{
			BufferedReader bReader = new BufferedReader(new FileReader(VERZEICHNIS));
			sZeile = bReader.readLine();
			while (sZeile != null) 
			{
				// Prüfen, ob die Zeile relevant ist
				//Value aus Zeile ermittlen (fehlerhaft oder erfolgreich)
				//und Auftr_Key ermittlen (ID des Auftrages)
				if(sZeile.contains("fehlgeschlagen!"))
				{
					sValueAusZeile = FEHLER;
					iAuftrag = sZeile.indexOf("Auftrag ");
					iWurde = sZeile.indexOf("fehlgeschlagen!");
					sTeil = sZeile.substring(iAuftrag+8, iWurde-24);
					sTimestampAlt = sZeile.substring(iAuftrag+35, iWurde-1);
					sText = sZeile.substring(iWurde-1, iWurde+15);
					Timestamp Time = pruefeTimestamp(sTimestampAlt);
					sTimestampNeu = Time.toString().replace(" ", "-").replace(":", ".");
					
					int ilaenge = sTimestampNeu.length();
					if (ilaenge <29)
					{
						for (int i = ilaenge; i<=29;i++)
						{
							//TODO
							//Füge so lange 0en hinzu bis es die länge 29 erreicht hat!
						}
					}
					sGesamt = sTeil + sTimestampNeu + sText;
					bZeileRelevant = true;
				}
				else if(sZeile.contains("weitergeleitet"))
				{
					sValueAusZeile = OK;
					iAuftrag = sZeile.indexOf("Auftrag ");
					iWurde = sZeile.indexOf("wurde");
					sTeil = sZeile.substring(iAuftrag+8, iWurde-24);
					sTimestampAlt = sZeile.substring(iAuftrag+35, iWurde-1);
					sText = sZeile.substring(iWurde-1, iWurde+33); 
					Timestamp Time = pruefeTimestamp(sTimestampAlt);
					sTimestampNeu = Time.toString().replace(" ", "-").replace(":", ".");
					sGesamt = sTeil + sTimestampNeu + sText;
					bZeileRelevant = true;
				}
				else
				{
					bZeileRelevant = false;					
				}
				if (bZeileRelevant)
				{
					// prüfen, ob Map schon den Key enthält
					// gegebenenfalls darauf reagieren
					// anderenfalls hinzufügen
					String sValueInMap = (String) hmAlleAuftraege.get(sGesamt);
					if (sValueInMap != null)
					{
						// schon vorhanden, prüfen was zu tun ist
						if (!sValueAusZeile.equals(sValueInMap))
						{
							if (sValueInMap.equals(FEHLER))
							{
								hmAlleAuftraege.put(sGesamt, sValueAusZeile);
							}
							else
							{
								System.out.println("Fehler bei ID"+sGesamt );
							}
						}
					}
					else
					{
						// noch nicht vorhanden -> hinzufügen
						hmAlleAuftraege.put(sGesamt, sValueAusZeile);
					}
				}
				sZeile = bReader.readLine();
			}
				
			bReader.close();
		}
		catch(IOException ioe)
		{
			ioe.printStackTrace();
		}
		
		// anschließend alle Keys durchitterieren und alle fehlerhaften in die fehlerhaft-Liste
		// und alle erfolgreichen in die Erfolgreich-Liste reinschreiebn
		Iterator itAlle = hmAlleAuftraege.keySet().iterator();
		String sValue;
		while (itAlle.hasNext())
		{
			sGesamt = (String) itAlle.next();
			sValue = (String) hmAlleAuftraege.get(sGesamt);
			if (sValue == null)
			{
				System.out.println(sGesamt);
			}
			else if (sValue.equals(OK))
			{
				m_alleErfolgreichen.add(sGesamt);
			}
			else if (sValue.equals(FEHLER))
			{
				m_alleFehlerhaften.add(sGesamt);
			}
			else
			{
				System.out.println("Nicht vorgesehener wert für key " + sGesamt + ": " + sValue);
			}
		}
	}
	public Timestamp pruefeTimestamp(String sEingabe)
	{
		Timestamp tsResult = null;
		if( (sEingabe == null) || (sEingabe.trim().length() == 0))
		{
			System.out.println("Kein Timestamp vorhanden - bitte eingeben!");
		}
		else
		{
			try
			{
				StringTokenizer tok = new StringTokenizer(sEingabe, " .:-_");
				StringBuffer buffer = new StringBuffer();
				for (int ii = 0; ii < 7; ii++)
				{
					if( tok.hasMoreTokens() )
					{
						buffer.append(tok.nextToken());
					}
					else
					{
						buffer.append("0");
					}
					switch( ii )
					{
						case 0:
						case 1:
							buffer.append('-');
							break;
						case 2:
							buffer.append(' ');
							break;
						case 3:
						case 4:
							buffer.append(':');
							break;
						case 5:
							buffer.append('.');
							break;
						default:
					}
				}
				tsResult = Timestamp.valueOf(buffer.toString());
			}
			catch (Exception ex)
			{
				System.out.println("Kein gültiger Timestamp: " + sEingabe);
			}
		}
		return tsResult;
	}
}
```


----------



## FArt (9. Nov 2009)

Aufwendig: schreibe eine eigene Klasse a la SimpleDateFormat
Oder: einfache Stringoperationen. Wo ist der Punkt? Wie lang ist der Text? Wie viele Nullen werden gebraucht? Fertig!


----------



## vinculum (9. Nov 2009)

Was hast du den als Ausgangsdaten?

Du kannst (Gregorian)Calendar benutzen, dort kannst du dir die einzelnen Bestandteile des Datums einzeln herausziehen. Dann musst du sie nur noch einzeln mit (Integer/Double/Long).toString(...) in Zeichenketten umwandeln und mit 0 auffüllen.


----------



## Spacerat (9. Nov 2009)

Solange deine Strings bis auf die Längen schon vorformatiert sind (wie es anscheinend der Fall ist) genügt so etwas:
	
	
	
	





```
// gegeben: String test;
StringBuilder newString = new StringBuilder(test);
while(newString.length() < 26) {
  newString.append("0");
}
test = newString.toString();
```


----------



## LYBD (10. Nov 2009)

Sauber jetzt gehts vielen Dank :toll::applaus:


----------



## Landei (10. Nov 2009)

Wenn du weißt, dass es nur ein paar Nullen sein können, geht auch:


```
String newString = test + "00000000".substring(0, 26-test.length());
```


----------

