Assert (bus-core 3.0.0 API)

java.lang.Object
- org.aoju.bus.core.lang.Assert

```
public class Assert
extends Object
```
断言
断言某些对象或值是否符合规定，否则抛出异常。经常用于做变量检查

Since:

JDK 1.8

Version:

3.0.0

Author:

Kimi Liu

Constructor Summary

Constructors
Constructor and Description

Assert()

Constructors
Constructor and Description
`Assert()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`hasText(String text, String message)` Assert that the given String contains valid text content; that is, it must not be `null` and must contain at least one non-whitespace character.
`static void`	`isAssignable(Class<?> superType, Class<?> subType)` Assert that `superType.isAssignableFrom(subType)` is `true`.
`static void`	`isAssignable(Class<?> superType, Class<?> subType, String errorMsgTemplate, Object... params)` Assert that `superType.isAssignableFrom(subType)` is `true`.
`static void`	`isFalse(boolean expression)` 断言是否为假，如果为 `true` 抛出 `IllegalArgumentException` 异常 Assert.isFalse(i < 0);
`static void`	`isFalse(boolean expression, String errorMsgTemplate, Object... params)` 断言是否为假，如果为 `true` 抛出 `IllegalArgumentException` 异常 Assert.isFalse(i < 0, "The value must be greater than zero");
`static <T> T`	`isInstanceOf(Class<?> type, T obj)` 断言给定对象是否是给定类的实例 Assert.instanceOf(Foo.class, foo);
`static <T> T`	`isInstanceOf(Class<?> type, T obj, String errorMsgTemplate, Object... params)` 断言给定对象是否是给定类的实例 Assert.instanceOf(Foo.class, foo);
`static void`	`isNull(Object object)` 断言对象是否为`null` ，如果不为`null` 抛出`IllegalArgumentException` 异常 Assert.isNull(value);
`static void`	`isNull(Object object, String errorMsgTemplate, Object... params)` 断言对象是否为`null` ，如果不为`null` 抛出`IllegalArgumentException` 异常 Assert.isNull(value, "The value must be null");
`static void`	`isTrue(boolean expression)` 断言是否为真，如果为 `false` 抛出 `IllegalArgumentException` 异常 Assert.isTrue(i > 0, "The value must be greater than zero");
`static void`	`isTrue(boolean expression, String errorMsgTemplate, Object... params)` 断言是否为真，如果为 `false` 抛出 `IllegalArgumentException` 异常 Assert.isTrue(i > 0, "The value must be greater than zero");
`static <T> T[]`	`noNullElements(T[] array)` 断言给定数组是否不包含`null`元素，如果数组为空或 `null`将被认为不包含 Assert.noNullElements(array);
`static <T> T[]`	`noNullElements(T[] array, String errorMsgTemplate, Object... params)` 断言给定数组是否不包含`null`元素，如果数组为空或 `null`将被认为不包含 Assert.noNullElements(array, "The array must have non-null elements");
`static String`	`notBlank(String text)` 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 `IllegalArgumentException` Assert.notBlank(name, "Name must not be blank");
`static String`	`notBlank(String text, String errorMsgTemplate, Object... params)` 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 `IllegalArgumentException` Assert.notBlank(name, "Name must not be blank");
`static String`	`notContain(String textToSearch, String substring)` 断言给定字符串是否不被另一个字符串包含（既是否为子串） Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
`static String`	`notContain(String textToSearch, String substring, String errorMsgTemplate, Object... params)` 断言给定字符串是否不被另一个字符串包含（既是否为子串） Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
`static <T> Collection<T>`	`notEmpty(Collection<T> collection)` 断言给定集合非空 Assert.notEmpty(collection);
`static <T> Collection<T>`	`notEmpty(Collection<T> collection, String errorMsgTemplate, Object... params)` 断言给定集合非空 Assert.notEmpty(collection, "Collection must have elements");
`static <K,V> Map<K,V>`	`notEmpty(Map<K,V> map)` 断言给定Map非空 Assert.notEmpty(map, "Map must have entries");
`static <K,V> Map<K,V>`	`notEmpty(Map<K,V> map, String errorMsgTemplate, Object... params)` 断言给定Map非空 Assert.notEmpty(map, "Map must have entries");
`static Object[]`	`notEmpty(Object[] array)` 断言给定数组是否包含元素，数组必须不为 `null` 且至少包含一个元素 Assert.notEmpty(array, "The array must have elements");
`static Object[]`	`notEmpty(Object[] array, String errorMsgTemplate, Object... params)` 断言给定数组是否包含元素，数组必须不为 `null` 且至少包含一个元素 Assert.notEmpty(array, "The array must have elements");
`static String`	`notEmpty(String text)` 检查给定字符串是否为空，为空抛出 `IllegalArgumentException` Assert.notEmpty(name);
`static String`	`notEmpty(String text, String errorMsgTemplate, Object... params)` 检查给定字符串是否为空，为空抛出 `IllegalArgumentException` Assert.notEmpty(name, "Name must not be empty");
`static <T> T`	`notNull(T object)` 断言对象是否不为`null` ，如果为`null` 抛出`IllegalArgumentException` 异常 Assert.notNull(clazz);
`static <T> T`	`notNull(T object, String errorMsgTemplate, Object... params)` 断言对象是否不为`null` ，如果为`null` 抛出`IllegalArgumentException` 异常 Assert that an object is not `null` .
`static void`	`state(boolean expression)` Assert a boolean expression, throwing `IllegalStateException` if the test result is `false`.
`static void`	`state(boolean expression, String errorMsgTemplate, Object... params)` Assert a boolean expression, throwing `IllegalStateException` if the test result is `false`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Assert
```
public Assert()
```
- Method Detail
  - isTrue
```
public static void isTrue(boolean expression,
                          String errorMsgTemplate,
                          Object... params)
                   throws IllegalArgumentException
```
    断言是否为真，如果为 false 抛出 IllegalArgumentException 异常
```
 Assert.isTrue(i > 0, "The value must be greater than zero");
 
```
    Parameters:
    
    expression - 波尔值
    
    errorMsgTemplate - 错误抛出异常附带的消息模板，变量用{}代替
    
    params - 参数列表
    
    Throws:
    
    IllegalArgumentException - if expression is false
  - isTrue
```
public static void isTrue(boolean expression)
                   throws IllegalArgumentException
```
    断言是否为真，如果为 false 抛出 IllegalArgumentException 异常
```
 Assert.isTrue(i > 0, "The value must be greater than zero");
 
```
    Parameters:
    
    expression - 波尔值
    
    Throws:
    
    IllegalArgumentException - if expression is false
  - isFalse
```
public static void isFalse(boolean expression,
                           String errorMsgTemplate,
                           Object... params)
                    throws IllegalArgumentException
```
    断言是否为假，如果为 true 抛出 IllegalArgumentException 异常
```
 Assert.isFalse(i < 0, "The value must be greater than zero");
 
```
    Parameters:
    
    expression - 波尔值
    
    errorMsgTemplate - 错误抛出异常附带的消息模板，变量用{}代替
    
    params - 参数列表
    
    Throws:
    
    IllegalArgumentException - if expression is false
  - isFalse
```
public static void isFalse(boolean expression)
                    throws IllegalArgumentException
```
    断言是否为假，如果为 true 抛出 IllegalArgumentException 异常
```
 Assert.isFalse(i < 0);
 
```
    Parameters:
    
    expression - 波尔值
    
    Throws:
    
    IllegalArgumentException - if expression is false
  - isNull
```
public static void isNull(Object object,
                          String errorMsgTemplate,
                          Object... params)
                   throws IllegalArgumentException
```
    断言对象是否为null ，如果不为null 抛出IllegalArgumentException 异常
```
 Assert.isNull(value, "The value must be null");
 
```
    Parameters:
    
    object - 被检查的对象
    
    errorMsgTemplate - 消息模板，变量使用{}表示
    
    params - 参数列表
    
    Throws:
    
    IllegalArgumentException - if the object is not null
  - isNull
```
public static void isNull(Object object)
                   throws NullPointerException
```
    断言对象是否为null ，如果不为null 抛出IllegalArgumentException 异常
```
 Assert.isNull(value);
 
```
    Parameters:
    
    object - 被检查对象
    
    Throws:
    
    NullPointerException - if the object is not null
  - notNull
```
public static <T> T notNull(T object,
                            String errorMsgTemplate,
                            Object... params)
                     throws NullPointerException
```
    断言对象是否不为null ，如果为null 抛出IllegalArgumentException 异常 Assert that an object is not null .
```
 Assert.notNull(clazz, "The class must not be null");
 
```
    Type Parameters:
    
    T - 被检查对象泛型类型
    
    Parameters:
    
    object - 被检查对象
    
    errorMsgTemplate - 错误消息模板，变量使用{}表示
    
    params - 参数
    
    Returns:
    
    被检查后的对象
    
    Throws:
    
    NullPointerException - if the object is null
  - notNull
```
public static <T> T notNull(T object)
                     throws NullPointerException
```
    断言对象是否不为null ，如果为null 抛出IllegalArgumentException 异常
```
 Assert.notNull(clazz);
 
```
    Type Parameters:
    
    T - 被检查对象类型
    
    Parameters:
    
    object - 被检查对象
    
    Returns:
    
    非空对象
    
    Throws:
    
    NullPointerException - if the object is null
  - notEmpty
```
public static String notEmpty(String text,
                              String errorMsgTemplate,
                              Object... params)
                       throws IllegalArgumentException
```
    检查给定字符串是否为空，为空抛出 IllegalArgumentException
```
 Assert.notEmpty(name, "Name must not be empty");
 
```
    Parameters:
    
    text - 被检查字符串
    
    errorMsgTemplate - 错误消息模板，变量使用{}表示
    
    params - 参数
    
    Returns:
    
    非空字符串
    
    Throws:
    
    IllegalArgumentException - 被检查字符串为空
  - notEmpty
```
public static String notEmpty(String text)
                       throws IllegalArgumentException
```
    检查给定字符串是否为空，为空抛出 IllegalArgumentException
```
 Assert.notEmpty(name);
 
```
    Parameters:
    
    text - 被检查字符串
    
    Returns:
    
    被检查的字符串
    
    Throws:
    
    IllegalArgumentException - 被检查字符串为空
  - notBlank
```
public static String notBlank(String text,
                              String errorMsgTemplate,
                              Object... params)
                       throws IllegalArgumentException
```
    检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 IllegalArgumentException
```
 Assert.notBlank(name, "Name must not be blank");
 
```
    Parameters:
    
    text - 被检查字符串
    
    errorMsgTemplate - 错误消息模板，变量使用{}表示
    
    params - 参数
    
    Returns:
    
    非空字符串
    
    Throws:
    
    IllegalArgumentException - 被检查字符串为空白
    
    See Also:
    
    StringUtils.isNotBlank(CharSequence)
  - notBlank
```
public static String notBlank(String text)
                       throws IllegalArgumentException
```
    检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 IllegalArgumentException
```
 Assert.notBlank(name, "Name must not be blank");
 
```
    Parameters:
    
    text - 被检查字符串
    
    Returns:
    
    非空字符串
    
    Throws:
    
    IllegalArgumentException - 被检查字符串为空白
    
    See Also:
    
    StringUtils.isNotBlank(CharSequence)
  - notContain
```
public static String notContain(String textToSearch,
                                String substring,
                                String errorMsgTemplate,
                                Object... params)
                         throws IllegalArgumentException
```
    断言给定字符串是否不被另一个字符串包含（既是否为子串）
```
 Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
 
```
    Parameters:
    
    textToSearch - 被搜索的字符串
    
    substring - 被检查的子串
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Returns:
    
    被检查的子串
    
    Throws:
    
    IllegalArgumentException - 非子串抛出异常
  - notContain
```
public static String notContain(String textToSearch,
                                String substring)
                         throws IllegalArgumentException
```
    断言给定字符串是否不被另一个字符串包含（既是否为子串）
```
 Assert.doesNotContain(name, "rod", "Name must not contain 'rod'");
 
```
    Parameters:
    
    textToSearch - 被搜索的字符串
    
    substring - 被检查的子串
    
    Returns:
    
    被检查的子串
    
    Throws:
    
    IllegalArgumentException - 非子串抛出异常
  - notEmpty
```
public static Object[] notEmpty(Object[] array,
                                String errorMsgTemplate,
                                Object... params)
                         throws IllegalArgumentException
```
    断言给定数组是否包含元素，数组必须不为 null 且至少包含一个元素
```
 Assert.notEmpty(array, "The array must have elements");
 
```
    Parameters:
    
    array - 被检查的数组
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Returns:
    
    被检查的数组
    
    Throws:
    
    IllegalArgumentException - if the object array is null or has no elements
  - notEmpty
```
public static Object[] notEmpty(Object[] array)
                         throws IllegalArgumentException
```
    断言给定数组是否包含元素，数组必须不为 null 且至少包含一个元素
```
 Assert.notEmpty(array, "The array must have elements");
 
```
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    被检查的数组
    
    Throws:
    
    IllegalArgumentException - if the object array is null or has no elements
  - noNullElements
```
public static <T> T[] noNullElements(T[] array,
                                     String errorMsgTemplate,
                                     Object... params)
                              throws IllegalArgumentException
```
    断言给定数组是否不包含null元素，如果数组为空或 null将被认为不包含
```
 Assert.noNullElements(array, "The array must have non-null elements");
 
```
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Returns:
    
    被检查的数组
    
    Throws:
    
    IllegalArgumentException - if the object array contains a null element
  - noNullElements
```
public static <T> T[] noNullElements(T[] array)
                              throws IllegalArgumentException
```
    断言给定数组是否不包含null元素，如果数组为空或 null将被认为不包含
```
 Assert.noNullElements(array);
 
```
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    被检查的数组
    
    Throws:
    
    IllegalArgumentException - if the object array contains a null element
  - notEmpty
```
public static <T> Collection<T> notEmpty(Collection<T> collection,
                                         String errorMsgTemplate,
                                         Object... params)
                                  throws IllegalArgumentException
```
    断言给定集合非空
```
 Assert.notEmpty(collection, "Collection must have elements");
 
```
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被检查的集合
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Returns:
    
    非空集合
    
    Throws:
    
    IllegalArgumentException - if the collection is null or has no elements
  - notEmpty
```
public static <T> Collection<T> notEmpty(Collection<T> collection)
                                  throws IllegalArgumentException
```
    断言给定集合非空
```
 Assert.notEmpty(collection);
 
```
    Type Parameters:
    
    T - 集合元素类型
    
    Parameters:
    
    collection - 被检查的集合
    
    Returns:
    
    被检查集合
    
    Throws:
    
    IllegalArgumentException - if the collection is null or has no elements
  - notEmpty
```
public static <K,V> Map<K,V> notEmpty(Map<K,V> map,
                                      String errorMsgTemplate,
                                      Object... params)
                               throws IllegalArgumentException
```
    断言给定Map非空
```
 Assert.notEmpty(map, "Map must have entries");
 
```
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    map - 被检查的Map
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Returns:
    
    被检查的Map
    
    Throws:
    
    IllegalArgumentException - if the map is null or has no entries
  - notEmpty
```
public static <K,V> Map<K,V> notEmpty(Map<K,V> map)
                               throws IllegalArgumentException
```
    断言给定Map非空
```
 Assert.notEmpty(map, "Map must have entries");
 
```
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    map - 被检查的Map
    
    Returns:
    
    被检查的Map
    
    Throws:
    
    IllegalArgumentException - if the map is null or has no entries
  - isInstanceOf
```
public static <T> T isInstanceOf(Class<?> type,
                                 T obj)
```
    断言给定对象是否是给定类的实例
```
 Assert.instanceOf(Foo.class, foo);
 
```
    Type Parameters:
    
    T - 被检查对象泛型类型
    
    Parameters:
    
    type - 被检查对象匹配的类型
    
    obj - 被检查对象
    
    Returns:
    
    被检查的对象
    
    Throws:
    
    IllegalArgumentException - if the object is not an instance of clazz
    
    See Also:
    
    Class.isInstance(Object)
  - isInstanceOf
```
public static <T> T isInstanceOf(Class<?> type,
                                 T obj,
                                 String errorMsgTemplate,
                                 Object... params)
                          throws IllegalArgumentException
```
    断言给定对象是否是给定类的实例
```
 Assert.instanceOf(Foo.class, foo);
 
```
    Type Parameters:
    
    T - 被检查对象泛型类型
    
    Parameters:
    
    type - 被检查对象匹配的类型
    
    obj - 被检查对象
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Returns:
    
    被检查对象
    
    Throws:
    
    IllegalArgumentException - if the object is not an instance of clazz
    
    See Also:
    
    Class.isInstance(Object)
  - isAssignable
```
public static void isAssignable(Class<?> superType,
                                Class<?> subType)
                         throws IllegalArgumentException
```
    Assert that superType.isAssignableFrom(subType) is true.
```
 Assert.isAssignable(Number.class, myClass);
 
```
    Parameters:
    
    superType - the super type to check
    
    subType - the sub type to check
    
    Throws:
    
    IllegalArgumentException - if the classes are not assignable
  - isAssignable
```
public static void isAssignable(Class<?> superType,
                                Class<?> subType,
                                String errorMsgTemplate,
                                Object... params)
                         throws IllegalArgumentException
```
    Assert that superType.isAssignableFrom(subType) is true.
```
 Assert.isAssignable(Number.class, myClass);
 
```
    Parameters:
    
    superType - the super type to check against
    
    subType - the sub type to check
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Throws:
    
    IllegalArgumentException - if the classes are not assignable
  - state
```
public static void state(boolean expression,
                         String errorMsgTemplate,
                         Object... params)
                  throws IllegalStateException
```
    Assert a boolean expression, throwing IllegalStateException if the test result is false. Call isTrue if you wish to throw IllegalArgumentException on an assertion failure.
```
 Assert.state(id == null, "The id property must not already be initialized");
 
```
    Parameters:
    
    expression - a boolean expression
    
    errorMsgTemplate - 异常时的消息模板
    
    params - 参数列表
    
    Throws:
    
    IllegalStateException - if expression is false
  - state
```
public static void state(boolean expression)
                  throws IllegalStateException
```
    Assert a boolean expression, throwing IllegalStateException if the test result is false.
    Call isTrue(boolean) if you wish to throw IllegalArgumentException on an assertion failure.
```
 Assert.state(id == null);
 
```
    Parameters:
    
    expression - a boolean expression
    
    Throws:
    
    IllegalStateException - if the supplied expression is false
  - hasText
```
public static void hasText(String text,
                           String message)
```
    Assert that the given String contains valid text content; that is, it must not be null and must contain at least one non-whitespace character.
```
Assert.hasText(name, "'name' must not be empty");
```
    Parameters:
    
    text - the String to check
    
    message - the exception message to use if the assertion fails
    
    Throws:
    
    IllegalArgumentException - if the text does not contain valid text content
    
    See Also:
    
    StringUtils.hasText(java.lang.String)

Class Assert

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Assert

Method Detail

isTrue

isTrue

isFalse

isFalse

isNull

isNull

notNull

notNull

notEmpty

notEmpty

notBlank

notBlank

notContain

notContain

notEmpty

notEmpty

noNullElements

noNullElements

notEmpty

notEmpty

notEmpty

notEmpty

isInstanceOf

isInstanceOf

isAssignable

isAssignable

state

state

hasText