Re: Graph traversieren wie ein Petri-Netz
- From: mail@xxxxxxxxxxxxxxxx
- Date: 3 May 2007 14:00:30 -0700
Projekt Netzplan.
Schon wieder was vergessen :(
package util;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.ObjectOutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import java.util.Locale;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.zip.Adler32;
import java.util.zip.CRC32;
/**
* Alle möglichen Methoden, hauptsächlich für Strings . <br/>
*
* <br/>
* <b>Author:</b> <a href="http://www.heinerkuecker.de";
target="_blank">Heiner Kücker</a>
* <br/>
*
* @author Heiner Kücker
* @version $Id$
*/
public final class StringUtil
{
/**
* Datumsformat für {@link #date2str} und {@link #parseDate}
*/
private static SimpleDateFormat formatDate = new
SimpleDateFormat("dd.MM.yyyy");
// TODO: schneller und threadsicher: private static
org.apache.commons.lang.time.FastDateFormat outputDateFormat =
org.apache.commons.lang.time.FastDateFormat.getInstance("dd.MM.yyyy");
/**
* Timestamp-Datumsformat für {@link #getTimeStamp}
*/
private static SimpleDateFormat formatTimestamp = new
SimpleDateFormat("dd.MM.yyyy HH:mm:ss", Locale.GERMAN);
/**
* Constructor declaration<br/>
* Instanziieren nicht erlaubt
*/
private StringUtil()
{
super();
}
/**
* String auf null, Länge 0 oder nur Spaces prüfen
*
* @param strValue zu prüfender String
* @return ob String empty (ja/nein)
*/
public static final boolean empty(String strValue) {
boolean bReturn = true;
if (strValue != null) {
if (strValue.trim().length() > 0) {
bReturn = false;
}
}
return bReturn;
} // end method empty
/**
* StringBuffer auf leer prüfen
*
* @param strBuffValue zu prüfender StringBuffer
* @return ob StringBuffer empty (ja/nein)
*/
public static final boolean empty(StringBuffer strBuffValue) {
boolean bReturn = true;
if (strBuffValue != null) {
if (strBuffValue.toString().trim().length() > 0) {
bReturn = false;
}
}
return bReturn;
} // end method empty
/**
* Verlängern eines Strings auf die gewünschte Länge mit
Leerzeichen. <br/>
* Der String wird nicht abgeschnitten, falls er länger ist als
verlangt.
*
* @param strPa zu verlängernder String
* @param iPaLen gewünschte Länge
* @return verlängerter String
*/
public static final String pad(String strPa, int iPaLen) {
if (strPa == null) {
strPa = "";
}// end if
if (strPa.length() >= iPaLen) {
return strPa;
}// end if
StringBuffer sb = new StringBuffer(iPaLen);
sb.append(strPa);
while (sb.length() < iPaLen) {
sb.append(' ');
}// end while
return sb.toString();
}// end method pad
/**
* String in Grossbuchtaben umwandeln, mit null-Abfangung
*
* @param strValue umzuwandlender String
* @return umgewandelter String oder null, wenn Parameter-String
null war
*/
public static final String upper(String strValue) {
if (strValue != null) {
strValue = strValue.toUpperCase();
}
return strValue;
} // end method upper
/**
* String.toLowerCase() mit Abfangung Null-Pointer. <br/>
*
* @param strPa umzuwandelnder String
* @return in Kleinbuchstaben umgewandelter String
*/
public static final String lower(String strPa) {
if (strPa == null) {
return null;
}// end if
return strPa.toLowerCase();
}// end method lower
/**
* Verlängern eines Strings auf die gewünschte Länge durch
* Einfügen von Leerzeichen am Anfang. <br/>
* Der String wird nicht abgeschnitten, falls er länger ist als
verlangt.
*
* @param strPa zu verlängernder String
* @param iPaLen gewünschte Länge
* @return verlängerter String
*/
public static final String leftPad(String strPa, int iPaLen) {
if (strPa == null) {
strPa = "";
}// end if
if (strPa.length() >= iPaLen) {
return strPa;
}// end if
StringBuffer sb = new StringBuffer(iPaLen);
sb.append(strPa);
while (sb.length() < iPaLen) {
sb.insert(0, ' ');
}// end while
return sb.toString();
}// end method leftPad
/**
* Filter the specified string for characters that are senstive to
* HTML interpreters, returning the string with these characters
replaced
* by the corresponding character entities.
*
* @param value The string to be filtered and returned
* @return the filtered String
*/
public static final String encodeHtml(String value) {
if (value == null) {
return (null);
}
char content[] = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length + 50);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case '<':
result.append("<");
break;
case '>':
result.append(">");
break;
case '&':
result.append("&");
break;
case '"':
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
} // end method encodeHtml
/**
* String in int umwandeln
*
* @param numStr String numerisch
* @return Zahl
*/
public static final int str2int(String numStr) {
if (empty(numStr)) {
return 0;
}
numStr = numStr.trim();
int retInt = 0;
try {
retInt = (new Integer(numStr)).intValue();
} catch (Exception e) {
;
}
return retInt;
} // end method str2int
/**
* String in Integer-Object umwandeln
*
* @param numStr String numerisch
* @return Intger-Object
*/
public static final Integer str2Integer(String numStr) {
Integer retInteger = null;
retInteger = new Integer(str2int(numStr));
return retInteger;
} // end method str2Integer
/**
* String in Integer-Object umwandeln mit Rückgabe null wen nicht
lesbar
*
* @param numStr String numerisch
* @return Integer-Object
*/
public static final Integer str2IntegerStrict(String numStr) {
Integer retInteger = null;
try {
retInteger = new Integer(numStr);
}
catch (Exception e)
{
;// nicht lesbar , return null
}
return retInteger;
} // end method str2IntegerStrict
/**
* String in Long-Object umwandeln mit Rückgabe null wen nicht
lesbar
*
* @param numStr String numerisch
* @return Long-Object
*/
public static final Long str2LongStrict(String numStr)
{
Long retLong = null;
try {
retLong = new Long( numStr.trim() );
}
catch (Exception e)
{
;// nicht lesbar , return null
}
return retLong;
} // end method str2LongStrict
/**
* Parsen eines Strings in ein Long,
* unter Nachsicht auf führende Nullen
* und nachfolgende Buchstaben oder
* Sonderzeichen
*
* @author Heiner Kücker
* @since 19.05.2004
*/
public static Long str2LongLenient(String pStr)
{
if (pStr == null || pStr.length() == 0 )
{
return null; // Garbage in, Garbage out
}
final String trimmedStr = pStr.trim();
StringBuffer tmpStrBuff = new StringBuffer();
int iPos = 0;
//laufen über führende Nullen
for(; iPos < trimmedStr.length() - 1 && trimmedStr.charAt(iPos)
== '0'; iPos++);
//sammeln aller Digits
for(; iPos < trimmedStr.length() &&
Character.isDigit(trimmedStr.charAt(iPos)); iPos++)
{
tmpStrBuff.append(trimmedStr.charAt(iPos));
}
Long retLong = null;
try
{
retLong = new Long( tmpStrBuff.toString() );
}
catch (Exception e)
{
;
}
return retLong;
}
/**
* Parsen eines Strings in ein Integer,
* unter Nachsicht auf führende Nullen
* und nachfolgende Buchstaben oder
* Sonderzeichen
*
* @author Heiner Kücker
* @since 19.05.2004
*/
public static Integer str2IntegerLenient(String pStr)
{
if (pStr == null || pStr.length() == 0 )
{
return null; // Garbage in, Garbage out
}
final String trimmedStr = pStr.trim();
StringBuffer tmpStrBuff = new StringBuffer();
int iPos = 0;
//laufen über führende Nullen
for(; iPos < trimmedStr.length() - 1 && trimmedStr.charAt(iPos)
== '0'; iPos++);
//sammeln aller Digits
for(; iPos < trimmedStr.length() &&
Character.isDigit(trimmedStr.charAt(iPos)); iPos++)
{
tmpStrBuff.append(trimmedStr.charAt(iPos));
}
Integer retInteger = null;
try
{
retInteger = new Integer( tmpStrBuff.toString() );
}
catch (Exception e)
{
;
}
return retInteger;
}
/**
* String in BigDecimal-Object umwandeln mit Rückgabe null wen nicht
lesbar
*
* @param pNumStr String numerisch
* @return BigDecimal-Object
*/
public static final BigDecimal strGerman2BigDecimalStrict(
final String pNumStr )
{
if (pNumStr == null)
{
return null;
}
BigDecimal retBigDecimal = null;
try
{
// Komma in Punkt tauschen
// TODO was ist bei Gruppen-Trennern 999,999.99 ???
final String tNumStr =
//pNumStr.replace( ',' , '.' ).trim();
germanToEnglischNumStrWithoutGrouping(
pNumStr );
retBigDecimal = new BigDecimal(tNumStr);
}
catch (Exception e)
{
;// nicht lesbar , return null
throw new RuntimeException( e );
}
return retBigDecimal;
} // end method str2BigDecimalStrict
/**
* Umwandlung eines deutschen
* numerischen Strings '999.999,99' in einen
* englischen numerischen String '999,999.99'
* ( Punkt zu Komma und Komma zu Punkt) .
*
* @param pGermanNumStr
* @return
*
* TODO mache Methode englischToGermanNumStr
*/
private static String germanToEnglischNumStr(
final String pGermanNumStr )
{
if ( pGermanNumStr == null )
{
return null;
}
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pGermanNumStr );
boolean hasKomma = false;
for (int i = 0; i < strBuff.length(); i++)
{
final char runChr = strBuff.charAt( i );
if ( runChr == '.' )
{
if ( hasKomma )
{
throw new RuntimeException( "Punkt folgt nach Komma,
das ist kein deutscher numerischer String: [" + i + "]" +
pGermanNumStr );
}
strBuff.setCharAt( i , ',' );
continue;
}
if ( runChr == ',' )
{
hasKomma = true;
strBuff.setCharAt( i , '.' );
continue;
}
if ( ! ( ( i == 0 && runChr == '-' )
|| Character.isDigit( runChr ) ) )
{
throw new RuntimeException( "Das ist kein deutscher
numerischer String: [" + i + "]" + pGermanNumStr );
}
}
return strBuff.toString();
}
/**
* Umwandlung eines deutschen
* numerischen Strings '999.999,99' in einen
* englischen numerischen String '999999.99'
* ( Punkt entfernen und Komma zu Punkt) .
*
* @param pGermanNumStr
* @return
*
* TODO mache Methode englischToGermanNumStrWithoutGrouping
*/
private static String germanToEnglischNumStrWithoutGrouping(
final String pGermanNumStr )
{
if ( pGermanNumStr == null )
{
return null;
}
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pGermanNumStr.length() );
boolean hasKomma = false;
for (int i = 0; i < pGermanNumStr.length(); i++)
{
final char runChr = pGermanNumStr.charAt( i );
if ( runChr == '.' )
{
if ( hasKomma )
{
throw new RuntimeException( "Punkt folgt nach Komma,
das ist kein deutscher numerischer String: gucke at pos [" + i + "]" +
pGermanNumStr );
}
}
else if ( runChr == ',' )
{
hasKomma = true;
strBuff.append( '.' );
}
else if ( ( i == 0 && runChr == '-' )
|| Character.isDigit( runChr ) )
{
strBuff.append( runChr );
}
else
{
throw new RuntimeException( "Das ist kein deutscher
numerischer String: gucke at pos [" + i + "]" + pGermanNumStr );
}
}
return strBuff.toString();
}
/**
* String in int umwandeln mit Tolerierung enthaltener
nichtnumerischer Zeichen . <br/>
* geparst wird bis zum Auftreten nichtnumerischer Zeichen.<br/>
* Entfernung führender Nullen läßt sich zuschalten
(auskommentierter Code).<br/>
*
* @param pNumStr String numerisch
* @return int Zahl
*/
public static final int str2intTolerant(
String pNumStr)
{
if ( empty( pNumStr ) )
{
return 0;
}
pNumStr = pNumStr.trim();
// Entfernen führende Nullen
// while ( numStr.length() > 1 && numStr.startsWith( "0" ) )
// {
// numStr = numStr.substring(1) ;
// }
// Entfernen evtl. nichtnumerische Zeichen
for (int i = 0; i < pNumStr.length(); i++) {
if (pNumStr.charAt(i) < '0' || pNumStr.charAt(i) > '9') {
// nicht numerisches Zeichen
pNumStr = pNumStr.substring(0, i);
break;
}
}
int retInt = 0;
try {
retInt = (new Integer(pNumStr)).intValue();
} catch (Exception e) {
;
}
return retInt;
} // end method str2intTolerant
/**
* Überprüfung einer Währungs-Eingabe und Umwandlung in ein double-
Wert
*
* @param inBetrag Betrag als String, der in ein double umgewandelt
werden soll
* @return double, der aus der Eingabe erzeugt wurde<br>
* ist inBetrag ein NULL-String, wird Double.NaN zurückgegeben
* @exception NumberFormatException, falls bei der Umwandlung ein
Fehler auftritt
* @see Double#NaN Double.NaN
*/
public static double parseDouble(String inBetrag)
throws NumberFormatException {
double retDouble;
String strTemp;
if (inBetrag == null) {
retDouble = Double.NaN;
}
else {
strTemp = inBetrag.replace(',', '.');
retDouble = Double.parseDouble(strTemp);
}
return retDouble;
} // end parseDouble
/**
* Überprüfung einer Währungs-Eingabe und Umwandlung in ein double,
aber ohne Werfen NumberFormatException
*
* @param inBetrag Betrag als String, der in ein double umgewandelt
werden soll
* @return double, der aus der Eingabe erzeugt wurde<br>
* ist inBetrag ein NULL-String, wird Double.NaN zurückgegeben
* @see Double#NaN Double.NaN
*/
public static double parseDoubleCatched(String inBetrag) {
double retDouble = 0;
try {
retDouble = parseDouble(inBetrag);
} catch (NumberFormatException ne) {
;
}
return retDouble;
} // end parseDouble
/**
* Umwandeln String in double-Wert
*
* @param parStr String numerisch
* @return double-Zahl
*/
public static double str2double(String parStr) {
return parseDoubleCatched(parStr);
}
/**
* Umwandeln String in double-Objekt
*
* @param parStr String numerisch
* @return double-Objekt
*/
public static Double str2Double(String parStr) {
return new Double(parseDoubleCatched(parStr));
}
/**
* null-String in Leerstring umwandeln
*
* @param str eventueller null-String
* @return nicht null-String
*/
public static final String notNull(String str) {
if (str == null) {
return "";
}
return str;
} // end method notNull
/**
* String in boolean umwandeln. <br/>
* true: true, TRUE, yes, YES, ja, JA, ok, OK, on, ON, 1 <br/>
* false: alles andere <br/>
*
* @param str String mit logischem Wert
* @return boolean-Wert
*/
public static final boolean str2bool(String str) {
boolean bReturn = false;
if (!empty(str)) {
str = str.toUpperCase().trim();
if ("TRUE".equals(str) || "YES".equals(str) || "Y".equals(str)
|| "JA".equals(str) || "J".equals(str)
|| "OK".equals(str) || "ON".equals(str) || "1".equals(str))
{
bReturn = true;
}
}
return bReturn;
} // end method str2bool
/**
* String in Boolean-Object umwandeln. <br/>
* true: true, TRUE, yes, YES, ja, JA, ok, OK, on, ON, 1 <br/>
* false: alles andere <br/>
*
* @param str String mit logischem Wert
* @return boolean-Object
*/
public static final Boolean str2boolObject(String str) {
return str2bool(str) ? Boolean.TRUE : Boolean.FALSE ;
} // end method str2boolObject
/**
* numerischen String in boolean umwandeln. <br/>
* true: x >= 1 <br/>
* false: x < 1 <br/>
*
* @param str String numerisch
* @return boolean-Wert
*/
public static final boolean numStr2bool(String str) {
boolean bReturn = false;
if (!empty(str)) {
int iTmp = -1;
try {
iTmp = str2int(str);
} catch (Exception e) {// Log.fatal (e);
}
bReturn = (iTmp > 0);
}
return bReturn;
} // end method str2bool
/**
* numerischen String in Boolean-Object umwandeln. <br/>
* true: true, TRUE, yes, YES, ja, JA, ok, OK, on, ON <br/>
* false: alles andere <br/>
*
* @param str String numerisch
* @return Boolean-Object
*/
public static final Boolean numStr2boolObject(String str) {
return (numStr2bool(str)) ? Boolean.TRUE : Boolean.FALSE;
} // end method str2bool
/**
* Entferne Hoch-Kommas
*
* @param value String mit Hochkommas
* @return String ohne Hochkommas
*/
public static final String stripHochKomma(String value) {
if (value == null) {
return (null);
}
char[] content = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case (char) 39:
break;
default:
result.append(content[i]);
}
}
return (result.toString());
} // end method stripHochKomma
/**
* Entfernen Newline (char(10)) und Carriage Return (char(13))
*
* @param value String mit Newline (char(10)) und Carriage Return
(char(13))
* @return String ohne Newline (char(10)) und Carriage Return
(char(13))
*/
public static final String stripBreak(String value) {
if (value == null) {
return (null);
}
char[] content = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case (char) 10:
break;
case (char) 13:
break;
default:
result.append(content[i]);
}
}
return (result.toString());
} // end method stripBreak
/**
* Entferne Carriage Return (char(13)) und encode Newline (char(10))
zu "\n"
*
* @param value String vorher
* @return String encoded
*/
public static final String encodeBreak(String value) {
if (value == null) {
return (null);
}
char[] content = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case (char) 10:
result.append((char) 92); // steht für Backslash
result.append("n"); // n von \n
break;
case (char) 13:
break;
default:
result.append(content[i]);
}
}
return (result.toString());
} // end method stripBreak
/**
* Entferne Carriage Return (char(13)) und encode Newline (char(10))
zu <br/>
*
* @param value String vorher
* @return String verarbeitet
*/
public static final String encodeBreakToTag(String value) {
if (value == null) {
return (null);
}
char[] content = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case (char) 10:
result.append("<br/>");
break;
case (char) 13:
break;
default:
result.append(content[i]);
}
}
return (result.toString());
} // end method stripBreak
/**
* Entfernen Space (32) und Tab (9)
*
* @param value String vorher
* @return String verarbeitet
*/
public static final String stripTabSpace(String value) {
if (value == null) {
return (null);
}
value = value.trim();
char[] content = new char[value.length()];
value.getChars(0, value.length(), content, 0);
StringBuffer result = new StringBuffer(content.length);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case (char) 32:
break;
case (char) 9:
break;
default:
result.append(content[i]);
}
}
return (result.toString());
} // end method stripTabSpace
/**
* ersten Buchstaben im String groß machen, Capitalize
*
* @param strPaLower zu bearbeitender String
* @return kapitalisierter String
*/
public static final String upper1(String strPaLower) {
String retString = null;
if (strPaLower != null) {
if (strPaLower.length() < 2) {
retString = strPaLower.toUpperCase();
}
else {
retString = strPaLower.substring(0, 1).toUpperCase();
retString += strPaLower.substring(1);
}
}
return retString;
} // end method upper1
/**
* aktuelles Datum als String
*
* @return aktuelles Datum als String
*/
public static final String currentDate() {
return date2str(new Date());
} // end method currentDate
/**
* Timestamp für aktuellen Zeitpunkt erstellen
*
* @return current Timestamp as String
*/
public static final String getTimeStamp() {
return formatTimestamp.format(new
Date(System.currentTimeMillis()));
}
/**
* Datum in String umwandeln
* im Format dd.MM.yyyy.
*
* @param pDate Datum
* @return Datums-String
*/
public static final String date2str(
final Date pDate)
{
if ( pDate == null )
{
return null;
}
return formatDate.format(pDate);
} // end method date2str
/**
* String im Format dd.MM.yyyy in Datum umwandeln
*
* @param pStr String mit Datum im Format dd.MM.yyyy
* @return Datum oder null, wenn Datum ungültig
*/
public static final Date str2date(
final String pStr )
{
//System.out.println( pStr );
return parseDateCatched(pStr);
} // end method str2date
/**
* String im Format dd.MM.yyyy in SQL-Datum umwandeln
*
* @param pDd_MM_jjjj_Point_separeted_Str String mit Datum im Format
dd.MM.yyyy
* @return SQL-Datum
*/
public static final java.sql.Date str2sqldate(
final String pDd_MM_jjjj_Point_separeted_Str )
{
final java.util.Date dateTmp =
str2date(pDd_MM_jjjj_Point_separeted_Str);
if ( dateTmp != null )
{
return new java.sql.Date(dateTmp.getTime());
}
return null;
} // end method str2sqldate
/**
* String im Format dd.MM.yyyy in SQL-Timestamp umwandeln
*
* @param pDd_MM_jjjj_StrValue String mit Datum im Format dd.MM.yyyy
* @return SQL-Datum
*/
public static final java.sql.Timestamp str2timestamp(
final String pDd_MM_jjjj_StrValue )
{
final java.util.Date dateTmp = str2date(pDd_MM_jjjj_StrValue);
if ( dateTmp != null )
{
return new java.sql.Timestamp( dateTmp.getTime() );
}
return null;
} // end method str2timestamp
/**
* Vergleich zweier Strings mit Nullpointer-Behandlung
*
* @param obj1 erster String
* @param obj2 zweiter String
* @return ob gleich
*/
public static final boolean stringEqual(String obj1, String obj2) {
if (obj1 == null && obj2 == null) {
return true;
}
if (obj1 != null) {
if (obj1.equals(obj2)) {
return true;
}
}
return false;
} // end method stringEqual
/**
* Vergleich zweier Double mit Nullpointer-Behandlung
*
* @param obj1 erstes Double
* @param obj2 zweites Double
* @return ob gleich
*/
public static final boolean doubleEqual(Double obj1, Double obj2) {
if (obj1 == null && obj2 == null) {
return true;
}
if (obj1 != null) {
if (obj1.equals(obj2)) {
return true;
}
}
return false;
} // end method doubleEqual
/**
* Vergleich zweier Objekte mit Nullpointer-Behandlung
*
* @param obj1 erstes Objekt
* @param obj2 zweites Objekt
* @return ob gleich
*/
public static final boolean objectEqual(Object obj1, Object obj2) {
if (obj1 == null && obj2 == null) {
return true;
}
if (obj1 != null && obj2 != null) {
if (obj1.getClass().isInstance(obj2)) {
if (obj1.equals(obj2)) {
return true;
}
}
}
return false;
} // end method objectEqual
/**
* Überprüfung einer Datums-Eingabe und ggf. Umwandlung in ein Date-
Objekt.
*
* @param inDatum Datum als String, das in ein Date-Objekt
umgewandelt werden soll
*
* @return retDatum Datum-Objekt, das aus der Eingabe erzeugt wurde
*
* @exception DomainParseException: Falls der Eingabestring nicht in
ein Datum
* umgewandelt werden kann, wird eine DomainParseException geworfen
*/
public static Date parseDate(String inDatum)
throws ParseException {
Date retDatum;
String strDatum = "";
String strDay;
String strMonth;
String strYear;
int indexDay;
int indexMonth;
GregorianCalendar cal;
int intError = -1;
ParseException e = new ParseException("Ecis: Not a valid Date",
intError);
ParsePosition pos = new ParsePosition(0);
if (inDatum == null) {
retDatum = null;
}
else {
strDatum = inDatum.trim();
try {
indexDay = strDatum.indexOf(".");
indexMonth = strDatum.indexOf(".", indexDay + 1);
strDay = strDatum.substring(0, indexDay);
strMonth = strDatum.substring(indexDay + 1, indexMonth);
strYear = strDatum.substring(indexMonth + 1);
if (strYear.length() != 4) {
throw e;
}
if ((str2int(strMonth) > 0) && (str2int(strMonth) < 13)) {
cal = new GregorianCalendar(str2int(strYear),
(str2int(strMonth) - 1), 1);
if ((str2int(strDay) < 1) || (str2int(strDay) >
cal.getActualMaximum(Calendar.DAY_OF_MONTH))) {
throw e;
}
}
else {
throw e;
}
} catch (Exception ex) {
throw e;
}
formatDate.setLenient(false);
retDatum = formatDate.parse(strDatum, pos);
if (retDatum == null) {
throw e;
}
}
return retDatum;
} // end parseDate
/**
* Überprüfung einer Datums-Eingabe und ggf. Umwandlung in ein Date-
Objekt.
*
* @param inDatum Datum als String, das in ein Date-Objekt
umgewandelt werden soll
* @return retDatum Datum-Objekt, das aus der Eingabe erzeugt wurde
*/
public static Date parseDateCatched(String inDatum) {
Date retDatum = null;
try {
retDatum = parseDate(inDatum);
} catch (ParseException pe) {// pe.printStackTrace() ;
}
return retDatum;
} // end parseDateCatched
/**
* Datum auf Gültigkeit prüfen
*
* @param testString
* @return gültig (ja/nein)
*/
public static boolean testDateString(String testString) {
Date testDate = parseDateCatched(testString);
if (testDate == null) {
return false;
}
return true;
} // end method testDateString
/**
* Zurückgeben der iLength Zeichen eines Strings ab dem linken Rand.
<br/>
* Mit Behandlung Nullpointer und Größenüberlauf. <br/>
* Wenn String kürzer als iLength, werden so viele Zeichen wie
vorhanden zurückgegeben. <br/>
*
* @param parString Original-String
* @param iLength Anzahl Zeichen
* @return String links
*/
public static String left(String parString, int iLength) {
String retString = null;
if (parString != null) {
if (parString.length() > 0) {
iLength = Math.min(iLength, parString.length());
retString = parString.substring(0, iLength);
}
else {
retString = parString;
}
}
return retString;
} // end method left
/**
* list(PrintWriter)-Methode eines Properties-Objekts auf einen
String umgeleitet
*
* @param prop Properties
* @return list-String
*/
public static String listToString(Properties prop) {
String retString = "";
if (prop != null) {
StringWriter strWriter = new StringWriter();
PrintWriter pWriter = new PrintWriter(strWriter);
prop.list(pWriter);
retString = strWriter.toString();
}
return retString;
} // end method listToString
/**
* Textdatei zeilenweise in ein String-Array einziehen . <br/>
* Jede Zeile bildet einen String im String-Array.<br/>
*
* @param fileName Dateiname
* @return String-Array
*/
public static String[] fileToStrArr(String fileName /*,String
pEncoding*/) {
if (fileName == null) {
return null;
}
return fileToStrArr(new File(fileName) /*,pEncoding*/);
} // end method fileToStrArr
/**
* Textdatei zeilenweise in ein String-Array einziehen . <br/>
* Jede Zeile bildet einen String im String-Array.<br/>
*
* @param pFile File-Object
* @param pEncoding The name of a supported
* <a href="../lang/package-
summary.html#charenc">character
* encoding</a>
*
* @return String-Array
*/
public static String[] fileToStrArr(
final File pFile
/*, String pEncoding*/)
{
if (pFile == null) {
return null;
}
try {
// BufferedReader zum zeilenweisen Lesen
//FileReader defFileReader = new FileReader(inFile);
//BufferedReader defBufferedReader = new
BufferedReader(defFileReader);
//Feststellen, ob die Applikation auf dem HOST OS/390 läuft, nur
provisorisch implementiert, nicht korrekt
boolean isHost = isHost();
FileInputStream fin = new FileInputStream(pFile);
InputStreamReader isr;
if (isHost)
{
//Encoding für HOST EBCDIC
isr = new InputStreamReader( fin , "8859_1" /*pEncoding*/ );
}
else
{
isr = new InputStreamReader( fin );
}
BufferedReader defBufferedReader = new BufferedReader( isr );
ArrayList strArrayList = new ArrayList();
String readLine = null;
while ((readLine = defBufferedReader.readLine()) != null) // bis
zum Ende der Datei
{
//Log.debug( "readLine: " +readLine );
// readLine = readLine.trim();
strArrayList.add(readLine);
} // end while
String[] retArr = arrayListToStrArr(strArrayList);
return retArr;
} catch (Exception e) {
System.err.println( e.getMessage() );
e.printStackTrace();
throw new
RuntimeException(ExceptionUtil.getMessageAndStackTrace(e));
}
// return null ;
} // end method fileToStrArr
/**
* ArrayList mit Strings in String[] umwandeln . <br/>
* Verwendet in {@link #fileToStrArr}.<br/>
*
* @param strArrayList ArrayList mit Strings
* @return String[]
* @exception ClassCastException wenn Element kein String
*/
public static String[] arrayListToStrArr(ArrayList strArrayList) {
if (strArrayList == null || strArrayList.isEmpty()) {
return new String[0];
}
String[] retArr = new String[strArrayList.size()];
for (int i = 0; i < strArrayList.size(); i++) {
retArr[i] = (String) strArrayList.get(i);
}
return retArr;
} // end method arrayListToStrArr
/**
* Teilstring von String links abschneiden, wenn möglich
*
* @param pSrcStr Original-String
* @param pCutStr abzuschneidender String
* @return abgeschnittener String
*/
public static String cutLeft(
final String pSrcStr,
final String pCutStr)
{
if (pSrcStr == null || pCutStr == null)
{
return pSrcStr;
}
String retStr = pSrcStr;
if ( retStr.startsWith( pCutStr ) )
{
retStr = retStr.substring(pCutStr.length()); // cutStr
abschneiden
}
return retStr;
}// end method cutLeft
/**
* Teilstring von String rechts abschneiden, wenn möglich
*
* @param srcStr Original-String
* @param cutStr abzuschneidender String
* @return abgeschnittener String
*/
public static String cutRight(String srcStr, String cutStr) {
if (srcStr == null || cutStr == null) {
return srcStr;
}
String retStr = srcStr;
if (retStr.endsWith(cutStr)) {
retStr = retStr.substring(0, retStr.length() -
cutStr.length()); // cutStr abschneiden
}
return retStr;
}// end method cutRight
/**
* Teilstring von String links und rechts abschneiden, wenn möglich
*
* @param srcStr Original-String
* @param cutLeftStr links abzuschneidender String
* @param cutRightStr rechts abzuschneidender String
* @return abgeschnittener String
*/
public static String cutLeftRight(//--
final String srcStr, //--
final String cutLeftStr, //
final String cutRightStr)
{
String retStr = cutLeft( srcStr , cutLeftStr );
retStr = cutRight( retStr , cutRightStr );
return retStr;
}// end method cutLeftRight
/**
* Speichern eines String in einer Datei ohne weitere Informationen
*
* @param outStr auszugebender String
* @param fileName Name der Datei, in welcher der String gespeichert
werden soll
* @return ob erfolgreich
*/
public static boolean str2file(String outStr, String fileName) {
return str2file(outStr, new File(fileName));
} // end method str2file
/**
* Speichern eines String in einer Datei ohne weitere Informationen
*
* @param pOutStr auszugebender String
* @param pOutFile Datei, in welcher der String gespeichert werden
soll
* @return ob erfolgreich
*/
public static boolean str2file(
final String pOutStr,
final File pOutFile)
{
System.out.println( "Schreibe: " + pOutFile.getAbsolutePath() );
boolean bReturn = false;
try {
if (pOutFile.exists()) {
pOutFile.delete();
}
pOutFile.createNewFile();
FileWriter outFileWriter = new FileWriter(pOutFile);
outFileWriter.write(pOutStr);
outFileWriter.close();
bReturn = true;
} catch (Exception e) {
System.err.println( e.getMessage() ); e.printStackTrace();
}
return bReturn;
// TODO in StringUtil.str2file verlagern
//File writeDir = new File(writeDirName);
//writeDir.mkdirs();
} // end method str2file
/**
* Einlesen einer Datei in einen String
*
* @param pFileNameWithPath Name der einzulesenden Datei
* @return String mit Datei-Inhalt
*/
public static String file2str(
final String pFileNameWithPath )
{
//System.out.println( "fileName: " + fileName );
return file2str(new File(pFileNameWithPath));
} // end method file2str
/**
* Einlesen einer Datei in einen String
*
* @param inFile einzulesende Datei
* @return String mit Datei-Inhalt
*/
public static String file2str(File inFile) {
//System.out.println( "inFile: " + inFile );
String strReturn = null;
try {
StringBuffer strBuff = new StringBuffer(1024 * 16);
// BufferedReader zum zeilenweisen Lesen
//FileReader defFileReader = new FileReader(inFile);
//BufferedReader defBufferedReader = new
BufferedReader(defFileReader);
//Feststellen, ob die Applikation auf dem HOST OS/390 läuft, nur
provisorisch implementiert, nicht korrekt
boolean isHost = isHost();
FileInputStream fin = new FileInputStream(inFile);
InputStreamReader isr;
if (isHost)
{
//Encoding für HOST EBCDIC
isr = new InputStreamReader( fin , "8859_1" /*pEncoding*/ );
}
else
{
isr = new InputStreamReader( fin );
}
BufferedReader defBufferedReader = new BufferedReader( isr );
String readLine = null;
while ((readLine = defBufferedReader.readLine()) != null) { //
bis zum Ende der Datei
//Log.debug( "readLine: " + readLine );
strBuff.append(readLine + "\n");
} // end while
strReturn = strBuff.toString();
} catch (Exception e) {
System.err.println( e.getMessage() ); e.printStackTrace();
}
return strReturn;
}// end method file2str
/**
* Umwandeln int-Wert in String mit Angabe Anzahl Stellen
*
* @param int-Wert
* @param Anzahl Stellen
*
* @return numerischer String, rechtsbündig
*/
public static String str(int iPaValue, int iPaDigits) {
return leftPad("" + iPaValue, iPaDigits);
}// end method str(int)
/**
* Umwandeln Integer-Objekt in String mit Angabe Anzahl Stellen. <br/
* Bei Übergabe null-Pointer wird der Wert 0 angenommen
*
* @param iPaValue Integer-Objekt
* @param iPaDigits Anzahl Stellen
*
* @return numerischer String, rechtsbündig
*/
public static String str(Integer iPaValue, int iPaDigits) {
int iTmp = 0;
if (iPaValue != null) {
iTmp = iPaValue.intValue();
}// end if
return leftPad("" + iTmp, iPaDigits);
}// end method str(Integer)
/**
* int-Wert in String mit führenden Nullen umwandeln
*/
public static String strzero(//--
final int pValueInt, //--
final int pDigitCount )
{
return strzero(String.valueOf(pValueInt), pDigitCount);
}// end method strzero
public static final String ZERO_20_STR = "00000000000000000000";
/**
* String mit führenden Nullen auffüllen.
*/
public static String strzero(
final String pStr,
final int pDigits)
{
String str = pStr.trim();
if (str.length() >= pDigits)
{
return str;
}
final int zeroLen = pDigits - str.length();
final boolean isNegative = str.trim().startsWith( "-" );
if ( isNegative )
{
str = str.substring( 1 );
}
if ( zeroLen < 21 )
{
return ( isNegative ? "-" : "" ) + ZERO_20_STR.substring(0,
zeroLen) + str;
}
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer(pDigits);
// Laut Buch ist Test auf Null schneller, TODO Test
for (int i = zeroLen; i > 0 ; i--)
{
strBuff.append( '0' );
}
strBuff.append(str);
return ( isNegative ? "-" : "" ) + strBuff.toString();
}// end method strzero
/**
* Zurückliefern String-Teil vor dem Bindestrich aus einem String
der einen Bindestrich enthält. <br/>
*
* @param strPaHyphen String mit Bindestrich
*
* @return String-Teil vor Bindestrich
*
* @deprecated umbenennen in preNumberSign und beschleunigen
*/
public static String preHyphen(String strPaHyphen) {
// Log.debug( strPaHyphen ) ;
StringTokenizer tok = new StringTokenizer(strPaHyphen, "-");
return tok.nextToken();
}// end method preHyphen
/**
* Zurückliefern String-Teil nach dem Bindestrich aus einem String
der einen Bindestrich enthält. <br/>
*
* @param strPaHyphen String mit Bindestrich
*
* @return String-Teil nach Bindestrich
* @deprecated umbenennen in postNumberSign und beschleunigen
*/
public static String postHyphen(String strPaHyphen) {
// Log.debug( strPaHyphen ) ;
StringTokenizer tok = new StringTokenizer(strPaHyphen, "-");
tok.nextToken();
return tok.nextToken();
}// end method preHyphen
/**
* Zurückliefern String-Teil vor dem Punkt aus einem String der
einen Punkt enthält. <br/>
*
* @param strPaHyphen String mit Punkt
*
* @return String-Teil vor Punkt
*/
public static String prePoint(String strPaPoint) {
// Log.debug( strPaPoint ) ;
StringTokenizer tok = new StringTokenizer(strPaPoint, ".");
return tok.nextToken();
}// end method prePoint
/**
* Zurückliefern String-Teil nach dem Punkt aus einem String der
einen Punkt enthält. <br/>
*
* @param strPaPoint String mit Punkt
*
* @return String-Teil nach Punkt
*/
public static String postPoint(String strPaPoint) {
// Log.debug( strPaPoint ) ;
StringTokenizer tok = new StringTokenizer(strPaPoint, ".");
tok.nextToken();
return tok.nextToken();
}
/**
* Zurückliefern des Teil-Strings nach
* dem spezifizierten Zeichen.
*
* @param pStr
* @param pChar
* @return
*/
public static String postChar(
final String pStr,
final char pChar )
{
if ( pStr == null )
{
return null;
}
final int charPos = pStr.indexOf( pChar );
return pStr.substring( charPos + 1 );
}
/**
* Zurückliefern String-Teil vor dem Nummern-Symbol # aus einem
String der einen Nummern-Symbol # enthält. <br/>
*
* @param strPaHyphen String mit Nummern-Symbol #
*
* @return String-Teil vor Nummern-Symbol #
*/
public static String preNumSign(String strPaNumSign) {
// Log.debug( strPaNumSign ) ;
StringTokenizer tok = new StringTokenizer(strPaNumSign, "#");
return tok.nextToken();
}// end method preNumSign
/**
* Zurückliefern String-Teil nach dem Nummern-Symbol # aus einem
String der einen Nummern-Symbol # enthält. <br/>
*
* @param strPaNumSign String mit Nummern-Symbol #
*
* @return String-Teil nach Nummern-Symbol #
*/
public static String postNumSign(String strPaNumSign) {
// Log.debug( strPaNumSign ) ;
StringTokenizer tok = new StringTokenizer(strPaNumSign, "#");
tok.nextToken();
return tok.nextToken();
}// end method preNumSign
/**
* Wiederholt einen String n-Mal
*
* @param pSingleStr zu wiederholender String
* @param pCount Anzahl Wiederholungen
*/
public static String repeat(
final String pSingleStr,
final int pCount)
{
StringBuffer sb = new StringBuffer( pCount *
pSingleStr.length() );
synchronized ( sb )
{
for (int i = 0; i < pCount; i++)
{
sb.append( pSingleStr );
}
return sb.toString();
}
}// end method repeat
/**
* Wiederholt einen String n-Mal
* mit einem trenn-String.
*
* @param pSingleStr zu wiederholender String
* @param pDelimStr Trenn-String
* @param pCount Anzahl Wiederholungen
*/
public static String repeat(
final String pSingleStr,
final String pDelimStr,
final int pCount)
{
StringBuffer sb = new StringBuffer( pCount *
( pSingleStr.length() + pDelimStr.length() ) );
synchronized ( sb )
{
for (int i = 0; i < pCount; i++)
{
sb.append( pSingleStr );
if ( i < pCount - 1 )
{
sb.append( pDelimStr );
}
}
return sb.toString();
}
}// end method repeat
/**
* Prüfen, ob ein String in einem anderen String enthalten ist mit
Nullpointer-Abfangung
*
* @param testStr zu durchsuchender String
* @param searchStr gesuchter String
*
* @return ob enthalten
*/
public static boolean contains(String testStr, String searchStr) {
boolean bRet = false;
if (testStr != null)
{
bRet = (testStr.indexOf(searchStr) > -1);
}// end if
return bRet;
}// end method contents
/**
* Prüfen, ob ein String in einem anderen String enthalten ist mit
Nullpointer-Abfangung
* unter ignorieren Gross-/Kleinschreibung
*
* @param testStr zu durchsuchender String
* @param searchStr gesuchter String
*
* @return ob enthalten
*/
public static boolean containsIgnoreCase(String testStr, String
searchStr) {
boolean bRet = false;
if (testStr != null && searchStr != null) {
bRet = (testStr.toUpperCase().indexOf(searchStr.toLowerCase()) >
-1);
}// end if
return bRet;
}// end method contentsIgnoreCase
/**
* Prüfen, ob ein Zeichen in einem anderen String enthalten ist mit
Nullpointer-Abfangung
*
* @param testStr zu durchsuchender String
* @param searchChr gesuchtes Zeichen
*
* @return ob enthalten
*/
public static boolean contains(String testStr, char searchChr) {
boolean bRet = false;
if (testStr != null) {
bRet = (testStr.indexOf(searchChr) > -1);
}// end if
return bRet;
}// end method contents
/**
* numerischen String (dezimal) in Hexadezimal-String umwandeln
*
* @param paStr umzuwandelnder String
*
* @return Hex-String
*/
public static String toHex(String paStr) {
int iTmp = str2int(paStr);
return Integer.toHexString(iTmp);
}// end method toHex
/**
* numerischen String (dezimal) in Hexadezimal-String mit zwei
Stellen umwandeln
*
* @param paStr umzuwandelnder String
*
* @return Hex-String, 2 Digits
*/
public static String toHexTwoDigits(String paStr) {
String retStr = toHex(paStr);
if (retStr.length() < 2) {
return "0" + retStr;
}
return retStr;
}// end method toHex
/**
* String auf Start mit anderem String prüfen
*
* @param paStr zu prüfender String
* @param paStrStart Start-String
*
* @return ja, wenn paStr mit paStrStart beginnt
*/
public static boolean startsWith(String paStr, String paStrStart) {
if (paStr != null && paStrStart != null) {
return paStr.startsWith(paStrStart);
}
return false;
} // end method startsWith
/**
* String auf Start mit anderem String prüfen
*
* @param paStr zu prüfender String
* @param paStrStart Start-String
*
* @return ja, wenn paStr mit paStrStart beginnt
*/
public static boolean startsWithIgnoreCase(String paStr, String
paStrStart) {
if (paStr != null && paStrStart != null) {
return paStr.toLowerCase().startsWith(paStrStart.toLowerCase());
}
return false;
} // end method startsWithIgnoreCase
/**
* String auf Enden mit anderem String prüfen
*
* @param paStr zu prüfender String
* @param paStrEnd Ende-String
*
* @return ja, wenn paStr mit paStrEnd endet
*/
public static boolean endsWith(String paStr, String paStrEnd) {
if (paStr != null && paStrEnd != null) {
return paStr.endsWith(paStrEnd);
}
return false;
} // end method endsWith
/**
* String auf Enden mit anderem String prüfen
*
* @param paStr zu prüfender String
* @param paStrEnd Ende-String
*
* @return ja, wenn paStr mit paStrEnd endet
*/
public static boolean endsWithIgnoreCase(String paStr, String
paStrEnd) {
if (paStr != null && paStrEnd != null) {
return paStr.toLowerCase().endsWith(paStrEnd.toLowerCase());
}
return false;
} // end method endsWithIgnoreCase
public static String getShortClassName(Object pObj)
{
Class clazz = pObj.getClass();
String str = clazz.getName();
if (str.indexOf('.') < 0)
{
return str;
}
return str.substring(str.lastIndexOf('.') + 1);
}
/**
* verlangte Anzahl Leerzeichen liefern
*
* @param pCount
* @return
*/
public static String spaces(int pCount)
{
StringBuffer strBuff = new StringBuffer(pCount);
for (int i = 0; i < pCount; i++)
{
strBuff.append(' ');
}
return strBuff.toString();
}
/**
* Prüfen, ob der String suchStr im String-Array strArr enthalten
ist
*
* @param suchStr String gesuchter
* @param strArr String[] zu durchsuchendes
* @return enthalten (ja/nein)
*/
public static boolean isInArray(String suchStr, String[] strArr)
{
for (int i = 0; i < strArr.length; i++)
{
if (stringEqual(suchStr, strArr[i]))
{
return true;
}
}
return false;
} // end method isInArray
/**
* Hinzufügen eines Objektes zu einem Objekt-Array
*
* @param originalArr vorheriges Array
* @param addTopic hinzuzufügende Methode
* @return vergrössertes Array
*/
public static Object[] arrAdd(final Object[] originalArr, final
Object addTopic)
{
Object[] newArr;
if (originalArr == null)
{
newArr =
(Object[]) java.lang.reflect.Array.newInstance(
addTopic.getClass(), 1);
newArr[0] = addTopic;
}
else
{
newArr =
(Object[]) java.lang.reflect.Array.newInstance(
//addTopic.getClass()
originalArr.getClass().getComponentType(),
originalArr.length + 1);
//for (int i = 0; i < originalArr.length; i++)
//{
// newArr[i] = originalArr[i];
//}
System.arraycopy( originalArr , 0 , newArr, 0 ,
originalArr.length );
newArr[newArr.length - 1] = addTopic;
}
return newArr;
}
/**
* Hinzufügen eines Objektes zu einem Objekt-Array
* an der gewünschten Position.
*
* @param originalArr vorheriges Array
* @param addTopic hinzuzufügende Methode
* @return vergrössertes Array
*/
public static Object[] arrAdd( //-
final Object[] originalArr, //-
final int pIndex, //-
final Object addTopic)
{
//@todo: mal auf Algorithmus ohne List umstellen
List list = Arrays.asList( originalArr );
list.add( pIndex , addTopic );
return list.toArray( originalArr );
}
/**
* Löschen eines Objektes aus einem Objekt-Array
* an der gewünschten Position.
*
* @param originalArr vorheriges Array
* @param addTopic hinzuzufügende Methode
* @return vergrössertes Array
*/
public static Object[] arrRemove( //-
final Object[] originalArr, //-
final int pIndex)
{
//@todo: mal auf Algorithmus ohne List umstellen
List list = Arrays.asList( originalArr );
list.remove( pIndex );
return list.toArray( originalArr );
}
/**
* Hinzufügen einer Methode zu einem Methoden-Array
*
* @param originalArr vorheriges Array
* @param addTopic hinzuzufügende Methode
* @return vergrössertes Array
*/
// public static Method[] arrAdd(Method[] originalArr, Method
addTopic)
// {
// if (originalArr == null)
// {
// originalArr = new Method[0];
// }
//
// Method[] newArr = new Method[originalArr.length + 1];
//
// for (int i = 0; i < originalArr.length; i++)
// {
// newArr[i] = originalArr[i];
// }
//
// newArr[newArr.length - 1] = addTopic;
//
// return newArr;
// }
/**
* Anhängen eines String-Arrays an ein zweidimensionales String-
Array
*
* @param originalArr Original-String[][]
* @param addStrArr anzufügendendes String[]
* @return Ergebnis-String[][]
*/
public static String[][] arrAdd(String[][] originalArr, String[]
addStrArr)
{
if (originalArr == null)
{
originalArr = new String[0][0];
}
String[][] newArr = new String[originalArr.length + 1][0];
for (int i = 0; i < originalArr.length; i++)
{
newArr[i] = originalArr[i];
}
newArr[newArr.length - 1] = addStrArr;
return newArr;
} // end method arrAdd
/**
* Entfernen aller leeren Zeilen (Einträge) am
* String-Array-Ende.
*
* @param pStrArr
* @return trimmed String-Array
*/
public static String[] arrTrim(
final String[] pStrArr)
{
if ( pStrArr == null )
{
return null;
}
int endPos = pStrArr.length - 1;
while ( endPos > 0 //--
&& empty( pStrArr[ endPos ] ) )
{
endPos--;
}
final String[] retStrArr = new String[ endPos + 1 ];
System.arraycopy( pStrArr , 0, retStrArr, 0, endPos + 1 );
return retStrArr;
}
/**
* Anfügen eines Strings an ein String-Array
*
* @param originalArr Original-String[]
* @param addStr anzuhängener String
* @return Ergebnis-String[]
*/
public static String[] arrAdd(String[] originalArr, String addStr)
{
if (originalArr == null)
{
return new String[]{ addStr };
}
String[] newArr = new String[originalArr.length + 1];
for (int i = 0; i < originalArr.length; i++)
{
newArr[i] = originalArr[i];
}
newArr[newArr.length - 1] = addStr;
return newArr;
} // end method arrAdd
/**
* Anfügen eines String-Array an ein String-Array
*
* @param originalArr Original-String[]
* @param addStr anzuhängener String
* @return Ergebnis-String[]
*/
public static String[] arrAdd(String[] originalArr, String[]
addStrArr)
{
if (originalArr == null)
{
originalArr = new String[0];
}
if ( addStrArr == null )
{
return originalArr; // evtl. clonen
}
String[] newArr = new String[originalArr.length +
addStrArr.length];
for (int i = 0; i < originalArr.length; i++)
{
newArr[i] = originalArr[i];
}
int j = originalArr.length;
for (int i = 0; i < addStrArr.length; i++)
{
newArr[j] = addStrArr[i];
j++;
}
return newArr;
} // end method arrAdd
/**
* Einfügen eines Strings am Anfang eines String-Arrays . <br/>
* verwendet in {@link
de.cnc.singletons.BerechtigungenSingleton}.<br/>
*
* @param addStr einzufügender String
* @param originalArr Original-String[]
* @return Ergebnis-String[]
*/
public static String[] arrAdd(String addStr, String[] originalArr)
{
if (originalArr == null)
{
originalArr = new String[0];
}
String[] newArr = new String[originalArr.length + 1];
newArr[0] = addStr;
for (int i = 0; i < originalArr.length; i++)
{
newArr[i + 1] = originalArr[i];
}
return newArr;
} // end method arrAdd
/**
* Durchsucht ein zweidimensionales String-Array nach dem Auftreten
des Suchstrings in Spalte suchIndex
* und gibt dafür den String in Spalte getIndex zurück. <br/>
* Bei nicht Finden wird null zurückgegeben.<br/>
* verwendet in {@link
de.cnc.singletons.BerechtigungenSingleton}.<br/>
*
* @param suchArr abzusuchendes String-Array
* @param suchIndex Spalte (2. Index) in der gesucht werden soll
* @param suchString gesuchter String
* @param getIndex Spalte (2. Index) aus welcher der Ergebnis-
String entnommen werden soll
* @return Ergebnis-String oder null, wenn erfolglos
*/
public static String findForKey(String[][] suchArr, int suchIndex,
String suchString, int getIndex)
{
String retString = null;
for (int i = 0; i < suchArr.length; i++)
{
if (StringUtil.stringEqual(suchArr[i][suchIndex], suchString))
{
retString = suchArr[i][getIndex];
break;
}
}
return retString;
} // end method findForKey
/**
* Formatieren des übergebenen Objektes entsperechend der
übergebenen Maske.
* Zur Zeit unterstützte Maskierungen:
*
* upper - Umwandeln in Grossbuchstaben
* int - Umwandeln in Integer
* stripHochKomma - Entfernen HochKomma
*
* Kombination mehrerer Optionen über kommaseparierte Liste.
*
* @param pUnmaskedObj unmaskiertes Objekt
* @param pMask Maske (Formatangabe)
* @return maskiertes Objekt
*/
public static Object mask(
final Object pUnmaskedObj,
final String pMask)
{
if ( empty( pMask ) )
{
return pUnmaskedObj;
}
if (pUnmaskedObj == null)
{
//dieser Block muss evtl. weg , zum Beispiel für nullToEmpty
return null;
}
Object retObj = pUnmaskedObj;
StringTokenizer toknzr = new StringTokenizer( pMask , "," );
while ( toknzr.hasMoreTokens() )
{
String maskTok = toknzr.nextToken();
if ("upper".equals( maskTok ))
{
retObj = upper( "" + retObj );
}
else if ("stripHochKomma".equals( maskTok ))
{
retObj = stripHochKomma( "" + retObj );
}
else if ("int".equals( maskTok ))
{
retObj = str2IntegerStrict( "" + retObj );
}
else if ("long".equals( maskTok ))
{
retObj = str2LongStrict( "" + retObj );
}
else
{
throw new IllegalArgumentException( "" + maskTok );
}
}
return retObj;
}
/**
* String trimmen mit NullPointer-Abfangung
*/
public static String trim(String pStr)
{
if (pStr == null)
{
return null;
}
return pStr.trim();
}
/**
* String rechts trimmen mit NullPointer-Abfangung
*/
public static String rTrim(
final String pStr)
{
if (pStr == null)
{
return null;
}
/**
* rückwärts über alle WhiteSpace laufen.
*/
int lastWhiteSpacePos = pStr.length();
while ( lastWhiteSpacePos > 0 //--
&& Character.isWhitespace( pStr.charAt( lastWhiteSpacePos -
1 ) ) )
{
lastWhiteSpacePos--;
}
return pStr.substring(0, lastWhiteSpacePos );
}
/**
* Clonen eines String-Array.
* @param pStrArr
* @return
*/
public static String[] cloneStrArr(
final String[] pStrArr)
{
if ( pStrArr == null )
{
return null;
}
final String[] retStrArr = new String[ pStrArr.length ];
for (int i = 0; i < pStrArr.length; i++)
{
final String str = pStrArr[i];
retStrArr[ i ] = str;
}
return retStrArr;
}
/**
* Clonen und Rechts Trimmen eines String-Array.
* @param pStrArr
* @return
*/
public static String[] rTrimStrArr(
final String[] pStrArr)
{
if ( pStrArr == null )
{
return null;
}
final String[] retStrArr = new String[ pStrArr.length ];
for (int i = 0; i < pStrArr.length; i++)
{
final String str = pStrArr[i];
retStrArr[ i ] = rTrim( str );
}
return retStrArr;
}
/**
* Zerlegen eines Strings in Token . <br/>
* Ersatz für StringTokenizer, da dieser Delimiter, die aus mehreren
Zeichen
* bestehen, als Liste alternativer Zeichen versteht.
* Diese Methode sieht den Mehrzeichen-Delimiter als Trennstring an.
*
* @param strPaValue zu zerteilender String
* @param strPaDelim Trenn-String
* @param bPaInclDelim ob Trenn-Strings mit in die Ausgabe
aufgenommen werden sollen
* @param pInclEmptyToken ob leere Tokens mit zurückgegeben werden
sollen
* @return Arraylist mit den String-Teilen (Token) oder null
*/
public static String[] tokenize(
String strPaValue ,
String strPaDelim ,
boolean bPaInclDelim ,
boolean pInclEmptyToken )
{
if ( strPaValue == null ) {
return null ;
}
ArrayList arrList = new ArrayList() ;
if ( strPaDelim == null ) {
arrList.add( strPaValue ) ;
return (String[]) arrList.toArray( new String[1] ) ;
}
int iPos = 0 ;
if ( strPaValue.startsWith( strPaDelim , iPos ) )
{
//Beginn mit Delimiter
if ( bPaInclDelim ) {
arrList.add( strPaDelim ) ;
}
iPos += strPaDelim.length() ;
if (pInclEmptyToken)
{
//empty Token, wenn der String mit dem Trennzeichen begonnen
hat
arrList.add( "" ) ;
}
}
while ( iPos < strPaValue.length() )
{
int iDelimPos = strPaValue.indexOf( strPaDelim , iPos ) ; //
evtl. - 1 ;
if ( iDelimPos < 0 ) {
//Delimiter nicht mehr enthalten
//Rückgabe des Restes vom String
arrList.add( strPaValue.substring( iPos ) ) ;
iPos = strPaValue.length() ; //ans Ende setzen für evtl.
weitere Auswertungen
break ;
}
else
{
//Beginn mit Token (Teilstück)
String strTmp = strPaValue.substring( iPos , iDelimPos ) ;
arrList.add( strTmp ) ;
iPos += strTmp.length() ; // = iEndPos ; // oder += iEndPos
//Delimiter überspringen
while ( iPos < strPaValue.length()
&& strPaValue.startsWith( strPaDelim , iPos ) ) //ab
Position
{
//Beginn mit Delimiter
if ( bPaInclDelim )
{
arrList.add( strPaDelim ) ;
}
iPos += strPaDelim.length() ;
if ( pInclEmptyToken
&& strPaValue.startsWith( strPaDelim , iPos ) ) //ab
Position
{
//es folgt sofort wieder ein Trenn-String
//empty Token
arrList.add( "" ) ;
}
}
}//end if
}//end while
return (String[]) arrList.toArray( new
String[ arrList.size() ] ) ;
}//end method tokenize
/**
* toString(), null-sicher
*
* @param pObj
* @return
*/
public static String toStr(Object pObj)
{
if (pObj == null)
{
return null;
}
return pObj.toString();
}
/**
* Vergrößert oder verkleinert das übergebene String-Array auf
* die gewünschte Größe iPaLength. Bei zu wenig Elementen
* wird das String-Array mit Leer-Strings aufgefüllt. Bei
* zu viel Elementen wird das String-Array ohne Rücksicht
* auf verlorenene Elemente entsprechend gekürzt . <br>
*
* @param strArrPa auszurichtendes String-Array
* @param iPaLength gewünschte Länge
* @return ausgerichtetes String-Array
*/
public static String[] padStrArr(String[] strArrPa, int iPaLength)
{
String[] retStrArr = new String[iPaLength];
for (int i = 0; i < iPaLength; i++)
{
if (strArrPa.length > i)
{
retStrArr[i] = strArrPa[i];
}
else
{
retStrArr[i] = "";
}
}
return retStrArr;
} // end method padStrArr
/**
* Erzeuge DB2-Timestamp-String
*
* @param pTimestamp
* @return
*/
// public static String toDB2TimestampStr(Timestamp pTimestamp)
// {
// return strzero( pTimestamp.getYear() + 1900, 4) + "-"
// + strzero( pTimestamp.getMonth() + 1 , 2 ) + "-"
// + strzero( pTimestamp.getDate() , 2 ) + "-"
// + strzero( pTimestamp.getHours() , 2 ) + "."
// + strzero( pTimestamp.getMinutes() , 2 ) + "."
// + strzero( pTimestamp.getSeconds() , 2 ) + "."
// + strzero( pTimestamp.getNanos() / 1000 , 6 )
// ;
// }
public static boolean isHost()
{
//Feststellen, ob die Applikation auf dem HOST OS/390 läuft, nur
provisorisch implementiert, nicht korrekt
return !
System.getProperty( "os.name" ).toUpperCase().startsWith( "WIN" );
}
/**
* Umwandlung Byte-Array in String unter Beachtung der Plattform OS/
390
*
* @param pByteArr
* @return
*/
public static String toStr( byte[] pByteArr)
{
//Feststellen, ob die Applikation auf dem HOST OS/390 läuft, nur
provisorisch implementiert, nicht korrekt
boolean isHost = isHost();
String retStr;
if (isHost)
{
//Encoding für HOST EBCDIC
try
{
retStr = new String( pByteArr , "8859_1" /*pEncoding*/ );
}
catch (UnsupportedEncodingException e)
{
System.err.println( e.getMessage() ); e.printStackTrace();
throw new RuntimeException( e.getMessage() );
}
}
else
{
retStr = new String( pByteArr );
}
return retStr;
}
/**
* Rückgabe String oder & n b s p ; wenn null oder Leerstring
* @param pObj
* @return
*/
public static String emptyToNbsp( final Object pObj )
{
if (pObj == null)
{
return " ";
}
if ( ! ( pObj instanceof String ) )
{
return toStr( pObj );
}
final String tStr = (String) pObj ;
if ( empty( tStr ) )
{
return " ";
}
return tStr;
}
/**
* regulärer Ausdruck nachempunden
* als Jokerzeichen dient '?' (CP/M)
*
* @param pStrValue
* @param pStrMask
* @return
*/
public static boolean match(//-
final String pStrValue, //-
final String pStrMask)
{
if (pStrValue== null || pStrMask == null)
{
return false;
}
if (pStrValue.length() != pStrMask.length() )
{
return false;
}
for (int i = 0; i < pStrMask.length(); i++)
{
if ( pStrMask.charAt( i ) == '?')
{
continue;
}
if ( pStrMask.charAt( i ) != pStrValue.charAt( i ))
{
return false;
}
}
return true;
}
/**
* regulärer Ausdruck nachempunden
* als Digit-Joker-Zeichen dient '9' (DBASE II)
*
* @param pStrValue
* @param pStrMask
* @return
*/
public static boolean digitMatch(//-
final String pStrValue, //-
final String pStrMask)
{
if (pStrValue== null || pStrMask == null)
{
return false;
}
if (pStrValue.length() != pStrMask.length() )
{
return false;
}
for (int i = 0; i < pStrMask.length(); i++)
{
if ( pStrMask.charAt( i ) == '9' )
{
if ( Character.isDigit( pStrValue.charAt( i ) ) )
{
continue;
}
else
{
return false;
}
}
if ( pStrMask.charAt( i ) != pStrValue.charAt( i ))
{
return false;
}
}
return true;
}
/**
* Check the specified String for Digits
* or other characters.
*
* @param pStr String to check
* @return whether only digits or not
*/
public static boolean onlyDigits(final String pStr)
{
if (pStr == null)
{
return false;
}
for (int i = 0; i < pStr.length(); i++)
{
if ( ! Character.isDigit( pStr.charAt(i) ) )
{
return false;
}
}
return true;
}
/**
* Formatierung {@link Date} oder
* {@link java.sql.Timestamp}.
*
* @param pObject
* @return
*/
public static String toFullStr(Date pDate) {
if (pDate == null){
return null;
}
if (pDate instanceof Timestamp){
// Konvertieren Nanos in Millisekunden
// siehe Javadoc of java.sql.Timestamp
pDate = new Date( ((Timestamp) pDate ).getTime()
+ ( ((Timestamp) pDate ).getNanos() / 1000000 ) );
}
//Apache-Commons: final FastDateFormat dateFormat =
FastDateFormat.getInstance( "yyyy-MM-dd HH:mm:ss.SSS" );
final DateFormat dateFormat = new SimpleDateFormat( "yyyy-MM-dd
HH:mm:ss.SSS" );
final String dateStr = dateFormat.format( pDate );
//TimeZone timeZone = pDate.g; TODO Ausgabe TimeZone
return dateStr;
}
/**
* Entfernen umliegende " oder ' vom übergebenen String.
*
* @param pSource
* @return
* @author Heiner Kücker
* @since Aug 2, 2005
*/
public static String stripStrEnc(final String pStr)
{
if ( pStr == null )
{
return null;
}
if ( pStr.startsWith( "\"" ) )
{
return cutLeftRight( pStr, "\"", "\"");
}
if ( pStr.startsWith( "'" ) )
{
return cutLeftRight( pStr, "'", "'");
}
return pStr; // evtl. Exception werfen
}
/**
* Abfrage eines Zeichen von einem String mit Abfangung
* Exception bei falscher Position.
*
* @param pStr abzufragender String
* @param pPos Zeichenposition
* @return abgefragtes Zeichen oder chr(0), wenn Position nicht ok
*/
public static char charAt(String pStr , int pPos)
{
try
{
return pStr.charAt(pPos);
}
catch (Exception e)
{
return (char) 0;
}
}
/**
*
*
* @param pStr
* @return
* @author Heiner Kücker
* @since Aug 5, 2005
*/
public static String encodeToJavaStrLiteral( //--
final String pStr )
{
if ( pStr == null )
{
return null;
}
final StringBuffer strBuff = new StringBuffer( (int)
( pStr.length() * 1.2f ) );
synchronized (strBuff )
{
strBuff.append( '"' );
for (int i = 0; i < pStr.length(); i++)
{
// TODO Einbau Oktal-Encoding
final char chr = pStr.charAt( i );
switch (chr)
{
case '\b' :
strBuff.append( "\\b" );
break;
case '\t' :
strBuff.append( "\\t" );
break;
case '\n' :
strBuff.append( "\\n" );
break;
case '\f' :
strBuff.append( "\\f" );
break;
case '\r' :
strBuff.append( "\\r" );
break;
case '\"' :
strBuff.append( "\\\"" );
break;
case '\'' :
strBuff.append( "\\'" );
break;
case '\\' :
strBuff.append( "\\\\" );
break;
default :
strBuff.append( chr );
break;
}
}
strBuff.append( '"' );
}
return strBuff.toString();
}
/**
*
*
* @param pStr
* @return
* @author Heiner Kücker
* @since Aug 5, 2005
*/
public static String decodeFromJavaStrLiteral( //--
final String pStr )
{
if ( pStr == null )
{
return null;
}
if ( pStr.length() < 2 )
{
throw new RuntimeException( "minimum length 2 expected: "
+ pStr );
}
if ( charAt( pStr , 0 ) != '\"' )
{
throw new RuntimeException( "start with quote \" expected:
" + pStr );
}
if ( charAt( pStr , pStr.length() - 1 ) != '\"' )
{
throw new RuntimeException( "end with quote \" expected: "
+ pStr );
}
final StringBuffer strBuff = new
StringBuffer( pStr.length() );
synchronized (strBuff )
{
for (int i = 1; i < pStr.length() - 1; i++)
{
if ( i < pStr.length() - 1 //--
&& pStr.charAt( i ) == '\\' )
{
final char chr = pStr.charAt( i + 1 );
strBuff.append( getDecodedChr(chr) );
i++;
}
else
{
strBuff.append( pStr.charAt( i ) );
}
}
}
return strBuff.toString();
}
/**
* Get decoded char for given encoded second char.
*
* @param strBuff
* @param chr
* @author Heiner Kücker
* @since Aug 5, 2005
*/
public static char getDecodedChr(//--
final char chr)
{
// TODO Einbau Oktal-Encoding
switch (chr)
{
case 'b' :
return '\b';
//break;
case 't' :
return '\t';
//break;
case 'n' :
return '\n';
//break;
case 'f' :
return '\f';
//break;
case 'r' :
return '\r';
//break;
case '"' :
return '\"';
//break;
case '\'' :
return '\'';
//break;
case '\\' :
return '\\';
//break;
default :
//return chr;
//break;
throw new RuntimeException( "illegal encoded character
\\" + chr );
}
}
/**
* Suche indexOf erstes White-Space
* ab festgelegter Position.
*
* @param pStr
* @param pStartIndex
* @return pos oder -1, wenn nicht gefunden
*/
public static int indexOfWhiteSpace(
final String pStr,
final int pStartIndex)
{
for (int i = pStartIndex; i < pStr.length(); i++)
{
final char runChar = pStr.charAt( i );
if ( Character.isWhitespace( runChar ) )
{
return i;
}
}
// kein WhiteSpace gefunden
return -1;
}
/**
* Suche indexOf erstes White-Space
* ab Position 0.
*
* @param pTempStr
* @return pos oder -1, wenn nicht gefunden
*/
public static int indexOfWhiteSpace(
final String pStr)
{
return indexOfWhiteSpace( pStr , 0 );
}
/**
* replace substrings within string.
*/
public static final String replace(
final String pStr,
final String pStrToReplace,
final String pStrNew)
{
if ( pStr == null )
{
return null;
}
UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pStr.length() + 256 );
//synchronized (buf)
{
int srcPos = 0;
int replacePos;
while ( srcPos < pStr.length() &&
( replacePos = pStr.indexOf( pStrToReplace ,
srcPos ) ) > -1 )
{
strBuff.append( pStr.substring( srcPos ,
replacePos ) );
strBuff.append( pStrNew );
srcPos = replacePos + pStrToReplace.length();
}
strBuff.append( pStr.substring( srcPos ) );
}
return strBuff.toString();
}
/**
* replace only one substring within string.
*/
public static final String replaceOnlyOne(
final String pStr,
final String pStrToReplace,
final String pStrNew)
{
if ( pStr == null )
{
return null;
}
UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pStr.length() + 256 );
//synchronized (buf)
{
int srcPos = 0;
int replacePos;
if ( srcPos < pStr.length() &&
( replacePos = pStr.indexOf( pStrToReplace ,
srcPos ) ) > -1 )
{
strBuff.append( pStr.substring( srcPos ,
replacePos ) );
strBuff.append( pStrNew );
srcPos = replacePos + pStrToReplace.length();
}
strBuff.append( pStr.substring( srcPos ) );
}
return strBuff.toString();
}
/**
* Konvertieren eines Datums 'yyyy-MM-dd'
* nach 'tt.MM.jjjj'.
*
* @param pAbrechBeginDbDatStr
* @return
*/
public static String dbDateStr2GermanDateStr(
final String pDbDatStr)
{
// TODO check parameter format
final String dayStr = pDbDatStr.substring( 8 , 10 );
final String monthStr = pDbDatStr.substring( 5, 7 );
final String yearStr = pDbDatStr.substring( 0 , 4 );
final String retStr = dayStr + "." + monthStr + "." + yearStr;
return retStr;
}
/**
* Zusammefügen aller Elemente der übergebenen
* Collection mit dem übergebenen Trenn-String.
*
* @param pColl zusammzufügende Collection
* @param pDelimStr Trenn-String
* @return
*/
public static String concat(
final Collection pColl,
final String pDelimStr)
{
if ( pColl == null )
{
return null;
}
return concat(
pColl.toArray() ,
pDelimStr );
}
/**
* Zusammefügen aller Elemente des übergebenen
* String-Arrays mit dem übergebenen Trenn-String.
*
* @param pObjArr zusammzufügendes Objekt-Array
* @param pDelimStr Trenn-String
* @return
*/
public static String concat(
final Object[] pObjArr,
final String pDelimStr)
{
final UnSynchStringBuffer concatStrBuff = new
UnSynchStringBuffer( 1024 );
//synchronized (concatStrBuff)
{
for (int i = 0; i < pObjArr.length; i++)
{
final String str = String.valueOf( pObjArr[i] );
concatStrBuff.append( str );
if ( pDelimStr != null
&& i < pObjArr.length - 1 )
{
concatStrBuff.append( pDelimStr );
}
}
return concatStrBuff.toString();
}
}
/**
* Zusammefügen aller Elemente des übergebenen
* String-Arrays mit dem übergebenen Trenn-String.
*
* @param pStrArr zusammzufügendes String-Array
* @param pDelimStr Trenn-String
* @return
*/
public static String concat(
final String[] pStrArr,
final String pDelimStr)
{
final UnSynchStringBuffer concatStrBuff = new
UnSynchStringBuffer( 1024 );
//synchronized (concatStrBuff)
{
for (int i = 0; i < pStrArr.length; i++)
{
final String str = pStrArr[i];
concatStrBuff.append( str );
if ( pDelimStr != null
&& i < pStrArr.length - 1 )
{
concatStrBuff.append( pDelimStr );
}
}
return concatStrBuff.toString();
}
}
/**
* Umwandeln einse Strings im Format
* 'yyyy-MM-dd' in ein Datum.
*
* @param pDatBelegStr
* @return
*/
public static java.sql.Date yyyyMMddStr2sqlDate(
final String pYyyyMMddDatStr)
{
return java.sql.Date.valueOf( pYyyyMMddDatStr );
}
/**
*/
public static String bigdecimalToFormattedGermanStr(
final BigDecimal pBigDecimal)
{
if ( pBigDecimal == null )
{
return null;
}
// Zwei Stellen hinter dem Komma absichern
final BigDecimal zweiStellenHinterDemKommaZahl =
pBigDecimal.setScale( 2 );
final String unformattedNumStr =
zweiStellenHinterDemKommaZahl.toString();
// Dezimal-Punkt in Dezimal-Komma umwandeln
final String decimalKommaStr = unformattedNumStr.replace( '.',
',' );
if ( decimalKommaStr.length() < 7 //--
|| ( decimalKommaStr.length() < 8 &&
decimalKommaStr.startsWith( "-" ) ) )
// die Zahl hat weniger als 4 Stellen vor dem komma und
muss nicht gruppiert werden
{
return decimalKommaStr;
}
// Gruppieren
//throw new UnsupportedOperationException( "Gruppieren noch
nicht implementiert: " + decimalKommaStr );
//System.out.println( decimalKommaStr );
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( decimalKommaStr );
final int decimalPosition = decimalKommaStr.indexOf( ',' );
int pos = decimalPosition;
while ( pos - 3 > 0 //--
&& strBuff.charAt( pos - 4 ) != '-' )
//
{
//System.out.println( strBuff.charAt( pos - 4 ) );
pos -= 3;
strBuff.insert( pos , '.' );
}
return strBuff.toString();
}
/**
* Den übergebenen String in Teilstücke mit der gewünschten
maximalen
* Länge (Breite) unterteilen und mit dem übergebenen Delimiter
(zum
* Beispiel Zeilenumbruch) wieder zusammenfügen.
*
* @param pStr zu zerteilender String
* @param pMaxWidth maximale Breite
* @param pDelimStr Trenner (zum Beispiel Zeilenumbruch)
* @return
*/
public static String splitForMaxWidth(
final String pStr,
final int pMaxWidth,
final String pDelimStr)
{
if ( pStr == null )
{
return null;
}
final int delimLength = pDelimStr == null ? 0 :
pDelimStr.length();
final UnSynchStringBuffer strBuff =
new UnSynchStringBuffer(
pStr.length() +
( delimLength * (int) Math.ceil( (double)
pMaxWidth / pMaxWidth ) ) );
int pos = 0;
while ( true /*pos < pMaxWidth*/ )
{
final int partSize = Math.min( pMaxWidth , pStr.length() -
pos );
final String partStr = pStr.substring( pos , pos +
partSize );
strBuff.append( partStr );
pos += partSize;
if ( pos < pStr.length() )
// nicht letzter Durchlauf
{
if ( delimLength > 0 )
{
strBuff.append( pDelimStr );
}
}
else
// letzter Durchlauf
{
break;
}
}
return strBuff.toString();
}
/**
* Von jeder Zeile des übergebenen String-Arrays
* links die spezifizierte Anzahl Zeichen abschneiden.
*
* @param pStrArr
* @param pCutSize
* @return
*/
public static String[] cutLeftArr(
final String[] pStrArr,
final int pCutSize)
{
if ( pStrArr == null )
{
return null;
}
final String[] retStrArr = new String[ pStrArr.length ];
for (int i = 0; i < pStrArr.length; i++)
{
retStrArr[ i ] =
cutLeft(
pStrArr[i],
pCutSize );
}
return retStrArr;
}
/**
* Vom übergebenen String links die
* spezifizierte Anzahl Zeichen abschneiden.
*
* @param pStr
* @param pCutSize
* @return
*/
private static String cutLeft(
final String pStr,
final int pCutSize)
{
if ( pStr == null )
{
return null;
}
if ( pStr.length() < pCutSize )
/// nachgiebig lenient
{
return "";
}
return pStr.substring( pCutSize );
}
/**
* Setze ein Zeichen auf einem als Zeichenfeld
* dienenden zeilenweisen string-Array.
*
* @param pLineStrArr
* @param pLineNr
* @param pChrPos
* @param pC
*/
public static void setCharAt(
final String[] pLineStrArr,
final int pLineNr,
final int pChrPos,
final char pChr )
{
// Achtung: Seiteneffekt
pLineStrArr[ pLineNr ] =
setCharAt(
pLineStrArr[ pLineNr ],
pChrPos,
pChr);
}
/**
* Setze eine Zeichen im spezifierten String an der
* spezifierten Position und verlängere den String
* mit Leerzeichen, wenn nötig.
*
* @param pStr
* @param pChrPos
* @param pChr
* @return String mit gesetztem Zeichen
*/
private static String setCharAt(
final String pStr,
final int pChrPos,
final char pChr)
{
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pStr );
strBuff.fillSpacesToLength( pChrPos + 1 );
strBuff.setCharAt( pChrPos, pChr);
return strBuff.toString();
}
/**
*
* @param pObj in einen int-Wert umzuwandelndes Objekt
* @param pNullIntVal dieser int-Wert wird übergeben, wenn das
Parameter-Oobjekt null ist.
* @return
*/
public static int obj2int(
final Object pObj,
final int pNullIntVal )
{
if ( pObj == null )
{
return pNullIntVal;
}
return str2intTolerant( String.valueOf( pObj ) );
}
/**
* Zurückgeben des Teil-Strings aus dem übergebenen
* String zwischen dem übergebenen Davor- und Danach-String.
*
* @param pStr Quell-String
* @param pPreStr Davor-String
* @param pPostStr Danach-String
* @return Teil-String zwischen pPreStr und pPostStr ohne pPreStr
und pPostStr.
*/
public static String between(
final String pStr,
final String pPreStr,
final String pPostStr )
{
if ( pStr == null )
{
return null;
}
if ( pPreStr.equals( pPostStr ) )
{
throw new RuntimeException( "pre string: '" + pPreStr + "'
must be different from post string: '" + pPostStr + "'" );
}
final int preStrPos = pStr.indexOf( pPreStr );
if ( preStrPos < 0 )
{
throw new RuntimeException( "pre string: '" + pPreStr + "'
not found in source string: '" + pStr + "'" );
}
final int afterPreStrPos = preStrPos + pPreStr.length();
//final int postStrPos = pStr.lastIndexOf( pPostStr );
final int postStrPos = pStr.indexOf( pPostStr ,
afterPreStrPos );
if ( preStrPos < 0 )
{
throw new RuntimeException( "post string: '" + pPostStr +
"' not found in source string: '" + pStr + "'" );
}
if ( postStrPos <= preStrPos )
{
throw new RuntimeException( "pre string: '" + pPreStr + "'
position: " + preStrPos + " must be lesser than post string: '" +
pPostStr + "' positon: " + postStrPos );
}
return pStr.substring( afterPreStrPos , postStrPos );
}
/**
* Zurückgeben des Teil-Strings
* vor dem übergebenen Trenn-String.
*
* @param pStr
* @param pDelimStr
* @return
*/
public static String preStr(
final String pStr,
final String pDelimStr )
{
if ( pStr == null )
{
return null;
}
final int delimStrPos = pStr.indexOf( pDelimStr );
if ( delimStrPos < 0 )
{
throw new RuntimeException( "delimiter string: '" +
pDelimStr + "' not found in source string: '" + pStr + "'" );
}
return pStr.substring( 0 , delimStrPos );
}
/**
* Zurückgeben des Teil-Strings
* nach dem übergebenen Trenn-String.
*
* @param pStr
* @param pDelimStr
* @return
*/
public static String postStr(
final String pStr,
final String pDelimStr )
{
if ( pStr == null )
{
return null;
}
final int delimStrPos = pStr.indexOf( pDelimStr );
if ( delimStrPos < 0 )
{
throw new RuntimeException( "delimiter string: '" +
pDelimStr + "' not found in source string: '" + pStr + "'" );
}
return pStr.substring( delimStrPos + pDelimStr.length() );
}
/**
* Vereinfachte Prüfsumme.
*
* @param pStr
* @return
*/
public long chrSum(
final String pStr )
{
if ( pStr == null )
{
return -1;
}
long chrSumLong = 0;
for (int i = 0; i < pStr.length(); i++)
{
final char runChr = pStr.charAt( i );
chrSumLong += runChr;
}
return chrSumLong;
}
/**
* Achtung, sehr langsam.
*
* @see http://www.galileocomputing.de/openbook/javainsel5/javainsel12_012.htm#Rxx747java12012040004031F03A100
*
* @param pStr
* @return
*/
public static String crc32(
final String pStr )
{
if ( pStr == null )
{
return null;
}
//throw new NotImplementedException();
final CRC32 crc = new CRC32();
final byte[] byteArr = serialize( pStr );
crc.update( byteArr );
return Long.toHexString( crc.getValue() );
}
/**
* Schneller als CRC32, aber ebenso gut.
*
* @see http://www.galileocomputing.de/openbook/javainsel5/javainsel12_012.htm#Rxx747java12012040004031F03A100
*
* @param pStr
* @return
*/
public static String adler32(
final String pStr )
{
if ( pStr == null )
{
return null;
}
//throw new NotImplementedException();
final Adler32 adler = new Adler32();
final byte[] byteArr = serialize( pStr );
adler.update( byteArr );
return Long.toHexString( adler.getValue() );
}
/**
* serialize.
*
* @param pObj
* @return
*/
public static byte[] serialize(
final Object pObj )
{
try
{
final ByteArrayOutputStream bos = new
ByteArrayOutputStream();
final ObjectOutputStream oos = new
ObjectOutputStream( bos );
oos.writeObject( pObj );
oos.close();
return bos.toByteArray();
}
catch (Exception e)
{
System.err.println( e );
e.printStackTrace();
throw new RuntimeException( e );
}
}
/**
* Verkürze den übergebenen String auf die gewünschte maximale
Länge.
*
* @param pStr
* @param pMaxLen
* @return verkürzter String
*/
public static String shortStrToMaxLen(
final String pStr ,
final int pMaxLen )
{
if ( pStr == null )
{
return null;
}
return pStr.substring(0 , Math.min( pStr.length() ,
pMaxLen ) );
}
/**
* Test
* @param args
*/
public static void main(String[] args)
{
//System.out.println( strzero(2, 2 ) );
//
System.out.println( dbDateStr2GermanDateStr( "2006-01-01" ) );
// System.out.println( replace( "aaa-bbb-ccc", "-", ":") );
// System.out.println( replace( "-aaa-bbb-ccc-", "-", ":") );
// System.out.println( replace( "--aaa--bbb--ccc--", "--",
":") );
// System.out.println( replace( "--aaa--bbb--ccc--", "--",
"???") );
// System.out.println( replace( "aaabbbccc", "--", "???") );
// System.out.println(
// "'"
// + splitForMaxWidth(
// "0123456789",
// 2,
// "'+\n'") + "'" );
System.out.println( bigdecimalToFormattedGermanStr(
new BigDecimal( "1234567.01" ) ) );
System.out.println( bigdecimalToFormattedGermanStr(
new BigDecimal( "12345678.01" ) ) );
System.out.println( bigdecimalToFormattedGermanStr(
new BigDecimal( "123456789.01" ) ) );
System.out.println( bigdecimalToFormattedGermanStr(
new BigDecimal( "-1234567.01" ) ) );
System.out.println( bigdecimalToFormattedGermanStr(
new BigDecimal( "-12345678.01" ) ) );
System.out.println( bigdecimalToFormattedGermanStr(
new BigDecimal( "-123456789.01" ) ) );
System.out.println(
strzero( "1" , 3 ) );
System.out.println(
strzero( "-1" , 3 ) );
System.out.println(
strzero( "1" , 23 ) );
System.out.println(
strzero( "-1" , 23 ) );
System.out.println(
between(
"aaa<bbb>ccc",
"<",
">" ) );
System.out.println(
germanToEnglischNumStr( "-1.894,01" ) );
System.out.println(
germanToEnglischNumStrWithoutGrouping( "-1.894,01" ) );
}
/**
* Zeichenweises ODER-Verknüpfen zweier
* Strings.
* Ein Leerzeichen gilt als logisch false,
* alles andere als logisch true.
* Dabei wird ein vorhandes Zeichen möglichst übernommen.
*
* @param pStr1
* @param pStr2
* @return
*/
public static String strOr(
final String pStr1,
final String pStr2 )
{
if ( pStr1.length() != pStr2.length() )
{
throw new RuntimeException( "diff length: " +
pStr1.length() + " to " + pStr2.length() );
}
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pStr1.length() );
for (int i = 0; i < pStr1.length(); i++)
{
final char chr1 = pStr1.charAt( i );
final char chr2 = pStr2.charAt( i );
if ( chr1 != ' ' )
{
strBuff.append( chr1 );
}
else if ( chr2 != ' ' )
{
strBuff.append( chr2 );
}
else
{
strBuff.append( ' ' );
}
}
return strBuff.toString();
}
/**
* Zeichenweises UND-Verknüpfen zweier
* Strings.
* Ein Leerzeichen gilt als logisch false,
* alles andere als logisch true.
* Dabei wird ein vorhandes Zeichen möglichst übernommen.
*
* @param pStr1
* @param pStr2
* @return
*/
public static String strAnd(
final String pStr1,
final String pStr2 )
{
if ( pStr1.length() != pStr2.length() )
{
throw new RuntimeException( "diff length: " +
pStr1.length() + " to " + pStr2.length() );
}
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pStr1.length() );
for (int i = 0; i < pStr1.length(); i++)
{
final char chr1 = pStr1.charAt( i );
final char chr2 = pStr2.charAt( i );
if ( chr1 == ' ' || chr2 == ' ' )
{
strBuff.append( ' ' );
}
else
{
strBuff.append( chr1 );
}
}
return strBuff.toString();
}
/**
* Zeichenweises Negieren eines Strings.
*
* Ein Leerzeichen gilt als logisch false,
* alles andere als logisch true.
*
* Dabei wird ein vorhandes Zeichen möglichst übernommen.
*
* @param pStr1
* @param pTrueChr bei true zu verwendendes Zeichen
* @return
*/
public static String strNot(
final String pStr,
final char pTrueChr )
{
final UnSynchStringBuffer strBuff = new
UnSynchStringBuffer( pStr.length() );
for (int i = 0; i < pStr.length(); i++)
{
final char chr = pStr.charAt( i );
if ( chr == ' ' )
{
strBuff.append( pTrueChr );
}
else
{
strBuff.append( ' ' );
}
}
return strBuff.toString();
}
/**
*
* @param tnrStr
* @return
*/
public static boolean isNumStr(
final String pStr )
{
if ( pStr == null )
{
return false;
}
for (int i = 0; i < pStr.length(); i++)
{
char chr = pStr.charAt( i );
if ( ! Character.isDigit( chr ) )
{
return false;
}
}
return true;
}
/**
* Zurückgeben eines Sub-Arrays des übergebenen
* String-Arrays.
*
* @param pStrArr
* @param pStartLineIndex
* @param pStopLineIndexExclusiv
* @return Sub-String-Array
*/
public static String[] subArr(
final String[] pStrArr,
final int pStartLineIndex,
final int pStopLineIndexExclusiv )
{
final int retStrArrSize = pStopLineIndexExclusiv -
pStartLineIndex;
final String[] retStrArr = new String[ retStrArrSize ];
System.arraycopy(
pStrArr, // src,
pStartLineIndex , // srcPos,
retStrArr , // dest,
0 , // destPos,
retStrArrSize //length
);
return retStrArr;
}
/**
* Zurückgeben eines Sub-Arrays des übergebenen
* String-Arrays vom angegebenen Index bis zum
* Ende des String-Arrays.
*
* @param pStrArr
* @param pStartLineIndex
* @param pStopLineIndexExclusiv
* @return Sub-String-Array
*/
public static String[] subArr(
final String[] pStrArr,
final int pStartLineIndex )
{
final String[] retStrArr =
subArr(
pStrArr,
pStartLineIndex ,
pStrArr.length );
return retStrArr;
}
/**
* @param pStrArr
* @param pSpaceCount
*/
public static String[] padStrArrForMaxLength(
final String[] pStrArr,
final int pSpaceCount )
{
final int maxLength =
StringUtil.getMaxLen( pStrArr );
final String[] retStrArr = new String[ pStrArr.length ];
for (int i = 0; i < pStrArr.length; i++)
{
final String str = pStrArr[i];
retStrArr[ i ] =
pad(
str,
maxLength + pSpaceCount );
}
return retStrArr;
}
/**
* @param pLineStrArr
* @return
*/
public static int getMaxLen(
final String[] pStrArr)
{
if ( pStrArr == null || pStrArr.length == 0 )
{
return 0;
}
int maxLen = 0;
for (int i = 0; i < pStrArr.length; i++)
{
final String str = pStrArr[i];
if ( str != null )
{
maxLen = Math.max( maxLen, str.length() );
}
}
return maxLen;
}
/**
* Anhängen des übergebenen Strings
* an jedes eeölment des übergebenen
* Strings.
*
* @param pStrArr
* @param pString
* @return
*/
public static String[] addPerElem(
final String[] pStrArr,
final String pString)
{
final String[] retStrArr = new String[ pStrArr.length ];
for (int i = 0; i < pStrArr.length; i++)
{
final String str = pStrArr[i];
retStrArr[ i ] =
str + pString;
}
return retStrArr;
}
} // end class StringUtil
.
- Prev by Date: Re: Kann ein Windows Service ein "normales" Programm starten?
- Next by Date: Re: Window resize Event nur einmal bearbeiten
- Previous by thread: Re: Graph traversieren wie ein Petri-Netz
- Next by thread: Java zugunsten von Lisp absteigendend?
- Index(es):
Relevant Pages
|
