# Package org.apache.commons.lang3

package org.apache.commons.lang3
Provides highly reusable 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 favor 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.

## String manipulation - StringUtils, StringEscapeUtils, RandomStringUtils

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.

## Character handling - CharSetUtils, CharSet, CharRange, CharUtils

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.

## JVM interaction - SystemUtils, CharEncoding

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 - SerializationUtils, SerializationException

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.

### Assorted functions - ObjectUtils, ClassUtils, ArrayUtils, BooleanUtils

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.

- ArrayUtils provides singleton empty arrays for all the basic types. These will largely be of use in the Collections API with its toArray methods, but also will be of use with methods which want to return an empty array on error.
- `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.
- Along side the add methods, there are also remove methods of two types. The first type remove the value at an index, `remove(xxx[], int)`, while the second type remove the first value from the array, `remove(xxx[], xxx)`.
- Nearing the end now. The `reverse(xxx[])` method turns an array around.
- The `subarray(xxx[], int, int)` method splices an array out of a larger array.
- Primitive to primitive wrapper conversion is handled by the `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.

#### Using toMap

    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.

## Flotsam - BitField, Validate

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).

Since:
  1.0

- Related Packages
  Package
  Description
  org.apache.commons.lang3.arch
  Provides classes to work with the values of the os.arch system property.
  org.apache.commons.lang3.builder
  Provides classes to create consistent `equals(Object)`, `toString()`, `hashCode()`, and `compareTo(Object)` methods.
  org.apache.commons.lang3.compare
  Provides classes to work with the `Comparable` and `Comparator` interfaces.
  org.apache.commons.lang3.concurrent
  Provides support classes for multi-threaded programming.
  org.apache.commons.lang3.event
  Provides some useful event-based utilities.
  org.apache.commons.lang3.exception
  Provides functionality for Exceptions.
  org.apache.commons.lang3.function
  Provides functional interfaces to complement those in `java.lang.function` and utilities for working with Java 8 lambdas.
  org.apache.commons.lang3.math
  Provides `java.math` extensions for business mathematical classes.
  org.apache.commons.lang3.mutable
  Provides typed mutable wrappers to primitive values and Object.
  org.apache.commons.lang3.reflect
  Provides high-level uses of the `java.lang.reflect` APIs.
  org.apache.commons.lang3.stream
  Provides utility classes to complement those in `java.util.stream`.
  org.apache.commons.lang3.text
  Deprecated: Provides classes for handling and manipulating text, partly as an extension to `java.text`.
  org.apache.commons.lang3.time
  Provides classes and methods to work with dates and durations.
  org.apache.commons.lang3.tuple
  Provides tuple classes, both mutable and immutable `Pair` and `Triple`.
  org.apache.commons.lang3.util
  Provides classes that work with the Java `java.util` package.
- Class
  Description
  AnnotationUtils
  Helper methods for working with `Annotation` instances.
  AppendableJoiner<T>
  Joins an array or `Iterable` into an existing `Appendable` like a `StringBuilder`; with the goal for call sites to avoid creating intermediary Strings.
  AppendableJoiner.Builder<T>
  Builds instances of `AppendableJoiner`.
  ArchUtils
  Provides methods for identifying the architecture of the current JVM based on the `"os.arch"` system property.
  ArrayFill
  Fills and returns arrays in the fluent style.
  ArraySorter
  Sorts and returns arrays in the fluent style.
  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.
  ClassLoaderUtils
  Helps work with `ClassLoader`.
  ClassPathUtils
  Operations regarding the classpath.
  ClassUtils
  Operates on classes without using reflection.
  ClassUtils.Interfaces
  Inclusivity literals for `ClassUtils.hierarchy(Class, Interfaces)`.
  Conversion
  Static methods to convert a type into another, with endianness and bit ordering awareness.
  DoubleRange
  Specializes `NumberRange` for `Double`s.
  EnumUtils
  Provides methods for Java enums.
  Functions
  Deprecated.
  Use `Failable`.
  Functions.FailableBiConsumer<O1, O2, T extends Throwable>
  Deprecated.
  Use `FailableBiConsumer`.
  Functions.FailableBiFunction<O1, O2, R, T extends Throwable>
  Deprecated.
  Use `FailableBiFunction`.
  Functions.FailableBiPredicate<O1, O2, T extends Throwable>
  Deprecated.
  Use `FailableBiPredicate`.
  Functions.FailableCallable<R, T extends Throwable>
  Deprecated.
  Use `FailableCallable`.
  Functions.FailableConsumer<O, T extends Throwable>
  Deprecated.
  Use `FailableConsumer`.
  Functions.FailableFunction<I, R, T extends Throwable>
  Deprecated.
  Use `FailableFunction`.
  Functions.FailablePredicate<I, T extends Throwable>
  Deprecated.
  Use `FailablePredicate`.
  Functions.FailableRunnable<T extends Throwable>
  Deprecated.
  Use `FailableRunnable`.
  Functions.FailableSupplier<R, T extends Throwable>
  Deprecated.
  Use `FailableSupplier`.
  IntegerRange
  Specializes `NumberRange` for `Integer`s.
  JavaVersion
  Enumerates all known versions of the Java specification.
  LocaleUtils
  Operations to assist when working with a `Locale`.
  LongRange
  Specializes `NumberRange` for `Long`s.
  NotImplementedException
  Thrown to indicate that a block of code has not been implemented.
  NumberRange<N extends Number>
  Specializes `Range` for `Number`s.
  ObjectUtils
  Operations on `Object`.
  ObjectUtils.Null
  Class used as a null placeholder where `null` has another meaning.
  RandomStringUtils
  Generates random `String`s.
  RandomUtils
  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.
  RuntimeEnvironment
  Helps query the runtime environment.
  SerializationException
  Exception thrown when the Serialization process fails.
  SerializationUtils
  Assists with the serialization process and performs additional functionality based on serialization.
  Streams
  Deprecated.
  Use `Streams`.
  Streams.ArrayCollector<O>
  Deprecated.
  Use `Streams.ArrayCollector`.
  Streams.FailableStream<O>
  Deprecated.
  Use `Streams.FailableStream`.
  StringEscapeUtils
  Deprecated.
  As of 3.6, use Apache Commons Text StringEscapeUtils instead.
  Strings
  String operations where you choose case-sensitive `Strings.CS` vs. case-insensitive `Strings.CI` through a singleton instance.
  Strings.Builder
  Builds `Strings` instances.
  StringUtils
  Operations on `String` that are `null` safe.
  SystemProperties
  Accesses current System Property names and values.
  SystemUtils
  Helpers for `System`.
  ThreadUtils
  Helpers for `Thread` and `ThreadGroup`.
  ThreadUtils.NamePredicate
  Deprecated.
  Use a `Predicate`.
  ThreadUtils.ThreadGroupPredicate
  Deprecated.
  Use a `Predicate`.
  ThreadUtils.ThreadIdPredicate
  Deprecated.
  Use a `Predicate`.
  ThreadUtils.ThreadPredicate
  Deprecated.
  Use a `Predicate`.
  Validate
  This class assists in validating arguments.