[Schmitzm-commits] r1611 - trunk/schmitzm-core/src/main/java/de/schmitzm/lang
scm-commit@wald.intevation.org
scm-commit at wald.intevation.org
Sat Jun 18 21:06:18 CEST 2011
Author: alfonx
Date: 2011-06-18 21:06:18 +0200 (Sat, 18 Jun 2011)
New Revision: 1611
Modified:
trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java
Log:
Modified: trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java
===================================================================
--- trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java 2011-06-14 18:27:48 UTC (rev 1610)
+++ trunk/schmitzm-core/src/main/java/de/schmitzm/lang/LangUtil.java 2011-06-18 19:06:18 UTC (rev 1611)
@@ -68,7 +68,8 @@
/**
* Diese Klasse stellt Hilfsfunktionen fuer Basisoperationen bereit.
*
- * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a> (University of Bonn/Germany)
+ * @author <a href="mailto:martin.schmitz at koeln.de">Martin Schmitz</a>
+ * (University of Bonn/Germany)
* @version 1.0
*/
public class LangUtil {
@@ -88,24 +89,30 @@
/**
* Date formatter for "dd.MM.yyyy [HH:mm:ss]".
*/
- public static final DateFormat DEFAULT_DATE_TIME_FORMATTER = new SimpleDateFormat("dd.MM.yyyy [HH:mm:ss]");
+ public static final DateFormat DEFAULT_DATE_TIME_FORMATTER = new SimpleDateFormat(
+ "dd.MM.yyyy [HH:mm:ss]");
/**
- * Liefert <code>true</code> wenn der String nur Nullen, Leerzeichen, Kommata und/oder Punkte enthält.
+ * Liefert <code>true</code> wenn der String nur Nullen, Leerzeichen,
+ * Kommata und/oder Punkte enthält.
*/
public static boolean onlyZero(String numerString) {
return onlyZerosRegEx.matcher(numerString).find();
}
/**
- * {@link ResourceProvider}, der die Lokalisation fuer Komponenten des Package {@code schmitzm.lang} zur Verfuegung
- * stellt. Diese sind in properties-Dateien unter {@code schmitzm.lang.resource.locales} hinterlegt.
+ * {@link ResourceProvider}, der die Lokalisation fuer Komponenten des
+ * Package {@code schmitzm.lang} zur Verfuegung stellt. Diese sind in
+ * properties-Dateien unter {@code schmitzm.lang.resource.locales}
+ * hinterlegt.
*/
public static ResourceProvider RESOURCE = ResourceProvider.newInstance(
- extendPackagePath(LangUtil.class, "resource.locales.LangResourceBundle"), Locale.ENGLISH);
+ extendPackagePath(LangUtil.class,
+ "resource.locales.LangResourceBundle"), Locale.ENGLISH);
/**
- * Liefert den einfachen Namen einer Klasse (ohne Package) oder den String "null", falls das Objekt {@code null} ist
+ * Liefert den einfachen Namen einer Klasse (ohne Package) oder den String
+ * "null", falls das Objekt {@code null} ist
*
* @param object
* ein Objekt
@@ -128,9 +135,10 @@
}
/**
- * Completes an incomplete date definition (in european dotted-format {@code dd.MM.yyyy}). Missing dots are also
- * added. In this case the method expects that day is given with 2 digits. If month and/or year is not given, these
- * information is completed with the current month/year.<br>
+ * Completes an incomplete date definition (in european dotted-format
+ * {@code dd.MM.yyyy}). Missing dots are also added. In this case the method
+ * expects that day is given with 2 digits. If month and/or year is not
+ * given, these information is completed with the current month/year.<br>
* Examples: Expect that current date is 29.03.2011, then
* <ul>
* <li>"12102009" is completed to "12.10.2009"</li>
@@ -143,7 +151,8 @@
*
* @param dateStr
* a european date definition as string
- * @return the source string if the given string contains other signs than digits and dots
+ * @return the source string if the given string contains other signs than
+ * digits and dots
*/
public static String completeEuropeanDateString(String dateStr) {
if (dateStr == null || !dateStr.matches("[\\d\\.]+"))
@@ -183,7 +192,8 @@
// "19" erweitern
String yearStr = dateStr.substring(dateStr.lastIndexOf(".") + 1);
if (Integer.parseInt(yearStr) < 100)
- dateStr = dateStr.substring(0, dateStr.lastIndexOf(".")) + ".19" + yearStr;
+ dateStr = dateStr.substring(0, dateStr.lastIndexOf("."))
+ + ".19" + yearStr;
}
return dateStr;
@@ -193,7 +203,8 @@
* Returns the current time as formatted string.
*
* @param format
- * date format as defined in {@link SimpleDateFormat} (if {@code null}, the default format is used)
+ * date format as defined in {@link SimpleDateFormat} (if
+ * {@code null}, the default format is used)
* @see #DEFAULT_DATE_TIME_FORMATTER
*/
public static String getCurrentTimeFormatted(String formatPattern) {
@@ -202,65 +213,78 @@
formatter = new SimpleDateFormat(formatPattern);
return formatter.format(new Date(System.currentTimeMillis()));
}
-
+
/**
- * Returns a new date which combines the date and time
- * information of several date objects.
- * @param date date the date information is taken from
- * @param time date the time information is taken from
+ * Returns a new date which combines the date and time information of
+ * several date objects.
+ *
+ * @param date
+ * date the date information is taken from
+ * @param time
+ * date the time information is taken from
*/
public static Date combineDate(Date date, Date time) {
- Calendar dateCal = GregorianCalendar.getInstance();
- dateCal.setTime( date != null ? date : new Date() );
- Calendar timeCal = GregorianCalendar.getInstance();
- timeCal.setTime( time != null ? time : new Date() );
-
- Calendar combinedDateCal = GregorianCalendar.getInstance();
+ Calendar dateCal = GregorianCalendar.getInstance();
+ dateCal.setTime(date != null ? date : new Date());
+ Calendar timeCal = GregorianCalendar.getInstance();
+ timeCal.setTime(time != null ? time : new Date());
- // combine date and time for new date object
- combinedDateCal.set( Calendar.HOUR_OF_DAY, timeCal.get(Calendar.HOUR_OF_DAY) );
- combinedDateCal.set( Calendar.MINUTE, timeCal.get(Calendar.MINUTE) );
- combinedDateCal.set( Calendar.SECOND, timeCal.get(Calendar.SECOND) );
- combinedDateCal.set( Calendar.MILLISECOND, timeCal.get(Calendar.MILLISECOND) );
+ Calendar combinedDateCal = GregorianCalendar.getInstance();
- combinedDateCal.set( Calendar.DATE, dateCal.get(Calendar.DATE) );
- combinedDateCal.set( Calendar.MONTH, dateCal.get(Calendar.MONTH) );
- combinedDateCal.set( Calendar.YEAR, dateCal.get(Calendar.YEAR) );
+ // combine date and time for new date object
+ combinedDateCal.set(Calendar.HOUR_OF_DAY,
+ timeCal.get(Calendar.HOUR_OF_DAY));
+ combinedDateCal.set(Calendar.MINUTE, timeCal.get(Calendar.MINUTE));
+ combinedDateCal.set(Calendar.SECOND, timeCal.get(Calendar.SECOND));
+ combinedDateCal.set(Calendar.MILLISECOND,
+ timeCal.get(Calendar.MILLISECOND));
- return combinedDateCal.getTime();
+ combinedDateCal.set(Calendar.DATE, dateCal.get(Calendar.DATE));
+ combinedDateCal.set(Calendar.MONTH, dateCal.get(Calendar.MONTH));
+ combinedDateCal.set(Calendar.YEAR, dateCal.get(Calendar.YEAR));
+
+ return combinedDateCal.getTime();
}
- /**
- * Tries several date formats to parse a date string.
- * @param dateStr the date string to parse
- * @param pattern date format pattern to try
- */
- public static Date parseDate(String dateStr, String... pattern) throws ParseException {
- DateFormat[] formats = new DateFormat[pattern.length];
- for (int i=0; i<formats.length; i++)
- formats[i] = new SimpleDateFormat(pattern[i]);
- return parseDate(dateStr, formats);
- }
+ /**
+ * Tries several date formats to parse a date string.
+ *
+ * @param dateStr
+ * the date string to parse
+ * @param pattern
+ * date format pattern to try
+ */
+ public static Date parseDate(String dateStr, String... pattern)
+ throws ParseException {
+ DateFormat[] formats = new DateFormat[pattern.length];
+ for (int i = 0; i < formats.length; i++)
+ formats[i] = new SimpleDateFormat(pattern[i]);
+ return parseDate(dateStr, formats);
+ }
- /**
- * Tries several date formats to parse a date string.
- * @param dateStr the date string to parse
- * @param formats date formats to try
- */
- public static Date parseDate(String dateStr, DateFormat... formats) throws ParseException {
- if (dateStr == null || dateStr.trim().equals(""))
- return null;
- dateStr = dateStr.trim();
- for (DateFormat format : formats)
- try {
- Date date = format.parse(dateStr);
- return date;
- } catch (Exception err) {
- }
- throw new ParseException("Could not parse date: "+dateStr,0);
- }
-
/**
+ * Tries several date formats to parse a date string.
+ *
+ * @param dateStr
+ * the date string to parse
+ * @param formats
+ * date formats to try
+ */
+ public static Date parseDate(String dateStr, DateFormat... formats)
+ throws ParseException {
+ if (dateStr == null || dateStr.trim().equals(""))
+ return null;
+ dateStr = dateStr.trim();
+ for (DateFormat format : formats)
+ try {
+ Date date = format.parse(dateStr);
+ return date;
+ } catch (Exception err) {
+ }
+ throw new ParseException("Could not parse date: " + dateStr, 0);
+ }
+
+ /**
* Returns an exception stack as string.
*/
public static String getStackTraceFromException(Throwable err) {
@@ -276,26 +300,30 @@
return stackTraceStr;
}
- /**
- * Trims a string to a maximum length.
- * @param str source string
- * @param maxSize maximum size
- * @return {@code null} if {@code null} is given
- */
+ /**
+ * Trims a string to a maximum length.
+ *
+ * @param str
+ * source string
+ * @param maxSize
+ * maximum size
+ * @return {@code null} if {@code null} is given
+ */
public static String trimToSize(String str, int maxSize) {
- if ( str == null )
- return null;
- str = str.trim();
- if ( str.length() <= maxSize )
- return str;
- return str.substring(0,maxSize);
+ if (str == null)
+ return null;
+ str = str.trim();
+ if (str.length() <= maxSize)
+ return str;
+ return str.substring(0, maxSize);
}
/**
* Checks whether both objects are {@code null} or equal.
*/
public static boolean checkEqual(Object o1, Object o2) {
- return o1 == null && o2 == null || o1 != null && o2 != null && o1.equals(o2);
+ return o1 == null && o2 == null || o1 != null && o2 != null
+ && o1.equals(o2);
}
/**
@@ -304,7 +332,8 @@
* @param delim
* Trennzeichen (kann {@code null} sein)
* @param strList
- * Liste von Strings ({@code null}-Elemente und leere Strings werden ignoriert
+ * Liste von Strings ({@code null}-Elemente und leere Strings
+ * werden ignoriert
* @return
*/
public static String listString(String delim, String... strList) {
@@ -329,17 +358,20 @@
* @param delim
* Trennzeichen (kann {@code null} sein)
* @param ignoreNulls
- * bestimmt, ob {@code null}-Elemente (und leere Strings) ignoriert werden
+ * bestimmt, ob {@code null}-Elemente (und leere Strings)
+ * ignoriert werden
* @param objList
* Liste von Objekten
* @return
*/
- public static String listObjects(String delim, boolean ignoreNulls, Object... objList) {
+ public static String listObjects(String delim, boolean ignoreNulls,
+ Object... objList) {
StringBuffer resultStr = new StringBuffer();
for (int i = 0; i < objList.length; i++) {
// ignore item if it is null or empty
if (ignoreNulls
- && (objList[i] == null || objList[i] instanceof String && "".equals(((String) objList[i]).trim())))
+ && (objList[i] == null || objList[i] instanceof String
+ && "".equals(((String) objList[i]).trim())))
continue;
// append delimiter (if necessary)
if (resultStr.length() > 0 && delim != null)
@@ -357,12 +389,14 @@
* @param delim
* Trennzeichen (kann {@code null} sein)
* @param ignoreNulls
- * bestimmt, ob {@code null}-Elemente (und leere Strings) ignoriert werden
+ * bestimmt, ob {@code null}-Elemente (und leere Strings)
+ * ignoriert werden
* @param objList
* Liste von Objekten
* @return
*/
- public static String listObjects(String delim, boolean ignoreNulls, Collection<?> values) {
+ public static String listObjects(String delim, boolean ignoreNulls,
+ Collection<?> values) {
Object[] objArray = values.toArray();
return listObjects(delim, ignoreNulls, objArray);
}
@@ -375,7 +409,8 @@
* @param fieldName
* feld name
*/
- public static boolean checkEnumValue(Class<? extends Enum> enumClass, String fieldName) {
+ public static boolean checkEnumValue(Class<? extends Enum> enumClass,
+ String fieldName) {
try {
Enum.valueOf(enumClass, fieldName);
return true;
@@ -385,13 +420,14 @@
}
/**
- * Fuegt alle Elemente eines Arrays in einen {@link Vector} ein. Wird als Vector <code>null</code> angegeben, wird
- * ein neuer Vector erzeugt.
+ * Fuegt alle Elemente eines Arrays in einen {@link Vector} ein. Wird als
+ * Vector <code>null</code> angegeben, wird ein neuer Vector erzeugt.
*
* @param obj
* einzufuegende Objekte
* @param vec
- * Vector in den die Elemente eingefuegt werden (kann <code>null</code> sein)
+ * Vector in den die Elemente eingefuegt werden (kann
+ * <code>null</code> sein)
* @return den Vector <code>vec</code> oder eine neue {@link Vector}-Instanz
*/
public static Vector addObjectsToVector(Object[] obj, Vector vec) {
@@ -416,13 +452,15 @@
Arrays.fill(maxSpacePattern, ' ');
for (int pos; (pos = outString.indexOf('\t')) >= 0;) {
- outString = outString.replaceFirst("\t", String.valueOf(maxSpacePattern, 0, tabLen - pos % tabLen));
+ outString = outString.replaceFirst("\t",
+ String.valueOf(maxSpacePattern, 0, tabLen - pos % tabLen));
}
return outString;
}
/**
- * Haengt eine beliebige Anzahl von Objekte als Strings (toString()) hintereinander.
+ * Haengt eine beliebige Anzahl von Objekte als Strings (toString())
+ * hintereinander.
*
* @param str
* aneinanderzuhaengende Objekte
@@ -436,7 +474,8 @@
}
/**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
+ * zwischen den Strings einen Trenner ein.
*
* @param sep
* Trenner
@@ -448,7 +487,8 @@
}
/**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
+ * zwischen den Strings einen Trenner ein.
*
* @param sep
* Trenner
@@ -459,79 +499,87 @@
return stringConcatWithSep(sep, null, str);
}
- /**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
- *
- * @param sep
- * Trenner
- * @param ignoreNulls
- * wenn {@code true} werden NULL-Werte ignoriert
- * @param str
- * aneinanderzuhaengende Stings
- */
- public static String stringConcatWithSep(String sep, boolean ignoreNulls, Object... str) {
- return stringConcatWithSep(sep, null, ignoreNulls, str);
- }
+ /**
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
+ * zwischen den Strings einen Trenner ein.
+ *
+ * @param sep
+ * Trenner
+ * @param ignoreNulls
+ * wenn {@code true} werden NULL-Werte ignoriert
+ * @param str
+ * aneinanderzuhaengende Stings
+ */
+ public static String stringConcatWithSep(String sep, boolean ignoreNulls,
+ Object... str) {
+ return stringConcatWithSep(sep, null, ignoreNulls, str);
+ }
- /**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
- * Optional werden die einzelnen Strings mit einem speziellen Zeichen (z.B. Apostroph oder Anfuehrungszeichen)
- * maskiert.
+ /**
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
+ * zwischen den Strings einen Trenner ein. Optional werden die einzelnen
+ * Strings mit einem speziellen Zeichen (z.B. Apostroph oder
+ * Anfuehrungszeichen) maskiert.
*
* @param sep
* Trenner
* @param maskChar
- * Zeichen, mit dem die aneinandergehaengten Strings gekapselt werden (z.B. Apostroph oder
- * Anfuehrungszeichen). Wenn {@code null} oder leer, werden die Strings nicht gekapselt.
+ * Zeichen, mit dem die aneinandergehaengten Strings gekapselt
+ * werden (z.B. Apostroph oder Anfuehrungszeichen). Wenn
+ * {@code null} oder leer, werden die Strings nicht gekapselt.
* @param str
* aneinanderzuhaengende Stings
*/
- public static String stringConcatWithSep(String sep, String maskChar, Object... str) {
-// StringBuffer sb = new StringBuffer();
-// for (int i = 0; str != null && i < str.length; i++) {
-// if (i > 0)
-// sb.append(sep);
-// if (maskChar != null)
-// sb.append(maskChar).append(str[i]).append(maskChar);
-// else
-// sb.append(str[i]);
-// }
-// return sb.toString();
- return stringConcatWithSep(sep, maskChar, false, str);
+ public static String stringConcatWithSep(String sep, String maskChar,
+ Object... str) {
+ // StringBuffer sb = new StringBuffer();
+ // for (int i = 0; str != null && i < str.length; i++) {
+ // if (i > 0)
+ // sb.append(sep);
+ // if (maskChar != null)
+ // sb.append(maskChar).append(str[i]).append(maskChar);
+ // else
+ // sb.append(str[i]);
+ // }
+ // return sb.toString();
+ return stringConcatWithSep(sep, maskChar, false, str);
}
- /**
- * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt zwischen den Strings einen Trenner ein.
- * Optional werden die einzelnen Strings mit einem speziellen Zeichen (z.B. Apostroph oder Anfuehrungszeichen)
- * maskiert.
- *
- * @param sep
- * Trenner
- * @param maskChar
- * Zeichen, mit dem die aneinandergehaengten Strings gekapselt werden (z.B. Apostroph oder
- * Anfuehrungszeichen). Wenn {@code null} oder leer, werden die Strings nicht gekapselt.
- * @param ignoreNulls
- * wenn {@code true} werden NULL-Werte ignoriert
- * @param str
- * aneinanderzuhaengende Stings
- */
- public static String stringConcatWithSep(String sep, String maskChar, boolean ignoreNulls, Object... str) {
- StringBuffer sb = new StringBuffer();
- for (int i = 0; str != null && i < str.length; i++) {
- if ( str[i] == null || str[i].toString().trim().equals("") )
- continue;
-// if (i > 0)
- if (sb.length() > 0)
- sb.append(sep);
- if (maskChar != null)
- sb.append(maskChar).append(str[i]).append(maskChar);
- else
- sb.append(str[i]);
- }
- return sb.toString();
- }
+ /**
+ * Haengt eine beliebige Anzahl von Strings hintereinander und fuegt
+ * zwischen den Strings einen Trenner ein. Optional werden die einzelnen
+ * Strings mit einem speziellen Zeichen (z.B. Apostroph oder
+ * Anfuehrungszeichen) maskiert.
+ *
+ * @param sep
+ * Trenner
+ * @param maskChar
+ * Zeichen, mit dem die aneinandergehaengten Strings gekapselt
+ * werden (z.B. Apostroph oder Anfuehrungszeichen). Wenn
+ * {@code null} oder leer, werden die Strings nicht gekapselt.
+ * @param ignoreNulls
+ * wenn {@code true} werden NULL-Werte ignoriert
+ * @param str
+ * aneinanderzuhaengende Stings
+ */
+ public static String stringConcatWithSep(String sep, String maskChar,
+ boolean ignoreNulls, Object... str) {
+ StringBuffer sb = new StringBuffer();
+ for (int i = 0; str != null && i < str.length; i++) {
+ if (str[i] == null || str[i].toString().trim().equals(""))
+ continue;
+ // if (i > 0)
+ if (sb.length() > 0)
+ sb.append(sep);
+ if (maskChar != null)
+ sb.append(maskChar).append(str[i]).append(maskChar);
+ else
+ sb.append(str[i]);
+ }
+ return sb.toString();
+ }
- /**
+ /**
* Fügt einer beliebigen Anzahl vo String ein Prefix hinzu
*/
public static String[] stringAddPrefix(String prefix, String... str) {
@@ -662,17 +710,20 @@
case 20:
return new Object[size[0]][size[1]][size[2]][size[3]][size[4]][size[5]][size[6]][size[7]][size[8]][size[9]][size[10]][size[11]][size[12]][size[13]][size[14]][size[15]][size[16]][size[17]][size[18]][size[19]];
}
- throw new IllegalArgumentException("Dimension not supported: " + size.length);
+ throw new IllegalArgumentException("Dimension not supported: "
+ + size.length);
}
/**
* Liefert die Dimension eines multi-dimensionalen {@link Object}-Array.<br>
- * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension belegt ist!</b>
+ * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension
+ * belegt ist!</b>
*
* @param array
* multi-dim. Array (Instanz von {@code Object[]..[]})
* @exception ArrayIndexOutOfBoundsException
- * wenn das 0te Element in einer Dimension mit {@code null} belegt ist
+ * wenn das 0te Element in einer Dimension mit {@code null}
+ * belegt ist
*/
public static int getArrayDimension(Object array) {
int dim = 0;
@@ -686,13 +737,16 @@
}
/**
- * Liefert die Groessen der einzelnen Dimensionen eines multi-dimensionalen {@link Object}-Array.<br>
- * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension belegt ist!</b>
+ * Liefert die Groessen der einzelnen Dimensionen eines multi-dimensionalen
+ * {@link Object}-Array.<br>
+ * <b>Diese Methode funktioniert nur, wenn das Element 0 in jeder Dimension
+ * belegt ist!</b>
*
* @param array
* multi-dim. Array (Instanz von {@code Object[]..[]})
* @exception ArrayIndexOutOfBoundsException
- * wenn das 0te Element in einer Dimension mit {@code null} belegt ist
+ * wenn das 0te Element in einer Dimension mit {@code null}
+ * belegt ist
*/
public static int[] getArrayLength(Object array) {
int[] dimSize = new int[getArrayDimension(array)];
@@ -738,25 +792,30 @@
}
/**
- * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen (einige) Elemente direkt neu belegt
- * werden. Ist das Flag {@code replNull} auf {@code false} gesetzt, werden {@code null}-Werte in {@code replElem}
- * ignoriert. So ist es z.B. moeglich, nur das 4. und 5. Element im neuen Array neu zu belegen und die davor
- * liegenden Elemente unangetastet zu lassen.
+ * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen
+ * (einige) Elemente direkt neu belegt werden. Ist das Flag {@code replNull}
+ * auf {@code false} gesetzt, werden {@code null}-Werte in {@code replElem}
+ * ignoriert. So ist es z.B. moeglich, nur das 4. und 5. Element im neuen
+ * Array neu zu belegen und die davor liegenden Elemente unangetastet zu
+ * lassen.
*
* @param source
* zu kopierender Array
* @param replNull
- * Bestimmt, ob {@code null}-Elemente von {@code replElem} im neuen Array gesetzt werden ({@code true})
- * oder nicht
+ * Bestimmt, ob {@code null}-Elemente von {@code replElem} im
+ * neuen Array gesetzt werden ({@code true}) oder nicht
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
- public static <T> T[] cloneArray(T[] source, boolean replNull, T... replElem) {
+ public static <T> T[] cloneArray(T[] source, boolean replNull,
+ T... replElem) {
if (source == null)
return null;
- T[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ T[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
if (replNull || replElem[i] != null)
newArray[i] = replElem[i];
@@ -764,13 +823,14 @@
}
/**
- * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen (einige) Elemente direkt neu belegt
- * werden.
+ * Kopiert einen Array (aber nicht dessen Elemente). Darueberhinaus koennen
+ * (einige) Elemente direkt neu belegt werden.
*
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static <T> T[] cloneArray(T[] source, T... replElem) {
@@ -783,14 +843,16 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static long[] cloneArray(long[] source, long... replElem) {
if (source == null)
return null;
- long[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ long[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -802,14 +864,16 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static int[] cloneArray(int[] source, int... replElem) {
if (source == null)
return null;
- int[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ int[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -821,14 +885,16 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static short[] cloneArray(short[] source, short... replElem) {
if (source == null)
return null;
- short[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ short[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -840,13 +906,15 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static byte[] cloneArray(byte[] source, byte... replElem) {
if (source == null)
return null;
- byte[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ byte[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -858,14 +926,16 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static double[] cloneArray(double[] source, double... replElem) {
if (source == null)
return null;
- double[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ double[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -877,14 +947,16 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static float[] cloneArray(float[] source, float... replElem) {
if (source == null)
return null;
- float[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ float[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -896,13 +968,15 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static boolean[] cloneArray(boolean[] source, boolean... replElem) {
if (source == null)
return null;
- boolean[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ boolean[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -914,13 +988,15 @@
* @param source
* zu kopierender Array
* @param replElem
- * Elemente (beginnend bei Index 0), die nach dem Kopieren im Array neu gesetzt werden
+ * Elemente (beginnend bei Index 0), die nach dem Kopieren im
+ * Array neu gesetzt werden
* @return Array von der Groesse {@code max(source.length, replElem.length)}
*/
public static char[] cloneArray(char[] source, char... replElem) {
if (source == null)
return null;
- char[] newArray = java.util.Arrays.copyOf(source, Math.max(source.length, replElem.length));
+ char[] newArray = java.util.Arrays.copyOf(source,
+ Math.max(source.length, replElem.length));
for (int i = 0; i < replElem.length; i++)
newArray[i] = replElem[i];
return newArray;
@@ -936,7 +1012,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static <T> T[] extendArray(T[] source, T... newElem) {
- T[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ T[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -952,7 +1029,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static long[] extendArray(long[] source, long... newElem) {
- long[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ long[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -968,7 +1046,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static int[] extendArray(int[] source, int... newElem) {
- int[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ int[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -984,7 +1063,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static short[] extendArray(short[] source, short... newElem) {
- short[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ short[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1000,7 +1080,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static byte[] extendArray(byte[] source, byte... newElem) {
- byte[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ byte[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1016,7 +1097,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static double[] extendArray(double[] source, double... newElem) {
- double[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ double[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1032,7 +1114,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static float[] extendArray(float[] source, float... newElem) {
- float[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ float[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1048,7 +1131,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static boolean[] extendArray(boolean[] source, boolean... newElem) {
- boolean[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ boolean[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1064,7 +1148,8 @@
* @return Array von der Groesse {@code source.length + newElem.length}
*/
public static char[] extendArray(char[] source, char... newElem) {
- char[] newArray = java.util.Arrays.copyOf(source, source.length + newElem.length);
+ char[] newArray = java.util.Arrays.copyOf(source, source.length
+ + newElem.length);
for (int i = 0; i < newElem.length; i++)
newArray[source.length + i] = newElem[i];
return newArray;
@@ -1076,32 +1161,39 @@
* @param clazz
* Klassen
* @param simple
- * gibt an, ob der einfache Klassenname ({@code true}) oder der komplette Klassenname inkl. Paketname (
- * {@code false}) zurueckgegeben wird.
+ * gibt an, ob der einfache Klassenname ({@code true}) oder der
+ * komplette Klassenname inkl. Paketname ( {@code false})
+ * zurueckgegeben wird.
*/
public static String[] getClassNames(Class[] clazz, boolean simple) {
String[] className = new String[clazz.length];
for (int i = 0; i < className.length; i++)
- className[i] = simple ? clazz[i].getSimpleName() : clazz[i].getName();
+ className[i] = simple ? clazz[i].getSimpleName() : clazz[i]
+ .getName();
return className;
}
/**
- * Instantiates an object by {@link Class#forName(String)}. The class must be present in runtime classpath.
+ * Instantiates an object by {@link Class#forName(String)}. The class must
+ * be present in runtime classpath.
*
* @param className
* full name of class (incl. package)
* @param fallback
- * if <code>true</code> this method returns <code>null</code> if {@link Class#forName(String)} fails
+ * if <code>true</code> this method returns <code>null</code> if
+ * {@link Class#forName(String)} fails
* @param constrArg
* arguments for the constructor
* @exception UnsupportedOperationException
- * if class could be loaded, but no matching constructor can be found
+ * if class could be loaded, but no matching constructor can
+ * be found
* @exception RuntimeException
- * if class can not be loaded and fallback is disabled or another error occurs during
+ * if class can not be loaded and fallback is disabled or
+ * another error occurs during
* {@link Constructor#newInstance(Object...)}
*/
- public static Object instantiateObject(String className, boolean fallback, Object... constrArg) {
+ public static Object instantiateObject(String className, boolean fallback,
+ Object... constrArg) {
try {
Class<?> clazz = Class.forName(className);
for (Constructor constructor : clazz.getConstructors())
@@ -1109,7 +1201,8 @@
return constructor.newInstance(constrArg);
} catch (IllegalArgumentException err) {
}
- throw new UnsupportedOperationException("No matching constructor found...");
+ throw new UnsupportedOperationException(
+ "No matching constructor found...");
} catch (ClassNotFoundException err) {
// if we want to fall back, we do nothing but
// return NULL
@@ -1127,7 +1220,8 @@
/**
* Ruft die Java Garbage Collection auf.
*
- * @return Anzahl an Bytes, die durch den Aufruf der Garbage Collection freigegeben wurden
+ * @return Anzahl an Bytes, die durch den Aufruf der Garbage Collection
+ * freigegeben wurden
* @see Runtime#gc()
* @see Runtime#freeMemory()
*/
@@ -1139,9 +1233,11 @@
}
/**
- * Ruft die Java Garbage Collection solange auf, bis kein Speicher mehr freigegeben werden kann.
+ * Ruft die Java Garbage Collection solange auf, bis kein Speicher mehr
+ * freigegeben werden kann.
*
- * @return Gesamt-Anzahl an Bytes, die durch die Aufrufe der Garbage Collection freigegeben wurden
+ * @return Gesamt-Anzahl an Bytes, die durch die Aufrufe der Garbage
+ * Collection freigegeben wurden
* @see #gc()
*/
public static long gcTotal() {
@@ -1152,19 +1248,22 @@
}
/**
- * Erzeugt einen neuen {@link URLClassLoader}, der vom {@linkplain ClassLoader#getSystemClassLoader()
- * System-ClassLoaders} abgeleitet ist.
+ * Erzeugt einen neuen {@link URLClassLoader}, der vom
+ * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoaders}
+ * abgeleitet ist.
*
* @param searchPath
* Pfade, in denen der ClassLoader nach Klassen sucht
*/
public static ClassLoader createClassLoader(URL[] searchPath) {
- return URLClassLoader.newInstance(searchPath, ClassLoader.getSystemClassLoader());
+ return URLClassLoader.newInstance(searchPath,
+ ClassLoader.getSystemClassLoader());
}
/**
- * Erzeugt einen neuen {@link URLClassLoader}, der vom {@linkplain ClassLoader#getSystemClassLoader()
- * System-ClassLoaders} abgeleitet ist.
+ * Erzeugt einen neuen {@link URLClassLoader}, der vom
+ * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoaders}
+ * abgeleitet ist.
*
* @param searchPath
* Pfad, in denm der ClassLoader nach Klassen sucht
@@ -1174,30 +1273,38 @@
}
/**
- * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader} erzeugt.
+ * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader}
+ * erzeugt.
*
* @param clazz
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfade, in denen der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der
- * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoader} zum Laden der Klasse verwendet)
+ * Pfade, in denen der ClassLoader nach Klassen sucht (wenn
+ * <code>null</code>, wird der
+ * {@linkplain ClassLoader#getSystemClassLoader()
+ * System-ClassLoader} zum Laden der Klasse verwendet)
*/
- public static Class loadClass(String clazz, URL[] searchPath) throws ClassNotFoundException {
+ public static Class loadClass(String clazz, URL[] searchPath)
+ throws ClassNotFoundException {
if (searchPath == null)
return Class.forName(clazz);
return createClassLoader(searchPath).loadClass(clazz);
}
/**
- * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader} erzeugt.
+ * Laed eine Klasse. Ggf. wird hierfuer ein neuer {@link ClassLoader}
+ * erzeugt.
*
* @param clazz
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfad, in dem der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der
- * {@linkplain ClassLoader#getSystemClassLoader() System-ClassLoader} zum Laden der Klasse verwendet)
+ * Pfad, in dem der ClassLoader nach Klassen sucht (wenn
+ * <code>null</code>, wird der
+ * {@linkplain ClassLoader#getSystemClassLoader()
+ * System-ClassLoader} zum Laden der Klasse verwendet)
*/
- public static Class loadClass(String clazz, URL searchPath) throws ClassNotFoundException {
+ public static Class loadClass(String clazz, URL searchPath)
+ throws ClassNotFoundException {
if (searchPath == null)
return Class.forName(clazz);
return createClassLoader(searchPath).loadClass(clazz);
@@ -1205,28 +1312,34 @@
/**
*
- * Laed eine Klasse derart das Klassen im Cache ignoriert werden. Dazu ist es erforderlich das unter dem Parameter
- * <code>searchPath</code> eine Verzeichnis "META-INF" vorhanden ist. Darin muss eine Datei "PREFERRED.LIST" sein.
- * Wie genau diese Datei aufgebaut sein muss, lässt sich in der Dokumentation des {@link PreferredClassLoader
+ * Laed eine Klasse derart das Klassen im Cache ignoriert werden. Dazu ist
+ * es erforderlich das unter dem Parameter <code>searchPath</code> eine
+ * Verzeichnis "META-INF" vorhanden ist. Darin muss eine Datei
+ * "PREFERRED.LIST" sein. Wie genau diese Datei aufgebaut sein muss, lässt
+ * sich in der Dokumentation des {@link PreferredClassLoader
* PreferredClassLoaders} nachlesen.
*
* @param classname
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfad, in dem der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der System-Klassenpfad
- * {@linkplain ClassLoader#getSystemResource(String) ClassLoader.getSystemResource("")} zum Laden der
- * Klasse verwendet)
+ * Pfad, in dem der ClassLoader nach Klassen sucht (wenn
+ * <code>null</code>, wird der System-Klassenpfad
+ * {@linkplain ClassLoader#getSystemResource(String)
+ * ClassLoader.getSystemResource("")} zum Laden der Klasse
+ * verwendet)
* @throws ClassNotFoundException
* @see PreferredClassLoader
*
* @author Dominik Appl
*/
- public static Class loadPreferredClass(String classname, URL searchPath) throws ClassNotFoundException {
+ public static Class loadPreferredClass(String classname, URL searchPath)
+ throws ClassNotFoundException {
if (searchPath == null)
// System-Klassenpfad verwenden
searchPath = ClassLoader.getSystemResource("");
- PreferredClassLoader classLoader = new PreferredClassLoader(new URL[] { searchPath }, Thread.currentThread()
- .getContextClassLoader(), null, false);
+ PreferredClassLoader classLoader = new PreferredClassLoader(
+ new URL[] { searchPath }, Thread.currentThread()
+ .getContextClassLoader(), null, false);
Class loadedClass = classLoader.loadClass(classname);
if (loadedClass == null)
return Class.forName(classname);
@@ -1235,8 +1348,10 @@
}
/**
- * Laed eine Klasse neu und erzeugt eine Objekt-Instanz. Als Suchpfad fuer die Klasse der System-Klassenpfad
- * {@linkplain ClassLoader#getSystemResource(String) ClassLoader.getSystemResource("")} verwendet.
+ * Laed eine Klasse neu und erzeugt eine Objekt-Instanz. Als Suchpfad fuer
+ * die Klasse der System-Klassenpfad
+ * {@linkplain ClassLoader#getSystemResource(String)
+ * ClassLoader.getSystemResource("")} verwendet.
*
* @param classname
* Klassenname (inkl. Paket)
@@ -1255,15 +1370,18 @@
* @param classname
* Klassenname (inkl. Paket)
* @param searchPath
- * Pfad, in dem der ClassLoader nach Klassen sucht (wenn <code>null</code>, wird der System-Klassenpfad
- * {@linkplain ClassLoader#getSystemResource(String) ClassLoader.getSystemResource("")} zum Laden der
- * Klasse verwendet)
+ * Pfad, in dem der ClassLoader nach Klassen sucht (wenn
+ * <code>null</code>, wird der System-Klassenpfad
+ * {@linkplain ClassLoader#getSystemResource(String)
+ * ClassLoader.getSystemResource("")} zum Laden der Klasse
+ * verwendet)
* @param param
* Parameter fuer den Konstruktor-Aufruf
* @exception RuntimeException
* falls irgendein Fehler auftritt
*/
- public static Object loadPreferredObject(String classname, URL searchPath, Object... param) {
+ public static Object loadPreferredObject(String classname, URL searchPath,
+ Object... param) {
try {
// Klasse laden
Class clazz = loadPreferredClass(classname, searchPath);
@@ -1284,14 +1402,16 @@
} catch (IllegalArgumentException err) {
}
// kein passender Konstruktor gefunden
- throw new UnsupportedOperationException("No matching constructor found...");
+ throw new UnsupportedOperationException(
+ "No matching constructor found...");
} catch (Exception err) {
throw new RuntimeException(err);
}
}
/**
- * Liefert das Package einer Klasse erweitert um einen relativen Pfad in Punkt-Notation.
+ * Liefert das Package einer Klasse erweitert um einen relativen Pfad in
+ * Punkt-Notation.
*
* @param clazz
* eine Klasse
@@ -1317,11 +1437,13 @@
*/
public static void checkIdentifierAndError(String identifier) {
if (!Character.isJavaIdentifierStart(identifier.charAt(0)))
- throw new IllegalArgumentException("Illegal first character '" + identifier.charAt(0) + "'");
+ throw new IllegalArgumentException("Illegal first character '"
+ + identifier.charAt(0) + "'");
for (int i = 1; i < identifier.length(); i++) {
char c = identifier.charAt(i);
if (!Character.isJavaIdentifierPart(c))
- throw new IllegalArgumentException("Illegal inner character '" + c + "'");
+ throw new IllegalArgumentException("Illegal inner character '"
+ + c + "'");
}
}
@@ -1342,7 +1464,8 @@
}
/**
- * Sortiert einen Array aus beliebigen Objekten nach der natuerlichen Sortierung ihrer {@code toString()}-Werte.
+ * Sortiert einen Array aus beliebigen Objekten nach der natuerlichen
+ * Sortierung ihrer {@code toString()}-Werte.
*
* @param objects
* Objekte
@@ -1375,7 +1498,8 @@
}
/**
- * Returns the maximum value of some integer collections. If a collection is empty, 0 is taken as its maximum value.
+ * Returns the maximum value of some integer collections. If a collection is
+ * empty, 0 is taken as its maximum value.
*
* @param collections
* some collections
@@ -1404,7 +1528,8 @@
}
/**
- * Returns the minimum value of some integer collections. If a collection is empty, 0 is taken as its minimum value.
+ * Returns the minimum value of some integer collections. If a collection is
+ * empty, 0 is taken as its minimum value.
*
* @param collections
* some collections
@@ -1419,11 +1544,11 @@
* @param value
* Wert
* @param digits
- * Anzahl an Nachkommastellen (negative Werte runden auf Vorkommastellen, also 10er-, 100er-, usw.
- * Stelle)
+ * Anzahl an Nachkommastellen (negative Werte runden auf
+ * Vorkommastellen, also 10er-, 100er-, usw. Stelle)
* @param mode
- * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 = Abrunden; wenn nicht angegeben, wird
- * normal gerundet)
+ * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 =
+ * Abrunden; wenn nicht angegeben, wird normal gerundet)
*/
public static double round(double value, int digits, int... mode) {
int roundMode = 0; // Default: Normal-Runden
@@ -1447,23 +1572,27 @@
}
/**
- * Rundet alle Werte einer {@link Collection} auf Nach- oder Vorkommastellen.<br>
+ * Rundet alle Werte einer {@link Collection} auf Nach- oder
+ * Vorkommastellen.<br>
* <b>Achtung:</b><br>
- * Es wird eine neue {@link Collection} des gleichen Typs erzeugt und die gerundeten Werte darin in der Reihenfolge
- * eingefuegt, wie sie von {@link Collection#iterator()} geliefert werden! Unter umstaenden kann die urspruengliche
- * Sortierung verloren gehen! Diese Methode sollte also im Zweifelsfall nur auf automatisch sortierte
- * {@link Collection Collections} angewandt werden (z.B. {@link TreeSet}).
+ * Es wird eine neue {@link Collection} des gleichen Typs erzeugt und die
+ * gerundeten Werte darin in der Reihenfolge eingefuegt, wie sie von
+ * {@link Collection#iterator()} geliefert werden! Unter umstaenden kann die
+ * urspruengliche Sortierung verloren gehen! Diese Methode sollte also im
+ * Zweifelsfall nur auf automatisch sortierte {@link Collection Collections}
+ * angewandt werden (z.B. {@link TreeSet}).
*
* @param values
* Werte
* @param digits
- * Anzahl an Nachkommastellen (negative Werte runden auf Vorkommastellen, also 10er-, 100er-, usw.
- * Stelle)
+ * Anzahl an Nachkommastellen (negative Werte runden auf
+ * Vorkommastellen, also 10er-, 100er-, usw. Stelle)
* @param mode
- * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 = Abrunden; wenn nicht angegeben, wird
- * normal gerundet)
+ * Modus für das Runden (0 = normal Runden, 1 = Aufrunden, -1 =
+ * Abrunden; wenn nicht angegeben, wird normal gerundet)
*/
- public static Collection<Number> round(Collection<Number> values, int digits, int... mode) {
+ public static Collection<Number> round(Collection<Number> values,
+ int digits, int... mode) {
try {
Collection<Number> newCollection = values.getClass().newInstance();
for (Number value : values) {
@@ -1471,7 +1600,8 @@
}
return newCollection;
} catch (Exception err) {
- throw new IllegalArgumentException("Can not handle collection: " + getSimpleClassName(values), err);
+ throw new IllegalArgumentException("Can not handle collection: "
+ + getSimpleClassName(values), err);
}
}
@@ -1489,14 +1619,17 @@
}
/**
- * Returns the class names of the top of a stack trace. Duplicate class names are eliminated.
+ * Returns the class names of the top of a stack trace. Duplicate class
+ * names are eliminated.
*
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack trace
+ * maximum count of classes, which are explored in the stack
+ * trace
*/
- public static String[] getLastStackTraceClasses(StackTraceElement[] stackTrace, int depth) {
+ public static String[] getLastStackTraceClasses(
+ StackTraceElement[] stackTrace, int depth) {
Vector<String> lastClasses = new Vector<String>();
for (StackTraceElement st : stackTrace) {
String className = st.getClassName();
@@ -1514,11 +1647,13 @@
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack trace
+ * maximum count of classes, which are explored in the stack
+ * trace
* @param out
* output stream to write to
*/
- public static void printLastStackTraceClasses(StackTraceElement[] stackTrace, int depth, PrintStream out) {
+ public static void printLastStackTraceClasses(
+ StackTraceElement[] stackTrace, int depth, PrintStream out) {
String[] lastClasses = getLastStackTraceClasses(stackTrace, depth);
for (int i = 0; i < lastClasses.length; i++) {
if (i > 0)
@@ -1533,22 +1668,27 @@
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack trace
+ * maximum count of classes, which are explored in the stack
+ * trace
* @see System#out
*/
- public static void printLastStackTraceClasses(StackTraceElement[] stackTrace, int depth) {
+ public static void printLastStackTraceClasses(
+ StackTraceElement[] stackTrace, int depth) {
printLastStackTraceClasses(stackTrace, depth, System.out);
}
/**
- * Initializes the {@link Logger} (root logger) with a default {@link ConsoleAppender}. This method does nothing
- * when the root logger already contains an appender, so it does not matter when this method is called twice or
- * more.
+ * Initializes the {@link Logger} (root logger) with a default
+ * {@link ConsoleAppender}. This method does nothing when the root logger
+ * already contains an appender, so it does not matter when this method is
+ * called twice or more.
*
* @param logLevel
- * log level (if {@code null} the level {@link Level#DEBUG} is used)
+ * log level (if {@code null} the level {@link Level#DEBUG} is
+ * used)
* @param logPattern
- * pattern for the console output (if {@code null} a default pattern "%r\t%p\t%c\t%m%n" is used)
+ * pattern for the console output (if {@code null} a default
+ * pattern "%r\t%p\t%c\t%m%n" is used)
*/
public static void initializeDefaultLogger(Level logLevel, String logPattern) {
// Diry-code by Steve:
@@ -1582,12 +1722,13 @@
}
/**
- * Erzeugt einen Log4j-Logger fuer ein Objekt. Als Identifier fuer den Logger wird der Klassenname des Objekts
- * verwendet.
+ * Erzeugt einen Log4j-Logger fuer ein Objekt. Als Identifier fuer den
+ * Logger wird der Klassenname des Objekts verwendet.
*
* @param object
* ein Objekt
- * @return Logger mit dem Namen "NULL", falls das uebergebene Objekt {@code null} ist
+ * @return Logger mit dem Namen "NULL", falls das uebergebene Objekt
+ * {@code null} ist
*/
public static Logger createLogger(Object object) {
if (object == null)
@@ -1598,13 +1739,15 @@
}
/**
- * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der Error-Eintrag erhaelt nur die Meldung, der
- * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
+ * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der
+ * Error-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
+ * detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
* @param mess
- * Fehlermeldung (wenn {@code null} wird die Message des Fehlers ausgegeben)
+ * Fehlermeldung (wenn {@code null} wird die Message des Fehlers
+ * ausgegeben)
* @param err
* ein Fehler
*/
@@ -1616,8 +1759,9 @@
}
/**
- * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der Error-Eintrag erhaelt nur die Meldung, der
- * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
+ * Erzeugt einen Error- und einen Debug-Eintrag in einem Logger. Der
+ * Error-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
+ * detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
@@ -1629,13 +1773,15 @@
}
/**
- * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der Warn-Eintrag erhaelt nur die Meldung, der
- * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
+ * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der
+ * Warn-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
+ * detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
* @param mess
- * Fehlermeldung (wenn {@code null} wird die Message des Fehlers ausgegeben)
+ * Fehlermeldung (wenn {@code null} wird die Message des Fehlers
+ * ausgegeben)
* @param err
* ein Fehler
*/
@@ -1647,8 +1793,9 @@
}
/**
- * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der Warn-Eintrag erhaelt nur die Meldung, der
- * Debug-Eintrag auch die detaillierten Informationen des Fehlers.
+ * Erzeugt einen Warn- und einen Debug-Eintrag in einem Logger. Der
+ * Warn-Eintrag erhaelt nur die Meldung, der Debug-Eintrag auch die
+ * detaillierten Informationen des Fehlers.
*
* @param logger
* ein Logger
@@ -1667,9 +1814,11 @@
* @param stackTrace
* stack trace to explore
* @param depth
- * maximum count of classes, which are explored in the stack trace
+ * maximum count of classes, which are explored in the stack
+ * trace
*/
- public static void logDebugLastStackTraceClasses(Category logger, StackTraceElement[] stackTrace, int depth) {
+ public static void logDebugLastStackTraceClasses(Category logger,
+ StackTraceElement[] stackTrace, int depth) {
String[] lastClasses = getLastStackTraceClasses(stackTrace, depth);
for (int i = 0; i < lastClasses.length; i++) {
String message = "";
@@ -1686,7 +1835,8 @@
* @param numClass
* TODO Martin, geht das nicht schöner? Ich bin zu doof
*/
- public static Number parseNumberAs(final String valueString, final Class<?> numClass) {
+ public static Number parseNumberAs(final String valueString,
+ final Class<?> numClass) {
if (StringUtils.trimToNull(valueString) == null)
return null;
@@ -1707,8 +1857,9 @@
} else if (numClass == Float.class) {
return doubleValue.floatValue();
} else {
- throw new RuntimeException("Please report that parseNumberAs has to support variables of type "
- + numClass.getCanonicalName());
+ throw new RuntimeException(
+ "Please report that parseNumberAs has to support variables of type "
+ + numClass.getCanonicalName());
}
}
@@ -1726,7 +1877,8 @@
}
/**
- * Interpretiert einen {@link String} zu einem {@link boolean} mit default <code>true</code>.
+ * Interpretiert einen {@link String} zu einem {@link boolean} mit default
+ * <code>true</code>.
*/
public static boolean parseStringDefaultTrue(String str) {
if (str == null)
@@ -1740,7 +1892,8 @@
}
/**
- * Interpretiert einen {@link String} zu einem {@link boolean} mit default <code>null</code>.
+ * Interpretiert einen {@link String} zu einem {@link boolean} mit default
+ * <code>null</code>.
*/
public static Boolean parseStringDefaultNull(String str) {
if (str == null)
@@ -1760,7 +1913,8 @@
}
/**
- * Interpretiert einen {@link String} zu einem {@link boolean} mit default <code>false</code>.
+ * Interpretiert einen {@link String} zu einem {@link boolean} mit default
+ * <code>false</code>.
*/
public static boolean parseStringDefaultFalse(String str) {
if (str == null)
@@ -1776,7 +1930,8 @@
}
/**
- * Removes leading and tailing "\n" newline commands. Very similar: StringUtils.trimToEmpty(string);
+ * Removes leading and tailing "\n" newline commands. Very similar:
+ * StringUtils.trimToEmpty(string);
*
* @param string
* return <code>null</code> if <code>null</code> is passed.
@@ -1810,10 +1965,12 @@
}
/**
- * Kann verwendet werden, um einen String von XML/HTML Tags zu säubern. Rückgabe ist ein ein String ohne Tags. Mehr
- * als 2 Leerzeichen werden zu einem Leerzeichen. Am Ende und Anfang nie Leerzeichen. Ein <li>wird zu einem * um die
- * Lesbarkeit als Rein-Text zu verbessern.<br/>
- * Die Methode basiert auf RegEx. Es wird also kein valides oder wellformed-XML erwartet.
+ * Kann verwendet werden, um einen String von XML/HTML Tags zu säubern.
+ * Rückgabe ist ein ein String ohne Tags. Mehr als 2 Leerzeichen werden zu
+ * einem Leerzeichen. Am Ende und Anfang nie Leerzeichen. Ein <li>wird zu
+ * einem * um die Lesbarkeit als Rein-Text zu verbessern.<br/>
+ * Die Methode basiert auf RegEx. Es wird also kein valides oder
+ * wellformed-XML erwartet.
*/
public static String removeTags(String withTags) {
String withoutTags = withTags;
@@ -1828,18 +1985,23 @@
}
/**
- * Liefert einen String zurück, der zeigt, wo die RegEx im String getroffen hat. Der getroffene Bereich wird
- * +-$border Zeichen ausgeschnitten und GROSS geschrieben. <br/>
+ * Liefert einen String zurück, der zeigt, wo die RegEx im String getroffen
+ * hat. Der getroffene Bereich wird +-$border Zeichen ausgeschnitten und
+ * GROSS geschrieben. <br/>
* Beispiele:
* <ul>
- * <li>assertEquals("abcBAUMdef", LangUtil.regExBereich("abcBaumdef", "Baum", 115)); <br/>
- * <li>assertEquals("5BAUM6", LangUtil.regExBereich("12345Baum67890", "Baum", 1));
+ * <li>assertEquals("abcBAUMdef", LangUtil.regExBereich("abcBaumdef",
+ * "Baum", 115)); <br/>
+ * <li>assertEquals("5BAUM6", LangUtil.regExBereich("12345Baum67890",
+ * "Baum", 1));
*/
static public String regExBereich(String value, String regex, int border) {
return regExBereich(value, regex, border, ".*", ".*");
}
- static public String regExBereich(String value, String regex, int border, String pre, String post) {
+ static public String regExBereich(String value, String regex, int border,
+ String pre, String post) {
+
if (border < 0)
throw new IllegalStateException("border may not be smaller 0!");
@@ -1858,8 +2020,26 @@
int s2 = Math.min(start, border);
String vorher = value.substring(start - s2, start);
- String nachher = value.substring(matcher.end(1), Math.min(matcher.end(1) + border, value.length()));
+ String nachher = value.substring(matcher.end(1),
+ Math.min(matcher.end(1) + border, value.length()));
- return vorher.toLowerCase() + treffer.toUpperCase() + nachher.toLowerCase();
+ return vorher.toLowerCase() + treffer.toUpperCase()
+ + nachher.toLowerCase();
}
+
+ /**
+ * Entfernt alle " " und NewLines.
+ * @param trimmed
+ * @return
+ */
+ public static String cleanToNull(String trimmed) {
+ if (trimmed == null)
+ return null;
+ trimmed = trimmed.replace("\n", " ");
+ trimmed = trimmed.replace("\r", " ");
+ trimmed = trimmed.replace("\t", " ");
+ trimmed = trimmed.replace("\u00A0", " ");
+ trimmed = trimmed.replaceAll("\\s{1,}", " ");
+ return StringUtils.trimToNull(trimmed);
+ }
}
More information about the Schmitzm-commits
mailing list