String mit Nullen auffüllen!

[LYBD]

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]

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]

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]

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]

Sauber jetzt gehts vielen Dank :toll::applaus:

 

[Landei]

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

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