/*\
* Copyright 2006 Klaus Rogall, Hamburg, Germany (klaus.rogall@web.de). All rights reserved.
* _____________________________________________________________________________________________________________________
*
* This file is "Open Source" as defined by the Open Source Initiative (OSI). You can redistribute it and/or modify it
* under the terms of the BSD License. The license text is appended to the end of this file.
\*/
package de.klaro.base.util;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.StringTokenizer;
/**
* Methoden zur String-Manipulation und String-Verarbeitung.
*
* @see java.lang.String
*/
public class Strings extends Object
{
/* ______________________________________________________________________________________________________________ *\
\* Konstanten */
private static final String[] EMPTY_STRING_ARRAY = new String[0];
/* ______________________________________________________________________________________________________________ *\
\* Klassenvariablen */
/* ______________________________________________________________________________________________________________ *\
\* Instanzvariablen */
/* ______________________________________________________________________________________________________________ *\
\* Konstruktoren */
/**
* Erzeugt eine Instanz dieser Klasse.
*
* Da verhindert werden soll, dass Instanzen dieser Klasse ausserhalb dieser Klasse erzeugt werdem, ist dieser
* Konstruktor 'private' deklariert.
*/
private Strings()
{
super();
}
/* ______________________________________________________________________________________________________________ *\
\* Instanzmethoden */
/* ______________________________________________________________________________________________________________ *\
\* Klassenmethoden */
/**
* Liefert den String oder einen Ersatz-String, falls der String 'null' ist.
*
* @param string Der String
* @param defaultValue Der Ersatz-String
* @return Der String oder der Ersatz-String, falls der String 'null' ist
*/
public static String nullAsText(CharSequence string,String defaultValue)
{
return (string == null)? defaultValue: string.toString();
}
/**
* Liefert den String oder einen Leer-String, falls der String 'null' ist.
*
* @param string Der String
* @return Der String oder ein Leer-String, falls der String 'null' ist
*/
public static String nullAsEmpty(CharSequence string)
{
return nullAsText(string,"");
}
/**
* Liefert den String oder 'null', falls der String ein Leer-String ist.
*
* @param string Der String
* @return Der String oder 'null', falls der String ein Leer-String ist
*/
public static String emptyAsNull(CharSequence string)
{
return emptyAsText(string,null);
}
/**
* Liefert den String oder 'null', falls der 'null', String ein Leer-String oder ein String nur aus White-Spaces ist.
*
* @param string Der String
* @return Der String oder 'null', falls der String 'null', ein Leer-String oder ein String nur aus White-Spaces ist
*/
public static String blankAsNull(String string)
{
return blankAsText(string,null);
}
/**
* Liefert den String oder einen Ersatz-String, falls der String 'null' oder ein Leer-String ist.
*
* @param string Der String
* @param defaultValue Der Ersatz-String
* @return Der String oder der Ersatz-String, falls der String 'null' oder ein Leer-String ist
*/
public static String emptyAsText(CharSequence string,String defaultValue)
{
return (isNullOrEmpty(string))? defaultValue: string.toString();
}
/**
* Liefert den String oder einen Ersatz-String, falls der String 'null', ein Leer-String oder ein String nur aus White-Spaces ist.
*
* @param string Der String
* @param defaultValue Der Ersatz-String
* @return Der String oder der Ersatz-String, falls der String 'null', ein Leer-String oder ein String nur aus White-Spaces ist
*/
public static String blankAsText(CharSequence string,String defaultValue)
{
return (isNullOrBlank(string))? defaultValue: string.toString();
}
/**
* Prft, ob ein 'null' oder ein Leer-String ist.
*
* @param string Der String
* @return Der String ist 'null' oder ein Leer-String.
*/
public static boolean isNullOrEmpty(CharSequence string)
{
return (string == null || string.length() == 0);
}
/**
* Prft, ob ein 'null', ein Leer-String oder ein String nur aus White-Spaces ist.
*
* @param string Der String
* @return Der String ist 'null', ein Leer-String oder ein String nur aus White-Spaces
*/
public static boolean isNullOrBlank(CharSequence string)
{
return (string == null || string.length() == 0 || string.toString().trim().length() == 0);
}
/**
* Prft, ob ein String gleich einem anderen ist, wobei auch 'null'-Werte bercksichtigt werden.
*
* @param string1 Der erste String
* @param string2 Der zweite String
* @return Die beiden String sind gleich oder beide Strings sind 'null'
*/
public static boolean equals(CharSequence string1,CharSequence string2)
{
return (string1 == null && string2 == null) || (string1 != null && string2 != null && string1.equals(string2));
}
/**
* Liefert den Pfad (den fhrenden Teil) eines strukturierten Strings.
*
* Ein strukturierter String besteht aus ein oder mehreren Segmenten, die durch ein bestimmtes Zeichen voneinander
* getrennt sind (zum Beispiel das Zeichen '/' bei Dateipfaden). Der Pfad ist alles ausser das letzte Segment.
* Das Trennzeichen, das den Pfad vom letzten Segment trennt, wird nicht zurckgegeben.
*
* Falls der String das Trennzeichen nicht enthlt, wird ein Leer-String geliefert.
*
* Beispiel: Fr den String "/de/klaro/base/util/Strings.java" und das Trennzeichen '/' hat der Pfad den Wert
* "/de/klaro/base/util".
*
* @param string Der String
* @param separator Das Trennzeichen
* @return Der Pfad (der String ohne das Segment hinter dem letzten Trennzeichen)
*/
public static String pathOf(CharSequence string,char separator)
{
String s = string.toString();
int index = s.lastIndexOf(separator);
return (index == -1)? "": s.substring(0,index);
}
/**
* Liefert die Basis (den schliessenden Teil) eines strukturierten Strings.
*
* Ein strukturierter String besteht aus ein oder mehreren Segmenten, die durch ein bestimmtes Zeichen voneinander
* getrennt sind (zum Beispiel das Zeichen '/' bei Dateipfaden). Die Basis ist das letzte Segment. Das Trennzeichen,
* das den Pfad vom letzten Teil trennt, wird nicht zurckgegeben.
*
* Falls der String das Trennzeichen nicht enthlt, wird der String selbst geliefert.
*
* Beispiel: Fr den String "/de/klaro/base/util/Strings.java" und das Trennzeichen '/' hat die Basis den Wert
* "Strings.java".
*
* @param string Der String
* @param separator Das Trennzeichen
* @return Die Basis (das Segment hinter dem letzten Trennzeichen)
*/
public static String baseOf(CharSequence string,char separator)
{
String s = string.toString();
int index = s.lastIndexOf(separator);
return (index == -1)? s: s.substring(index + 1);
}
/**
* Entfernt alle fhrenden und schliessenden Leerzeichen sowie mehrere Leerzeichen, die aufeinander folgen.
*
* Hat der String den Wert 'null', dann wird ein Leer-String geliefert.
*
* @param string Der zu trimmende String
* @return Der getrimmte String
*/
public static String trim(CharSequence string)
{
if (string == null)
return "";
String s = string.toString().trim();
int index = 0;
while ((index = s.indexOf(" ",index)) >= 0)
s = s.substring(0,index) + s.substring(index + 1);
return s;
}
/**
* Sucht einen String in einem Reihe von Strings und liefert die Position des ersten Treffers.
*
* @param string Der String
* @param strings Die Strings, in denen gesucht wird
* @return Die Position des ersten Treffers, oder -1 falls der String in den Strings nicht vorhanden ist
*/
public static int positionOf(CharSequence string,CharSequence... strings)
{
if (string == null)
return -1;
for (int index = 0; index < strings.length; index++)
{
if (string.equals(strings[index]))
return index;
}
return -1;
}
/**
* Sucht einen String in einem Reihe von Strings und liefert die Position des letzten Treffers.
*
* @param string Der String
* @param strings Die Strings, in denen gesucht wird
* @return Die Position des ersten Treffers, oder -1 falls der String in den Strings nicht vorhanden ist
*/
public static int lastPositionOf(CharSequence string,CharSequence... strings)
{
if (string == null)
return -1;
for (int index = strings.length - 1; index >= 0; index--)
{
if (string.equals(strings[index]))
return index;
}
return -1;
}
/**
* Liefert den Index des letzten Zeichens aus einer Menge von Zeichen in einem String.
*
* @param string Der String
* @param matchString Die Menge von Zeichen, die gesucht werden soll
* @return Der Index des letzten Zeichens, oder -1 falls keines der Zeichen im String vorhanden ist
*/
public static int lastIndexOf2(CharSequence string,String matchString)
{
if (string == null)
return -1;
if (matchString == null || matchString.length() == 0)
return -1;
for (int i = string.length() - 1; i >= 0; i--)
if (matchString.indexOf(string.charAt(i)) >= 0)
return i;
return -1;
}
/**
* Verlngert oder verkrzt einen String auf eine Hchst- oder Mindestlnge.
*
* Der String wird zunchst auf die angegebene Hchstlnge gekrzt (sofern der String lnger ist als die Hchstlnge
* und der Wert fr die gewnschte Hchstlnge grsser 0 ist).
*
* Danach wird das Ergebnis auf die angegebene Mindestlnge verlngert (sofern die gewnschte Mindestlnge grsser 0
* ist).
*
* Die Verlngerung bzw. die Krzung wird wahlweise am Anfang oder am Ende des Strings vorgenommen, wobei bei der
* Verlngerung das Zeichen bestimmt werden kann.
*
* Beispiele:
*
* trim("ABCDEFGH", 4,10,'-',true) --> "ABCD------"
* trim("ABCDEFGH", 4,10,'-',false) --> "------EFGH"
* trim("ABCDEFGH",10, 4,'-',true) --> "ABCDEFGH"
* trim("ABCDEFGH",10, 4,'-',false) --> "ABCDEFGH"
* trim("ABCDEFGH",10,10,'-',true) --> "ABCDEFGH--"
* trim("ABCDEFGH", 4, 0,'-',true) --> "ABCD"
* trim("ABCDEFGH", 4, 0,'-',false) --> "EFGH"
* trim("ABCDEFGH", 0, 4,'-',true) --> "ABCDEFGH"
* trim("ABCDEFGH", 0, 4,'-',false) --> "ABCDEFGH"
*
* @param string Der String
* @param maxLength Die Hchstlnge, auf die das Ergebnis gekrzt wird (oder 0 wenn keine Krzung durchgefhrt werden soll)
* @param minLength Die Mindestlnge, auf die das Ergebnis verlngert wird (oder 0 wenn keine Verlngerung durchgefhrt werden soll)
* @param filler Das Zeichen, das benutzt wird, um das Ergebnis zu verlngern
* @param trailing Die Verlngerung bzw. Krzung wird am Ende (statt am Anfang) des Ergebnisses vorgenommen
* @return Der formatierte String
*/
public static String trim(CharSequence string,int maxLength,int minLength,char filler,boolean trailing)
{
int length = string.length();
// Krzung des Strings auf die Hchstlnge
if (maxLength > 0)
{
if (length > maxLength)
{
string = (trailing)? string.toString().substring(0,maxLength): string.toString().substring(length - maxLength);
length = maxLength;
}
}
// Verlngerung des Strings auf die Mindestlnge
if (minLength > 0)
{
if (length < minLength)
{
int bufLength = minLength - length;
StringBuilder buffer = new StringBuilder(bufLength);
buffer.setLength(bufLength);
for (int i = 0; i < bufLength; i++)
buffer.setCharAt(i,filler);
string = (trailing)? string .toString()+ buffer: buffer + string.toString();
}
}
return string.toString();
}
/**
* Schneidet einen String am Ende ab, so dass eine maximale Lnge nicht berschritten wird.
*
* Wahlweise kann bestimmt werden, ob (fr den Fall, dass tatschlich Zeichen abgeschnitten wurde) am Ende eine
* Ellipse (drei Punkte) angehngt werden. Die maximale Lnge bezieht sich dann auf den Text inklusive Ellipse.
*
* Das Abschneiden wird entweder an einer beliebigen Stelle, oder an Wortgrenzen durchgefhrt. Sollte es keine
* Wortgrenze innerhalb der vorgegebenen Lnge geben, wird mitten in einem Wort geteilt.
* "/de/klaro/base/util".
*
* @param string Der String
* @param maxlength Die maximale Lnge (inklusive Ellipsenzeichen)
* @param words Es sollen Wortgrenzen beachtet werden
* @param ellipsis Wenn der Text abgeschnitten wird, werden Ellipsenzecihen (drei Punkte) angefgt
* @return Der auf eine maximale Lnge gekrzte String
*/
public static String crop(CharSequence string,int maxlength,boolean words,boolean ellipsis)
{
if (string == null)
{
return null;
}
if (string.length() <= maxlength)
{
return string.toString();
}
int maxindex = (ellipsis)? maxlength - 3: maxlength;
if (maxindex < 1)
throw new IllegalArgumentException("resulting length must not be less than 1");
if (!words)
{
string = string.toString().substring(0,maxindex);
if (ellipsis)
string = string + "...";
return string.toString();
}
for (int i = maxindex - 1; i > 0; i--)
{
if (Character.isWhitespace(string.charAt(i)))
return crop(string,(ellipsis)? i + 3: i,false,ellipsis);
}
return crop(string,maxlength,false,ellipsis);
}
/**
* Erzeugt einen String beliebiger Lnge, dessen Zeichen alle identisch sind.
*
* @param length Die Lnge des Strings
* @param filler Das Zeichen, aus dem der String bestehen soll
* @return Der String, dessen Zeichen alle identisch sind
*/
public static String string(int length,char filler)
{
return trim("",0,length,filler,true);
}
/**
* Formatiert eine Integer-Zahl rechtsbndig auf eine bestimmte Mindestlnge.
*
* @param number Die Zahl
* @param radix Die Basis der Zahldarstellung (2 fr binr, 8 for oktal, 10 for dezimal, 16 for hexadezimal)
* @param digits Die Anzahl der Stellen
* @param blankPadded Die freien Stellen werden mit Leerzeichen (statt mit Nullen) aufgefllt
* @return Die formatierte Zahl als String
*/
public static String format(int number,int radix,int digits,boolean blankPadded)
{
return trim(Integer.toString(number,radix).toUpperCase(),0,digits,(blankPadded)? ' ': '0',false);
}
/**
* Formatiert eine Integer-Zahl rechtsbndig auf eine bestimmte Mindestlnge (wobei Leerzeichen zum Auffllen auf
* die Mindestlnge benutzt werden).
*
* @param number Die Zahl
* @param radix Die Basis der Zahldarstellung (2 fr binr, 8 for oktal, 10 for dezimal, 16 for hexadezimal)
* @param digits Die Anzahl der Stellen
* @return Die formatierte Zahl als String
*/
public static String format(int number,int radix,int digits)
{
return format(number,radix,digits,true);
}
/**
* Formatiert eine Integer-Zahl rechtsbndig auf eine bestimmte Mindestlnge.
*
* @param number Die Zahl
* @param digits Die Anzahl der Stellen
* @param blankPadded Die freien Stellen werden mit Leerzeichen (statt mit Nullen) aufgefllt
* @return Die formatierte Zahl als String
*/
public static String format(int number,int digits,boolean blankPadded)
{
return format(number,10,digits,blankPadded);
}
/**
* Formatiert eine Integer-Zahl rechtsbndig auf eine bestimmte Mindestlnge (wobei Leerzeichen zum Auffllen auf
* die Mindestlnge benutzt werden).
*
* @param number Die Zahl
* @param digits Die Anzahl der Stellen
* @return Die formatierte Zahl als String
*/
public static String format(int number,int digits)
{
return format(number,10,digits,true);
}
/**
* Formatiert eine Long-Zahl rechtsbndig auf eine bestimmte Mindestlnge.
*
* @param number Die Zahl
* @param radix Die Basis der Zahldarstellung (2 fr binr, 8 for oktal, 10 for dezimal, 16 for hexadezimal)
* @param digits Die Anzahl der Stellen
* @param blankPadded Die freien Stellen werden mit Blanks (statt mit Nullen) aufgefllt
* @return Die formatierte Zahl als String
*/
public static String format(long number,int radix,int digits,boolean blankPadded)
{
return trim(Long.toString(number,radix).toUpperCase(),0,digits,(blankPadded)? ' ': '0',false);
}
/**
* Formatiert eine Long-Zahl rechtsbndig auf eine bestimmte Mindestlnge (wobei Leerzeichen zum Auffllen auf die
* Mindestlnge benutzt werden).
*
* @param number Die Zahl
* @param radix Die Basis der Zahldarstellung (2 fr binr, 8 for oktal, 10 for dezimal, 16 for hexadezimal)
* @param digits Die Anzahl der Stellen
* @return Die formatierte Zahl als String
*/
public static String format(long number,int radix,int digits)
{
return format(number,radix,digits,true);
}
/**
* Formatiert eine Long-Zahl rechtsbndig auf eine bestimmte Mindestlnge.
*
* @param number Die Zahl
* @param digits Die Anzahl der Stellen
* @param blankPadded Die freien Stellen werden mit Blanks (statt mit Nullen) aufgefllt
* @return Die formatierte Zahl als String
*/
public static String format(long number,int digits,boolean blankPadded)
{
return format(number,10,digits,blankPadded);
}
/**
* Formatiert eine Long-Zahl rechtsbndig auf eine bestimmte Mindestlnge (wobei Leerzeichen zum Auffllen auf die
* Mindestlnge benutzt werden).
*
* @param number Die Zahl
* @param digits Die Anzahl der Stellen
* @return Die formatierte Zahl als String
*/
public static String format(long number,int digits)
{
return format(number,10,digits,true);
}
/**
* Wandelt einen String in eine Short-Ganzzahl um.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Numbers delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als Short-Ganzzahl
* @see Numbers#parse(CharSequence, short)
*/
public static short parse(CharSequence string,short defaultValue)
{
return Numbers.parse(string,defaultValue);
}
/**
* Wandelt einen String in eine Integer-Ganzzahl um.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Numbers delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als Integer-Ganzzahl
* @see Numbers#parse(CharSequence, int)
*/
public static int parse(CharSequence string,int defaultValue)
{
return Numbers.parse(string,defaultValue);
}
/**
* Wandelt einen String in eine Long-Ganzzahl um.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Numbers delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als Long-Ganzzahl
* @see Numbers#parse(CharSequence, long)
*/
public static long parse(CharSequence string,long defaultValue)
{
return Numbers.parse(string,defaultValue);
}
/**
* Wandelt einen String in eine Float-Dezimalzahl um.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Numbers delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als Float-Dezimalzahl
* @see Numbers#parse(CharSequence, float)
*/
public static float parse(CharSequence string,float defaultValue)
{
return Numbers.parse(string,defaultValue);
}
/**
* Wandelt einen String in eine Double-Dezimalzahl um.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Numbers delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als Double-Dezimalzahl
* @see Numbers#parse(CharSequence, double)
*/
public static double parse(CharSequence string,double defaultValue)
{
return Numbers.parse(string,defaultValue);
}
/**
* Wandelt einen String in ein BigDecimal-Dezimalzahl um.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Numbers delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als Double-Dezimalzahl
* @see Numbers#parse(CharSequence, double)
*/
public static BigDecimal parse(CharSequence string,BigDecimal defaultValue)
{
return Numbers.parse(string,defaultValue);
}
/**
* Wandelt einen String in einen Boolean-Wert um.
*
* Neben den blichen Strings "true" und "false" werden auch "yes" und "no" sowie "on" und "off" erkannt und
* entsprechend umgewandelt. Gro-/Kleinschreibung wird nicht beachtet.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Booleans delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als boolescher Wert
* @see Booleans#parse(CharSequence, boolean)
*/
public static boolean parse(CharSequence string,boolean defaultValue)
{
return Booleans.parse(string,defaultValue);
}
/**
* Wandelt einen String in ein Locale um.
*
* Neben den blichen Strings "true" und "false" werden auch "yes" und "no" sowie "on" und "off" erkannt und
* entsprechend umgewandelt. Gro-/Kleinschreibung wird nicht beachtet.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Locales delegiert.
*
* @param string Der String
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Der String als boolescher Wert
* @see Locales#parse(CharSequence, Locale)
*/
public static Locale parse(CharSequence string,Locale defaultValue)
{
return Locales.parse(string,defaultValue);
}
/**
* Wandelt einen String in ein Datum um.
*
* Das Format muss entsprechend der Formatierungen der Klasse SimpleDateFormat angegeben werden.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Dates delegiert.
*
* @param string Der String
* @param format Das Format
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Das Datum als Long-Ganzzahl
* @see java.text.SimpleDateFormat
* @see Dates#parse(CharSequence, String, long)
*/
public static long parse(CharSequence string,String format,long defaultValue)
{
return Dates.parse(string,format,defaultValue);
}
/**
* Wandelt einen String in ein Datum um.
*
* Das Format muss entsprechend der Formatierungen der Klasse SimpleDateFormat angegeben werden.
*
* Der Aufruf wird an die Methode parse der Utilities-Klasse Dates delegiert.
*
* @param string Der String
* @param format Das Format
* @param defaultValue Der Default-Wert, der geliefert wird, wenn die Umwandlung fehlschlgt
* @return Das Datum
* @see java.text.SimpleDateFormat
* @see Dates#parse(CharSequence, String, Date)
*/
public static Date parse(CharSequence string,String format,Date defaultValue)
{
return Dates.parse(string,format,defaultValue);
}
/**
* Erzeugt ein String-Array aus Tokens eines Strings.
*
* Die Tokens mssen mit einem Semikolon voneinander separiert sein.
*
* @param string Der String mit den Tokens
* @return Das String-Array
*/
public static String[] tokenize(CharSequence string)
{
return tokenize(string,';','\0');
}
/**
* Erzeugt ein String-Array aus Tokens eines Strings, wobei die Tokens mit einem definierbaren Trennzeichen
* voneinander separiert sind.
*
* @param string Der String mit den Tokens
* @param separator Das Trennzeichen
* @return Das String-Array
*/
public static String[] tokenize(CharSequence string,char separator)
{
return tokenize(string,separator,'\0');
}
/**
* Erzeugt ein String-Array aus Tokens eines Strings, wobei die Tokens mit einem definierbaren Trennzeichen
* voneinander separiert sind.
*
* Trennzeichen, die innerhalb des angegebenen Quotierungszeichen enthalten sind, werden ignoriert.
*
* Beispiel: Der String
*
* aaa; bbb ; "ccc;ddd";eee; ;ggg;hhh"hhh;iii;
*
* ergibt mit dem Separator ';' und dem Quotierungszeichen '"' folgendes String-Array:
*
* [0] --> aaa
* [1] --> bbb
* [2] --> ccc;ddd (der Separator ist durch das Quotierungszeichen maskiert)
* [3] --> eee
* [4] --> (Leer-String)
* [5] --> ggg
* [6] --> hhh"hhh (da das Qutierungszeichen nicht am Anfang steht, wird es als normales Zeichen interpretiert)
* [7] --> iii
* [8] --> (Leer-String)
*
* @param string Der String mit den Tokens
* @param separator Das Trennzeichen
* @param quote Das Quotierungszeichen
* @return Das String-Array
*/
public static String[] tokenize(CharSequence string,char separator,char quote)
{
string = string.toString().trim();
if (string.length() == 0)
return EMPTY_STRING_ARRAY;
StringTokenizer tokenizer = new StringTokenizer(string.toString(),String.valueOf(separator),true);
List<String> elements = new ArrayList<String>();
boolean add = true;
boolean quoted = false;
StringBuilder collector = new StringBuilder();
for (int i = 0; tokenizer.hasMoreElements(); i++)
{
String next = tokenizer.nextToken();
// Der Token ist ein Separator
if (next.length() == 1 && next.charAt(0) == separator)
{
// Innerhalb eines quotierten Tokens wird das Trennzeichen an das Token angefgt
if (quoted)
{
collector.append(separator);
continue;
}
// Einfgen eines leeren Tokens, weil ein zuvor ein Trennzeichen vorhanden war
if (add)
elements.add("");
// Flag setzen, um anzuzeigen, dass das nchste Token eingefgt werden muss
add = true;
continue;
}
// Das letzte Token war ein Trennzeichen, also muss das Token hinzugefgt werden
if (add)
{
// Das Token beginnt mit einem Quotierungszeichen
if (!quoted && next.length() >= 1 && next.charAt(0) == quote)
{
// Ein neues Token wird begonnen
collector.setLength(0);
next = next.substring(1);
quoted = true;
}
// Das TOken endet mit einem Quotierungszeichen
if (quoted && next.length() >= 1 && next.charAt(next.length() - 1) == quote)
{
// Das Token kann nun hinzugefgt werden
collector.append(next.substring(0,next.length() - 1));
next = collector.toString();
quoted = false;
}
// Das Token ist Teil eines quotierten Abschnitts
if (quoted)
{
// Das Token ist kein neues Token, sondern muss zum aktuellen Token hinzugefgt werden
collector.append(next);
continue;
}
// Flag setzen, um anzuzeigen, dass kein nchstes Token eingefgt werden muss
add = false;
}
// Das Token kann nun aufgenommen werden
elements.add(next.trim());
}
// Leeres Token anfgen, weil zuvor ein Trennzeichen gefunden wurde
if (add)
elements.add("");
return elements.toArray(new String[elements.size()]);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist ein Semikolon. Die einzelnen Tokens werden erzeugt, indem die Methode
* toString fr jedes Element der Iteration aufgerufen wird.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable)
{
return asString(iterable,';','\0',false,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das Semikolon. Die einzelnen Tokens werden mit Hilfe des angegebenen
* String-Providers erzeugt.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,StringProvider<T> stringProvider)
{
return asString(iterable,';','\0',false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element der Iteration aufgerufen wird.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Das Trennzeichzen zwischen den Tokens
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,char separator)
{
return asString(iterable,separator,'\0',false,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element der Iteration aufgerufen wird.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Die Trennzeichzen zwischen den Tokens
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,String separator)
{
return asString(iterable,separator,'\0',false,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden mit Hilfe des
* angegebenen String-Providers erzeugt.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Das Trennzeichzen zwischen den Tokens
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,char separator,StringProvider<T> stringProvider)
{
return asString(iterable,separator,'\0',false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Die einzelnen Tokens werden erzeugt, indem die Methode toString fr jedes Element der Iteration aufgerufen
* wird.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @param separator Die Trennzeichzen zwischen den Tokens
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,String separator,StringProvider<T> stringProvider)
{
return asString(iterable,separator,'\0',false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString() fr jedes Element der Iteration aufgerufen wird. Falls eines der Tokens das Trennzeichen
* enthlt, wird das Token mit einem fhrenden und einem schliessendem Quotierungzeichen umfasst.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,char separator,char quote)
{
return asString(iterable,separator,quote,false,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString() fr jedes Element der Iteration aufgerufen wird. Falls eines der Tokens das Trennzeichen
* enthlt, wird das Token mit einem fhrenden und einem schliessendem Quotierungzeichen umfasst.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Die Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,String separator,char quote)
{
return asString(iterable,separator,quote,false,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden mit Hilfe des
* angegebenen String-Providers erzeugt. Falls eines der Tokens das Trennzeichen enthlt, wird das Token mit einem
* fhrenden und einem schliessendem Quotierungzeichen umfasst.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Das Trennzeichzen zwischen den Tokens
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @param quote Das Quotierungszeichen
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<T> iterable,char separator,char quote,StringProvider<T> stringProvider)
{
return asString(iterable,separator,quote,false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString() fr jedes Element der Iteration aufgerufen wird. Falls eines der Tokens das Trennzeichen
* enthlt, wird das Token mit einem fhrenden und einem schliessendem Quotierungzeichen umfasst.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Die Trennzeichzen zwischen den Tokens
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @param quote Das Quotierungszeichen
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,String separator,char quote,StringProvider<T> stringProvider)
{
return asString(iterable,separator,quote,false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element der Iteration aufgerufen wird. Die Tokens werden mit einem fhrenden und
* einem schliessendem Quotierungzeichen umfasst, wenn entweder das Token das Trennzeichen enthlt oder wenn das
* Force-Flag gesetzt ist.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param force Die Quotierung soll immer durchgefhrt werden
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,char separator,char quote,boolean force)
{
return asString(iterable,separator,quote,force,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element der Iteration aufgerufen wird. Die Tokens werden mit einem fhrenden und
* einem schliessendem Quotierungzeichen umfasst, wenn entweder das Token das Trennzeichen enthlt oder wenn das
* Force-Flag gesetzt ist.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Die Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param force Die Quotierung soll immer durchgefhrt werden
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,String separator,char quote,boolean force)
{
return asString(iterable,separator,quote,force,new StringProvider.NaturalStringProvider<T>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element der Iteration aufgerufen wird. Die Tokens werden mit einem fhrenden und
* einem schliessendem Quotierungzeichen umfasst, wenn entweder das Token das Trennzeichen enthlt oder wenn das
* Force-Flag gesetzt ist.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param force Die Quotierung soll immer durchgefhrt werden
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,char separator,char quote,boolean force,StringProvider<T> stringProvider)
{
return asString(iterable,String.valueOf(separator),quote,force,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element der Iteration aufgerufen wird. Die Tokens werden mit einem fhrenden und
* einem schliessendem Quotierungzeichen umfasst, wenn entweder das Token das Trennzeichen enthlt oder wenn das
* Force-Flag gesetzt ist.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param iterable Die Iteration
* @param separator Die Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param force Die Quotierung soll immer durchgefhrt werden
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(Iterable<? extends T> iterable,String separator,char quote,boolean force,StringProvider<T> stringProvider)
{
StringBuilder buffer = new StringBuilder();
boolean quoted = (quote != '\0');
int i = 0;
for (T object: iterable)
{
if (i++ > 0)
buffer.append(separator);
String token = stringProvider.getStringValue(object);
boolean appendQuote = (quoted && (force || token.indexOf(separator) >= 0));
if (appendQuote)
buffer.append(quote);
buffer.append(token);
if (appendQuote)
buffer.append(quote);
}
return buffer.toString();
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist ';'. Die einzelnen Tokens werden erzeugt, indem die Methode toString
* fr jedes Element des Arrays aufgerufen wird.
*
* @param array Das Array
* @return Ein String aus Tokens
*/
public static String asString(Object[] array)
{
return asString(array,';','\0',false,new StringProvider.NaturalStringProvider<Object>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist ';'. Die einzelnen Tokens werden erzeugt, indem die Methode toString
* fr jedes Element des Arrays aufgerufen wird.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param array Das Array
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(T[] array,StringProvider<T> stringProvider)
{
return asString(array,';','\0',false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element des Arrays aufgerufen wird.
*
* @param array Das Array
* @param separator Das Trennzeichzen zwischen den Tokens
* @return Ein String aus Tokens
*/
public static String asString(Object[] array,char separator)
{
return asString(array,separator,'\0',false,new StringProvider.NaturalStringProvider<Object>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element des Arrays aufgerufen wird.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param array Das Array
* @param separator Das Trennzeichzen zwischen den Tokens
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(T[] array,char separator,StringProvider<T> stringProvider)
{
return asString(array,separator,'\0',false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString() fr jedes Element des Arrays aufgerufen wird. Falls eines der Tokens das Trennzeichen
* enthlt, wird das Token mit einem fhrenden und einem schliessendem Quotierungzeichen umfasst.
*
* @param array Das Array
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @return Ein String aus Tokens
*/
public static String asString(Object[] array,char separator,char quote)
{
return asString(array,separator,quote,false,new StringProvider.NaturalStringProvider<Object>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString() fr jedes Element des Arrays aufgerufen wird. Falls eines der Tokens das Trennzeichen
* enthlt, wird das Token mit einem fhrenden und einem schliessendem Quotierungzeichen umfasst.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param array Das Array
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(T[] array,char separator,char quote,StringProvider<T> stringProvider)
{
return asString(array,separator,quote,false,stringProvider);
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element des Arrays aufgerufen wird. Die Tokens werden mit einem fhrenden und einem
* schliessendem Quotierungzeichen umfasst, wenn entweder das Token das Trennzeichen enthlt oder wenn das
* Force-Flag gesetzt ist.
*
* @param array Das Array
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param force Die Quotierung soll immer durchgefhrt werden
* @return Ein String aus Tokens
*/
public static String asString(Object[] array,char separator,char quote,boolean force)
{
return asString(array,separator,quote,force,new StringProvider.NaturalStringProvider<Object>());
}
/**
* Erzeugt einen String mit Tokens.
*
* Das Trennzeichen zwischen den Tokens ist das angegebene Zeichen. Die einzelnen Tokens werden erzeugt, indem die
* Methode toString fr jedes Element des Arrays aufgerufen wird. Die Tokens werden mit einem fhrenden und einem
* schliessendem Quotierungzeichen umfasst, wenn entweder das Token das Trennzeichen enthlt oder wenn das
* Force-Flag gesetzt ist.
*
* @param <T> Der Datentyp der Objekte der Iteration
* @param array Das Array
* @param separator Das Trennzeichzen zwischen den Tokens
* @param quote Das Quotierungszeichen
* @param force Die Quotierung soll immer durchgefhrt werden
* @param stringProvider Ein String-Provider fr die Objekte aus der Iteration
* @return Ein String aus Tokens
*/
public static <T extends Object> String asString(T[] array,char separator,char quote,boolean force,StringProvider<T> stringProvider)
{
StringBuilder buffer = new StringBuilder();
boolean quoted = (quote != '\0');
int i = 0;
for (T object: array)
{
if (i++ > 0)
buffer.append(separator);
String token = stringProvider.getStringValue(object);
boolean appendQuote = (quoted && (force || token.indexOf(separator) >= 0));
if (appendQuote)
buffer.append(quote);
buffer.append(token);
if (appendQuote)
buffer.append(quote);
}
return buffer.toString();
}
/**
* Lscht alle Vorkommen eines Zeichens in einem String-Buffer.
*
* @param buffer Der String-Buffer
* @param character Das Zeichen
* @return Der um das Zeichen reduzierte String-Buffer
*/
public static StringBuilder deleteAll(StringBuilder buffer,char character)
{
int i = 0;
while (i < buffer.length())
{
if (buffer.charAt(i) == character)
buffer.deleteCharAt(i);
else
i++;
}
return buffer;
}
/**
* Lscht alle Vorkommen eines Zeichens in einem String.
*
* @param string Der String
* @param character Das Zeichen
* @return Der um das Zeichen reduzierte String
*/
public static String deleteAll(CharSequence string,char character)
{
return deleteAll(new StringBuilder(string),character).toString();
}
/**
* Liefert den Index des ersten Zeichens aus einer Menge von Zeichen in einem String.
*
* @param string Der String
* @param matchString Die Menge von Zeichen, die gesucht werden soll
* @return Der Index des ersten Zeichens, oder -1 falls keines der Zeichen im String vorhanden ist
*/
public static int indexOf(CharSequence string,String matchString)
{
if (string == null)
return -1;
if (matchString == null || matchString.length() == 0)
return -1;
for (int i = 0; i < string.length(); i++)
if (matchString.indexOf(string.charAt(i)) >= 0)
return i;
return -1;
}
/**
* Liefert den Index des letzten Zeichens aus einer Menge von Zeichen in einem String.
*
* @param string Der String
* @param matchString Die Menge von Zeichen, die gesucht werden soll
* @return Der Index des letzten Zeichens, oder -1 falls keines der Zeichen im String vorhanden ist
*/
public static int lastIndexOf(CharSequence string,String matchString)
{
if (string == null)
return -1;
if (matchString == null || matchString.length() == 0)
return -1;
for (int i = string.length() - 1; i >= 0; i--)
if (matchString.indexOf(string.charAt(i)) >= 0)
return i;
return -1;
}
/**
* Liefert den String, der vor dem ersten Vorkommen eines anderen Strings folgt.
*
* @param string Der String
* @param matchString Der String, der im anderen String enthalten ist
* @return Der String vor dem enthaltenen String, oder der Leerstring, falls dieser nicht enthalten ist
*/
public static String substringBefore(CharSequence string,String matchString)
{
if (string == null)
return null;
if (matchString == null || matchString.length() == 0)
return string.toString();
int index = indexOf(string,matchString);
return (index < 0)? "": string.toString().substring(0,index);
}
/**
* Liefert den String, der nach dem ersten Vorkommen eines anderen Strings folgt.
*
* @param string Der String
* @param matchString Der String, der im anderen String enthalten ist
* @return Der String nach dem enthaltenen String, oder der Leerstring, falls dieser nicht enthalten ist
*/
public static String substringAfter(CharSequence string,String matchString)
{
if (string == null)
return null;
if (matchString == null || matchString.length() == 0)
return string.toString();
int index = indexOf(string,matchString);
return (index < 0)? "": string.toString().substring(index + matchString.length());
}
/**
* Erzeugt einen String, in dem alle Sonderzeichen durch deren in eckigen Klammern eingefassten Hex-Code ersetzt
* sind.
*
* @param string Der String
* @return Der Debug-String
*/
public static String debugString(CharSequence string)
{
StringBuilder result = new StringBuilder();
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
if (c < 32 || c > 126)
{
result.append('[');
result.append(format(c, 16, 2, false));
result.append(']');
}
else
{
result.append(c);
}
}
return result.toString();
}
/**
* Prft, ob ein String nur aus einer definierten Menge von Zeichen besteht.
*
* Wenn entweder der String oder die Zeichenmenge den Wert 'null' hat, wird 'false' geliefert.
* Wenn die Zeichenmenge leer ist, dann wird 'true' geliefert. Wenn der String leer ist, dann wird
* 'false' geliefert, es sei denn, die Zeichenmenge ist ebenfalls leer.
*
* @param string Der String
* @param allowedChars Die Menge der erlaubten Zeichen
* @return Der String enthlt nur erlaubte Zeichen
*/
public static boolean hasOnly(CharSequence string,String allowedChars)
{
if (string == null || allowedChars == null)
return false;
if (allowedChars.length() == 0)
return true;
if (string.length() == 0)
return false;
for (int i = 0; i < string.length(); i++)
if (allowedChars.indexOf(string.charAt(i)) < 0)
return false;
return true;
}
/**
* Prft, ob ein String nur aus Ziffern besteht.
*
* Wenn der String den Wert 'null' hat, wird 'false' geliefert. Wenn der String leer ist, wird 'true' geliefert.
*
* @param string Der String
* @return Der String enthlt nur Ziffern
*/
public static boolean hasOnlyDigits(CharSequence string)
{
if (string == null)
return false;
if (string.length() == 0)
return true;
for (int i = 0; i < string.length(); i++)
if (!Character.isDigit(string.charAt(i)))
return false;
return true;
}
/**
* Prft, ob ein String nur aus Buchstaben besteht.
*
* Wenn der String den Wert 'null' hat, wird 'false' geliefert. Wenn der String leer ist, wird 'true' geliefert.
*
* @param string Der String
* @return Der String enthlt nur Buchstaben
*/
public static boolean hasOnlyLetters(CharSequence string)
{
if (string == null)
return false;
if (string.length() == 0)
return true;
for (int i = 0; i < string.length(); i++)
if (!Character.isLetter(string.charAt(i)))
return false;
return true;
}
/**
* Prft, ob ein String mindestens ein Zeichen aus einer definierten Menge von Zeichen enthlt.
*
* Wenn entweder der String oder die Zeichenmenge den Wert 'null' hat, wird 'false' geliefert.
* Wenn die Zeichenmenge leer ist, dann wird 'true' geliefert. Wenn der String leer ist, dann wird
* 'false' geliefert, es sei denn, die Zeichenmenge ist ebenfalls leer.
*
* @param string Der String
* @param allowedChars Die Menge der erlaubten Zeichen
* @return Der String enthlt nur erlaubte Zeichen
*/
public static boolean hasSome(CharSequence string,String allowedChars)
{
if (string == null || allowedChars == null)
return false;
if (allowedChars.length() == 0)
return true;
if (string.length() == 0)
return false;
for (int i = 0; i < string.length(); i++)
if (allowedChars.indexOf(string.charAt(i)) >= 0)
return true;
return false;
}
/**
* Prft, ob ein String mindestens eine Ziffer enthlt.
*
* Wenn der String den Wert 'null' hat oder leer ist, wird 'false' geliefert.
*
* @param string Der String
* @return Der String enthlt mindestens eine Ziffer
*/
public static boolean hasSomeDigits(CharSequence string)
{
if (string == null)
return false;
if (string.length() == 0)
return false;
for (int i = 0; i < string.length(); i++)
if (Character.isDigit(string.charAt(i)))
return true;
return false;
}
/**
* Prft, ob ein String mindestens einen Buchstaben enthlt.
*
* Wenn der String den Wert 'null' hat oder leer ist, wird 'false' geliefert.
*
* @param string Der String
* @return Der String enthlt mindestens einen Buchstaben
*/
public static boolean hasSomeLetters(CharSequence string)
{
if (string == null)
return false;
if (string.length() == 0)
return false;
for (int i = 0; i < string.length(); i++)
if (Character.isLetter(string.charAt(i)))
return true;
return false;
}
/**
* Zhlt die Anzahl der Zeichen in einem String, die in einer angegebenen Menge von Zeichen enthalten sind.
*
* Wenn der String oder die Zeichenmenge den Wert 'null' hat, wird -1 geliefert. Wenn der String oder die
* Zeichenmenge leer ist, wird 0 geliefert.
*
* @param string Der String, in dem die Zeichen gezhlt werden sollen
* @param pattern Die Zeichenmenge
* @return Die Anzahl der gezhlten Zeichen
*/
public static int countChars(CharSequence string,String pattern)
{
if (string == null || pattern == null)
return -1;
if (string.length() == 0 || pattern.length() == 0)
return 0;
int count = 0;
for (int i = 0; i < string.length(); i++)
if (pattern.indexOf(string.charAt(i)) >= 0)
count++;
return count;
}
/**
* Wandelt den ersten Buchtsaben eines String-Buffers in einen Grossbuchstaben.
*
* @param buffer Der String-Buffer
* @return Der String-Buffer mit dem ersten Buchstaben als Grossbuchstaben
*/
public static StringBuilder firstToUpperCase(StringBuilder buffer)
{
if (buffer == null || buffer.length() == 0)
return buffer;
char c = buffer.charAt(0);
if (!Character.isUpperCase(c)) buffer.setCharAt(0,Character.toUpperCase(c));
return buffer;
}
/**
* Wandelt den ersten Buchtsaben eines Strings in einen Grossbuchstaben.
*
* @param string Der String
* @return Der String mit dem ersten Buchstaben als Grossbuchstaben
*/
public static String firstToUpperCase(CharSequence string)
{
if (string == null)
{
return null;
}
if (string.length() == 0)
{
return string.toString();
}
char c = string.charAt(0);
if (!Character.isUpperCase(c)) string = Character.toUpperCase(c) + string.toString().substring(1);
return string.toString();
}
/**
* Wandelt den ersten Buchtsaben eines String-Buffers in einen Kleinbuchstaben.
*
* @param buffer Der String-Buffer
* @return Der String-Buffer mit dem ersten Buchstaben als Kleinbuchstaben
*/
public static StringBuilder firstToLowerCase(StringBuilder buffer)
{
if (buffer == null || buffer.length() == 0)
return buffer;
char c = buffer.charAt(0);
if (!Character.isLowerCase(c)) buffer.setCharAt(0,Character.toLowerCase(c));
return buffer;
}
/**
* Wandelt den ersten Buchtsaben eines Strings in einen Kleinbuchstaben.
*
* @param string Der String
* @return Der String mit dem ersten Buchstaben als Kleinbuchstaben
*/
public static String firstToLowerCase(CharSequence string)
{
if (string == null)
{
return null;
}
if (string.length() == 0)
{
return string.toString();
}
char c = string.charAt(0);
if (!Character.isLowerCase(c)) string = Character.toLowerCase(c) + string.toString().substring(1);
return string.toString();
}
/**
* Wandelt einen String in einen Java-konformen Variablen-Bezeichner um.
*
* Das erste Zeichen wird in Kleinbuchstaben umgewandelt. Wortgrenzen werden nicht ausgegeben, das darauf folgende
* Zeichen wird in einen Grobuchstaben ungewandelt. Wortgrenzen sind alle Zeichen, die nicht Teil eines Bezeichners
* sein drfen (z.B. Leerzeichen, Bindestriche und andere Sonderzeichen). Unterstriche werden ebenfalls als
* Wortgrenze interpretiert, auch wenn diese Teil eines Bezeichners sein drfen.
*
* @param string Der String
* @return Der Java-konforme Variablen-Bezeichner
*/
public static String toJavaVariableIdentifier(CharSequence string)
{
StringBuilder result = new StringBuilder(string.length());
boolean first = true;
boolean specialChar = false;
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
if (c == '_')
{
specialChar = true;
continue;
}
if (first)
{
if (Character.isJavaIdentifierStart(c))
{
first = false;
result.append(Character.toLowerCase(c));
}
continue;
}
if (Character.isJavaIdentifierPart(c))
{
if (specialChar)
{
specialChar = false;
result.append(Character.toUpperCase(c));
}
else
{
result.append(c);
}
continue;
}
specialChar = true;
}
return result.toString();
}
/**
* Wandelt einen String in einen Java-konformen Konstanten-Bezeichner um.
*
* Alle Zeichen werden in Gleinbuchstaben umgewandelt. Wortgrenzen werden in Unterstriche umgewandelt. Wortgrenzen
* sind alle Zeichen, die nicht Teil eines Bezeichners sein drfen (z.B. Leerzeichen, Bindestriche und andere
* Sonderzeichen).
*
* @param string Der String
* @return Der Java-konforme Konstanten-Bezeichner
*/
public static String toJavaConstantIdentifier(CharSequence string)
{
StringBuilder result = new StringBuilder(string.length());
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
if (Character.isJavaIdentifierPart(c))
{
// Das Zeichen muss zuvor in einen String gewandelt werden, um solche Flle abzudecken: "" --> "SS"
result.append(Character.toString(c).toUpperCase());
}
else
{
result.append('_');
}
}
return result.toString();
}
/**
* Tauscht Zeichen in einem String gegen ein anderes Zeichen.
*
* @param string Der String
* @param string1 Der String mit den zu tauschenden Zeichen (muss dieselbe Lnge haben wie string2)
* @param string2 Der String mit den neuen Zeichen (muss dieselbe Lnge haben wie string1)
* @return Der String mit den ausgetauschten Zeichen
*/
public static String replaceAny(CharSequence string,String string1,String string2)
{
if (string1 == null || string1.length() == 0)
return string.toString();
if (string2 == null || string2.length() == 0)
return string.toString();
if (string1.length() != string2.length())
throw new IllegalArgumentException("string lengths not equal");
if (string == null)
return null;
if (string.length() == 0)
return string.toString();
StringBuilder result = new StringBuilder(string.length());
for (int i = 0; i < string.length(); i++)
{
char c = string.charAt(i);
int index = string1.indexOf(c);
result.append((index < 0)? c: string2.charAt(index));
}
return result.toString();
}
/**
* Erzeugt einen String, der fr eine toString-Methode benutzt werden kann.
*
* Der String hat folgendes Format:
*
* SimpleClassName [hash=xxx; prop1=val1; prop2=val2; ...]
*
* "SimpleClassName" ist der Klassenname (ohne Package-Name). "hash=xxx" gibt den Hash-Code der jeweiligen Instanz
* in Hex-Darstellung wieder. Der Hash-Code identifiziert die Instanz. "propx=valx" ist eine Aufzhlung diverser
* Eigenschaften, die die Instanz charakterisieren; diese Eigenschaften mssen in der Parameterliste dieser Methode
* angegeben werden.
*
* Die Methode erwartet als ersten Parameter die Instanz, deren Werte ausgegeben werden sollen. Darauf folgt eine
* gerade Anzahl von Parametern: der jeweils erste Parameter ist der Name einer Eigenschaft (und sollte ein String
* sein), der jeweils zweite Parameter ist der Wert der Eigenschaft. Beispiel (passend zu dem o.g. Beispiel):
*
* Strings.buildToStringText(this, "prop1", getProp1(), "prop2", getProp2());
*
* @param object Die Instanz, zu der die Ausgabe erzeugt werden soll
* @param details Gruppen von je zwei Parametern (Eigenschaftsname und -wert)
* @return The text representation
*/
public static String buildToStringText(Object object, Object... details)
{
if (object == null)
return "null";
StringBuilder result = new StringBuilder();
result.append(object.getClass().getSimpleName());
result.append(" [hash=");
result.append(Integer.toString(System.identityHashCode(object), 16));
boolean f = false;
for (Object argument: details)
{
result.append((f)? "=": "; ");
result.append(argument);
f = !f;
}
result.append("]");
return result.toString();
}
/* ______________________________________________________________________________________________________________ *\
\* Klassen */
}
/*\
* _____________________________________________________________________________________________________________________
*
* This software is distributed under the terms of the BSD License:
*
* Copyright 2006 Klaus Rogall, Hamburg, Germany (klaus.rogall@web.de). All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
* - Neither the name of the Klaus Rogall nor the names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* _____________________________________________________________________________________________________________________
\*/
