java.lang
classes.See: Description
Interface | Description |
---|---|
ThreadUtils.ThreadGroupPredicate |
A predicate for selecting threadgroups.
|
ThreadUtils.ThreadPredicate |
A predicate for selecting threads.
|
Class | Description |
---|---|
AnnotationUtils |
Helper methods for working with
Annotation instances. |
ArchUtils |
An utility class for the os.arch System Property.
|
ArrayUtils |
Operations on arrays, primitive arrays (like
int[] ) and
primitive wrapper arrays (like Integer[] ). |
BitField |
Supports operations on bit-mapped fields.
|
BooleanUtils |
Operations on boolean primitives and Boolean objects.
|
CharEncoding | Deprecated
Java 7 introduced
StandardCharsets , which defines these constants as
Charset objects. |
CharSequenceUtils |
Operations on
CharSequence that are
null safe. |
CharSet |
A set of characters.
|
CharSetUtils |
Operations on
CharSet instances. |
CharUtils |
Operations on char primitives and Character objects.
|
ClassPathUtils |
Operations regarding the classpath.
|
ClassUtils |
Operates on classes without using reflection.
|
Conversion |
Static methods to convert a type into another, with endianness and bit ordering awareness.
|
EnumUtils |
Utility library to provide helper methods for Java enums.
|
LocaleUtils |
Operations to assist when working with a
Locale . |
ObjectUtils |
Operations on
Object . |
ObjectUtils.Null |
Class used as a null placeholder where
null
has another meaning. |
RandomStringUtils |
Operations for random
String s. |
RandomUtils |
Utility library that supplements the standard
Random class. |
Range<T> |
An immutable range of objects from a minimum to maximum point inclusive.
|
RegExUtils |
Helpers to process Strings using regular expressions.
|
SerializationUtils |
Assists with the serialization process and performs additional functionality based
on serialization.
|
StringEscapeUtils | Deprecated
as of 3.6, use commons-text
StringEscapeUtils instead
|
StringUtils |
Operations on
String that are
null safe. |
SystemUtils |
Helpers for
java.lang.System . |
ThreadUtils |
Helpers for
java.lang.Thread and java.lang.ThreadGroup . |
ThreadUtils.NamePredicate |
A predicate implementation which matches a thread or threadgroup name.
|
ThreadUtils.ThreadIdPredicate |
A predicate implementation which matches a thread id.
|
Validate |
This class assists in validating arguments.
|
Enum | Description |
---|---|
ClassUtils.Interfaces |
Inclusivity literals for
ClassUtils.hierarchy(Class, Interfaces) . |
JavaVersion |
An enum representing all the versions of the Java specification.
|
Exception | Description |
---|---|
NotImplementedException |
Thrown to indicate that a block of code has not been implemented.
|
SerializationException |
Exception thrown when the Serialization process fails.
|
Provides highly reusable static utility methods, chiefly concerned with adding value to the java.lang
classes.
Most of these classes are immutable and thus thread-safe.
However CharSet
is not currently guaranteed thread-safe under all circumstances.
The top level package contains various Utils classes, whilst there are various subpackages including org.apache.commons.lang3.math
, org.apache.commons.lang3.concurrent
and org.apache.commons.lang3.builder
.
Using the Utils classes is generally simplicity itself.
They are the equivalent of global functions in another language, a collection of stand-alone, thread-safe, static methods.
In contrast, subpackages may contain interfaces which may have to be implemented or classes which may need to be extended to get the full functionality from the code.
They may, however, contain more global-like functions.
Lang 3.0 requires JDK 1.5+, since Lang 3.2 it requires JDK 6+; The legacy release 2.6 requires JDK 1.2+. In both cases you can find features of later JDKs being maintained by us and likely to be removed or modified in favour of the JDK in the next major version. Note that Lang 3.0 uses a different package than its predecessors, allowing it to be used at the same time as an earlier version.
You will find deprecated methods as you stroll through the Lang documentation. These are removed in the next major version.
All util classes contain empty public constructors with warnings not to use. This may seem an odd thing to do, but it allows tools like Velocity to access the class as if it were a bean. In other words, yes we know about private constructors and have chosen not to use them.
Lang has a series of String utilities.
The first is StringUtils
, oodles and oodles of functions which tweak, transform, squeeze and cuddle java.lang.Strings
.
In addition to StringUtils, there are a series of other String manipulating classes; RandomStringUtils
and StringEscapeUtils
.
RandomStringUtils speaks for itself.
It's provides ways in which to generate pieces of text, such as might be used for default passwords.
StringEscapeUtils contains methods to escape and unescape Java, JavaScript, JSON, HTML and XML.
These are ideal classes to start using if you're looking to get into Lang.
StringUtils' StringUtils.capitalize(String)
, StringUtils.substringBetween(String, String)
/Before
/After
, StringUtils.split(String)
and StringUtils.join(Object[])
are good methods to begin with.
In addition to dealing with Strings, it's also important to deal with chars and Characters.
CharUtils
exists for this purpose, while CharSetUtils
exists for set-manipulation of Strings.
Be careful, although CharSetUtils takes an argument of type String, it is only as a set of characters.
For example, CharSetUtils.delete("testtest", "tr")
will remove all t's and all r's from the String, not just the String "tr".
CharRange
and CharSet
are both used internally by CharSetUtils, and will probably rarely be used.
SystemUtils is a simple little class which makes it easy to find out information about which platform you are on.
For some, this is a necessary evil. It was never something I expected to use myself until I was trying to ensure that Commons Lang itself compiled under JDK 1.2.
Having pushed out a few JDK 1.3 bits that had slipped in (Collections.EMPTY_MAP
is a classic offender), I then found that one of the Unit Tests was dying mysteriously under JDK 1.2, but ran fine under JDK 1.3.
There was no obvious solution and I needed to move onwards, so the simple solution was to wrap that particular test in a if(SystemUtils.isJavaVersionAtLeast(1.3f)) {
, make a note and move on.
The CharEncoding
class is also used to interact with the Java environment and may be used to see which character encodings are supported in a particular environment.
Serialization doesn't have to be that hard! A simple util class can take away the pain, plus it provides a method to clone an object by unserializing and reserializing, an old Java trick.
Would you believe it, ObjectUtils
contains handy functions for Objects, mainly null-safe implementations of the methods on Object
.
ClassUtils
is largely a set of helper methods for reflection.
Of special note are the comparators hidden away in ClassUtils, useful for sorting Class and Package objects by name; however they merely sort alphabetically and don't understand the common habit of sorting java
and javax
first.
Next up, ArrayUtils
.
This is a big one with many methods and many overloads of these methods so it is probably worth an in depth look here.
Before we begin, assume that every method mentioned is overloaded for all the primitives and for Object.
Also, the short-hand 'xxx' implies a generic primitive type, but usually also includes Object.
add(xxx[], xxx)
will add a primitive type to an array, resizing the array as you'd expect. Object is also supported. clone(xxx[])
clones a primitive or Object array. contains(xxx[], xxx)
searches for a primitive or Object in a primitive or Object array. getLength(Object)
returns the length of any array or an IllegalArgumentException if the parameter is not an array. hashCode(Object)
, equals(Object, Object)
, toString(Object)
indexOf(xxx[], xxx)
and indexOf(xxx[], xxx, int)
are copies of the classic String methods, but this time for primitive/Object arrays. In addition, a lastIndexOf set of methods exists. isEmpty(xxx[])
lets you know if an array is zero-sized or null. isSameLength(xxx[], xxx[])
returns true if the arrays are the same length. remove(xxx[], int)
, while the second type remove the first value from the array, remove(xxx[], xxx)
. reverse(xxx[])
method turns an array around. subarray(xxx[], int, int)
method splices an array out of a larger array. toObject(xxx[])
and toPrimitive(Xxx[])
methods. Lastly, ArrayUtils.toMap(Object[])
is worthy of special note.
It is not a heavily overloaded method for working with arrays, but a simple way to create Maps from literals.
Map colorMap = ArrayUtils.toMap(new String[][] {{
{"RED", "#FF0000"},
{"GREEN", "#00FF00"},
{"BLUE", "#0000FF"}
});
Our final util class is BooleanUtils
.
It contains various Boolean acting methods, probably of most interest is the BooleanUtils.toBoolean(String)
method which turns various positive/negative Strings into a Boolean object, and not just true/false as with Boolean.valueOf.
On reaching the end of our package, we are left with a couple of classes that haven't fit any of the topics so far.
The BitField
class provides a wrapper class around the classic bitmask integer, whilst the Validate
class may be used for assertions (remember, we support Java 1.2).
Copyright © 2001–2018 The Apache Software Foundation. All rights reserved.